merge: rebase 到最新 main（吸納 PR #15 個人自助指令群）後新增管理端指令群

- main 已合併 PR #15（profile/password/email/sessions/tokens/mfa 與 eqrcode 依賴）
- 保留 main 的 self_service 模組與 api.ex 個人自助端點，於其上重套管理端：
  jwks/accounts/audit-logs 指令、API 端點、CLI 接線、docs §3.8–§3.10、README 表格
- mix precommit 全綠（150 tests：admin 100 + self-service 50）

README.md

@@ -24,6 +24,9 @@ Bear 目前所有流程都依賴「瀏覽器」：登入 `/login`、儀表板 La
 | `bear logout` | 撤銷 refresh token（`POST /revoke`） | P2 |
 | `bear status` | 顯示登入狀態與 token 剩餘效期 | P2 |
 | `bear apps list/show/create/update/rotate-secret/toggle` | App 管理（需 bear App 管理 JSON API，PAT 登入、admin 限定） | P3（✅ 已實作） |
+| `bear jwks list/show/create/toggle` | 簽章金鑰管理（admin 限定） | P3（✅ 已實作） |
+| `bear accounts list/show/create/update/set-password/delete` | 帳號管理（admin 限定） | P3（✅ 已實作） |
+| `bear audit-logs list` | 稽核日誌查詢（admin 限定） | P3（✅ 已實作） |
 | `bear profile show/set` | 個人資料檢視／更新（需 bear 個人自助 JSON API） | P3（✅ 已實作） |
 | `bear password change` | 變更密碼（互動輸入，不進 shell history） | P3（✅ 已實作） |
 | `bear email change --new EMAIL` | 變更 email（雙向驗證碼流程） | P3（✅ 已實作） |
@@ -47,6 +50,9 @@ Bear 目前所有流程都依賴「瀏覽器」：登入 `/login`、儀表板 La
 | `bear logout` | ✅ 已實作（清除本機憑證；PAT 需至網頁撤銷） |
 | `bear status` | ✅ 已實作（純本機判定，顯示 PAT／環境變數模式） |
 | `bear apps` | ✅ 已實作（`list`／`show`／`create`／`update`／`rotate-secret`／`toggle`；issue #10，對接 alterminal/bear#28 的 `/api/v1/apps` JSON API，admin PAT 限定） |
+| `bear jwks` | ✅ 已實作（`list`／`show`／`create`／`toggle`；issue #12，對接 alterminal/bear#46 的 `/api/v1/jwks` JSON API，admin PAT 限定） |
+| `bear accounts` | ✅ 已實作（`list`／`show`／`create`／`update`／`set-password`／`delete`；issue #12，對接 alterminal/bear#46 的 `/api/v1/accounts` JSON API；密碼不進命令列，初始／新密碼一次性輸出） |
+| `bear audit-logs` | ✅ 已實作（`list` 含 `--category` 過濾與 emails 對照；issue #12，對接 alterminal/bear#46 的 `/api/v1/audit-logs` JSON API） |
 | `bear profile`／`password`／`email`／`sessions`／`tokens`／`mfa` | ✅ 已實作（issue #11，對接 alterminal/bear#38 的 `/api/v1/profile*` JSON API，任何有效 PAT 皆可）：`profile show/set`、`password change`、`email change --new`、`sessions list/revoke/revoke-others`、`tokens list/create/revoke`、`mfa status/setup/disable/recovery-codes`。規格見 `docs/commands.md` §3.7 |
 
 ### 建置與執行

docs/commands.md

@@ -512,6 +512,162 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 
 ---
 
+### 3.8 `bear jwks`：簽章金鑰管理指令群（admin，已實作）
+
+> 依賴：bear 伺服器端 **JWK 管理 JSON API**（alterminal/bear#36／PR #46，資源前綴 `/api/v1/jwks`，PAT Bearer 認證、admin 限定）。API 已上線，本節指令群已實作（issue #12）。
+
+
+比照 `apps` 的「資源群組」結構。金鑰材質（`key_data`）**永不經 CLI 顯示**（API 端即不序列化；公開 JWK 走 `/.well-known/jwks.json`），本群組僅管理公開中繼資料。
+
+
+```
+bear jwks list [--json]
+bear jwks show <kid> [--json]
+bear jwks create --kid KID [--alg ALG] [--json]
+bear jwks toggle <kid> [--json]
+```
+
+**認證與授權（群組共通）**：一律使用既有 PAT 憑證（`bear login --token` 或 `BEAR_TOKEN` 環境變數）作為 Bearer，僅限 admin 角色。
+`401`（token 無效）→ 退出碼 `3`，提示重新 `bear login`；`403`（非 admin）→ 退出碼 `8`，提示此操作需 admin 權限，不重試。
+
+
+**識別與退出碼**：金鑰一律以 `kid`（人類可讀）識別；API 路徑參數為 UUID，由 CLI 先以 list 比對解析。退出碼同 §3.6 群組共通表（0／1／2／3／6／8）。
+
+
+#### 3.8.1 `bear jwks list`
+
+**行為**：`GET /api/v1/jwks`（Bearer PAT），列出所有金鑰（active 與 inactive），最新在前；人類可讀輸出為表格（ID 前 8 碼、KID、KTY、ALG、ACTIVE、CREATED AT）。
+
+```
+ID        KID          KTY  ALG   ACTIVE    CREATED AT
+0192cccc  sig-2026-01  RSA  RS256 active    2026-09-09T00:00:00Z
+0192cccc  sig-2025-12  EC   ES256 inactive  2025-12-01T00:00:00Z
+```
+
+
+**`--json` 輸出範例**：`{"ok": true, "jwks": [{…}]}`（僅公開欄位，無 `key_data`）。
+
+
+#### 3.8.2 `bear jwks show <kid>`
+
+**行為**：`GET /api/v1/jwks/{id}`（以 kid 解析），印出公開欄位（id、kid、kty、alg、use、active、created_at）；找不到 kid → 退出碼 `1`。
+
+#### 3.8.3 `bear jwks create --kid KID [--alg ALG]`
+
+| 選項 | 預設 | 說明 |
+|------|------|------|
+| `--kid` | （必填） | 金鑰識別碼 |
+| `--alg` | `RS256` | `RS256`／`RS384`／`RS512`／`ES256`／`ES384`／`ES512` |
+
+**行為**：`POST /api/v1/jwks`（body 為 kid 與 alg；金鑰由伺服器產生）。成功印出 `JWK 已建立：<kid>（<alg>／active）`。`alg` 非法 → 退出碼 `2`（本地檢查）；kid 重複等 422 → 退出碼 `1` 逐欄位列錯。
+
+**`--json` 輸出範例**：`{"ok": true, "jwk": {…}}`
+
+#### 3.8.4 `bear jwks toggle <kid>`
+
+**行為**：`POST /api/v1/jwks/{id}/toggle`（以 kid 解析），切換 `active ⇄ inactive`；成功印出如 `sig-2026-01：active → inactive`。
+**`--json` 輸出範例**：`{"ok": true, "jwk": {"id": "…", "kid": "…", "active": false}}`
+
+---
+
+### 3.9 `bear accounts`：帳號管理指令群（admin，已實作）
+
+> 依賵：bear 伺服器端 **帳號管理 JSON API**（alterminal/bear#36／PR #46，資源前綴 `/api/v1/accounts`，PAT Bearer 認證、admin 限定）。API 已上線，本節指令群已實作（issue #12）。
+
+帳號 JSON 不含機密欄位（hash_password、totp_secret、recovery codes；API 端保證），CLI 亦不顯示。敏感規則與伺服器端一致：不可移除自己的 admin 角色（403）、不可刪除自己（403）。
+
+```
+bear accounts list [--page N] [--per-page N] [--json]
+bear accounts show <email> [--json]
+bear accounts create --email EMAIL [--role user|admin] [--generate-password] [--json]
+bear accounts update <email> --role user|admin [--json]
+bear accounts set-password <email> [--generate-password] [--json]
+bear accounts delete <email> [--json]
+```
+
+**認證與授權（群組共通）**：同 §3.8（PAT Bearer、僅限 admin；401 → 3；403 → 8）。退出碼同 §3.6 群組共通表。
+
+**識別與密碼**：帳號一律以 `email` 識別；API 路徑參數為 UUID，由 CLI 先以 list 分頁比對解析。密碼不進命令列（避免 shell history 與 ps）：交互提示輸入（不回顧）或 `--generate-password` 由 CLI 產生。初始／新密碼只在成功當下一次性輸出。
+
+#### 3.9.1 `bear accounts list`
+
+**行為**：`GET /api/v1/accounts`（Bearer PAT，分頁，最新在前）；人類可讀輸出為表格。
+
+```
+EMAIL               ROLE   TOTP  CREATED AT
+admin@example.com   admin  on    2026-01-01T00:00:00Z
+alice@example.com   user   off   2026-02-01T00:00:00Z
+```
+
+**`--json` 輸出範例**：`{"ok": true, "page": 1, "per_page": 20, "total": 2, "accounts": […]}`
+
+#### 3.9.2 `bear accounts show <email>`
+
+**行為**：`GET /api/v1/accounts/{id}`（以 email 解析），印出公開欄位（id、email、role、totp_enabled、created_at、updated_at）；找不到 → 退出碼 `1`。
+
+#### 3.9.3 `bear accounts create`
+
+| 選項 | 預設 | 說明 |
+|------|------|------|
+| `--email` | （必填） | 帳號 email（唯一） |
+| `--role` | `user` | `user` 或 `admin` |
+| `--generate-password` | 互動輸入 | 由 CLI 產生 16 字元隨機密碼（含字母與數字） |
+
+**行為**：`POST /api/v1/accounts`（免信箱驗證；密碼以明文放入 `hash_password`，伺服器端驗強度後雜湏）。成功印出帳號摘要與一次性密碼區塊：
+
+```
+帳號已建立：new@example.com（user）
+初始密碼（只顯示這一次，請立即保存並轉交當事人）：
+  xK7mP9qR2sL4wY6z
+```
+
+**`--json` 輸出範例**：`{"ok": true, "account": {…}, "initial_password": "…"}`（密碼只出現這一次）。
+
+#### 3.9.4 `bear accounts update <email> --role user|admin`
+
+**行為**：`PUT /api/v1/accounts/{id}`（body 為 role）。成功印出 `alice@example.com：角色 → admin`。伺服器拒絕自降 admin（403）→ 退出碼 `8`。`--role` 罪給或非法 → 退出碼 `2`。
+
+#### 3.9.5 `bear accounts set-password <email>`
+
+**行為**：`PUT /api/v1/accounts/{id}/password`（管理員設新密碼，免舊密碼）。密碼來源同 create；非 TTY 且未給 `--generate-password` → 退出碼 `2`，提示加 `--generate-password`。成功後一次性顯示新密碼（同 create 提示）。
+
+#### 3.9.6 `bear accounts delete <email>`
+
+**行為**：`DELETE /api/v1/accounts/{id}`（管理端硬刪除，免驗證碼）。成功印出 `已刪除帳號：<email>`；伺服器拒絕自刪（403）→ 退出碼 `8`。
+
+**`--json` 輸出範例**：`{"ok": true, "email": "alice@example.com", "deleted": true}`
+
+---
+
+### 3.10 `bear audit-logs`：稽核日誌指令群（admin，已實作）
+
+> 依賵：bear 伺服器端 **稽核日誌 JSON API**（alterminal/bear#36／PR #46，`/api/v1/audit-logs`，PAT Bearer 認證、admin 限定）。API 已上線，本節指令群已實作（issue #12）。
+
+```
+bear audit-logs list [--page N] [--per-page N] [--category CATEGORY] [--json]
+```
+
+**認證與授權**：同 §3.8（PAT Bearer、僅限 admin；401 → 3；403 → 8）。
+
+#### 3.10.1 `bear audit-logs list`
+
+| 選項 | 預設 | 說明 |
+|------|------|------|
+| `--page` | `1` | 分頁頁碼 |
+| `--per-page` | `50` | 每頁筆數（伺服器上限 200） |
+| `--category` | 全部 | 過濾類別（伺服器端支援；如 `account`、`jwk`） |
+
+**行為**：`GET /api/v1/audit-logs`（Bearer PAT，最新在前）；回應附 `emails` 對照（account/actor id → email），人類可讀輸出以 email 呈現、無對照時顯示 id 前 8 碼：
+
+```
+TIME                CATEGORY  EVENT                    ACTOR              ACCOUNT
+2026-09-09T01:00:00Z  account   account_created_by_admin  admin@example.com  alice@example.com
+```
+
+**`--json` 輸出範例**：`{"ok": true, "page": 1, "per_page": 50, "total": 1, "total_pages": 1, "emails": {…}, "entries": […]}`
+
+---
+
 ## 4. 退出碼總表
 
 | 碼 | 語意 |
@@ -524,7 +680,7 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 | `5` | 授權被拒絕（access_denied） |
 | `6` | 網路／伺服器錯誤 |
 | `7` | 設定檔／憑證檔格式損毀 |
-| `8` | 權限不足（HTTP 403；App 管理操作僅限 admin） |
+| `8` | 權限不足（HTTP 403；管理端操作僅限 admin：apps／jwks/accounts/audit-logs） |
 
 ---
 
@@ -613,6 +769,7 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 | `status` | 顯示 access token 剩餘秒數 | 純本機判定：顯示模式（PAT／BEAR_TOKEN 環境變數）與 issuer |
 | `apps` | P3 暫緩 | ✅ 已實作（issue #10）：`list`／`show`／`create`／`update`／`rotate-secret`／`toggle`，對接 alterminal/bear#28 的 `/api/v1/apps` JSON API（PAT Bearer、admin 限定）。`client_id` → UUID 由 CLI 以 list 解析；一次性 `client_secret` 僅於 create／rotate-secret 成功當下輸出 |
 | `profile`／`password`／`email`／`sessions`／`tokens`／`mfa` | P3 暫緩 | ✅ 已實作（issue #11）：`profile show/set`、`password change`、`email change`、`sessions list/revoke/revoke-others`、`tokens list/create/revoke`、`mfa status/setup/disable/recovery-codes`，對接 alterminal/bear#38 的 `/api/v1/profile*` JSON API（PAT Bearer、任何有效帳號）。敏感輸入互動提示；一次性明文（PAT 明文、recovery codes）僅於成功當下輸出；mfa setup 的 ASCII QR 由本機 eqrcode 生成 |
+| `jwks`／`accounts`／`audit-logs` | P3 暫緩 | ✅ 已實作（issue #12）：對接 alterminal/bear#46 的管理端 JSON API（PAT Bearer、admin 限定）；規格見 §3.8–§3.10 |
 
 退出碼差異：`login`／`whoami` 的 token 無效（401）依 §3.1 為 `3`（本節實作一致）。
 

lib/bear_cli/accounts.ex

@@ -0,0 +1,348 @@
+defmodule BearCli.Accounts do
+  @moduledoc """
+  `bear accounts` 指令群（帳號管理；docs/commands.md §3.9、issue #12）。
+
+  對應伺服器端帳號管理 JSON API（alterminal/bear#46，`/api/v1/accounts`、
+  PAT Bearer、admin 限定）。認證沿用既有 PAT 憑證（`BEAR_TOKEN` 或憑證檔）。
+
+  CLI 對外介面一律以 `email` 識別帳號（人類可讀、唯一）；API 路徑參數為
+  UUID，由本模組先以 list 分頁比對解析。帳號 JSON 不含 `hash_password`、
+  `totp_secret` 等機密欄位（API 端保證），CLI 亦不顯示。
+
+  `create`／`set-password` 未給 `--password` 時由 CLI 產生隨機密碼，並只在
+  成功當下一次性輸出（不寫入憑證檔／log／`--verbose`）；密碼一律不進命令列
+  （避免 shell history／`ps`），改以互動輸入（不回顧）或 `--generate-password`。
+
+  敏感規則與伺服器端一致：不可移除自己的 admin 角色（403）、不可刪除自己（403）。
+
+  退出碼：0 成功；1 404／422；2 用法錯誤；3 未登入或 401；6 網路／伺服器
+  錯誤；8 權限不足（403，僅限 admin）。
+  """
+
+  import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
+  alias BearCli.Api
+
+  @list_per_page_fetch 100
+  @max_fetch_pages 50
+
+  # -- 入口 --
+
+  @doc """
+  執行 `bear accounts <動詞>`，回傳退出碼。`opts[:accounts_api]` 可注入假
+  API 模組供測試（需實作 `accounts_list/3`、`accounts_create/3`、
+  `accounts_get/3`、`accounts_update_role/4`、`accounts_set_password/4`、
+  `accounts_delete/3`）。
+  """
+  def run(verb, opts) do
+    api = opts[:accounts_api] || Api
+
+    with {:ok, ctx} <- context(opts) do
+      execute(verb, ctx, opts, api)
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- 各動詞 --
+
+  defp execute(:list, ctx, opts, api) do
+    params = [page: opts[:page] || 1, per_page: opts[:per_page] || 20]
+
+    case api.accounts_list(ctx.issuer, ctx.token, params) do
+      {:ok, body} ->
+        accounts = body["data"] || []
+        page = body["page"] || params[:page]
+        per_page = body["per_page"] || params[:per_page]
+        total = body["total"] || length(accounts)
+        render_list(opts, accounts, page, per_page, total)
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:show, ctx, opts, api) do
+    with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
+      case api.accounts_get(ctx.issuer, ctx.token, account["id"]) do
+        {:ok, body} ->
+          show_account(body["data"] || %{}, opts)
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:create, ctx, opts, api) do
+    with {:ok, password} <- read_password(opts) do
+      attrs = %{"email" => opts[:email], "hash_password" => password}
+      attrs = if opts[:role], do: Map.put(attrs, "role", opts[:role]), else: attrs
+
+      case api.accounts_create(ctx.issuer, ctx.token, attrs) do
+        {:ok, body} ->
+          account = body["data"] || %{}
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, account: account, initial_password: password}))
+          else
+            IO.puts("帳號已建立：#{account["email"]}（#{account["role"]}）")
+            print_password_block(password)
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:update, ctx, opts, api) do
+    with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
+      case api.accounts_update_role(ctx.issuer, ctx.token, account["id"], %{"role" => opts[:role]}) do
+        {:ok, body} ->
+          updated = body["data"] || %{}
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, account: updated}))
+          else
+            IO.puts("#{updated["email"]}：角色 → #{updated["role"]}")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:"set-password", ctx, opts, api) do
+    with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api),
+         {:ok, password} <- read_password(opts) do
+      case api.accounts_set_password(ctx.issuer, ctx.token, account["id"], %{
+             "hash_password" => password
+           }) do
+        {:ok, _body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, email: account["email"], new_password: password}))
+          else
+            IO.puts("已為 #{account["email"]} 設定新密碼。")
+            print_password_block(password)
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:delete, ctx, opts, api) do
+    with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
+      case api.accounts_delete(ctx.issuer, ctx.token, account["id"]) do
+        {:ok, _body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, email: account["email"], deleted: true}))
+          else
+            IO.puts("已刪除帳號：#{account["email"]}")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- email → UUID 解析（分頁全量列舉比對；設頁數上限避免無限迴圈）--
+
+  defp resolve_account(_ctx, nil, _api), do: {:error, "缺少 <email> 參數", 2}
+
+  defp resolve_account(ctx, email, api) do
+    with {:ok, all} <- fetch_all(ctx, api) do
+      case Enum.find(all, &(&1["email"] == email)) do
+        nil -> {:error, "找不到 email 為 #{email} 的帳號", 1}
+        account -> {:ok, account}
+      end
+    else
+      {:error, message, code} -> {:error, message, code}
+    end
+  end
+
+  defp fetch_all(ctx, api) do
+    do_fetch_all(ctx, api, 1, [])
+  end
+
+  defp do_fetch_all(_ctx, _api, page, acc) when page > @max_fetch_pages, do: {:ok, acc}
+
+  defp do_fetch_all(ctx, api, page, acc) do
+    case api.accounts_list(ctx.issuer, ctx.token, page: page, per_page: @list_per_page_fetch) do
+      {:ok, body} ->
+        entries = body["data"] || []
+        acc = acc ++ entries
+        total = body["total"]
+
+        if entries == [] or length(entries) < @list_per_page_fetch or
+             (is_integer(total) and length(acc) >= total) do
+          {:ok, acc}
+        else
+          do_fetch_all(ctx, api, page + 1, acc)
+        end
+
+      {:error, _kind, _detail} = error ->
+        {message, code} = format_api_error(ctx, error)
+        {:error, message, code}
+    end
+  end
+
+  # -- 密碼輸入（不進命令列；非 TTY 且未 --generate-password → 用法錯誤）--
+
+  defp read_password(%{generate_password: true}), do: {:ok, generate_password()}
+
+  defp read_password(_opts) do
+    if tty?() do
+      password = prompt_password("新密碼（至少 8 字元，含字母與數字）：")
+      confirm = prompt_password("再次輸入新密碼：")
+
+      cond do
+        password != confirm ->
+          {:error, "兩次輸入的密碼不一致", 2}
+
+        weak_password?(password) ->
+          {:error, "密碼至少 8 字元且須包含字母與數字", 2}
+
+        true ->
+          {:ok, password}
+      end
+    else
+      {:error, "非 TTY 環境無法互動輸入密碼；請加 --generate-password 由 CLI 產生", 2}
+    end
+  end
+
+  @password_chars "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789"
+  @password_length 16
+
+  defp generate_password do
+    @password_chars
+    |> String.codepoints()
+    |> Enum.take_random(@password_length)
+    |> Enum.join()
+  end
+
+  defp weak_password?(password) when is_binary(password) do
+    String.length(password) >= 8 and Regex.match?(~r/[a-zA-Z]/, password) and
+      Regex.match?(~r/[0-9]/, password)
+  end
+
+  defp weak_password?(_), do: true
+
+  defp tty? do
+    :io.columns() != {:error, :enotsup}
+  end
+
+  defp prompt_password(prompt) do
+    IO.puts(:stderr, prompt)
+    IO.gets("") |> String.trim_trailing("\n")
+  end
+
+  # -- 輸出 --
+
+  defp render_list(opts, accounts, page, per_page, total) do
+    if opts[:json] do
+      IO.puts(
+        Jason.encode!(%{
+          ok: true,
+          page: page,
+          per_page: per_page,
+          total: total,
+          accounts: accounts
+        })
+      )
+    else
+      print_table(accounts)
+    end
+  end
+
+  @table_headers ["EMAIL", "ROLE", "TOTP", "CREATED AT"]
+
+  defp print_table(accounts) do
+    rows =
+      Enum.map(accounts, fn account ->
+        [
+          account["email"] || "",
+          account["role"] || "",
+          totp_label(account["totp_enabled"]),
+          account["created_at"] || ""
+        ]
+      end)
+
+    widths =
+      Enum.with_index(@table_headers, fn _header, i ->
+        Enum.max([
+          String.length(Enum.at(@table_headers, i))
+          | Enum.map(rows, &String.length(Enum.at(&1, i)))
+        ])
+      end)
+
+    render_row = fn cells ->
+      cells
+      |> Enum.with_index()
+      |> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
+      |> Enum.join("  ")
+      |> String.trim_trailing()
+    end
+
+    IO.puts(render_row.(@table_headers))
+    Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
+  end
+
+  @account_fields ~w(id email role totp_enabled created_at updated_at)
+
+  defp show_account(account, opts) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: true, account: account}))
+    else
+      Enum.each(@account_fields, fn field ->
+        IO.puts("#{String.pad_trailing(field, 16)}: #{format_account_value(account[field])}")
+      end)
+    end
+  end
+
+  defp format_account_value(nil), do: "(無)"
+  defp format_account_value(true), do: "已啟用"
+  defp format_account_value(false), do: "未啟用"
+  defp format_account_value(value) when is_binary(value), do: value
+  defp format_account_value(value), do: Jason.encode!(value)
+
+  defp totp_label(true), do: "on"
+  defp totp_label(false), do: "off"
+  defp totp_label(_), do: "(未知)"
+
+  # 初始／新密碼只在成功當下一次性輸出（不寫入憑證檔／log／--verbose）。
+  defp print_password_block(password) do
+    IO.puts("初始密碼（只顯示這一次，請立即保存並轉交當事人）：")
+    IO.puts("  #{password}")
+  end
+
+  # -- 錯誤處理 --
+
+  defp fail_api(opts, ctx, error) do
+    {message, code} = format_api_error(ctx, error)
+    fail(opts, message, code)
+  end
+end

lib/bear_cli/admin.ex

@@ -0,0 +1,273 @@
+defmodule BearCli.Admin do
+  @moduledoc """
+  `bear jwks`／`bear accounts`／`bear audit-logs` 管理端指令群的共用層
+  （docs/commands.md §3.8–§3.10、issue #12）。
+
+  `parse/3` 由 `BearCli.CLI` 的 fallback 分派呼叫，負責解析三個資源群組的
+  子指令與選項並做本地用法驗證；`context/1`／`fail/3`／`format_api_error/3`
+  為各群組模組共用的背景與錯誤處理。
+  """
+
+  alias BearCli.{Accounts, AuditLogs, Config, Credentials, Jwks}
+
+  @jwks_verbs ~w(list show create toggle)
+  @accounts_verbs ~w(list show create update set-password delete)
+  @audit_logs_verbs ~w(list)
+
+  @jwks_create_switches [kid: :string, alg: :string]
+
+  @accounts_list_switches [page: :integer, per_page: :integer]
+  @accounts_create_switches [email: :string, role: :string, generate_password: :boolean]
+  @accounts_update_switches [role: :string]
+  @accounts_set_password_switches [generate_password: :boolean]
+
+  @audit_logs_list_switches [page: :integer, per_page: :integer, category: :string]
+
+  @algs ~w(RS256 RS384 RS512 ES256 ES384 ES512)
+  @roles ~w(user admin)
+
+  @global_switches [
+    issuer: :string,
+    config: :string,
+    json: :boolean,
+    verbose: :boolean,
+    help: :boolean,
+    version: :boolean
+  ]
+
+  # -- 解析（非管理端指令回 :error，交回 CLI 報未知指令）--
+
+  @doc """
+  解析 `jwks`／`accounts`／`audit-logs` 群組的 argv，回傳 `{:ok, {module, verb}, opts}`
+  或 `{:error, message, code}`；非本層負責的指令回 `:error`。
+  """
+  def parse(["jwks" | rest], global), do: parse_group("jwks", @jwks_verbs, rest, global)
+
+  def parse(["accounts" | rest], global),
+    do: parse_group("accounts", @accounts_verbs, rest, global)
+
+  def parse(["audit-logs" | rest], global),
+    do: parse_group("audit-logs", @audit_logs_verbs, rest, global)
+
+  def parse(_, _), do: :error
+
+  defp parse_group(group, verbs, rest, global) do
+    case rest do
+      [verb | args] ->
+        if verb in verbs do
+          switches = group_switches(group, verb)
+
+          case OptionParser.parse(args, strict: @global_switches ++ switches) do
+            {opts, positionals, []} ->
+              validate(group, verb, positionals, merge_opts(global, opts_to_map(opts)))
+
+            {_opts, _extra, [{opt, _} | _]} ->
+              {:error, "無法解析選項：#{opt}", 2}
+          end
+        else
+          {:error, "未知的 #{group} 子指令：#{verb}（可用：#{Enum.join(verbs, " ")}）", 2}
+        end
+
+      [] ->
+        {:error, "#{group} 缺少子指令（可用：#{Enum.join(verbs, " ")}）", 2}
+    end
+  end
+
+  defp group_switches("jwks", "list"), do: []
+  defp group_switches("jwks", "show"), do: []
+  defp group_switches("jwks", "create"), do: @jwks_create_switches
+  defp group_switches("jwks", "toggle"), do: []
+  defp group_switches("accounts", "list"), do: @accounts_list_switches
+  defp group_switches("accounts", "show"), do: []
+  defp group_switches("accounts", "create"), do: @accounts_create_switches
+  defp group_switches("accounts", "update"), do: @accounts_update_switches
+  defp group_switches("accounts", "set-password"), do: @accounts_set_password_switches
+  defp group_switches("accounts", "delete"), do: []
+  defp group_switches("audit-logs", "list"), do: @audit_logs_list_switches
+
+  # keyword 轉 map（本層無 :keep 選項，直接 Map.new）。
+  defp opts_to_map(opts), do: Map.new(opts)
+
+  defp merge_opts(global, opts), do: Map.merge(Map.new(global), opts)
+
+  # -- 本地用法驗證（用法錯誤 → 退出碼 2）--
+
+  # jwks
+  defp validate("jwks", "list", [], opts), do: {:ok, {Jwks, :list}, opts}
+  defp validate("jwks", "list", extra, _opts), do: positional_error("jwks list", extra, 0)
+
+  defp validate("jwks", "show", [kid], opts),
+    do: {:ok, {Jwks, :show}, Map.put(opts, :kid_arg, kid)}
+
+  defp validate("jwks", "show", [], _opts), do: {:error, "jwks show 缺少 <kid>", 2}
+  defp validate("jwks", "show", extra, _opts), do: positional_error("jwks show", extra, 1)
+
+  defp validate("jwks", "create", [], opts) do
+    cond do
+      blank?(opts[:kid]) ->
+        {:error, "jwks create 缺少必選參數：--kid", 2}
+
+      opts[:alg] && opts[:alg] not in @algs ->
+        {:error, "--alg 不接受的值：#{opts[:alg]}（可用：#{Enum.join(@algs, "、")}）", 2}
+
+      true ->
+        {:ok, {Jwks, :create}, opts}
+    end
+  end
+
+  defp validate("jwks", "create", extra, _opts), do: positional_error("jwks create", extra, 0)
+
+  defp validate("jwks", "toggle", [kid], opts),
+    do: {:ok, {Jwks, :toggle}, Map.put(opts, :kid_arg, kid)}
+
+  defp validate("jwks", "toggle", [], _opts), do: {:error, "jwks toggle 缺少 <kid>", 2}
+  defp validate("jwks", "toggle", extra, _opts), do: positional_error("jwks toggle", extra, 1)
+
+  # accounts
+  defp validate("accounts", "list", [], opts), do: {:ok, {Accounts, :list}, opts}
+  defp validate("accounts", "list", extra, _opts), do: positional_error("accounts list", extra, 0)
+
+  defp validate("accounts", "show", [email], opts),
+    do: {:ok, {Accounts, :show}, Map.put(opts, :email_arg, email)}
+
+  defp validate("accounts", "show", [], _opts), do: {:error, "accounts show 缺少 <email>", 2}
+  defp validate("accounts", "show", extra, _opts), do: positional_error("accounts show", extra, 1)
+
+  defp validate("accounts", "create", [], opts) do
+    cond do
+      blank?(opts[:email]) ->
+        {:error, "accounts create 缺少必選參數：--email", 2}
+
+      opts[:role] && opts[:role] not in @roles ->
+        {:error, "--role 不接受的值：#{opts[:role]}（可用：#{Enum.join(@roles, "、")}）", 2}
+
+      true ->
+        {:ok, {Accounts, :create}, opts}
+    end
+  end
+
+  defp validate("accounts", "create", extra, _opts),
+    do: positional_error("accounts create", extra, 0)
+
+  defp validate("accounts", "update", [email], opts) do
+    if blank?(opts[:role]) or opts[:role] not in @roles do
+      {:error, "accounts update 必須給 --role user|admin", 2}
+    else
+      {:ok, {Accounts, :update}, Map.put(opts, :email_arg, email)}
+    end
+  end
+
+  defp validate("accounts", "update", [], _opts), do: {:error, "accounts update 缺少 <email>", 2}
+
+  defp validate("accounts", "update", extra, _opts),
+    do: positional_error("accounts update", extra, 1)
+
+  defp validate("accounts", "set-password", [email], opts),
+    do: {:ok, {Accounts, :"set-password"}, Map.put(opts, :email_arg, email)}
+
+  defp validate("accounts", "set-password", [], _opts),
+    do: {:error, "accounts set-password 缺少 <email>", 2}
+
+  defp validate("accounts", "set-password", extra, _opts),
+    do: positional_error("accounts set-password", extra, 1)
+
+  defp validate("accounts", "delete", [email], opts),
+    do: {:ok, {Accounts, :delete}, Map.put(opts, :email_arg, email)}
+
+  defp validate("accounts", "delete", [], _opts), do: {:error, "accounts delete 缺少 <email>", 2}
+
+  defp validate("accounts", "delete", extra, _opts),
+    do: positional_error("accounts delete", extra, 1)
+
+  # audit-logs
+  defp validate("audit-logs", "list", [], opts), do: {:ok, {AuditLogs, :list}, opts}
+
+  defp validate("audit-logs", "list", extra, _opts),
+    do: positional_error("audit-logs list", extra, 0)
+
+  defp positional_error(command, extra, _max) do
+    {:error, "#{command} 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+  end
+
+  # -- 共用背景（token／issuer；三個群組模組共用）--
+
+  @doc "解析 token／issuer 背景，回傳 {:ok, ctx} 或 {:error, message, code}。"
+  def context(opts) do
+    if token = Config.env_token() do
+      # BEAR_TOKEN 優先於憑證檔（不讀檔、不寫檔）。
+      {:ok, %{token: token, issuer: resolve_issuer(opts, nil)}}
+    else
+      case Credentials.load() do
+        {:ok, creds} ->
+          token = creds["access_token"]
+
+          if blank?(token) do
+            {:error, "憑證檔缺少 access_token，請重新 bear login", 7}
+          else
+            {:ok, %{token: token, issuer: resolve_issuer(opts, creds["issuer"])}}
+          end
+
+        :error ->
+          {:error, "未登入（請先執行 bear login）", 3}
+      end
+    end
+  end
+
+  defp resolve_issuer(opts, stored_issuer) do
+    opts[:issuer] || stored_issuer || Config.resolve_issuer(nil, opts[:config])
+  end
+
+  # -- 共用錯誤處理 --
+
+  @doc "輸出錯誤（--json 走 stdout JSON、人類模式走 stderr），回傳退出碼。"
+  def fail(opts, message, code) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: false, error: message, code: code}))
+    else
+      IO.puts(:stderr, "錯誤：#{message}")
+    end
+
+    code
+  end
+
+  @doc "API 錯誤 → 訊息與退出碼（管理端共通對應）。"
+  def format_api_error(_ctx, {:error, :unauthorized, desc}) do
+    {"token 無效或已過期（#{desc}），請重新 bear login", 3}
+  end
+
+  def format_api_error(_ctx, {:error, :forbidden, _desc}) do
+    {"此操作需 admin 權限（HTTP 403）", 8}
+  end
+
+  def format_api_error(_ctx, {:error, :not_found, _desc}) do
+    {"找不到目標資源（HTTP 404）", 1}
+  end
+
+  def format_api_error(_ctx, {:error, :unprocessable_entity, body}) do
+    details =
+      body
+      |> Map.get("errors", %{})
+      |> Enum.map(fn {field, messages} ->
+        "#{field}: #{Enum.join(List.wrap(messages), "、")}"
+      end)
+      |> Enum.join("；")
+
+    if details == "" do
+      {"驗證失敗（HTTP 422）", 1}
+    else
+      {"驗證失敗（HTTP 422）：#{details}", 1}
+    end
+  end
+
+  def format_api_error(_ctx, {:error, :server_error, status}) do
+    {"伺服器回應 #{status}", 6}
+  end
+
+  def format_api_error(ctx, {:error, :network, reason}) do
+    {"無法連線到 #{ctx.issuer}：#{reason}", 6}
+  end
+
+  defp blank?(nil), do: true
+  defp blank?(""), do: true
+  defp blank?(_), do: false
+end

lib/bear_cli/api.ex

@@ -6,6 +6,8 @@ defmodule BearCli.Api do
   - App 管理 API `/api/v1/apps`（alterminal/bear#28；PAT Bearer、admin 限定）。
   - 個人自助 API `/api/v1/profile*`（alterminal/bear#35；PAT Bearer、
     任何有效帳號）：profile／密碼／email／sessions／PAT／MFA。
+  - 管理端 API `/api/v1/jwks`/`/api/v1/accounts`/`/api/v1/audit-logs`
+    (alterminal/bear#36; PAT Bearer, admin only).
   """
 
   @finch BearCli.Finch
@@ -265,4 +267,85 @@ defmodule BearCli.Api do
         {:error, :network, Exception.message(exception)}
     end
   end
+
+  @doc "`GET /api/v1/jwks`: list all keys (active and inactive), newest first (no pagination)."
+  def jwks_list(issuer, token) do
+    api_request(issuer, token, :get, "/api/v1/jwks")
+  end
+
+  @doc """
+  `POST /api/v1/jwks`: create a new signing key. attrs: `%{"kid" => "...", "alg" => "RS256"}`
+  (`alg` optional; RS256/384/512, ES256/384/512). Key material is never serialized.
+  """
+  def jwks_create(issuer, token, attrs) do
+    api_request(issuer, token, :post, "/api/v1/jwks", json: attrs)
+  end
+
+  @doc "`GET /api/v1/jwks/{id}`: single key (public metadata only)."
+  def jwks_get(issuer, token, id) do
+    api_request(issuer, token, :get, "/api/v1/jwks/" <> URI.encode(id))
+  end
+
+  @doc "`POST /api/v1/jwks/{id}/toggle`: switch key between active and inactive."
+  def jwks_toggle(issuer, token, id) do
+    api_request(issuer, token, :post, "/api/v1/jwks/" <> URI.encode(id) <> "/toggle", json: %{})
+  end
+
+  # -- Accounts API (alterminal/bear#46; PAT Bearer, admin only) --
+
+  @doc """
+  `GET /api/v1/accounts`: paginated list (newest first; per_page max 100).
+  Returns `{:ok, %{"data" => [accounts], "page" => n, "per_page" => n, "total" => n}}`.
+  """
+  def accounts_list(issuer, token, params \\ []) do
+    api_request(issuer, token, :get, "/api/v1/accounts", params: params)
+  end
+
+  @doc """
+  `POST /api/v1/accounts`: create an account directly (no email verification).
+  attrs: `%{"email" => "...", "hash_password" => "<plaintext>", "role" => "user|admin"}`
+  (`role` optional, default `user`).
+  """
+  def accounts_create(issuer, token, attrs) do
+    api_request(issuer, token, :post, "/api/v1/accounts", json: attrs)
+  end
+
+  @doc "`GET /api/v1/accounts/{id}`: single account (no credential fields)."
+  def accounts_get(issuer, token, id) do
+    api_request(issuer, token, :get, "/api/v1/accounts/" <> URI.encode(id))
+  end
+
+  @doc """
+  `PUT /api/v1/accounts/{id}`: update role; attrs: `%{"role" => "user|admin"}`.
+  """
+  def accounts_update_role(issuer, token, id, attrs) do
+    api_request(issuer, token, :put, "/api/v1/accounts/" <> URI.encode(id), json: attrs)
+  end
+
+  @doc """
+  `PUT /api/v1/accounts/{id}/password`: admin sets a new password (no old password
+  needed); attrs: `%{"hash_password" => "<plaintext>"}`.
+  """
+  def accounts_set_password(issuer, token, id, attrs) do
+    api_request(issuer, token, :put, "/api/v1/accounts/" <> URI.encode(id) <> "/password",
+      json: attrs
+    )
+  end
+
+  @doc "`DELETE /api/v1/accounts/{id}`: hard-delete an account (admin path). Returns `{:ok, %{}}` (204 empty)."
+  def accounts_delete(issuer, token, id) do
+    api_request(issuer, token, :delete, "/api/v1/accounts/" <> URI.encode(id))
+  end
+
+  # -- Audit logs API (alterminal/bear#46; PAT Bearer, admin only) --
+
+  @doc """
+  `GET /api/v1/audit-logs`: paginated list (newest first). params: `page:` /
+  `per_page:` (max 200) / `category:` filter. Returns `{:ok, %{"data" => [entries],
+  "page" => n, "per_page" => n, "total" => n, "total_pages" => n,
+  "emails" => %{id => email}}}`.
+  """
+  def audit_logs_list(issuer, token, params \\ []) do
+    api_request(issuer, token, :get, "/api/v1/audit-logs", params: params)
+  end
 end

lib/bear_cli/audit_logs.ex

@@ -0,0 +1,103 @@
+defmodule BearCli.AuditLogs do
+  @moduledoc """
+  `bear audit-logs` 指令群（稽核日誌；docs/commands.md §3.10、issue #12）。
+
+  對應伺服器端稽核日誌 JSON API（alterminal/bear#46，`/api/v1/audit-logs`、
+  PAT Bearer、admin 限定）。認證沿用既有 PAT 憑證（`BEAR_TOKEN` 或憑證檔）。
+
+  退出碼：0 成功；2 用法錯誤；3 未登入或 401；6 網路／伺服器錯誤；
+  8 權限不足（403，僅限 admin）。
+  """
+
+  import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
+  alias BearCli.Api
+
+  # -- 入口 --
+
+  @doc """
+  執行 `bear audit-logs <動詞>`，回傳退出碼。`opts[:audit_logs_api]` 可注入
+  假 API 模組供測試（需實作 `audit_logs_list/3`）。
+  """
+  def run(:list, opts) do
+    api = opts[:audit_logs_api] || Api
+
+    with {:ok, ctx} <- context(opts) do
+      params =
+        [page: opts[:page] || 1, per_page: opts[:per_page] || 50]
+        |> maybe_put(:category, opts[:category])
+
+      case api.audit_logs_list(ctx.issuer, ctx.token, params) do
+        {:ok, body} ->
+          entries = body["data"] || []
+
+          if opts[:json] do
+            IO.puts(
+              Jason.encode!(
+                Map.take(body, ["page", "per_page", "total", "total_pages", "emails"])
+                |> Map.merge(%{ok: true, entries: entries})
+              )
+            )
+          else
+            print_table(entries, body["emails"] || %{})
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          {message, code} = format_api_error(ctx, error)
+          fail(opts, message, code)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp maybe_put(params, _key, nil), do: params
+  defp maybe_put(params, _key, ""), do: params
+  defp maybe_put(params, key, value), do: Keyword.put(params, key, value)
+
+  # -- 輸出 --
+
+  @table_headers ["TIME", "CATEGORY", "EVENT", "ACTOR", "ACCOUNT"]
+
+  defp print_table(entries, emails) do
+    rows =
+      Enum.map(entries, fn entry ->
+        [
+          entry["created_at"] || "",
+          entry["category"] || "",
+          entry["event"] || "",
+          email_of(emails, entry["actor_id"]),
+          email_of(emails, entry["account_id"])
+        ]
+      end)
+
+    widths =
+      Enum.with_index(@table_headers, fn _header, i ->
+        Enum.max([
+          String.length(Enum.at(@table_headers, i))
+          | Enum.map(rows, &String.length(Enum.at(&1, i)))
+        ])
+      end)
+
+    render_row = fn cells ->
+      cells
+      |> Enum.with_index()
+      |> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
+      |> Enum.join("  ")
+      |> String.trim_trailing()
+    end
+
+    IO.puts(render_row.(@table_headers))
+    Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
+  end
+
+  defp email_of(_emails, nil), do: "-"
+
+  defp email_of(emails, id) do
+    case Map.get(emails, id) do
+      nil -> String.slice(id || "", 0, 8)
+      email -> email
+    end
+  end
+end

lib/bear_cli/cli.ex

@@ -8,7 +8,7 @@ defmodule BearCli.CLI do
   優先使用該值，不讀寫本機憑證檔。
   """
 
-  alias BearCli.{Api, Apps, Config, Credentials, SelfService}
+  alias BearCli.{Accounts, Admin, Api, Apps, AuditLogs, Config, Credentials, Jwks, SelfService}
 
   @global_switches [
     issuer: :string,
@@ -319,6 +319,14 @@ defmodule BearCli.CLI do
     end
   end
 
+  # 管理端指令群（jwks/accounts/audit-logs；解析委由 BearCli.Admin）
+  defp parse_command(group, args, global) when group in ~w(jwks accounts audit-logs) do
+    case Admin.parse([group | args], global) do
+      :error -> {:error, "未知指令：#{group}（可用 bear --help 查看說明）", 2}
+      parsed -> parsed
+    end
+  end
+
   defp parse_command(unknown, _args, _global) do
     {:error, "未知指令：#{unknown}（可用 bear --help 查看說明）", 2}
   end
@@ -595,6 +603,19 @@ defmodule BearCli.CLI do
         ss_opts = Map.merge(inject_opts, Map.take(cmd_opts, [:ss_api, :io, :tty?]))
         SelfService.run(group, verb, Map.merge(cmd_opts, ss_opts))
 
+      # 管理端指令群（jwks/accounts/audit-logs；各自注入對應的 api 模組）
+      {:ok, {Jwks, verb}, cmd_opts} when is_atom(verb) ->
+        jwks_api = cmd_opts[:jwks_api] || opts[:jwks_api] || Api
+        Jwks.run(verb, Map.put(cmd_opts, :jwks_api, jwks_api))
+
+      {:ok, {Accounts, verb}, cmd_opts} when is_atom(verb) ->
+        accounts_api = cmd_opts[:accounts_api] || opts[:accounts_api] || Api
+        Accounts.run(verb, Map.put(cmd_opts, :accounts_api, accounts_api))
+
+      {:ok, {AuditLogs, verb}, cmd_opts} when is_atom(verb) ->
+        audit_logs_api = cmd_opts[:audit_logs_api] || opts[:audit_logs_api] || Api
+        AuditLogs.run(verb, Map.put(cmd_opts, :audit_logs_api, audit_logs_api))
+
       {:ok, command, cmd_opts} ->
         cond do
           cmd_opts[:version] ->
@@ -903,6 +924,9 @@ defmodule BearCli.CLI do
       logout                登出（清除本機憑證）
       status                顯示登入狀態
       apps <動詞>            App 管理（admin；bear apps --help 查看）
+      jwks <動詞>            簽章金鑰管理（admin）
+      accounts <動詞>        帳號管理（admin）
+      audit-logs list        稽核日誌（admin）
       profile <動詞>         個人資料（show／set）
       password change       變更密碼（互動輸入，不進 shell history）
       email change --new E  變更 email（雙向驗證碼流程）

lib/bear_cli/jwks.ex

@@ -0,0 +1,198 @@
+defmodule BearCli.Jwks do
+  @moduledoc """
+  `bear jwks` 指令群（簽章金鑰管理；docs/commands.md §3.8、issue #12）。
+
+  對應伺服器端 JWK 管理 JSON API（alterminal/bear#46，`/api/v1/jwks`、
+  PAT Bearer、admin 限定）。認證沿用既有 PAT 憑證（`BEAR_TOKEN` 或憑證檔）。
+
+  金鑰材質（`key_data`）永不經 CLI 顯示（API 端即不序列化）；本群組只管理
+  公開中繼資料（kid／kty／alg／active 等）。
+
+  退出碼：0 成功；1 404／422；2 用法錯誤；3 未登入或 401；6 網路／伺服器
+  錯誤；8 權限不足（403，僅限 admin）。
+  """
+
+  import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
+  alias BearCli.Api
+
+  # -- 入口 --
+
+  @doc """
+  執行 `bear jwks <動詞>`，回傳退出碼。`opts[:jwks_api]` 可注入假 API 模組
+  供測試（需實作 `jwks_list/2`、`jwks_create/3`、`jwks_get/3`、`jwks_toggle/3`）。
+  """
+  def run(verb, opts) do
+    api = opts[:jwks_api] || Api
+
+    with {:ok, ctx} <- context(opts) do
+      execute(verb, ctx, opts, api)
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- 各動詞 --
+
+  defp execute(:list, ctx, opts, api) do
+    case api.jwks_list(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        render_list(opts, body["data"] || [])
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:show, ctx, opts, api) do
+    with {:ok, key} <- resolve_key(ctx, opts[:kid_arg], api) do
+      case api.jwks_get(ctx.issuer, ctx.token, key["id"]) do
+        {:ok, body} ->
+          show_key(body["data"] || %{}, opts)
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:create, ctx, opts, api) do
+    attrs = %{"kid" => opts[:kid], "alg" => opts[:alg] || "RS256"}
+
+    case api.jwks_create(ctx.issuer, ctx.token, attrs) do
+      {:ok, body} ->
+        key = body["data"] || %{}
+
+        if opts[:json] do
+          IO.puts(Jason.encode!(%{ok: true, jwk: key}))
+        else
+          IO.puts("JWK 已建立：#{key["kid"]}（#{key["alg"]}／#{status_label(key)}）")
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:toggle, ctx, opts, api) do
+    with {:ok, key} <- resolve_key(ctx, opts[:kid_arg], api) do
+      case api.jwks_toggle(ctx.issuer, ctx.token, key["id"]) do
+        {:ok, body} ->
+          updated = body["data"] || %{}
+
+          if opts[:json] do
+            IO.puts(
+              Jason.encode!(%{
+                ok: true,
+                jwk: %{id: updated["id"], kid: updated["kid"], active: updated["active"]}
+              })
+            )
+          else
+            IO.puts("#{key["kid"]}：#{status_label(key)} → #{status_label(updated)}")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- kid → UUID 解析（API 路徑參數為 UUID，CLI 對外介面用 kid）--
+
+  defp resolve_key(_ctx, nil, _api), do: {:error, "缺少 <kid> 參數", 2}
+
+  defp resolve_key(ctx, kid, api) do
+    case api.jwks_list(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        case Enum.find(body["data"] || [], &(&1["kid"] == kid)) do
+          nil -> {:error, "找不到 kid 為 #{kid} 的金鑰", 1}
+          key -> {:ok, key}
+        end
+
+      {:error, _kind, _detail} = error ->
+        {message, code} = format_api_error(ctx, error)
+        {:error, message, code}
+    end
+  end
+
+  # -- 輸出 --
+
+  defp render_list(opts, keys) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: true, jwks: keys}))
+    else
+      print_table(keys)
+    end
+  end
+
+  @table_headers ["ID", "KID", "KTY", "ALG", "ACTIVE", "CREATED AT"]
+
+  defp print_table(keys) do
+    rows =
+      Enum.map(keys, fn key ->
+        [
+          String.slice(key["id"] || "", 0, 8),
+          key["kid"] || "",
+          key["kty"] || "",
+          key["alg"] || "",
+          status_label(key),
+          key["created_at"] || ""
+        ]
+      end)
+
+    widths =
+      Enum.with_index(@table_headers, fn _header, i ->
+        Enum.max([
+          String.length(Enum.at(@table_headers, i))
+          | Enum.map(rows, &String.length(Enum.at(&1, i)))
+        ])
+      end)
+
+    render_row = fn cells ->
+      cells
+      |> Enum.with_index()
+      |> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
+      |> Enum.join("  ")
+      |> String.trim_trailing()
+    end
+
+    IO.puts(render_row.(@table_headers))
+    Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
+  end
+
+  @key_fields ~w(id kid kty alg use active created_at)
+
+  defp show_key(key, opts) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: true, jwk: key}))
+    else
+      Enum.each(@key_fields, fn field ->
+        IO.puts("#{String.pad_trailing(field, 14)}: #{format_key_value(key[field])}")
+      end)
+    end
+  end
+
+  defp format_key_value(nil), do: "(無)"
+  defp format_key_value(value) when is_binary(value), do: value
+  defp format_key_value(value), do: Jason.encode!(value)
+
+  defp status_label(%{"active" => true}), do: "active"
+  defp status_label(%{"active" => false}), do: "inactive"
+  defp status_label(_), do: "(未知)"
+
+  # -- 錯誤處理 --
+
+  defp fail_api(opts, ctx, error) do
+    {message, code} = format_api_error(ctx, error)
+    fail(opts, message, code)
+  end
+end

test/bear_cli/admin_commands_test.exs

@@ -0,0 +1,526 @@
+defmodule BearCli.AdminCommandsTest do
+  @moduledoc """
+  `bear jwks`/`bear accounts`/`bear audit-logs` 管理端指令群單元測試（issue #12）：
+  注入 fake API，涵蓋解析、輸出、退出碼與 401/403/404/422 分流。
+  """
+  use ExUnit.Case, async: false
+
+  alias BearCli.{Accounts, AuditLogs, CLI, Jwks}
+
+  # -- fake API --
+
+  defmodule FakeApi do
+    @jwks [
+      %{
+        "id" => "0192cccc-0000-7000-8000-000000000001",
+        "kid" => "sig-2026-01",
+        "kty" => "RSA",
+        "alg" => "RS256",
+        "use" => "sig",
+        "active" => true,
+        "created_at" => "2026-09-09T00:00:00Z"
+      },
+      %{
+        "id" => "0192cccc-0000-7000-8000-000000000002",
+        "kid" => "sig-2025-12",
+        "kty" => "EC",
+        "alg" => "ES256",
+        "use" => "sig",
+        "active" => false,
+        "created_at" => "2025-12-01T00:00:00Z"
+      }
+    ]
+
+    @accounts [
+      %{
+        "id" => "0192bbbb-0000-7000-8000-000000000001",
+        "email" => "admin@example.com",
+        "role" => "admin",
+        "totp_enabled" => true,
+        "created_at" => "2026-01-01T00:00:00Z",
+        "updated_at" => "2026-01-01T00:00:00Z"
+      },
+      %{
+        "id" => "0192bbbb-0000-7000-8000-000000000002",
+        "email" => "alice@example.com",
+        "role" => "user",
+        "totp_enabled" => false,
+        "created_at" => "2026-02-01T00:00:00Z",
+        "updated_at" => "2026-02-01T00:00:00Z"
+      }
+    ]
+
+    @audit_entries [
+      %{
+        "id" => "0192dddd-0000-7000-8000-000000000001",
+        "event" => "account_created_by_admin",
+        "category" => "account",
+        "account_id" => "0192bbbb-0000-7000-8000-000000000002",
+        "actor_id" => "0192bbbb-0000-7000-8000-000000000001",
+        "ip" => "127.0.0.1",
+        "metadata" => %{"via" => "api"},
+        "created_at" => "2026-09-09T01:00:00Z"
+      }
+    ]
+
+    @emails %{
+      "0192bbbb-0000-7000-8000-000000000001" => "admin@example.com",
+      "0192bbbb-0000-7000-8000-000000000002" => "alice@example.com"
+    }
+
+    def jwks_list(_issuer, _token), do: ok_or_error(%{"data" => @jwks})
+
+    def jwks_create(_issuer, _token, attrs) do
+      key = %{
+        "id" => "0192cccc-0000-7000-8000-000000000003",
+        "kid" => attrs["kid"],
+        "kty" => "RSA",
+        "alg" => attrs["alg"],
+        "use" => "sig",
+        "active" => true,
+        "created_at" => "2026-09-09T02:00:00Z"
+      }
+
+      ok_or_error(%{"data" => key})
+    end
+
+    def jwks_get(_issuer, _token, id) do
+      case Enum.find(@jwks, &(&1["id"] == id)) do
+        nil -> {:error, :not_found, "not_found"}
+        key -> ok_or_error(%{"data" => key})
+      end
+    end
+
+    def jwks_toggle(_issuer, _token, id) do
+      case Enum.find(@jwks, &(&1["id"] == id)) do
+        nil ->
+          {:error, :not_found, "not_found"}
+
+        key ->
+          new_active = !key["active"]
+          ok_or_error(%{"data" => %{key | "active" => new_active}})
+      end
+    end
+
+    def accounts_list(_issuer, _token, params) do
+      page = params[:page] || 1
+      per_page = params[:per_page] || 20
+
+      ok_or_error(%{
+        "data" => Enum.slice(@accounts, (page - 1) * per_page, per_page),
+        "page" => page,
+        "per_page" => per_page,
+        "total" => length(@accounts)
+      })
+    end
+
+    def accounts_create(_issuer, _token, attrs) do
+      account = %{
+        "id" => "0192bbbb-0000-7000-8000-000000000003",
+        "email" => attrs["email"],
+        "role" => attrs["role"] || "user",
+        "totp_enabled" => false,
+        "created_at" => "2026-09-09T00:00:00Z",
+        "updated_at" => "2026-09-09T00:00:00Z"
+      }
+
+      ok_or_error(%{"data" => account})
+    end
+
+    def accounts_get(_issuer, _token, id) do
+      case Enum.find(@accounts, &(&1["id"] == id)) do
+        nil -> {:error, :not_found, "not_found"}
+        account -> ok_or_error(%{"data" => account})
+      end
+    end
+
+    def accounts_update_role(_issuer, _token, id, attrs) do
+      case Enum.find(@accounts, &(&1["id"] == id)) do
+        nil ->
+          {:error, :not_found, "not_found"}
+
+        account ->
+          ok_or_error(%{"data" => %{account | "role" => attrs["role"]}})
+      end
+    end
+
+    def accounts_set_password(_issuer, _token, id, _attrs) do
+      case Enum.find(@accounts, &(&1["id"] == id)) do
+        nil -> {:error, :not_found, "not_found"}
+        _account -> ok_or_error(%{})
+      end
+    end
+
+    def accounts_delete(_issuer, _token, id) do
+      case Enum.find(@accounts, &(&1["id"] == id)) do
+        nil -> {:error, :not_found, "not_found"}
+        _account -> ok_or_error(%{})
+      end
+    end
+
+    def audit_logs_list(_issuer, _token, params) do
+      category = params[:category]
+
+      entries =
+        if category,
+          do: Enum.filter(@audit_entries, &(&1["category"] == category)),
+          else: @audit_entries
+
+      ok_or_error(%{
+        "data" => entries,
+        "page" => params[:page] || 1,
+        "per_page" => params[:per_page] || 50,
+        "total" => length(entries),
+        "total_pages" => 1,
+        "emails" => @emails
+      })
+    end
+
+    defp ok_or_error(body) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        {:ok, body}
+      end
+    end
+  end
+
+  # -- 測試輔助 --
+
+  setup do
+    old_token = System.get_env("BEAR_TOKEN")
+    old_creds = System.get_env("BEAR_CREDENTIALS")
+
+    on_exit(fn ->
+      restore(old_token, "BEAR_TOKEN")
+      restore(old_creds, "BEAR_CREDENTIALS")
+    end)
+
+    System.put_env("BEAR_TOKEN", "admin-pat")
+    System.put_env("BEAR_CREDENTIALS", "/nonexistent/credentials.json")
+    :ok
+  end
+
+  defp run_out(argv) do
+    ExUnit.CaptureIO.with_io(fn ->
+      CLI.dispatch(CLI.parse(argv), admin_apis())
+    end)
+  end
+
+  defp run_err(argv) do
+    ExUnit.CaptureIO.with_io(:stderr, "", fn ->
+      CLI.dispatch(CLI.parse(argv), admin_apis())
+    end)
+  end
+
+  defp admin_apis do
+    [jwks_api: FakeApi, accounts_api: FakeApi, audit_logs_api: FakeApi]
+  end
+
+  defp with_api_error(error) do
+    Process.put(:fake_api_error, error)
+  end
+
+  # -- jwks --
+
+  test "jwks list renders table" do
+    {code, out} = run_out(["jwks", "list"])
+    assert code == 0
+    assert out =~ "KID"
+    assert out =~ "sig-2026-01"
+    assert out =~ "sig-2025-12"
+    assert out =~ "active"
+    assert out =~ "inactive"
+  end
+
+  test "jwks list --json outputs spec shape" do
+    {code, out} = run_out(["jwks", "list", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert Enum.any?(decoded["jwks"], &(&1["kid"] == "sig-2026-01"))
+    # key_data 永不出現
+    refute out =~ "key_data"
+  end
+
+  test "jwks show resolves kid and prints public metadata" do
+    {code, out} = run_out(["jwks", "show", "sig-2026-01"])
+    assert code == 0
+    assert out =~ "kid"
+    assert out =~ "sig-2026-01"
+    assert out =~ "RS256"
+    refute out =~ "key_data"
+  end
+
+  test "jwks show unknown kid exits 1" do
+    {code, err} = run_err(["jwks", "show", "no-such-key"])
+    assert code == 1
+    assert err =~ "找不到"
+  end
+
+  test "jwks create sends kid/alg and prints summary" do
+    {code, out} = run_out(["jwks", "create", "--kid", "sig-2026-09", "--alg", "ES256"])
+    assert code == 0
+    assert out =~ "JWK 已建立：sig-2026-09"
+    assert out =~ "ES256"
+  end
+
+  test "jwks create without --kid exits 2" do
+    {code, err} = run_err(["jwks", "create"])
+    assert code == 2
+    assert err =~ "--kid"
+  end
+
+  test "jwks create invalid alg exits 2" do
+    {code, err} = run_err(["jwks", "create", "--kid", "k", "--alg", "HS256"])
+    assert code == 2
+    assert err =~ "--alg"
+  end
+
+  test "jwks toggle prints transition" do
+    {code, out} = run_out(["jwks", "toggle", "sig-2026-01"])
+    assert code == 0
+    assert out =~ "sig-2026-01：active → inactive"
+  end
+
+  test "jwks toggle --json returns new state" do
+    {code, out} = run_out(["jwks", "toggle", "sig-2026-01", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["jwk"]["kid"] == "sig-2026-01"
+    assert decoded["jwk"]["active"] == false
+  end
+
+  test "jwks list 403 exits 8 with admin hint" do
+    with_api_error({:error, :forbidden, "Admin role required."})
+    {code, err} = run_err(["jwks", "list"])
+    assert code == 8
+    assert err =~ "admin"
+  end
+
+  test "jwks list 401 exits 3" do
+    with_api_error({:error, :unauthorized, "invalid_token"})
+    {code, err} = run_err(["jwks", "list"])
+    assert code == 3
+    assert err =~ "bear login"
+  end
+
+  test "jwks unknown verb exits 2" do
+    {code, err} = run_err(["jwks", "rotate"])
+    assert code == 2
+    assert err =~ "未知的 jwks 子指令"
+  end
+
+  # -- accounts --
+
+  test "accounts list renders table" do
+    {code, out} = run_out(["accounts", "list"])
+    assert code == 0
+    assert out =~ "EMAIL"
+    assert out =~ "admin@example.com"
+    assert out =~ "alice@example.com"
+  end
+
+  test "accounts list --json outputs spec shape" do
+    {code, out} = run_out(["accounts", "list", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["page"] == 1
+    assert decoded["total"] == 2
+    assert Enum.any?(decoded["accounts"], &(&1["email"] == "alice@example.com"))
+  end
+
+  test "accounts list pagination params pass through" do
+    {code, out} = run_out(["accounts", "list", "--per-page", "1", "--page", "2"])
+    assert code == 0
+    assert out =~ "alice@example.com"
+    refute out =~ "admin@example.com"
+  end
+
+  test "accounts show resolves email and prints fields" do
+    {code, out} = run_out(["accounts", "show", "alice@example.com"])
+    assert code == 0
+    assert out =~ "email"
+    assert out =~ "alice@example.com"
+    refute out =~ "hash_password"
+    refute out =~ "totp_secret"
+  end
+
+  test "accounts show unknown email exits 1" do
+    {code, err} = run_err(["accounts", "show", "nobody@example.com"])
+    assert code == 1
+    assert err =~ "找不到"
+  end
+
+  test "accounts create --generate-password sends plaintext once" do
+    {code, out} =
+      run_out([
+        "accounts",
+        "create",
+        "--email",
+        "new@example.com",
+        "--generate-password",
+        "--role",
+        "admin"
+      ])
+
+    assert code == 0
+    assert out =~ "帳號已建立：new@example.com"
+    assert out =~ "初始密碼（只顯示這一次"
+  end
+
+  test "accounts create without email exits 2" do
+    {code, err} = run_err(["accounts", "create", "--generate-password"])
+    assert code == 2
+    assert err =~ "--email"
+  end
+
+  test "accounts create invalid role exits 2" do
+    {code, err} =
+      run_err([
+        "accounts",
+        "create",
+        "--email",
+        "x@example.com",
+        "--role",
+        "root",
+        "--generate-password"
+      ])
+
+    assert code == 2
+    assert err =~ "--role"
+  end
+
+  test "accounts update requires --role" do
+    {code, err} = run_err(["accounts", "update", "alice@example.com"])
+    assert code == 2
+    assert err =~ "--role"
+  end
+
+  test "accounts update sends role and prints transition" do
+    {code, out} = run_out(["accounts", "update", "alice@example.com", "--role", "admin"])
+    assert code == 0
+    assert out =~ "alice@example.com：角色 → admin"
+  end
+
+  test "accounts set-password non-tty without generate exits 2" do
+    {code, err} = run_err(["accounts", "set-password", "alice@example.com"])
+    assert code == 2
+    assert err =~ "--generate-password"
+  end
+
+  test "accounts set-password --generate-password prints one-time password" do
+    {code, out} =
+      run_out(["accounts", "set-password", "alice@example.com", "--generate-password"])
+
+    assert code == 0
+    assert out =~ "只顯示這一次"
+  end
+
+  test "accounts delete prints confirmation" do
+    {code, out} = run_out(["accounts", "delete", "alice@example.com"])
+    assert code == 0
+    assert out =~ "已刪除帳號：alice@example.com"
+  end
+
+  test "accounts delete 403 self-delete exits 8" do
+    with_api_error({:error, :forbidden, "cannot delete yourself"})
+    {code, err} = run_err(["accounts", "delete", "admin@example.com"])
+    assert code == 8
+    assert err =~ "admin"
+  end
+
+  test "accounts list 403 exits 8" do
+    with_api_error({:error, :forbidden, "Admin role required."})
+    {code, _err} = run_err(["accounts", "list"])
+    assert code == 8
+  end
+
+  # -- audit-logs --
+
+  test "audit-logs list renders table with emails" do
+    {code, out} = run_out(["audit-logs", "list"])
+    assert code == 0
+    assert out =~ "EVENT"
+    assert out =~ "account_created_by_admin"
+    assert out =~ "admin@example.com"
+    assert out =~ "alice@example.com"
+  end
+
+  test "audit-logs list --json outputs spec shape" do
+    {code, out} = run_out(["audit-logs", "list", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["total"] == 1
+    assert decoded["total_pages"] == 1
+    assert decoded["emails"]["0192bbbb-0000-7000-8000-000000000002"] == "alice@example.com"
+    assert Enum.any?(decoded["entries"], &(&1["event"] == "account_created_by_admin"))
+  end
+
+  test "audit-logs list --category filters server-side" do
+    {code, out} = run_out(["audit-logs", "list", "--category", "account"])
+    assert code == 0
+    assert out =~ "account_created_by_admin"
+  end
+
+  test "audit-logs list --category jwk filters to empty" do
+    {code, out} = run_out(["audit-logs", "list", "--category", "jwk"])
+    assert code == 0
+    refute out =~ "account_created_by_admin"
+  end
+
+  test "audit-logs list 403 exits 8" do
+    with_api_error({:error, :forbidden, "Admin role required."})
+    {code, err} = run_err(["audit-logs", "list"])
+    assert code == 8
+    assert err =~ "admin"
+  end
+
+  test "audit-logs list network error exits 6" do
+    with_api_error({:error, :network, "econnrefused"})
+    {code, err} = run_err(["audit-logs", "list"])
+    assert code == 6
+    assert err =~ "econnrefused"
+  end
+
+  # -- 解析 --
+
+  test "parse returns group module and verb" do
+    assert {:ok, {Jwks, :list}, opts} = CLI.parse(["jwks", "list", "--json"])
+    assert opts[:json] == true
+
+    assert {:ok, {Accounts, :create}, opts2} =
+             CLI.parse(["accounts", "create", "--email", "x@example.com", "--generate-password"])
+
+    assert opts2[:email] == "x@example.com"
+    assert opts2[:generate_password] == true
+
+    assert {:ok, {AuditLogs, :list}, opts3} = CLI.parse(["audit-logs", "list", "--page", "2"])
+    assert opts3[:page] == 2
+  end
+
+  test "unknown group verb reports in group error" do
+    assert {:error, msg, 2} = CLI.parse(["accounts", "purge"])
+    assert msg =~ "未知的 accounts 子指令"
+  end
+
+  test "accounts update keeps positional email" do
+    assert {:ok, {Accounts, :update}, opts} =
+             CLI.parse(["accounts", "update", "a@example.com", "--role", "admin"])
+
+    assert opts[:email_arg] == "a@example.com"
+    assert opts[:role] == "admin"
+  end
+
+  # -- 輔助 --
+
+  defp restore(nil, key), do: System.delete_env(key)
+  defp restore(value, key), do: System.put_env(key, value)
+end