@whyshu/argent-engine 0.0.0-stage → 0.6.1

package/engine/scripts/install-license.mjs

@@ -0,0 +1,641 @@
+#!/usr/bin/env node
+/**
+ * install-license —— 把签名许可文件**安全安装**到客户机（2026-09-30）
+ *
+ * 装机三步曲的第 ③ 步：服务端 `issue-license-file.mjs` 签发 → 传到客户机 → 本脚本安装。
+ * 安全要求（都是"装机时最容易做错"的地方）：
+ *   · **先验签再落盘**：验不过绝不写（否则客户机上多一份"看起来有授权"的坏文件）；
+ *   · 落盘 **0600**、临时文件 + rename（写一半断电不会留下半份许可）；
+ *   · 覆盖前**备份**旧文件（*.bak-<时间戳>），便于回滚到上一份许可；
+ *   · 密钥文件（`--secret-file`）同样 0600 + 备份，且**从不回显密钥值**。
+ *
+ * 用法：
+ *   node scripts/install-license.mjs --file <许可文件> [--secret-file <密钥文件>] [--json] [--dry-run]
+ *   node scripts/install-license.mjs --file <许可文件> --sign-v2 [--device-code <64hex>|--device-from-local|--no-device]
+ *        [--secret-file <密钥文件>] [--json] [--dry-run]        # 本地**重签**成 v2（把 device 纳入签名）
+ *   node scripts/install-license.mjs --file <许可文件> --instance-token-file <实例令牌文件> [--json] [--dry-run]
+ *        # ↑ **机器自带凭证**（2026-10-05）：与许可同一条离线下发链路一并安装
+ * 目标路径：`$ARGENT_DATA_DIR/license.json`（未设则 `~/.dsh/argent/license.json`）；
+ *           密钥 `$ARGENT_DATA_DIR/license.secret`；实例令牌 `$ARGENT_DATA_DIR/instance-token.json`。
+ * 退出码：0 已安装（含宽限；**含"与现役一致、什么都没做"**）｜ 1 验签失败/已超期/设备码不匹配或自助重绑用尽/
+ *        **现役倒退被拒**（`regression_refused`）（三者都**未写入**）｜ 2 用法或读取错误
+ *
+ * `--json` 回显形状（**2026-10-04 起恒定**）：任何退出路径里 `device` 与 `rebind` 两个键**都存在** ——
+ * `device` = `deviceEcho()` 的稳定对象或 `null`（`null` = 设备这一层没到，如用法错）；
+ * `rebind` = `rebindEcho()` 的稳定对象 `{consumed,count,rebindsLeft,store,canRebind,note}`（guard 拒绝）
+ * 或 `null`（用法/读取错）。**动机**：`regression_refused` 曾经既没有 `device` 也没有 `rebind` ⇒
+ * 消费者按成功路径读 `.rebind.consumed` 当场 `TypeError`，把一次**可读的拒绝**变成调用方崩溃
+ * （2026-10-04 定位的间歇失败正是这么暴露的）。补占位**不改**拒绝语义、退出码与既有字段含义。
+ *
+ * 设备绑定（§3.6① 第 3 步，2026-10-03）：载荷里**可选**的 `device` 声明存在时**先比对**本机设备码 ——
+ * 不一致 ⇒ **不落盘**（原许可一个字节都不动）+ exit 1 + `reason:device_mismatch`；
+ * 自助重绑用 `--rebind`（最多 3 次，第 4 次起 `rebind_exhausted` + 人工指引），计数落
+ * `$ARGENT_DATA_DIR/license-rebind.json`。
+ *   · `device.signed`：v1 ⇒ **false**（该字段**未进签名**，是"服务端声明 + 客户端比对"）；
+ *     v2（`--sign-v2` 或服务端升 v2 后签发）⇒ **true**（内容/缺位都被签名覆盖）。
+ *
+ * 重绑（`--rebind`）与**现役许可比对**（2026-10-04，装机/续期侧的两条守卫）：
+ *   · `--rebind`：设备码不匹配但还有自助次数 ⇒ 消耗 1 次并放行（计数落 `$ARGENT_DATA_DIR/license-rebind.json`）；
+ *   · **比对现役**（`$ARGENT_DATA_DIR/license.json`，唯一判据：它自己也能验签过）：
+ *     ⓐ **幂等**：与现役**载荷+签名逐字节相同** ⇒ `unchanged:true`，**不备份、不重写**（续期重放不再产生 churn）；
+ *     ⓑ **拒绝倒退**（`regression_refused`，exit 1，**不落盘**）：更早到期（`stale`）或能力/业务线/席位被收窄（`narrowed`）
+ *       —— 一次手滑就能把客户有效期改短 / 静默收回能力，所以默认拒绝；确实要装（如纠错、吊销）⇒ 显式 `--allow-regression`；
+ *     ⓒ **设备不一致**（续期被换绑）只**如实标注**（`renewal.deviceChanged`），不在这一层拒绝：
+ *       设备这一侧的拒绝由 ② 的比对负责（不匹配 ⇒ 不落盘），两处判据不重复。
+ *
+ * 重签（`--sign-v2` / `--sign-version <1|2>`，2026-10-03）：把**已验签**的原件按 v2 载荷重签一份
+ * （`device` = `--device-code`，缺省取本机设备码）。三条纪律：
+ *   ① **只签不改**：capabilities/verticals/seats/issuedAt/expiresAt/graceDays 逐字继承验签过的原件
+ *      ⇒ 重签**不扩权**（且原件必须**先验签通过**，否则拒绝——不给人"拿垃圾换成有效许可"的入口）；
+ *   ② **密钥必须显式**：只认 `--secret-file` 或 `ARGENT_LICENSE_SECRET`，**不**自动用本机已装的
+ *      `license.secret`（那会让"拿生产密钥自签"变成一次无意识的默认动作）；
+ *   ③ `--sign-version 1` 是**回滚**用（重签回 v1 ⇒ 产物里**没有** `device`：v1 根本签不了它）。
+ * ⚠️ 签名是 HMAC-SHA256（对称密钥）⇒ 能读密钥的人**总能自签**；重签工具只保证"口径与契约一致"，
+ *    不构成安全边界（要防伪造得换非对称签名，见 §3.6③）。
+ *
+ * ## 实例令牌（`--instance-token-file`，2026-10-05「机器自带凭证」）
+ * 客户机是"一直开着、没人登录"的 ⇒ 账号 JWT（**30 天**）到期即 401，服务端一轮换密钥就全灭
+ * （2026-09-14 实况）。实例令牌是**离线签名**的长期凭证（默认 365 天），由服务端
+ * `whyshu-svr/scripts/issue-instance-token.mjs` 签发，本脚本与许可**一并**装到
+ * `$ARGENT_DATA_DIR/instance-token.json`（0600，只 `token` 一个键是权威）。
+ * **先判后写**（三条，全在写盘之前）：① 形态（`it1.` 三段 + `typ=instance-token`）；
+ * ② 归属（令牌 `userId` == 本次许可 `userId`）；③ 绑定（两边都有设备码时必须一致）；
+ * ④ 期限（已过期 ⇒ 拒装）。契约与续期/吊销见 `whyshu-svr/docs/ops/instance-token.md`。
+ */
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import {
+  dataDir, defaultLicensePath, defaultSecretPath, loadLicenseFile, signaturePayloadOf, signLicenseFile, verifyLicenseFile,
+} from '../core/lib/license-file.mjs'
+import { MAX_REBINDS, bindingOf, currentDevice, deviceClaimOf, readRebindStore, rebindStorePath, recordRebind } from '../core/lib/license-device.mjs'
+
+const argOf = (name, dflt = null) => {
+  const i = process.argv.indexOf(name)
+  return i > -1 ? process.argv[i + 1] ?? dflt : dflt
+}
+const has = (name) => process.argv.includes(name)
+const stamp = () => new Date().toISOString().replace(/[:.]/g, '-')
+
+/**
+ * `rebind` 回显的**稳定形状**（2026-10-04 补；起因是一次间歇失败暴露的接口缺陷）。
+ * 键集合恒定 `{consumed, count, rebindsLeft, store, canRebind, note}`，其中 `consumed` **恒为布尔**。
+ * 为什么必须恒定：消费者（宿主 UI / `license` verb / 测试）按**成功路径**读 `.rebind.consumed`
+ * 是最自然的写法；若某条拒绝路径压根没有这个键，一次**可读的拒绝**就表现成调用方 TypeError
+ * ——`TypeError: Cannot read properties of undefined (reading 'consumed')`（2026-10-04 定位的
+ * 间歇失败正是这么暴露的：`regression_refused` 的 JSON 里没有 `rebind`）。
+ * 语义（三条路径一致，不因路径不同而变）：
+ *   · `consumed`   = 本次是否**真的**消耗了一次自助重绑（拒绝路径恒 false：拒绝 ⇒ 未落盘 ⇒ 未计数）；
+ *   · `count`      = 计数文件里的**当前**值（拒绝路径 = 未变；`null` = 还没读到计数）；
+ *   · `rebindsLeft`= 自助重绑还剩几次（`null` = 这一层没到）；
+ *   · `store`      = 计数文件路径（`null` = 还没读到计数）；
+ *   · `canRebind`  = `--rebind` 这条路还走不走得通（= 还有剩余次数；与"本次拒绝的原因"无关，
+ *                    拒绝原因在 `reason`，补救动作写在 `note`/`next`）；
+ *   · `note`       = 人话（点名补救动作）。
+ * ⛔ 纪律：只是**补占位/统一形状** —— 不改拒绝语义、不改退出码、不改任何既有字段的含义。
+ */
+const rebindEcho = ({ consumed = false, count = null, rebindsLeft = null, store = null, canRebind = false, note = '' } = {}) => ({
+  consumed: consumed === true, count, rebindsLeft, store, canRebind, note,
+})
+
+/**
+ * 失败出口：**A2 形状**（`--json` 时 stdout 只有一份 JSON；人话走 stderr）。
+ * `reason` 是机器可判短码（`core/contracts/argent.contracts.json#reasonCodes`），**不要**靠 grep 中文。
+ * **形状恒定（2026-10-04）**：任何退出路径里 `rebind` 与 `device` 两个键**都存在**，调用方不必猜
+ * 字段是否存在 —— `device` 是对象或 `null`（`null` = 设备这一层根本没到，如用法错）；
+ * `rebind` 是 `rebindEcho()` 的稳定对象（guard 拒绝，exit 1）或 `null`（用法/读取错，exit 2）。
+ * 具体路径给得出更全的回显时（如设备比对拒绝）由调用方在 `extra` 里显式覆盖，**默认只是兜底**。
+ */
+const fail = (reason, message, code = 2, extra = {}) => {
+  if (has('--json')) {
+    const body = { ok: false, empty: false, code, reason, error: message, dryRun: has('--dry-run'), ...extra }
+    // 兜底占位：guard 拒绝（exit 1）= 调用方很可能就是要读 `.rebind.consumed` 的那条路 ⇒ 给完整形状；
+    // 用法错（exit 2）= `null`（"没做这件事"，与"做了但结果为空"一眼分得开，同 `resign` 的口径）。
+    if (!('rebind' in body)) body.rebind = code === 1 ? rebindEcho({ note: `未消耗自助重绑次数（在「${reason}」这一步被拒，未落盘）` }) : null
+    if (!('device' in body)) body.device = null
+    console.log(JSON.stringify(body, null, 2))
+  }
+  console.error(`✗ ${message}`)
+  process.exit(code)
+}
+const die = (m, code = 2) => fail(code === 1 ? 'guard_rejected' : 'usage_error', m, code)
+
+if (has('--help') || has('-h')) {
+  console.log('用法：node scripts/install-license.mjs --file <许可文件> [--secret-file <密钥文件>] [--instance-token-file <实例令牌文件>] [--rebind] [--allow-regression] [--json] [--dry-run]')
+  console.log('      node scripts/install-license.mjs --file <许可文件> --sign-v2 [--device-code <64hex>|--device-from-local|--no-device] [--secret-file <密钥文件>] [--json] [--dry-run]')
+  console.log('  --instance-token-file：可选；与许可**同一条链路**安装"机器自带凭证"（默认 365 天，不再依赖 30 天账号令牌）')
+  console.log('  --allow-regression：显式放行"比现役更早到期 / 能力席位被收窄"的安装（默认拒绝：regression_refused）')
+  process.exit(0)
+}
+
+const dryRun = has('--dry-run')
+const rebindRequested = has('--rebind')
+const allowRegression = has('--allow-regression')
+
+// ── 实例令牌（**机器自带凭证**，2026-10-05）：与许可走**同一条离线下发链路** ─────────
+// 为什么要一起装：交付一台机器时要交付"它能自己活下去"的凭证。账号 JWT 只有 30 天、服务端
+// 一轮换就全灭（2026-09-14 实况）⇒ 遥测会静默转 401 长退避。实例令牌是离线签名的长期凭证，
+// 客户机原样回传、服务端本地验签（契约：whyshu-svr/docs/ops/instance-token.md）。
+// 三条纪律：
+//   ① **先判后写**：令牌里的 `userId`/`deviceCode` 必须与**本次安装的许可**一致 —— 装错一份令牌
+//      不会立刻报错，只会让那台机器的上报长期 401/403（静默故障），所以在**装机这一刻**就拦；
+//   ② **结构化单键**：文件里只有 `token` 一个键是**权威**（其余键仅便于人工核对，不参与鉴权）；
+//   ③ **不装不算失败**：没给 `--instance-token-file` ⇒ 只回显 `installed:false`，绝不改许可那一步的结论。
+const INSTANCE_TOKEN_FILENAME = 'instance-token.json'
+const INSTANCE_TOKEN_PREFIX = 'it1.'
+const instanceTokenSrc = argOf('--instance-token-file') ? resolve(argOf('--instance-token-file')) : null
+
+/** 解析令牌文件：JSON 信封（`{token}`）或裸紧凑串都接受。返回 `{token, payload, raw, error}`。 */
+function parseInstanceToken(rawText) {
+  const raw = String(rawText || '').trim()
+  if (!raw) return { token: '', payload: null, raw, error: 'empty' }
+  let token = raw
+  if (raw.startsWith('{')) {
+    try {
+      const doc = JSON.parse(raw)
+      token = String((doc || {}).token || '').trim()
+    } catch {
+      return { token: '', payload: null, raw, error: 'unparsable-json' }
+    }
+  }
+  if (!token) return { token: '', payload: null, raw, error: 'missing-token-key' }
+  if (!token.startsWith(INSTANCE_TOKEN_PREFIX)) {
+    return { token, payload: null, raw, error: 'bad_prefix' }
+  }
+  const parts = token.split('.')
+  if (parts.length !== 3) return { token, payload: null, raw, error: 'malformed' }
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'))
+    if (!payload || typeof payload !== 'object') return { token, payload: null, raw, error: 'malformed' }
+    // 客户端**不验签**（没有签名密钥，那是服务端的事）；只做形状自检 + 装机期的绑定核对
+    if (payload.typ !== 'instance-token') return { token, payload, raw, error: 'bad_type' }
+    return { token, payload, raw, error: '' }
+  } catch {
+    return { token, payload: null, raw, error: 'malformed' }
+  }
+}
+const signV2 = has('--sign-v2')
+const signVersionArg = argOf('--sign-version')
+const deviceCodeArg = argOf('--device-code')
+const deviceFromLocal = has('--device-from-local')
+const noDevice = has('--no-device')
+// 重签版本：`--sign-v2` = `--sign-version 2`（同一件事的两个写法；都不给 ⇒ 不重签）
+const signVersion = signV2 ? 2 : (signVersionArg === null ? null : Number(signVersionArg))
+if (signVersion !== null && ![1, 2].includes(signVersion)) {
+  die(`--sign-version 只认 1 或 2（本客户端支持的签名版本：v1 9 项 / v2 9 项 + device）：${signVersionArg}`, 2)
+}
+if (signVersion === null && (deviceCodeArg || deviceFromLocal || noDevice)) {
+  die('`--device-code` / `--device-from-local` / `--no-device` 只在重签时才有意义 ⇒ 请与 `--sign-v2`（或 `--sign-version 2`）一起用', 2)
+}
+
+const src = argOf('--file')
+if (!src) die('必须给 --file <许可文件>（用法见 --help）')
+const srcPath = resolve(src)
+if (!existsSync(srcPath)) die(`许可文件不存在：${srcPath}`, 2)
+let file = null
+try { file = JSON.parse(readFileSync(srcPath, 'utf-8')) } catch (e) { die(`许可文件解析失败：${e.message}`, 2) }
+
+// ── 密钥：显式 --secret-file 优先（随后会被安装到本机密钥位）──────────
+const secretSrc = argOf('--secret-file') ? resolve(argOf('--secret-file')) : null
+if (secretSrc && !existsSync(secretSrc)) die(`密钥文件不存在：${secretSrc}`, 2)
+// 兼容两种交付形态：① 纯密钥文本（本客户端 license.secret 的形态）；② 从服务端 .env 直接拷来的一行
+// `LICENSE_SIGNING_SECRET=xxxx`。hex 里不带 `=`，所以按 `键=值` 解析不会误伤纯文本。
+const secretRaw = secretSrc ? readFileSync(secretSrc, 'utf-8') : ''
+const secretText = (secretRaw.match(/^[ \t]*(?:export[ \t]+)?[A-Za-z_][A-Za-z0-9_]*[ \t]*=[ \t]*(.+)$/m)?.[1] ?? secretRaw).trim()
+if (secretSrc && !secretText) die(`密钥文件是空的：${secretSrc}`, 2)
+
+// ① **先验签**：密钥优先用 --secret-file 带来的那把，其次本机既有来源（env / 已装密钥文件）
+const originalVersion = Number(file.v) === 1 ? 1 : (Number(file.v) === 2 ? 2 : null)
+let r = verifyLicenseFile(file, { secret: secretText || undefined })
+if (!r.ok) {
+  const detail = r.reason === 'expired' ? r.warnings.join('；')
+    : (r.reason === 'no_secret' ? '本机没有签名密钥' : '文件被改动过，或者不是用本机这把密钥签的')
+  const hint = r.reason === 'no_secret'
+    ? '用 --secret-file <密钥文件> 指定服务端那把密钥，或先设置 ARGENT_LICENSE_SECRET'
+    : (r.reason === 'expired'
+      ? '请让服务端重新签发（node scripts/issue-license-file.mjs --user <id>）'
+      : '不要把这份文件装到客户机（先确认传输过程没有损坏/被改）')
+  fail('bad_signature', `验签未通过（${r.reason}）：${detail} ⇒ ${hint}`, 1)
+}
+
+// ①′ **重签**（可选）：把**已验签**的原件按 v2 载荷重签（`device` 进签名）。
+//    纪律见文件头：只签不改（不扩权）、密钥必须显式、`--sign-version 1` 是回滚用。
+let resign = null
+if (signVersion !== null) {
+  // ⛔ **不**走 `resolveSecret()` 的完整来源链：它兜底会读本机已装的 `license.secret`
+  //    （= 拿生产密钥自签变成无意识的默认动作）⇒ 重签只认**显式**来源：`--secret-file` 或环境变量。
+  const keySecret = String(secretText || process.env.ARGENT_LICENSE_SECRET || '').trim()
+  if (!keySecret) {
+    die('重签必须**显式**给密钥来源：`--secret-file <密钥文件>` 或 `ARGENT_LICENSE_SECRET`'
+      + '（⛔ 不会自动用本机已装的 license.secret —— 那会让"拿生产密钥自签"变成一次无意识的默认动作）', 2)
+  }
+  let device = null
+  if (signVersion === 2 && !noDevice) {
+    if (deviceCodeArg) {
+      const code = String(deviceCodeArg).trim()
+      if (!/^[0-9a-f]{64}$/i.test(code)) {
+        die(`--device-code 必须是 64 位十六进制的**设备码**（\`argent license request\` 打印的那串）；`
+          + `⛔ 不要给主机名/MAC/IP（D3：指纹只认硬件 UUID 一项）：${code.slice(0, 32)}…`, 2)
+      }
+      device = { code: code.toLowerCase(), algo: 'ioplatformuuid-sha256', issuedAt: new Date().toISOString() }
+    } else {
+      // 缺省：读**本机**设备码（`--device-from-local` 与"什么都没给"是同一条路）
+      const dev = currentDevice({})
+      if (!dev.ok) {
+        die(`读不到本机设备码（${dev.reason}）：${dev.error} ⇒ 要么显式给 --device-code <64hex>，要么显式 --no-device`
+          + '（不静默降级成 unbound：那会把"绑不上"悄悄变成"没绑定"）', 2)
+      }
+      device = { code: dev.code, algo: dev.algo, issuedAt: dev.issuedAt }
+    }
+  }
+  // `issuedAt` 原件不动（"只签不改"）；载荷字段全部取自**验签过**的 `r`（不是原始 JSON）
+  const source = {
+    v: signVersion, userId: r.userId, capabilities: r.capabilities, verticals: r.verticals, seats: r.seats,
+    issuedAt: r.issuedAt, expiresAt: r.expiresAt, graceDays: r.graceDays, instanceHint: r.instanceHint,
+    ...(device ? { device } : {}),
+  }
+  const signedRes = signLicenseFile(source, keySecret, { version: signVersion })
+  if (!signedRes.ok) die(`重签失败（${signedRes.reason}${signedRes.warning ? `：${signedRes.warning}` : ''}）`, 2)
+  file = signedRes.file
+  // **重签完必须自验**：回显与后续判定一律看**产物**（不是原件的结论）；自验不过 ⇒ 不落盘
+  const rv = verifyLicenseFile(file, { secret: keySecret })
+  if (!rv.ok) die(`重签产物自验失败（${rv.reason}）：拒绝安装（原许可未改动）`, 2)
+  r = rv
+  resign = {
+    requested: true, from: originalVersion, to: signVersion,
+    payload: signedRes.payload,
+    deviceCode: device ? device.code : null,
+    keySource: secretSrc ? 'secret-file' : 'env',
+    note: `已按 v${signVersion} 重签：capabilities/verticals/seats/issuedAt/expiresAt/graceDays **逐字继承验签过的原件**`
+      + '（重签**不扩权**）'
+      + (signVersion === 2
+        ? '；`device` 已进签名 ⇒ 此后改它/摘它/降 v 重拼都会验签失败'
+        : '；⚠️ 重签回 v1 ⇒ 产物里**没有** `device`（v1 的载荷签不了它），设备绑定随之失效'),
+  }
+}
+
+// ② **设备比对**（§3.6① 第 3 步）：`device` 是**可选**字段 ⇒ 无声明 = unbound 放行（D1-兼容，存量许可不受影响）
+const claimed = deviceClaimOf(file)
+const storePath = rebindStorePath()
+const store = readRebindStore({ path: storePath })
+const deviceInfo = currentDevice({})
+const binding = bindingOf({ claimed, current: deviceInfo, store })
+const mismatch = binding.binding === 'mismatch'
+// `--rebind` 只在**确实不匹配**且**还有自助次数**时才有意义（本就一致 ⇒ 不消耗次数）
+const rebindConsumed = mismatch && rebindRequested && binding.rebindsLeft > 0
+/**
+ * `device` 回显的**唯一构造点**（成功 / 设备拒绝 / 现役倒退拒绝三条路径共用 ⇒ 形状不会各自漂移）。
+ * `signed` = 该版本的签名载荷**覆盖 device 这一项**（v2 ⇒ true；v1 ⇒ false：服务端声明 + 客户端比对）。
+ */
+const deviceEcho = () => ({
+  present: Boolean(claimed), signed: r.deviceSigned === true, binding: binding.binding, reason: binding.reason,
+  sanctioned: binding.sanctioned, code: claimed ? claimed.code : null, algo: claimed ? claimed.algo : null,
+  machineCode: binding.machineCode, machineReadable: deviceInfo.ok === true,
+  rebindsLeft: binding.rebindsLeft, note: binding.note,
+})
+if (mismatch && !rebindConsumed) {
+  // 不匹配 ⇒ **不落盘**（原文件一个字节都不动），exit 1 + 结构化 reason（**回显设备态**，宿主才好指引人）
+  fail(binding.reason, `设备码不匹配 ⇒ 拒绝安装（原许可未改动）：${binding.note}`, 1, {
+    signatureVersion: r.signatureVersion === 2 ? 2 : (r.signatureVersion === 1 ? 1 : null),
+    deviceSigned: r.deviceSigned === true,
+    device: deviceEcho(),
+    rebind: rebindEcho({
+      count: store.count, rebindsLeft: binding.rebindsLeft, store: storePath,
+      canRebind: binding.rebindsLeft > 0,
+      note: binding.rebindsLeft > 0 ? `可用 --rebind 自助重绑（还剩 ${binding.rebindsLeft} 次）` : '自助重绑次数已用尽 ⇒ 需人工（服务端重签）',
+    }),
+  })
+}
+
+const targetLicense = defaultLicensePath()
+const targetSecret = defaultSecretPath()
+
+// ── ②′ **现役许可比对**（2026-10-04）：幂等 / 拒绝倒退 / 换绑如实标注 ────────────
+// 判据只有一条前置：**现役自己也得验签过**（或"验签过但已过期"——那正是最常见的续期场景）。
+// 现役根本验不过（坏文件/别人的密钥/没密钥）⇒ 不做比对（本次安装是修复，不是倒退），只告警。
+let incumbentRaw = null
+try { incumbentRaw = JSON.parse(readFileSync(targetLicense, 'utf-8')) } catch { incumbentRaw = null }
+const incumbent = loadLicenseFile(targetLicense, { secret: secretText || undefined })
+const incumbentUsable = incumbent.ok === true || incumbent.reason === 'expired'
+const incPayload = incumbentRaw ? signaturePayloadOf(incumbentRaw) : null
+const newPayload = signaturePayloadOf(file)
+const incumbentDeviceCode = incumbent.deviceClaimed ? incumbent.deviceClaimed.code : null
+const unchanged = Boolean(incPayload && newPayload && incumbentRaw
+  && incPayload.version === newPayload.version
+  && incPayload.payload === newPayload.payload
+  && String(incumbentRaw.sig || '').toLowerCase() === String(file.sig || '').toLowerCase())
+let comparison = null
+let renewal = null
+if (incumbent.present !== false || incumbentRaw) {
+  const incCaps = incumbentUsable ? (incumbent.capabilities || []) : []
+  const incVerts = incumbentUsable ? (incumbent.verticals || []) : []
+  const missingCapabilities = incumbentUsable ? incCaps.filter((c) => !r.capabilities.includes(c)) : []
+  // `verticals` 空数组 = **不限**（口径见 license-file.mjs）⇒ 只在"两边都非空"时才谈收窄
+  const missingVerticals = (incVerts.length && r.verticals.length) ? incVerts.filter((v) => !r.verticals.includes(v)) : []
+  const seatsNarrowed = incumbentUsable && Number(r.seats) < Number(incumbent.seats || 0)
+  comparison = {
+    comparable: incumbentUsable,
+    incumbentReason: incumbent.reason,
+    unchanged,
+    stale: incumbentUsable && Date.parse(r.expiresAt) < Date.parse(incumbent.expiresAt),
+    narrowed: missingCapabilities.length > 0 || missingVerticals.length > 0 || seatsNarrowed,
+    missingCapabilities, missingVerticals, seatsNarrowed,
+    incumbentExpiresAt: incumbentUsable ? incumbent.expiresAt : null,
+    incomingExpiresAt: r.expiresAt,
+  }
+  renewal = {
+    incumbentExpiresAt: incumbentUsable ? incumbent.expiresAt : null,
+    incomingExpiresAt: r.expiresAt,
+    // 同机续期**不得**换绑：设备码变了 = 换绑（要么拿错文件，要么这台机器不是签发对象）
+    deviceChanged: Boolean(incumbentDeviceCode && claimed && incumbentDeviceCode !== claimed.code),
+    incumbentDeviceCode, incomingDeviceCode: claimed ? claimed.code : null,
+    note: '同机续期应保持 `device.code` 逐字一致；不同码 = **换绑**（`--rebind` 自助 3 次，超限人工）',
+  }
+  if (incumbentUsable && (comparison.stale || comparison.narrowed) && !allowRegression) {
+    const why = [
+      comparison.stale ? `新文件更早到期（现役 ${incumbent.expiresAt} → 新 ${r.expiresAt}）` : '',
+      comparison.narrowed ? `能力/业务线/席位被收窄（缺 ${[...missingCapabilities, ...missingVerticals].join(',') || '—'}`
+        + `${seatsNarrowed ? `；席位 ${incumbent.seats} → ${r.seats}` : ''}）` : '',
+    ].filter(Boolean).join('；')
+    fail('regression_refused', `拒绝安装：这次安装会让现役许可**倒退**（${why}）⇒ 原许可未改动。`
+      + '确实要装（纠错/吊销/换绑）请显式加 `--allow-regression`（会把差异写进回显与告警）', 1, {
+      signatureVersion: r.signatureVersion === 2 ? 2 : (r.signatureVersion === 1 ? 1 : null),
+      deviceSigned: r.deviceSigned === true,
+      // 设备态与重绑态在**这条拒绝里也不能缺席**（2026-10-04）：同样的消费者会读
+      // `.device.binding` / `.rebind.consumed`；缺键 = 一次可读的拒绝变成调用方 TypeError。
+      device: deviceEcho(),
+      rebind: rebindEcho({
+        count: store.count, rebindsLeft: binding.rebindsLeft, store: storePath,
+        canRebind: binding.rebindsLeft > 0,
+        note: '未消耗自助重绑次数（本次在「②′ 现役许可比对」这一步被拒 ⇒ **未落盘**、计数未变）；'
+          + '要放行一次倒退请显式加 `--allow-regression`（**不是** `--rebind`）'
+          + (rebindConsumed ? `；若改用 --allow-regression 重装，本次设备重绑会消耗 1 次（还剩 ${binding.rebindsLeft} 次）` : ''),
+      }),
+      incumbent: {
+        present: true, path: targetLicense, verified: incumbent.ok === true, reason: incumbent.reason,
+        expiresAt: incumbentUsable ? incumbent.expiresAt : null,
+        signatureVersion: incumbent.signatureVersion === 2 ? 2 : (incumbent.signatureVersion === 1 ? 1 : null),
+        capabilities: incCaps, verticals: incVerts, seats: incumbentUsable ? incumbent.seats : null, deviceCode: incumbentDeviceCode,
+      },
+      comparison, renewal, allowRegression: false,
+      next: '核对是不是拿错了文件；确需倒退 ⇒ 重跑并加 `--allow-regression`',
+    })
+  }
+}
+
+// ── ②″ 实例令牌**先判后写**（2026-10-05）：装错一份令牌只会造成长期静默 401/403 ──────
+// 判据（三条，全部**在写任何文件之前**）：
+//   ⓐ 形态：`it1.` 前缀 + 三段 + 载荷可解 + `typ=instance-token`；
+//   ⓑ 归属：令牌的 `userId` 必须等于**本次许可的** `userId`（拿错账号的文件 = 上报会挂到别人名下）；
+//   ⓒ 绑定：两边都声明了设备码时必须一致（拿错机器的文件 = 遥测长期 403）。
+//   ⓓ 期限：已过期 ⇒ 拒装（装了也是死信，还容易被误当成"已切换"）。
+let tokenInstall = null
+if (instanceTokenSrc) {
+  if (!existsSync(instanceTokenSrc)) fail('token_usage_error', `--instance-token-file 不存在：${instanceTokenSrc}`, 2)
+  const parsed = parseInstanceToken(readFileSync(instanceTokenSrc, 'utf-8'))
+  if (parsed.error) {
+    fail('token_malformed', `实例令牌文件不可用（${parsed.error}）：${instanceTokenSrc}`
+      + '；请用 whyshu-svr 的 `node scripts/issue-instance-token.mjs --user … --instance …` 重新签发', 1)
+  }
+  const p = parsed.payload
+  if (String(p.userId || '') !== String(r.userId)) {
+    fail('token_user_mismatch', `实例令牌属于账号 ${String(p.userId).slice(0, 24)}…，与本次许可的账号 `
+      + `${String(r.userId).slice(0, 24)}… **不是同一个** ⇒ 拒绝安装（上报会挂到别人名下）`, 1)
+  }
+  if (claimed && p.deviceCode && String(p.deviceCode).toLowerCase() !== String(claimed.code).toLowerCase()) {
+    fail('token_device_mismatch', `实例令牌绑定的是设备 ${String(p.deviceCode).slice(0, 12)}…，`
+      + `本机许可是 ${String(claimed.code).slice(0, 12)}… ⇒ 拒绝安装（换机/换绑后需按新设备码重签令牌）`, 1)
+  }
+  const expMs = Date.parse(String(p.exp || ''))
+  if (!Number.isFinite(expMs) || expMs <= Date.now()) {
+    fail('token_expired', `实例令牌${Number.isFinite(expMs) ? `已于 ${p.exp} 过期` : '缺少可解析的 exp'} ⇒ 拒绝安装，请重新签发`, 1)
+  }
+  tokenInstall = { src: instanceTokenSrc, parsed, path: join(dataDir(), INSTANCE_TOKEN_FILENAME) }
+}
+
+const result = {
+  // A2 最小集（--json 的消费方按字段判，不 grep 中文）
+  ok: true, empty: false, code: 0, reason: null,
+  dryRun, source: srcPath, target: targetLicense, secretInstalled: false,
+  userId: r.userId, capabilities: r.capabilities, verticals: r.verticals, seats: r.seats,
+  expiresAt: r.expiresAt, graceDays: r.graceDays, graceUntil: r.graceUntil, inGrace: r.inGrace,
+  // 签名版本（1｜2）与"device 是否进签名"的唯一回显（判据来自验签结果，本脚本不重算）
+  signatureVersion: r.signatureVersion === 2 ? 2 : (r.signatureVersion === 1 ? 1 : null),
+  deviceSigned: r.deviceSigned === true,
+  // 重签（`--sign-v2`）：如未重签 ⇒ null（"没做这件事"与"做了但结果为空"必须一眼分得开）
+  resign,
+  // 设备侧如实回显（`signed:true` = v2 已进签名；`false` = v1 未进签名）
+  // —— 与两条拒绝路径**共用** `deviceEcho()`：形状只在那一处定义（拒绝路径不再自建一份）
+  device: deviceEcho(),
+  rebind: rebindConsumed
+    ? { consumed: false, pending: true, note: `将消耗 1 次自助重绑（已用 ${store.count}/${MAX_REBINDS}）` }
+    : { consumed: false, note: mismatch ? '未重绑（缺 --rebind 或次数用尽）' : '设备码一致或未声明 ⇒ 未消耗重绑次数' },
+  // 现役比对（②′）：`unchanged` = 与现役**载荷+签名**逐字节相同 ⇒ 不备份、不重写（幂等）
+  unchanged,
+  incumbent: comparison ? {
+    present: true, path: targetLicense, verified: incumbent.ok === true, reason: incumbent.reason,
+    expiresAt: comparison.incumbentExpiresAt,
+    signatureVersion: incumbent.signatureVersion === 2 ? 2 : (incumbent.signatureVersion === 1 ? 1 : null),
+    capabilities: incumbentUsable ? incumbent.capabilities : [], verticals: incumbentUsable ? incumbent.verticals : [],
+    seats: incumbentUsable ? incumbent.seats : null, deviceCode: incumbentDeviceCode,
+  } : { present: false, path: targetLicense, verified: false, reason: incumbent.reason || 'missing' },
+  comparison, renewal, allowRegression,
+  backups: [], warnings: [
+    ...r.warnings,
+    ...(binding.warnings || []),
+    ...(comparison && comparison.comparable === false && comparison.incumbentReason !== 'missing'
+      ? [`现役许可未通过验签（${comparison.incumbentReason}）⇒ 本次**不做**降级/缩权比对（按"修复"处理；`
+        + `要核对现役实情请看 \`argent license status\`）`] : []),
+    ...(comparison && comparison.unchanged ? ['本文件与现役许可**逐字节一致** ⇒ 未重写、未备份（幂等）'] : []),
+    ...(comparison && (comparison.stale || comparison.narrowed) && allowRegression
+      ? [`⚠️ 已用 --allow-regression 放行一次**倒退**安装：${comparison.stale ? '更早到期；' : ''}`
+        + `${comparison.narrowed ? `收窄（缺 ${[...comparison.missingCapabilities, ...comparison.missingVerticals].join(',') || '—'}）` : ''}`] : []),
+    ...(renewal && renewal.deviceChanged
+      ? [`设备码与现役不同（${String(incumbentDeviceCode || '').slice(0, 12)}… → ${String(claimed && claimed.code || '').slice(0, 12)}…）`
+        + '⇒ 这是**换绑**而不是续期：自助 3 次（`--rebind`），超限需人工（服务端按 `license request` 的设备码重签）'] : []),
+    ...(resign && resign.to === 2 ? ['本许可已按 **v2** 重签：`device` 进签名 ⇒ 改它/摘它/降 v 重拼都会验签失败'
+      + '（⚠️ 但签名仍是 HMAC 对称密钥 ⇒ 不防"持有 license.secret 的人重签"）'] : []),
+  ],
+}
+
+if (!dryRun) {
+  mkdirSync(dataDir(), { recursive: true, mode: 0o700 })
+  // ⓪ 幂等：与现役逐字节一致 ⇒ **什么都不做**（不备份、不重写、不动 mtime）——
+  //    续期/重放同一份文件是常态，不能每次都在客户机上留一堆 .bak 与新的 mtime。
+  if (unchanged) {
+    try { result.mode = `0${(statSync(targetLicense).mode & 0o777).toString(8)}` } catch { /* 权限拿不到不致命 */ }
+    result.verifiedAfterInstall = true
+  } else {
+    // ② 备份旧文件（许可 + 密钥各自备份；备份里同样有秘密 ⇒ 0600）
+    const backupOf = (p) => {
+      if (!existsSync(p)) return null
+      const b = `${p}.bak-${stamp()}`
+      copyFileSync(p, b)
+      chmodSync(b, 0o600)
+      return b
+    }
+    const licBackup = backupOf(targetLicense)
+    if (licBackup) result.backups.push(licBackup)
+    // ③ 密钥先落盘（先密钥后许可：中途失败时至少不会出现"有许可没密钥"的假象）
+    if (secretSrc) {
+      const secBackup = backupOf(targetSecret)
+      if (secBackup) result.backups.push(secBackup)
+      writeFileSync(`${targetSecret}.tmp`, `${secretText}\n`, { mode: 0o600 })
+      renameSync(`${targetSecret}.tmp`, targetSecret)
+      chmodSync(targetSecret, 0o600)
+      result.secretInstalled = true
+    }
+    // ④ 原子写许可：tmp（0600）→ rename；失败不留半份
+    const tmp = `${targetLicense}.tmp`
+    try {
+      writeFileSync(tmp, JSON.stringify(file, null, 2) + '\n', { mode: 0o600 })
+      chmodSync(tmp, 0o600)
+      renameSync(tmp, targetLicense)
+    } catch (e) {
+      rmSync(tmp, { force: true })
+      die(`写入失败（已保留原许可）：${e.message}`, 2)
+    }
+    chmodSync(targetLicense, 0o600)
+    result.mode = `0${(statSync(targetLicense).mode & 0o777).toString(8)}`
+    // ⑤ 读回验收：装完必须能**用真实加载路径**验签通过（不是"我写完了"就算数）
+    const back = loadLicenseFile(targetLicense)
+    result.verifiedAfterInstall = back.ok
+    if (!back.ok) die(`安装后复验失败（${back.reason}）：${targetLicense}`, 2)
+  }
+  // ⑥ 自助重绑计数（**只在真写且确实不匹配时**消耗一次；dry-run 绝不落盘 ⇒ A3 零副作用）  //    放在"幂等跳过"之外：即便许可文件与现役一致，这一次重绑也是**真发生过**的（不能少记一次）。
+  if (rebindConsumed) {
+    const rec = recordRebind(store, { code: claimed.code })
+    result.rebind = {
+      consumed: true,
+      count: rec.count,
+      rebindsLeft: Math.max(0, MAX_REBINDS - rec.count),
+      store: rec.path,
+      storeWritten: rec.ok === true,
+      note: `自助重绑已消耗 1 次（第 ${rec.count}/${MAX_REBINDS} 次）；这是**礼貌上限**（计数文件删掉即归零），`
+        + '不是可强制执行的限制 —— 要真额度控制只能在服务端签发侧',
+    }
+    if (rec.ok !== true) result.warnings.push(`重绑计数写不下（${rec.error}）：本次已放行，但下次会被再算一次`)
+    // ⚠️ 回显**落盘后**的真相：重绑已记录 ⇒ 设备这一侧现在是 `rebound`（放行），
+    //    剩余次数也要减 1。若照抄落盘前的结论，宿主会看到"刚重绑成功但仍是 mismatch"的自相矛盾。
+    const after = bindingOf({ claimed, current: deviceInfo, store: readRebindStore({ path: storePath }) })
+    result.device = { ...result.device, binding: after.binding, reason: after.reason, rebindsLeft: after.rebindsLeft, note: after.note }
+  }
+}
+
+// ── ⑦ 实例令牌落盘（与许可**同一条离线下发链路**；只有给了 `--instance-token-file` 才走这里）──
+// 与许可同一套纪律：**0600 + tmp→rename（原子）+ 覆盖前备份 + 逐字节相同则不重写（幂等）**。
+// ⛔ 绝不回显令牌值；回显只有 userId / instanceId / 设备码前 12 位 / 到期日。
+if (tokenInstall && !dryRun) {
+  const target = tokenInstall.path
+  const incoming = JSON.stringify({
+    _doc: '实例令牌（机器自带凭证）。只读 `token` 一个键；其余键仅便于人工核对，不参与鉴权。'
+      + '契约见 whyshu-svr/docs/ops/instance-token.md',
+    v: Number(tokenInstall.parsed.payload.v || 1),
+    token: tokenInstall.parsed.token,
+    userId: String(tokenInstall.parsed.payload.userId || ''),
+    instanceId: String(tokenInstall.parsed.payload.instanceId || ''),
+    deviceCode: String(tokenInstall.parsed.payload.deviceCode || ''),
+    scope: String(tokenInstall.parsed.payload.scope || ''),
+    issuedAt: String(tokenInstall.parsed.payload.issuedAt || ''),
+    exp: String(tokenInstall.parsed.payload.exp || ''),
+  }, null, 2) + '\n'
+  let existing = null
+  try { existing = readFileSync(target, 'utf-8') } catch { existing = null }
+  // 幂等判据：**只比 token 那一串**（元数据措辞变化不该造成 churn）
+  const existingToken = existing && existing.trim().startsWith('{')
+    ? String((JSON.parse(existing) || {}).token || '').trim()
+    : String(existing || '').trim()
+  const tokenUnchanged = existingToken === tokenInstall.parsed.token
+  if (tokenUnchanged) {
+    tokenInstall.unchanged = true
+  } else {
+    if (existing !== null) {
+      const b = `${target}.bak-${stamp()}`
+      copyFileSync(target, b)
+      chmodSync(b, 0o600)
+      tokenInstall.backup = b
+    }
+    const tmp = `${target}.tmp`
+    try {
+      writeFileSync(tmp, incoming, { mode: 0o600 })
+      chmodSync(tmp, 0o600)
+      renameSync(tmp, target)
+    } catch (e) {
+      rmSync(tmp, { force: true })
+      // 令牌装不上**不该**把已经装好的许可一起判失败：如实回显 + 告警，退出码保持 0
+      result.warnings.push(`实例令牌写入失败（许可已装好，机器仍可用账号令牌兜底）：${e.message}`)
+      tokenInstall = null
+    }
+  }
+  if (tokenInstall) {
+    try { tokenInstall.mode = `0${(statSync(target).mode & 0o777).toString(8)}` } catch { /* 权限拿不到不致命 */ }
+    // 读回验收：装完必须能**按客户端真实读取路径**解出同一串（不是"我写完了"就算数）
+    const back = parseInstanceToken(readFileSync(target, 'utf-8'))
+    tokenInstall.verified = back.token === tokenInstall.parsed.token
+    if (!tokenInstall.verified) result.warnings.push(`实例令牌安装后复验失败（${back.error || '内容不一致'}）：${target}`)
+  }
+}
+result.instanceToken = tokenInstall ? {
+  installed: !dryRun,
+  path: tokenInstall.path,
+  source: tokenInstall.src,
+  mode: tokenInstall.mode || (dryRun ? null : undefined),
+  unchanged: tokenInstall.unchanged === true,
+  verified: tokenInstall.verified === true,
+  backup: tokenInstall.backup || null,
+  userId: String(tokenInstall.parsed.payload.userId || ''),
+  instanceId: String(tokenInstall.parsed.payload.instanceId || ''),
+  deviceBound: Boolean(tokenInstall.parsed.payload.deviceCode),
+  deviceCodePrefix: String(tokenInstall.parsed.payload.deviceCode || '').slice(0, 12),
+  scope: String(tokenInstall.parsed.payload.scope || ''),
+  exp: String(tokenInstall.parsed.payload.exp || ''),
+  header: 'x-instance-token',
+  note: '客户机 `scripts/telemetry.py` 会优先用它上报（`--status` 的 credential.kind=instance）；账号令牌保留为兜底',
+} : { installed: false, path: null, note: '未提供 --instance-token-file ⇒ 只装了许可（机器仍靠账号令牌上报，30 天到期需重配）' }
+
+if (has('--json')) {
+  console.log(JSON.stringify(result, null, 2))
+} else {
+  console.log(`${dryRun ? '🔎 [dry-run] 会安装' : (unchanged ? '✅ 与现役逐字节一致、未改动' : '✅ 已安装')}离线许可：${srcPath} → ${targetLicense}`)
+  console.log(`   账号：${r.userId} ｜ 席位：${r.seats}`)
+  console.log(`   能力：${r.capabilities.join(',') || '(未列能力 ⇒ 客户端拒一切能力)'}`)
+  console.log(`   业务线：${r.verticals.join(',') || '(空 = 不限)'}`)
+  console.log(`   到期：${r.expiresAt} ｜ 宽限 ${r.graceDays} 天（至 ${r.graceUntil}）`)
+  console.log(`   签名版本：v${result.signatureVersion} ｜ device 进签名：${result.deviceSigned ? '是' : '否'}`)
+  console.log(`   设备绑定：${result.device.binding}（${result.device.reason}）`
+    + `${result.device.present ? ` ｜ 许可设备码 ${String(result.device.code).slice(0, 12)}…` : ''}`
+    + ` ｜ 自助重绑还剩 ${result.device.rebindsLeft} 次`)
+  if (resign) {
+    console.log(`   ✍️ 重签：v${resign.from ?? '?'} → v${resign.to}`
+      + `${resign.deviceCode ? `（device=${String(resign.deviceCode).slice(0, 12)}…）` : '（未声明 device）'}`
+      + ` ｜ 密钥来源 ${resign.keySource}`)
+    console.log(`      · ${resign.note}`)
+  }
+  if (rebindConsumed) console.log(`   🔁 ${result.rebind.note}`)
+  if (comparison && result.incumbent.present) {
+    console.log(`   现役：${result.incumbent.reason}${result.incumbent.expiresAt ? ` ｜ 到期 ${result.incumbent.expiresAt}` : ''}`
+      + ` ｜ 能力 ${(result.incumbent.capabilities || []).join(',') || '(空)'}`
+      + `${result.comparison.unchanged ? ' ｜ **与本文件逐字节一致**（幂等：未重写、未备份）' : ''}`
+      + `${result.comparison.stale ? ' ｜ ⚠️ 本文件更早到期' : ''}`
+      + `${result.comparison.narrowed ? ' ｜ ⚠️ 本文件收窄了能力/席位' : ''}`)
+  }
+  if (renewal && renewal.deviceChanged) console.log(`   ↻ 换绑：device ${String(renewal.incumbentDeviceCode || '').slice(0, 12)}… → ${String(renewal.incomingDeviceCode || '').slice(0, 12)}…（不是续期）`)
+  if (secretSrc) console.log(`   密钥：已安装到 ${targetSecret}（0600，值不打印）`)
+  else console.log('   密钥：沿用本机既有来源（ARGENT_LICENSE_SECRET 或已装密钥文件）')
+  if (result.instanceToken.installed) {
+    console.log(`${result.instanceToken.unchanged ? '🔁 实例令牌与现役逐字节一致、未改动' : '🔑 已安装实例令牌（机器自带凭证）'}：`
+      + `${result.instanceToken.path}（${result.instanceToken.mode || '0600'}）`)
+    console.log(`   归属 ${result.instanceToken.userId} ｜ 实例 ${result.instanceToken.instanceId}`
+      + ` ｜ 设备 ${result.instanceToken.deviceBound ? `${result.instanceToken.deviceCodePrefix}…（已绑定）` : '（未绑定）'}`
+      + ` ｜ 用途 ${result.instanceToken.scope} ｜ 有效至 ${result.instanceToken.exp}`)
+    console.log('   ⛔ 令牌值不打印；本机上报从此**不再依赖 30 天账号令牌**，`--status` 的 credential.kind 应显示 instance')
+  } else if (instanceTokenSrc) {
+    console.log(`   ⚠️ 实例令牌：${dryRun ? 'dry-run（未写入）' : '未安装'} ⇒ ${result.instanceToken.note}`)
+  } else {
+    console.log('   ℹ️ 未提供 --instance-token-file ⇒ 机器仍靠**账号令牌**上报（30 天到期需重配；'
+      + '要根治请用 whyshu-svr 的 `scripts/issue-instance-token.mjs` 签发后带上该参数）')
+  }
+  for (const b of result.backups) console.log(`   备份：${b}`)
+  for (const w of result.warnings) console.log(`   ⚠️ ${w}`)
+  console.log(`   自检：argent license status${dryRun ? '（本次是 dry-run：**没有**写任何文件，连备份/重绑计数都没落）' : ''}`)
+}
+process.exit(0)