dsh-jev-guard 0.5.1

package/tools/selftest-i18n.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * 双语文案自检:目录完整、两语言同键、英文侧真的没有残留中文,以及一个关键的不变量 ——
+ * **换了界面语言不得改变发给判定服务的那句话**。
+ *
+ * 为什么单独有这份自检:
+ *   1. 文案开始按语言分叉之后,"某个键只写了一种语言"是一种**静默降级** ——
+ *      运行时退回中文,英文用户看到一句中文,没有任何报错。
+ *   2. 占位符(`{token}`、`{cli}`)漏一个,输出就会少一段关键信息,而复制粘贴的
+ *      授权行一旦不完整,用户拿到的令牌与 AI 重试的命令就对不上(见 selftest-reason)。
+ *   3. 判定层与界面层**必须解耦**:那句问话与 state 的键属于 `promptLang`,默认是
+ *      标定过的中文;界面切成英文时它**不能**跟着变,否则阈值这条被测过的边界会悄悄挪动。
+ *
+ * 全部离线:不联网、不碰 ~/.jev-guard。语言切来切去是本文件自己的事,结束时还原。
+ *
+ * @module jev-guard/tools/selftest-i18n
+ */
+
+import { ASK_RULES, DENY_RULES, staticRule } from '../lib/rules.js'
+import { FALLBACK_LANG, LANGS, detectLang, keysOf, normalizeLang, setLang, t } from '../lib/i18n.js'
+import { judgeQuestion } from '../lib/gate.js'
+import { explain, reviseGuidance, shellName, templates } from '../lib/verdict.js'
+
+let failed = 0
+let checks = 0
+
+/**
+ * @param label - 用例名。
+ * @param ok - 断言结果。
+ * @param detail - 失败细节。
+ */
+function expect(label, ok, detail = '') {
+  checks += 1
+  if (!ok) failed += 1
+  process.stdout.write(`${ok ? 'ok  ' : 'FAIL'}  ${label}${ok ? '' : `   ${detail}`}\n`)
+}
+
+/** 取出一条消息里的占位符名字(排序后便于比较)。 */
+const placeholders = (text) => [...String(text).matchAll(/\{(\w+)\}/g)].map(m => m[1]).sort()
+
+const CJK = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\u3000-\u303f\uff00-\uffef]/
+
+// ── 1. 目录完整性 ───────────────────────────────────────────────────────────
+const zhKeys = keysOf('zh-CN')
+const enKeys = keysOf('en')
+const missingEn = zhKeys.filter(k => !enKeys.includes(k))
+const missingZh = enKeys.filter(k => !zhKeys.includes(k))
+expect('两种语言的键集合一致', missingEn.length === 0 && missingZh.length === 0,
+  `只有中文:${missingEn.join(',') || '-'} / 只有英文:${missingZh.join(',') || '-'}`)
+expect('目录非空且覆盖到 CLI 与判定理由', zhKeys.length > 80 && zhKeys.some(k => k.startsWith('verdict.')) && zhKeys.some(k => k.startsWith('cli.')),
+  `${zhKeys.length} 个键`)
+
+const badPlaceholders = []
+for (const key of zhKeys) {
+  setLang('zh-CN')
+  const zh = placeholders(t(key))
+  setLang('en')
+  const en = placeholders(t(key))
+  if (zh.join() !== en.join()) badPlaceholders.push(`${key}(${zh.join('+') || '-'} vs ${en.join('+') || '-'})`)
+}
+expect('同一键的占位符在两种语言里一致', badPlaceholders.length === 0, badPlaceholders.join(', '))
+
+// 会话内 notice 的摘要会渲染成对话里的折叠行,DSH 对它的上限是 120 字符
+// (CONTEXT_SUMMARY_MAX_CHARS;超了就被截断,读者看到的话断在半句上)。英文通常更长,
+// 所以两种语言都量一遍 —— "只有英文超了"这类问题只有双语并排才看得见。
+const summaryKeys = zhKeys.filter(k => /^notice\..*\.summary$/.test(k))
+expect('notice 摘要键齐备(没有密钥 / 降级 / 恢复)', summaryKeys.length === 3, summaryKeys.join(','))
+const overlongSummaries = []
+for (const lang of ['zh-CN', 'en']) {
+  setLang(lang)
+  for (const key of summaryKeys) {
+    const text = t(key)
+    if (text.length > 120 || text.includes('\n')) overlongSummaries.push(`${lang}:${key}(${text.length})`)
+  }
+}
+expect('notice 摘要 ≤120 字符且不含换行', overlongSummaries.length === 0, overlongSummaries.join(', '))
+setLang('zh-CN')
+
+// ── 2. 英文侧不得残留中文(半翻译是最常见的静默缺陷)─────────────────────────
+setLang('en')
+const leftovers = enKeys.filter(k => CJK.test(t(k)))
+expect('英文文案里没有残留中文', leftovers.length === 0, leftovers.slice(0, 5).join(','))
+const keyAsValue = enKeys.filter(k => t(k) === k)
+expect('英文查表不会返回键名本身(返回键名 = 键写错或漏翻)', keyAsValue.length === 0, keyAsValue.slice(0, 5).join(','))
+
+// ── 3. 语言解析 ─────────────────────────────────────────────────────────────
+expect('zh / zh-TW / zh-Hans 都归到 zh-CN', ['zh', 'zh-TW', 'zh-Hans'].every(v => normalizeLang(v) === 'zh-CN'))
+expect('en / en-US / EN 都归到 en', ['en', 'en-US', 'EN'].every(v => normalizeLang(v) === 'en'))
+expect('不认识的语言返回 undefined(由调用方决定怎么办)', normalizeLang('klingon') === undefined && normalizeLang('') === undefined)
+
+// 探测链只认**显式信号**。这一段是 2026-09-20 真机踩坑后的护栏:DSH 插件跑在 WSL 里,
+// 那里 LANG=C.UTF-8,当时链条落到 Intl → Node 报 en-US(ICU 兜底值,不是用户偏好),
+// 于是会话里的理由悄悄变英文,而 Windows 侧 CLI 仍是中文 —— 同一台机器两种语言。
+expect('JEV_GUARD_LANG 优先于 locale 变量', detectLang({ JEV_GUARD_LANG: 'en', LANG: 'zh_CN.UTF-8' }) === 'en')
+expect('locale 变量能定语言(LC_ALL 优先于 LANG)', detectLang({ LC_ALL: 'zh_CN.UTF-8', LANG: 'en_US.UTF-8' }) === 'zh-CN')
+expect('LANG=en_US.UTF-8 这样的真实 locale 会解析成 en', detectLang({ LANG: 'en_US.UTF-8' }) === 'en')
+expect('C / POSIX / 空 = 没有信号,不是英文', detectLang({ LANG: 'C.UTF-8' }) === undefined && detectLang({ LANG: 'POSIX' }) === undefined && detectLang({}) === undefined)
+expect('没有信号时的落点是项目主语言 zh-CN', FALLBACK_LANG === 'zh-CN')
+const autoPick = setLang('auto')
+const intlNow = (() => { try { return Intl.DateTimeFormat().resolvedOptions().locale } catch { return '?' } })()
+expect('本机 auto 解析出的语言受支持(且不会因为 Intl 兜底值而变成英文)',
+  LANGS.includes(autoPick.lang), `解析=${autoPick.lang} 理由=${autoPick.reason} 本机 Intl=${intlNow}`)
+
+// ── 4. 英文判定理由:形状与中文一致(路径、引号、令牌都不能少)────────────────
+// 上面探测链那一节以 `setLang('auto')` 收尾(在本机 = 中文),所以这里显式切回英文。
+setLang('en')
+const EN_CMD = "rm -rf /tmp/it's"
+const risk = { action: 'block', source: 'jev', p: 0.912, model: 'm', ms: 1 }
+const enReason = explain(EN_CMD, risk, { policy: 'never', token: 'ALLOW-0A2DB6157F', platform: 'win32' })
+expect('英文理由带四态抬头与概率', enReason.includes('Jev guard [blocked]') && enReason.includes('91.2%'), enReason.slice(0, 160))
+expect('英文理由说明这是自动判定', enReason.includes('automatic decision'))
+expect('英文理由里的授权行按 win32 用 PowerShell 引号', enReason.includes("allow 'rm -rf /tmp/it''s'"), enReason)
+expect('英文理由带令牌原文', enReason.includes('ALLOW-0A2DB6157F'))
+expect('英文理由的平台名是英文', shellName('linux') === 'a POSIX shell (bash etc.)' && shellName('win32') === 'PowerShell', shellName('linux'))
+
+const enRule = staticRule('git push --force origin main')
+expect('命中规则的英文理由来自规则本身(不是退回 id)', Boolean(enRule) && /force-pushes/.test(enRule.why), String(enRule?.why))
+const enRuleReason = explain('git push --force origin main', { action: 'block', source: 'static-rule', rule: enRule }, {})
+expect('英文理由把规则 id 与英文 why 一起写出', enRuleReason.includes('hard rule `git-force-push` hit (force-pushes'), enRuleReason.slice(0, 200))
+
+const enGuidance = reviseGuidance(EN_CMD, { action: 'revise', source: 'jev', p: 0.6 }, { policy: 'never' })
+expect('英文 revise 指导语含三条模板', enGuidance.includes('Safer forms to try:') && (enGuidance.match(/^- /gm) ?? []).length === 3, enGuidance)
+
+// ── 5. 规则与模板:两种语言都得有 ─────────────────────────────────────────────
+const allRules = [...DENY_RULES, ...ASK_RULES]
+const ruleGaps = allRules.filter(r => LANGS.some(l => typeof r.why?.[l] !== 'string' || r.why[l].trim() === ''))
+expect(`全部 ${allRules.length} 条 L0 规则都有两种语言的理由`, ruleGaps.length === 0, ruleGaps.map(r => r.id).join(','))
+for (const lang of LANGS) {
+  setLang(lang)
+  const list = templates()
+  expect(`${lang}:三条降级模板都带至少 2 个例子`, list.length === 3 && list.every(x => x.examples.length >= 2), JSON.stringify(list.map(x => [x.id, x.examples.length])))
+}
+
+// 规则理由必须**跟着界面语言走**(它是给人/模型读的拒绝理由的一部分)。
+setLang('en')
+const enWhy = staticRule('mkfs.ext4 /dev/sdb1')?.why
+setLang('zh-CN')
+const zhWhy = staticRule('mkfs.ext4 /dev/sdb1')?.why
+expect('规则理由随界面语言切换', enWhy !== zhWhy && /formats a filesystem/.test(enWhy) && /格式化文件系统/.test(zhWhy), `${enWhy} | ${zhWhy}`)
+
+// ── 6. 不变量:界面语言**不得**改变发给判定服务的东西 ─────────────────────────
+// 这是本次改造最要紧的一条:阈值是在中文问话上标定的(114 例),英文界面不能把它挪走。
+setLang('en')
+const qEnUi = judgeQuestion(undefined)
+const qDefault = judgeQuestion()
+expect('界面切成英文后,发给 Jev 的问话仍是标定过的中文',
+  qEnUi.instructions === qDefault.instructions && /不可逆/.test(qEnUi.instructions), qEnUi.instructions)
+const qEnPrompt = judgeQuestion('en')
+expect('promptLang: "en" 时才用英文问话(显式选择)', qEnPrompt.instructions !== qDefault.instructions && /irreversibly/.test(qEnPrompt.instructions), qEnPrompt.instructions)
+expect('英文问话的 criteria 也是英文', qEnPrompt.criteria.true !== qDefault.criteria.true && /block-device|version history/.test(qEnPrompt.criteria.true))
+
+// state 的键同理:它属于 promptLang。用 buildState 的**键**来断言,不联网。
+const { buildState } = await import('../lib/gate.js')
+const zhState = await buildState('node scripts/x.mjs', { promptLang: 'zh-CN', inlineScripts: false })
+const enState = await buildState('node scripts/x.mjs', { promptLang: 'en', inlineScripts: false })
+expect('state 的键随 promptLang 切换', Object.keys(zhState)[0] === '命令' && Object.keys(enState)[0] === 'command',
+  `${Object.keys(zhState)[0]} / ${Object.keys(enState)[0]}`)
+
+// 更硬的一条:**界面语言不得进入请求体**。同一 promptLang 下,中英两种界面必须构造出
+// 逐字节相同的 state 与问话 —— 否则"换文案"就悄悄变成了"换判定",而 p 的抖动会把它掩盖掉。
+const { evaluateCommand } = await import('../lib/gate.js')
+const payloads = []
+for (const uiLang of ['zh-CN', 'en']) {
+  setLang(uiLang)
+  payloads.push(JSON.stringify({
+    state: await buildState('node scripts/x.mjs', { promptLang: 'zh-CN', inlineScripts: false }),
+    question: judgeQuestion('zh-CN'),
+  }))
+}
+expect('界面语言不进请求体:中英两种界面构造出完全相同的 state 与问话', payloads[0] === payloads[1], payloads.join(' vs '))
+expect('evaluateCommand 也不会把界面语言带进判定(离线:预筛路径)', typeof evaluateCommand === 'function')
+
+// 还原:本文件把语言切来切去,退出前恢复中文,免得留在英文上。
+setLang('zh-CN')
+
+process.stdout.write(`\n${failed === 0 ? '全部通过' : `${failed} 项失败`}(${checks} 例)\n`)
+process.exit(failed === 0 ? 0 : 1)

package/tools/selftest-quota.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * 额度降级自检 —— 离线,靠替身 `fetch` 模拟各种失败。
+ *
+ * 为什么这份自检重要:这里测的全是"出问题时的行为",而**出问题时的静默失效**是这个项目
+ * 已经踩过的坑(审计日志那一次整整白跑一轮)。所以每个断言都在问同一个问题:
+ * "额度/密钥坏掉以后,人还能不能发现,以及阀门还剩哪一层在工作?"
+ *
+ * 全部用临时目录与显式路径,不碰 `~/.jev-guard`,不联网。
+ *
+ * @module jev-guard/tools/selftest-quota
+ */
+
+import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { DEFAULTS, evaluateCommand } from '../lib/gate.js'
+import { setLang } from '../lib/i18n.js'
+import {
+  KINDS, classifyFailure, clearDegraded, cooldownMs, enterDegraded, isDegraded, isSticky, kindScope, probeDue,
+  readDegraded, statusText, warningLine,
+} from '../lib/quota.js'
+import { explain } from '../lib/verdict.js'
+
+// 下面的断言读的是中文文案(告警行、状态报告),先把语言钉死;英文侧见 selftest-i18n。
+setLang('zh-CN')
+
+let failed = 0
+let checks = 0
+
+/**
+ * @param label - 用例名。
+ * @param ok - 断言结果。
+ * @param detail - 失败细节。
+ */
+function expect(label, ok, detail = '') {
+  checks += 1
+  if (!ok) failed += 1
+  process.stdout.write(`${ok ? 'ok  ' : 'FAIL'}  ${label}${ok ? '' : `   ${detail}`}\n`)
+}
+
+const dir = await mkdtemp(join(tmpdir(), 'jev-guard-quota-'))
+const cfg = { degradedPath: join(dir, 'degraded.json') }
+
+/** 一条会走联网判定的命令(不在 L0、也不是只读预筛)。 */
+const CMD = 'rm -rf /home/user/jev-guard-demo'
+
+/** 替身 fetch:按脚本依次返回响应或抛错,并记录调用次数。 */
+let calls = []
+let script = []
+globalThis.fetch = async () => {
+  calls.push(1)
+  const next = script.shift()
+  if (next === undefined) throw new Error('fetch called more times than scripted')
+  if (next instanceof Error) throw next
+  return {
+    ok: next.status >= 200 && next.status < 300,
+    status: next.status,
+    text: async () => next.body ?? '',
+    json: async () => next.json ?? {},
+  }
+}
+
+const httpError = (status, body = '') => {
+  const e = new Error(`HTTP ${status}: ${body}`)
+  e.status = status
+  e.body = body
+  return e
+}
+const okAnswer = (p, usage) => ({ status: 200, json: { model: 'jev-1.13.0', answers: { destroys_data: { noul: p } }, ...(usage ? { usage } : {}) } })
+
+// 1) 分类:能定就定,定不了就不降级(宁可少降级,不要误降级)
+expect('402 → quota', classifyFailure(httpError(402, 'insufficient credits')).kind === 'quota')
+expect('401 → auth', classifyFailure(httpError(401, 'bad key')).kind === 'auth')
+expect('403 → auth', classifyFailure(httpError(403, 'forbidden')).kind === 'auth')
+expect('429(纯限流)→ rate-limit', classifyFailure(httpError(429, 'slow down')).kind === 'rate-limit')
+expect('429(含额度字样)→ quota', classifyFailure(httpError(429, 'quota exceeded')).kind === 'quota')
+expect('500 → server', classifyFailure(httpError(500)).kind === 'server')
+expect('503 → server', classifyFailure(httpError(503)).kind === 'server')
+expect('超时 → timeout', classifyFailure(Object.assign(new Error('timed out'), { name: 'TimeoutError' })).kind === 'timeout')
+expect('网络 → network', classifyFailure(new TypeError('fetch failed')).kind === 'network')
+const noKey = Object.assign(new Error('no key'), { code: 'no-key' })
+expect('无密钥 → no-key', classifyFailure(noKey).kind === 'no-key')
+expect('未知 → unknown(不降级)', classifyFailure(new Error('???')) && !KINDS.unknown.degraded)
+
+// 2) 会降级的类别,以及**两种降级方式**(2026-09-20,D15):
+//    · quota / auth = 服务侧状况 → 冷却式:到期放一次探测;
+//    · no-key = 本地配置状况 → **粘性**:没密钥时零 HTTP、没有可探测对象,所以靠"密钥出现"结束,
+//      而且带作用域 —— 只压制写下它的那条入口(密钥解析各入口独立,degraded.json 却是全机共享)。
+const degrading = Object.entries(KINDS).filter(([, v]) => v.degraded).map(([k]) => k).sort()
+expect('会降级的类别 = auth / no-key / quota', degrading.join(',') === 'auth,no-key,quota', degrading.join(','))
+expect('no-key 降级(没有效密钥必须像额度耗尽那样明说,而不是静默 fail-open)', KINDS['no-key'].degraded === true)
+expect('no-key 是粘性的(不靠时间结束)', KINDS['no-key'].sticky === true && cooldownMs('no-key', {}) === 0)
+expect('no-key 的作用域是本地(只压制写下它的入口)', KINDS['no-key'].scope === 'local' && kindScope('no-key') === 'local')
+expect('quota / auth 的作用域是全局(服务侧状况影响所有入口)',
+  kindScope('quota') === 'global' && kindScope('auth') === 'global' && KINDS.quota.scope === 'global')
+expect('rate-limit / server / timeout / network 也都不降级',
+  !KINDS['rate-limit'].degraded && !KINDS.server.degraded && !KINDS.timeout.degraded && !KINDS.network.degraded)
+
+// 3) 额度耗尽:这次判定 fail-open,并且**留下可读状态**
+script = [httpError(402, 'insufficient credits')]
+calls = []
+const first = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined, quotaGuard: true })
+expect('402 → 判定仍是 allow(fail-open)', first.action === 'allow' && first.source === 'error', `${first.action}/${first.source}`)
+expect('402 → 带上分类 errorKind=quota', first.errorKind === 'quota', String(first.errorKind))
+expect('402 → 判定上带着降级信息', first.degraded?.kind === 'quota')
+expect('402 → 判定上带着一句告警', typeof first.warning === 'string' && first.warning.includes('降级'))
+expect('402 → 确实发了一次请求', calls.length === 1, String(calls.length))
+const state = await readDegraded(cfg)
+expect('402 → 写出了降级状态文件', state !== null && state.kind === 'quota')
+expect('402 → 状态里有恢复时间与失败次数', Number.isFinite(state.until) && state.failures === 1)
+expect('402 → 状态文件里是人可读的 ISO 时间', typeof JSON.parse(await readFile(cfg.degradedPath, 'utf8')).until === 'string')
+
+// 4) 降级窗口内:不再发请求、直接放行、并告诉调用方为什么
+script = []
+calls = []
+const second = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('降级窗口内 → source=degraded', second.source === 'degraded', String(second.source))
+expect('降级窗口内 → 完全没有发请求(省钱)', calls.length === 0, String(calls.length))
+expect('降级窗口内 → allow', second.action === 'allow')
+expect('降级窗口内 → 理由里说明"没经过语义判定"', explain(CMD, second).includes('降级'), explain(CMD, second).slice(0, 80))
+// 这条单独立着:降级放行曾经复用预筛的文案("确定性预筛"),读者会以为它被确认过无害。
+expect('降级放行的理由不说"确定性预筛"', !explain(CMD, second).includes('确定性预筛'), explain(CMD, second).slice(0, 80))
+expect('降级放行的理由明确说未经过语义判定', explain(CMD, second).includes('未经过语义判定'))
+
+// 5) **免费的 L0 照常工作**(默认策略的核心承诺)
+calls = []
+const l0 = await evaluateCommand('mkfs.ext4 /dev/sdb1', { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('降级期间 L0 deny 仍然拦(免费层没停)', l0.action === 'block' && l0.source === 'static-rule', `${l0.action}/${l0.source}`)
+expect('降级期间 L0 判定也带着降级信息', l0.degraded?.kind === 'quota')
+expect('降级期间 L0 判定不发请求', calls.length === 0, String(calls.length))
+const l0ask = await evaluateCommand('truncate -s 0 /tmp/x.txt', { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('降级期间 L0 ask 仍然要求人工确认', l0ask.action === 'escalate' && l0ask.source === 'static-rule', `${l0ask.action}`)
+const fast = await evaluateCommand('ls -la /var/log', { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('降级期间预筛仍然放行只读命令', fast.source === 'prefilter')
+
+// 6) degradePolicy:'off' = 连 L0 一起暂停(显式选择,不是默认)
+const off = await evaluateCommand('mkfs.ext4 /dev/sdb1', { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined, degradePolicy: 'off' })
+expect("degradePolicy:'off' → 连 L0 也放行", off.action === 'allow' && off.source === 'degraded', `${off.action}/${off.source}`)
+
+// 7) 冷却到期 → 放**一次**探测;成功即自动恢复(不需要人做任何事)
+//
+// 种一个"已到期"的状态时**直接写文件**,不用 enterDegraded() —— 后者正是被测对象的一部分,
+// 用它来铺垫会污染 failures 计数(第一版就这么写,断言当场对不上)。
+const seedExpired = async (failures = 1) => {
+  const { writeFile } = await import('node:fs/promises')
+  await writeFile(cfg.degradedPath, `${JSON.stringify({
+    kind: 'quota', label: '判定服务额度已用尽', since: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
+    until: new Date(Date.now() - 60 * 1000).toISOString(), cooldownMs: 900000, failures, probes: 0, policy: 'l0-only',
+  })}\n`)
+}
+await seedExpired(1)
+const st = await readDegraded(cfg)
+expect('冷却已到期 → probeDue', probeDue(st, Date.now()) === true)
+script = [okAnswer(0.9, { input_tokens: 500, output_tokens: 20 })]
+calls = []
+const recovered = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('探测成功 → 恢复成正常判定', recovered.source === 'jev' && recovered.action === 'block', `${recovered.source}/${recovered.action}`)
+expect('探测成功 → 记录为 probe/recovered', recovered.probe === true && recovered.recovered === true, JSON.stringify({ probe: recovered.probe, recovered: recovered.recovered }))
+expect('探测成功 → 降级状态被清掉', (await readDegraded(cfg)) === null)
+expect('探测成功 → 拿到了 usage(成本可见性)', recovered.usage?.input_tokens === 500, JSON.stringify(recovered.usage))
+expect('此时文件目录里没有残留 tmp 文件', (await readdir(dir)).every(f => !f.endsWith('.tmp')), (await readdir(dir)).join(','))
+
+// 8) 探测失败 → 继续降级(而且不会每命令都试)
+await seedExpired(1)
+script = [httpError(402, 'still no credits')]
+calls = []
+const stillDown = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('探测失败 → 仍然 fail-open', stillDown.action === 'allow' && stillDown.source === 'error')
+expect('探测失败 → 判定上标记为一次探测', stillDown.probe === true)
+const renewed = await readDegraded(cfg)
+expect('探测失败 → 续期(failures 1 → 2,probes 0 → 1)', renewed.failures === 2 && renewed.probes === 1, JSON.stringify({ f: renewed.failures, p: renewed.probes }))
+const afterProbe = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('续期之后不再试(一次探测只花一次钱)', afterProbe.source === 'degraded' && calls.length === 1, `${afterProbe.source}/${calls.length}`)
+
+// 9) 瞬态失败**不**降级(超时/网络/5xx 只逐次放行)
+await clearDegraded(cfg)
+script = [Object.assign(new Error('timed out'), { name: 'TimeoutError' })]
+const transient = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('超时 → fail-open 但不降级', transient.source === 'error' && transient.errorKind === 'timeout' && (await readDegraded(cfg)) === null)
+
+// 10) 状态文件坏掉 → 当作健康(宁可去问一次 API,也不要卡在降级里)
+const { writeFile } = await import('node:fs/promises')
+await writeFile(cfg.degradedPath, '{ 这不是 JSON')
+expect('损坏的状态文件 → readDegraded 返回 null', (await readDegraded(cfg)) === null)
+script = [okAnswer(0.1)]
+const afterCorrupt = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined })
+expect('损坏状态下照常发请求', afterCorrupt.source === 'jev', String(afterCorrupt.source))
+
+// 11) 告警与状态报告是给人看的,必须包含"原因/还剩多久/现在还剩哪一层"
+await enterDegraded('quota', { cfg, detail: 'HTTP 402: insufficient credits' })
+const warn = warningLine(await readDegraded(cfg))
+expect('告警行含"降级"、类别与剩余时间', warn.includes('降级') && warn.includes('额度') && warn.includes('分钟'), warn)
+const report = statusText(await readDegraded(cfg))
+expect('状态报告含原因', report.includes('额度'))
+expect('状态报告含恢复方式(自动探测)', report.includes('自动探测'))
+expect('状态报告说明免费层仍在工作', report.includes('L0'))
+expect('状态报告含原始错误', report.includes('402'))
+const healthy = statusText(null, Date.now(), { apiKeyPresent: false })
+expect('健康状态报告会指出"没有密钥"', healthy.includes('正常') && healthy.includes('没有解析到'))
+
+// 12) 没有状态文件时,一切都是普通路径
+await clearDegraded(cfg)
+expect('清除后 isDegraded=false', isDegraded(await readDegraded(cfg)) === false)
+
+// 13) **没有密钥 → 粘性降级**(D15):一次 HTTP 都不发,而且不靠时间结束
+script = []
+calls = []
+await clearDegraded(cfg)
+const noKeyVerdict = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: undefined, cache: undefined, scope: 'cli' })
+expect('没有密钥 → 仍然 fail-open(allow)但带着分类', noKeyVerdict.action === 'allow' && noKeyVerdict.errorKind === 'no-key',
+  `${noKeyVerdict.action}/${noKeyVerdict.errorKind}`)
+expect('没有密钥 → 一次请求都没发(没有可花钱的东西)', calls.length === 0, String(calls.length))
+expect('没有密钥 → 判定上带着粘性告警', String(noKeyVerdict.warning ?? '').includes('条件消失'), String(noKeyVerdict.warning))
+const nk = await readDegraded(cfg)
+expect('没有密钥 → 写出了降级状态', nk !== null && nk.kind === 'no-key', String(nk?.kind))
+expect('没有密钥 → 状态里记了粘性与入口身份', isSticky(nk) === true && nk.scope === 'cli', JSON.stringify({ sticky: nk?.sticky, scope: nk?.scope }))
+const farFuture = nk.until + 24 * 3600 * 1000
+expect('粘性不靠时间:一天之后仍然是降级', isDegraded(nk, farFuture, 'cli') === true)
+expect('粘性永不探测(没有可探测对象)', probeDue(nk, farFuture, 'cli') === false)
+expect('粘性告警不说"等 N 分钟"(它不等时间)', !warningLine(nk).includes('分钟'), warningLine(nk))
+expect('粘性状态报告写明"当场自动恢复"', statusText(nk).includes('当场自动恢复'), statusText(nk).split('\n')[3] ?? '')
+expect('粘性状态报告说明影响范围仅本入口', statusText(nk).includes('cli'), statusText(nk))
+calls = []
+const stillNoKey = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: undefined, cache: undefined, scope: 'cli' })
+expect('粘性窗口内 → 直接放行,不再去撞密钥', stillNoKey.source === 'degraded' && calls.length === 0, `${stillNoKey.source}/${calls.length}`)
+
+// 14) **作用域隔离**:某条入口读不到密钥,不该把密钥正常的其它入口按停
+await clearDegraded(cfg)
+await enterDegraded('no-key', { cfg, scope: 'cli' })
+const scoped = await readDegraded(cfg)
+expect('CLI 的 no-key 状态对自己生效', isDegraded(scoped, Date.now(), 'cli') === true)
+expect('CLI 的 no-key 状态**不**压制 DSH 侧', isDegraded(scoped, Date.now(), 'dsh-adapter') === false)
+expect('CLI 的 no-key 状态对 DSH 侧也不算探测到期', probeDue(scoped, Date.now(), 'dsh-adapter') === false)
+script = [okAnswer(0.9)]
+calls = []
+const otherEntry = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined, scope: 'dsh-adapter' })
+expect('别的入口照常判定(没有被按停)', otherEntry.source === 'jev' && calls.length === 1, `${otherEntry.source}/${calls.length}`)
+// 服务侧状态相反:quota 描述的是"服务坏了",它对每条入口都成立,所以是全局的。
+await clearDegraded(cfg)
+await enterDegraded('quota', { cfg })
+const globalState = await readDegraded(cfg)
+expect('服务侧(quota)状态压制所有入口',
+  isDegraded(globalState, Date.now(), 'cli') === true && isDegraded(globalState, Date.now(), 'dsh-adapter') === true)
+expect('服务侧状态的作用域记为 global', globalState.scope === 'global', String(globalState.scope))
+
+// 15) **密钥一出现 → 粘性状态当场清除**(不重启、不等冷却)
+await clearDegraded(cfg)
+await enterDegraded('no-key', { cfg, scope: 'cli' })
+expect('铺垫:粘性 no-key 状态在位', (await readDegraded(cfg))?.kind === 'no-key')
+script = [okAnswer(0.9)]
+calls = []
+const revived = await evaluateCommand(CMD, { ...DEFAULTS, ...cfg, apiKey: 'x', cache: undefined, scope: 'cli' })
+expect('密钥出现 → 恢复成正常判定', revived.source === 'jev' && revived.action === 'block', `${revived.source}/${revived.action}`)
+expect('密钥出现 → 状态文件当场清掉', (await readDegraded(cfg)) === null)
+expect('密钥出现 → 只花了一次请求(没有多余探测)', calls.length === 1, String(calls.length))
+
+await rm(dir, { recursive: true, force: true })
+process.stdout.write(`\n${failed === 0 ? '全部通过' : `${failed} 项失败`}(${checks} 例)\n`)
+process.exit(failed === 0 ? 0 : 1)