dsh-router-core 0.3.14 → 0.3.15

package/docs/suppliers.md

@@ -14,7 +14,7 @@
 | | 谁负责 |
 |---|---|
 | 组合回退、按策略选中模型 | 核心 |
-| **账号池**:选号、冷却、禁用、遍历回退 | 核心 |
+| **账号池**:选号、冷却、遍历回退 | 核心 |
 | 响应写入(状态行、SSE 头、JSON body) | 核心 |
 | 模型启用/禁用、自定义模型、别名 | 核心 |
 | 凭证存储(`env.credentials`) | 核心 |
@@ -75,7 +75,7 @@ js 报告**此刻**观察到的账户状况,而不是把上游原始响应丢给
 | `ok` | 正常 |
 | `rate_limit` | 限流(429 类) |
 | `quota` | 额度/权益不足 |
-| `session_dead` | 凭证彻底失效,必须重新登录才能恢复 |
+| `session_dead` | 凭证失效/凭证被上游拒(403 类,含风控误伤) |
 | `unavailable` | 上游不可用(404 / 服务下线) |
 | `transport` | 网络/连接层失败(没拿到 HTTP 状态) |
 | `unknown` | 说不清是什么错 |
@@ -86,11 +86,11 @@ js 报告**此刻**观察到的账户状况,而不是把上游原始响应丢给
 都报一次,于是一个都选不出来(表现为「组合越用越没号可用」)。所以「这个模型
 不属于我」一定要报 `no_such_model`,核心才知道该换供应商而不是换账号。
 
-**js 只说「现在怎么了」,不说「该怎么办」。** 冷却多久、是否禁用、要不要换号
+**js 只说「现在怎么了」,不说「该怎么办」。** 冷却多久、要不要换号
 都是核心的策略(见下),js 不该自己记冷却表——那样每个插件都会长出一份
 互相不一致的实现。
 
-核心在 `status()` 之上叠加 `cooling` / `disabled` / `err_count` / `until` / `reason`
+核心在 `status()` 之上叠加 `cooling` / `err_count` / `until` / `reason`
 再给面板,所以 js 不用(也不该)填这些字段。`accounts` 为空数组 = 无账号供应商。
 注意 `err_count` 现在是**限流退避等级**(反复被限流的号等级递增),不是
 「连续失败次数」——面板按等级展示,等级在成功后清零。
@@ -101,7 +101,7 @@ js 只要知道这一条:**报 `rate_limit`/`transport`/`unknown` 只影响「
 模型」**,不会牵连该号上的其它模型。一个连接服务多个模型时,模型 A 被限流不该
 让模型 B 也不可用。
 
-例外是 `session_dead`:凭证失效是连接级问题,该号**所有模型**都停用。
+例外是 `session_dead`:凭证失效是连接级问题,该号**所有模型**都停用(连接级冷却,到期自愈)。
 
 ## `chatOnce(uid, req)`:一次只服务一个账号
 
@@ -124,7 +124,7 @@ type ChatOnceResult =
 |---|---|
 | `rate_limit` | **指数退避**:首次 2s,每次翻倍,上限 5 分钟;成功后等级清零 |
 | `quota` | 冷却 10 分钟 |
-| `session_dead` | **永久禁用该号**(所有模型都停用,需重新登录才能恢复) |
+| `session_dead` | **连接级冷却 30 分钟**(该号所有模型都停用,到期自愈;没有永久禁用——403 分不清凭证死活与风控误伤) |
 | `unavailable` / `transport` / `unknown` | 瞬时短冷却 30s(**每次都冷**,不攒次数) |
 | `no_such_model` | **不惩罚账号**,核心直接跳过整个供应商换下一个 |
 
@@ -137,7 +137,7 @@ type ChatOnceResult =
 「请求参数非法」「上游临时不可用」)建议归 `rate_limit`——瞬时/请求类的错,
 短冷换号比长冷划算。
 
-冷却/禁用/退避等级都是**内存态**,重启归零(与凭证、积分的持久化不同)。
+冷却/退避等级都是**内存态**,重启归零(与凭证、积分的持久化不同)。
 重启后所有号都会重新被选中一次,所以**上游确实挂了的号会各撞一次**,属预期。
 要跨重启保留,届时给账号池加一个落盘 state 文件即可,接口不用变。
 
@@ -274,7 +274,7 @@ export const id = 'echo'
 export const name = 'Echo'
 export const priority = 10
 
-// 只报「现在状态」:冷却/禁用/退避等级由核心叠加,积分由核心持久化
+// 只报「现在状态」:冷却/退避等级由核心叠加,积分由核心持久化
 // credits: -1 = 不支持/没拉到(别写 0,0 会被当成「用完了」存下来)
 const accounts = [{ uid: 'echo-1', nickname: 'Echo 1', credits: -1, state: 'ok' }]
 

package/lib/client-registry.js

@@ -116,10 +116,6 @@ window.__ModuleLoader__.load({
 			return `剩余 ${Math.ceil(minutes / 60)} 小时`;
 		}
 		function statusBadge(account) {
-			if (account.disabled) return {
-				text: "已禁用",
-				cls: "dshr-badge-danger"
-			};
 			if (account.cooling) return {
 				text: "冷却中",
 				cls: "dshr-badge-warn"
@@ -768,7 +764,7 @@ window.__ModuleLoader__.load({
 							className: "dshr-linkList",
 							children: orderedAccounts.map((account, index) => {
 								const badge = statusBadge(account);
-								const coolingText = account.cooling || account.disabled ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
+								const coolingText = account.cooling ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
 								return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 									className: `dshr-linkRow${dragIndex === index ? " dshr-linkRowDragging" : ""}`,
 									draggable: renameUid !== account.uid,
@@ -3585,7 +3581,7 @@ window.__ModuleLoader__.load({
 						className: "dshr-supplierGrid",
 						children: group.map((supplier) => {
 							const supplierAccounts = accounts.filter((a) => a.supplier === supplier.id);
-							const healthy = supplierAccounts.filter((a) => !a.cooling && !a.disabled).length;
+							const healthy = supplierAccounts.filter((a) => !a.cooling).length;
 							return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								className: "dshr-supplierCard",
 								onClick: () => setDetailSupplier(supplier),

package/lib/client.js

@@ -116,10 +116,6 @@ window.__ModuleLoader__.load({
 			return `剩余 ${Math.ceil(minutes / 60)} 小时`;
 		}
 		function statusBadge(account) {
-			if (account.disabled) return {
-				text: "已禁用",
-				cls: "dshr-badge-danger"
-			};
 			if (account.cooling) return {
 				text: "冷却中",
 				cls: "dshr-badge-warn"
@@ -768,7 +764,7 @@ window.__ModuleLoader__.load({
 							className: "dshr-linkList",
 							children: orderedAccounts.map((account, index) => {
 								const badge = statusBadge(account);
-								const coolingText = account.cooling || account.disabled ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
+								const coolingText = account.cooling ? `${account.reason ?? ""}${untilLabel(account) !== "" ? ` · ${untilLabel(account)}` : ""}` : "";
 								return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 									className: `dshr-linkRow${dragIndex === index ? " dshr-linkRowDragging" : ""}`,
 									draggable: renameUid !== account.uid,
@@ -3585,7 +3581,7 @@ window.__ModuleLoader__.load({
 						className: "dshr-supplierGrid",
 						children: group.map((supplier) => {
 							const supplierAccounts = accounts.filter((a) => a.supplier === supplier.id);
-							const healthy = supplierAccounts.filter((a) => !a.cooling && !a.disabled).length;
+							const healthy = supplierAccounts.filter((a) => !a.cooling).length;
 							return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								className: "dshr-supplierCard",
 								onClick: () => setDetailSupplier(supplier),

package/lib/index.js

@@ -106,42 +106,34 @@ const MINUTE = 6e4;
 const RULES = {
 	ok: {
 		cooldown: 0,
-		disable: false,
 		counts: false
 	},
 	rate_limit: {
 		cooldown: "backoff",
-		disable: false,
 		counts: false
 	},
 	quota: {
 		cooldown: 10 * MINUTE,
-		disable: false,
 		counts: false
 	},
 	session_dead: {
-		cooldown: 0,
-		disable: true,
+		cooldown: 30 * MINUTE,
 		counts: false
 	},
 	unavailable: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	transport: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	unknown: {
 		cooldown: "transient",
-		disable: false,
 		counts: false
 	},
 	no_such_model: {
 		cooldown: 0,
-		disable: false,
 		counts: false
 	}
 };
@@ -183,7 +175,7 @@ var AccountPool = class {
 	supplierId;
 	/** (supplier, model, uid) → 冷却/退避。 */
 	cooldowns = /* @__PURE__ */ new Map();
-	/** uid → 连接级禁用 / 手动暂停。 */
+	/** uid → 连接级冷却 / 手动暂停。 */
 	byUid = /* @__PURE__ */ new Map();
 	rrCursor = 0;
 	/** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -213,46 +205,30 @@ var AccountPool = class {
 		}
 		return e;
 	}
-	/** 某连接整体状态（禁用/手动暂停）。 */
+	/** 某连接整体状态（连接级冷却/手动暂停）。 */
 	uidState(uid) {
 		let e = this.byUid.get(uid);
 		if (!e) {
 			e = {
 				until: 0,
-				disabled: false,
 				reason: ""
 			};
 			this.byUid.set(uid, e);
 		}
 		return e;
 	}
-	/** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
+	/** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
 	uidBlocked(uid, now) {
 		const e = this.byUid.get(uid);
-		if (!e) return {
-			blocked: false,
-			disabled: false
-		};
-		if (e.disabled) return {
-			blocked: true,
-			disabled: true
-		};
-		if (e.until > now) return {
-			blocked: true,
-			disabled: false
-		};
-		return {
-			blocked: false,
-			disabled: false
-		};
+		return e !== void 0 && e.until > now;
 	}
 	/**
 	* 给定要试的模型，该连接是否可服务：
-	*  - 未被连接级禁用/手动暂停（跨模型）；
+	*  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
 	*  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
 	*/
 	healthy(uid, model, now) {
-		if (this.uidBlocked(uid, now).blocked) return false;
+		if (this.uidBlocked(uid, now)) return false;
 		const c = this.cooldowns.get(this.key(model, uid));
 		if (!c) return true;
 		return c.until <= now;
@@ -371,16 +347,17 @@ var AccountPool = class {
 	blockKey(modelId) {
 		return `${this.supplierId}${SEP}${modelId}`;
 	}
-	/** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+	/** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
 	noteFailure(uid, modelId, state, message) {
 		const rule = RULES[state];
-		if (rule.disable) {
+		if (rule.cooldown === 0) return;
+		if (state === "session_dead") {
 			const e = this.uidState(uid);
-			e.disabled = true;
+			const cd = rule.cooldown;
+			e.until = Math.max(e.until, Date.now() + (typeof cd === "number" ? cd : 0));
 			e.reason = message;
 			return;
 		}
-		if (rule.cooldown === 0) return;
 		const e = this.entry(modelId, uid);
 		e.reason = message;
 		if (rule.cooldown === "backoff") {
@@ -394,7 +371,7 @@ var AccountPool = class {
 		}
 		e.until = Math.max(e.until, Date.now() + rule.cooldown);
 	}
-	/** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+	/** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
 	noteSuccess(uid, modelId) {
 		const e = this.cooldowns.get(this.key(modelId, uid));
 		if (e) e.backoffLevel = 0;
@@ -406,7 +383,7 @@ var AccountPool = class {
 		e.reason = reason;
 		for (const [k, ce] of this.cooldowns) if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0;
 	}
-	/** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+	/** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
 	*
 	* 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
 	* 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -417,11 +394,10 @@ var AccountPool = class {
 		const now = Date.now();
 		return accounts.map((a) => {
 			const u = this.byUid.get(a.uid);
-			const disabled = u?.disabled ?? false;
-			const manualCooling = u !== void 0 && !u.disabled && u.until > now;
-			let cooling = manualCooling;
-			let maxUntil = manualCooling ? u.until : 0;
-			let reason = manualCooling ? u.reason : void 0;
+			const uidCooling = u !== void 0 && u.until > now;
+			let cooling = uidCooling;
+			let maxUntil = uidCooling ? u.until : 0;
+			let reason = uidCooling ? u.reason : void 0;
 			let err = 0;
 			for (const [k, ce] of this.cooldowns) {
 				if (!k.endsWith(`${SEP}${a.uid}`)) continue;
@@ -441,7 +417,6 @@ var AccountPool = class {
 			return {
 				...a,
 				cooling,
-				disabled,
 				err_count: err,
 				until: cooling && maxUntil > 0 ? new Date(maxUntil).toISOString() : void 0,
 				reason: reason !== void 0 && reason !== "" ? reason : void 0
@@ -3207,7 +3182,7 @@ function cap(set, key) {
 }
 /** 账号状态指纹（积分 + 健康），用于判断刷新是否落地。 */
 function fingerprint(accounts) {
-	return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}:${a.disabled}`).join("|");
+	return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}`).join("|");
 }
 /**
 * 反复调插件已有的 status()，直到快照稳定再返回（是否有变化 = changed）。

package/lib/types/router/account-pool.d.ts

@@ -1,5 +1,5 @@
 /**
- * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、遍历回退。
+ * 账号池 —— dsh-router 核心策略：选号、冷却、遍历回退。
  *
  * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里。
  *
@@ -11,7 +11,8 @@
  * 失败而对其它模型也不可用，这是错的。
  *
  *   - 冷却/限流退避/瞬时 → 键 = (supplierId, modelId, uid)，只冷「这个号 × 这个模型」
- *   - 禁用(session_dead)     → 键 = uid（登录态问题，该号所有模型都不可用）
+ *   - 凭证失效(session_dead) → 键 = uid 连接级冷却（登录态问题，该号所有模型都不可用）；
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，冷却到期自愈
  *   - 手动冷却(面板)         → 键 = uid（管理员整连接暂停）
  *
  * 为什么键里要带 supplierId：不同供应商**会有同名的模型 id**（如 traework 与
@@ -19,7 +20,7 @@
  * 会把跨供应商的同名模型串到一起。尽管本池实例当前是单供应商（loader 每供应商
  * 一个 AccountPool），键仍显式带 supplierId，语义自明且将来若池合并也安全。
  *
- * 天花板：冷却/禁用都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
+ * 天花板：冷却都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
  * 得落盘，届时加 stateFile 即可，接口不用变。
  */
 import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts';
@@ -28,7 +29,7 @@ export declare class AccountPool {
     private supplierId;
     /** (supplier, model, uid) → 冷却/退避。 */
     private cooldowns;
-    /** uid → 连接级禁用 / 手动暂停。 */
+    /** uid → 连接级冷却 / 手动暂停。 */
     private byUid;
     private rrCursor;
     /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -42,13 +43,13 @@ export declare class AccountPool {
     constructor(supplierId?: string);
     private key;
     private entry;
-    /** 某连接整体状态（禁用/手动暂停）。 */
+    /** 某连接整体状态（连接级冷却/手动暂停）。 */
     private uidState;
-    /** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
+    /** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
     private uidBlocked;
     /**
      * 给定要试的模型，该连接是否可服务：
-     *  - 未被连接级禁用/手动暂停（跨模型）；
+     *  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
      *  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
      */
     private healthy;
@@ -109,13 +110,13 @@ export declare class AccountPool {
     dropBlock(modelId: string): void;
     /** 块状态键：与冷却同粒度 (supplier, model)，不含 uid。 */
     private blockKey;
-    /** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+    /** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
     noteFailure(uid: string, modelId: string, state: AccountState, message: string): void;
-    /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+    /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
     noteSuccess(uid: string, modelId: string): void;
     /** 手动暂停整连接（面板/管理用途，跨模型）。ms<=0 表示解除。 */
     cooldown(uid: string, ms: number, reason: string): void;
-    /** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+    /** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
      *
      * 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
      * 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -124,7 +125,6 @@ export declare class AccountPool {
      */
     decorate(accounts: SupplierAccountNow[], modelId?: string): Array<SupplierAccountNow & {
         cooling: boolean;
-        disabled: boolean;
         err_count: number;
         until?: string;
         reason?: string;

package/lib/types/router/types.d.ts

@@ -13,7 +13,6 @@ export interface SupplierAccount {
     cooling: boolean;
     until?: string;
     reason?: string;
-    disabled: boolean;
     err_count?: number;
 }
 /** 供应商面板状态。 */

package/lib/types/shared.d.ts

@@ -22,7 +22,6 @@ export interface RouterAccount {
     cooling: boolean;
     until?: string;
     reason?: string;
-    disabled: boolean;
     err_count?: number;
     /** 所属供应商 id。 */
     supplier?: string;

package/lib/types/suppliers/contract.d.ts

@@ -30,7 +30,7 @@ export interface SupplierEnv {
      * 不报上来，它就会继续留在池里被轮转选中，每次都白撞一次同一个错误。
      *
      * 核心实现 = `pool.noteFailure(uid, model, state, message)`，按该状态的规则
-     * 冷却/禁用。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
+     * 冷却。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
      * 流内 `code=4008`，三个号里两个如此，round-robin 下 2/3 请求直接失败
      * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出轮转。
      *
@@ -43,7 +43,7 @@ export type SupplierFactory = (env: SupplierEnv) => SupplierModule;
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
  *
- * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、要不要换号
  * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
  *
  * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
@@ -57,7 +57,7 @@ export type AccountState = 'ok' | 'rate_limit' | 'quota' | 'session_dead' | 'una
  * 把它冷却掉（历史上正是这个坑）。
  */
  | 'no_such_model';
-/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {
     uid: string;
     nickname?: string;
@@ -92,7 +92,7 @@ export type ChatOnceResult =
     status: number;
     body: string;
 }
-/** 失败：核心据此做冷却/禁用/换号。 */
+/** 失败：核心据此做冷却/换号。 */
  | {
     ok: false;
     state: AccountState;
@@ -114,7 +114,7 @@ export interface SupplierModule {
      * 应提供它——否则所有供应商弹窗都显示同一句通用提示（如默认会写 OpenRouter）。
      */
     readonly apiKeyHint?: string;
-    /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+    /** 报账号「现在状态」。冷却/错误累计由核心叠加，插件不算这些。 */
     status(): SupplierStatusNow;
     /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
     listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {

package/src/client/RouterView.tsx

@@ -100,7 +100,7 @@ export function RouterView({ onBack }: RouterViewProps): JSX.Element {
         <div className="dshr-supplierGrid">
           {group.map(supplier => {
             const supplierAccounts = accounts.filter(a => a.supplier === supplier.id)
-            const healthy = supplierAccounts.filter(a => !a.cooling && !a.disabled).length
+            const healthy = supplierAccounts.filter(a => !a.cooling).length
             return (
               <section key={supplier.id} className="dshr-supplierCard" onClick={() => setDetailSupplier(supplier)}>
                 <div className="dshr-supplierRow">

package/src/client/SupplierDetail.tsx

@@ -62,7 +62,6 @@ function untilLabel(account: RouterAccount): string {
 }
 
 function statusBadge(account: RouterAccount): { text: string; cls: string } {
-  if (account.disabled) return { text: '已禁用', cls: 'dshr-badge-danger' }
   if (account.cooling) return { text: '冷却中', cls: 'dshr-badge-warn' }
   return { text: '健康', cls: 'dshr-badge-ok' }
 }
@@ -666,7 +665,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
               <div className="dshr-linkList">
                 {orderedAccounts.map((account, index) => {
                   const badge = statusBadge(account)
-                  const coolingText = account.cooling || account.disabled
+                  const coolingText = account.cooling
                     ? `${account.reason ?? ''}${untilLabel(account) !== '' ? ` · ${untilLabel(account)}` : ''}`
                     : ''
                   return (

package/src/router/account-pool.test.ts

@@ -1,10 +1,11 @@
 /**
- * 账号池（核心策略）测试 —— 选号/冷却/禁用/遍历回退。
+ * 账号池（核心策略）测试 —— 选号/冷却/遍历回退。
  *
  * 关键语义（v2）：
  *   - 冷却单元 = (supplierId, modelId, uid)。某连接在模型 A 上失败，只冷
  *     (A, 该连接)，该连接调模型 B 不受影响。
- *   - 禁用(session_dead) = 连接级(uid)：该号所有模型都不可用。
+ *   - session_dead = 连接级(uid)可恢复冷却：该号所有模型都不可用，到期自愈。
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，误伤号不该被钉死。
  *   - no_such_model 不惩罚账号（模型不属于本供应商不是号的错）。
  * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
  */
@@ -327,16 +328,18 @@ test('【颗粒度】同一连接对不同模型的退避独立累加/清零', (
   assert.equal(p.decorate(list, 'm1')[0]?.err_count, 0)
 })
 
-// ============ 连接级禁用(跨模型) ============
+// ============ 连接级冷却(跨模型, session_dead) ============
 
-test('【颗粒度】session_dead 是连接级禁用：跨该号所有模型', () => {
+test('【颗粒度】session_dead 是连接级冷却：跨该号所有模型，到期自愈', () => {
   const p = pool()
   const list = accs(['a'])
   p.noteFailure('a', 'm1', 'session_dead', '凭证失效')
   // 该号在 m1、m2 上都不可用（登录态问题，不是模型问题）
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined)
   assert.equal(p.pick(list, [], 'fallback', 'm2'), undefined)
-  assert.equal(p.decorate(list)[0]?.disabled, true)
+  const d = p.decorate(list)[0]
+  assert.equal(d?.cooling, true)
+  assert.ok(d?.until !== undefined, 'session_dead 冷却必须有 until（可恢复）')
 })
 
 test('处置：未知错误第一次就冷却（坏号不留在池里等下一次撞）', () => {
@@ -347,7 +350,7 @@ test('处置：未知错误第一次就冷却（坏号不留在池里等下一
   assert.equal(p.pick(list.filter((x) => x.uid === 'a'), [], 'fallback', 'm1'), undefined)
 })
 
-test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（聚合展示）', () => {
+test('decorate：把冷却叠加到插件报的「现在状态」上（聚合展示）', () => {
   const p = pool()
   const list: SupplierAccountNow[] = [
     { uid: 'ok', credits: 5, state: 'ok' },
@@ -359,10 +362,9 @@ test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（
   const out = p.decorate(list)
   const by = new Map(out.map((a) => [a.uid, a]))
   assert.equal(by.get('ok')?.cooling, false)
-  assert.equal(by.get('ok')?.disabled, false)
   assert.equal(by.get('cool')?.cooling, true)
   assert.equal(by.get('cool')?.until !== undefined, true)
-  assert.equal(by.get('dead')?.disabled, true)
+  assert.equal(by.get('dead')?.cooling, true, 'session_dead 连接级冷却也展示为冷却中')
   // 插件报的字段要原样透出（不能被 decorate 吃掉）
   assert.equal(by.get('ok')?.credits, 5)
 })
@@ -375,7 +377,6 @@ test('no_such_model 不惩罚账号：不冷却、不计数', () => {
   assert.equal(p.pick(list, [], 'fallback', 'm1'), 'a')
   const out = p.decorate(list, 'm1')[0]
   assert.equal(out?.cooling, false)
-  assert.equal(out?.disabled, false)
   assert.equal(out?.err_count, 0)
 })
 
@@ -389,7 +390,7 @@ test('状态表：各 AccountState 的处置符合预期', () => {
   const by = new Map(p.decorate(list).map((a) => [a.uid, a]))
   assert.equal(by.get('rate')?.cooling, true)
   assert.equal(by.get('quota')?.cooling, true)
-  assert.equal(by.get('dead')?.disabled, true)
+  assert.equal(by.get('dead')?.cooling, true, 'session_dead = 连接级冷却')
   assert.equal(by.get('unavail')?.cooling, true, '瞬时错误第一次就冷却')
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined, '四个号都不可服务')
 })

package/src/router/account-pool.ts

@@ -1,5 +1,5 @@
 /**
- * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、遍历回退。
+ * 账号池 —— dsh-router 核心策略：选号、冷却、遍历回退。
  *
  * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里。
  *
@@ -11,7 +11,8 @@
  * 失败而对其它模型也不可用，这是错的。
  *
  *   - 冷却/限流退避/瞬时 → 键 = (supplierId, modelId, uid)，只冷「这个号 × 这个模型」
- *   - 禁用(session_dead)     → 键 = uid（登录态问题，该号所有模型都不可用）
+ *   - 凭证失效(session_dead) → 键 = uid 连接级冷却（登录态问题，该号所有模型都不可用）；
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，冷却到期自愈
  *   - 手动冷却(面板)         → 键 = uid（管理员整连接暂停）
  *
  * 为什么键里要带 supplierId：不同供应商**会有同名的模型 id**（如 traework 与
@@ -19,13 +20,13 @@
  * 会把跨供应商的同名模型串到一起。尽管本池实例当前是单供应商（loader 每供应商
  * 一个 AccountPool），键仍显式带 supplierId，语义自明且将来若池合并也安全。
  *
- * 天花板：冷却/禁用都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
+ * 天花板：冷却都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
  * 得落盘，届时加 stateFile 即可，接口不用变。
  */
 import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts'
 import { prefixFingerprint } from './prefix-affinity.ts'
 
-/** 各 AccountState 的处置：冷却策略 / 是否禁用 / 是否计入连续错误。 */
+/** 各 AccountState 的处置：冷却策略 / 是否计入连续错误。 */
 interface Rule {
   /**
    * 冷却策略：
@@ -35,14 +36,19 @@ interface Rule {
    *  - `0` 不冷却
    */
   cooldown: number | 'transient' | 'backoff'
-  /** 是否永久禁用（需重新登录才能恢复）。 */
-  disable: boolean
   /** 是否计入连续错误（攒够阈值自动冷却）。 */
   counts: boolean
 }
 
 const MINUTE = 60_000
 
+/**
+ * 凭证失效（session_dead）的连接级冷却时长。
+ * 403 = 凭证死 or 风控误伤，上游语义分不清——取「足够长、但不永久」的窗口：
+ * 误伤号到点自愈（用户无需重启/重登），真死号每窗口只重试一次，不刷上游。
+ */
+const SESSION_DEAD_COOLDOWN_MS = 30 * MINUTE
+
 /**
  * 状态 → 处置表。**核心策略就在这一张表里**，插件只报状态不做决策。
  *
@@ -57,16 +63,19 @@ const MINUTE = 60_000
  * 核心不必再猜文本，更准。
  */
 const RULES: Record<AccountState, Rule> = {
-  ok: { cooldown: 0, disable: false, counts: false },
-  rate_limit: { cooldown: 'backoff', disable: false, counts: false },
-  quota: { cooldown: 10 * MINUTE, disable: false, counts: false },
-  session_dead: { cooldown: 0, disable: true, counts: false },
+  ok: { cooldown: 0, counts: false },
+  rate_limit: { cooldown: 'backoff', counts: false },
+  quota: { cooldown: 10 * MINUTE, counts: false },
+  // 凭证失效也只做**连接级冷却**（跨该号所有模型），到期自愈：上游 403 常是
+  // 风控/WAF 拦截，与凭证死活分不清（codebuddy 三号被 403 误禁的教训）。
+  // 真死号损失 = 每窗口重试一次，可接受；误伤号到点自动回来，无需重启。
+  session_dead: { cooldown: SESSION_DEAD_COOLDOWN_MS, counts: false },
   // 404/服务下线、传输中断、未知：每次都瞬时短冷却（见上方 9router 对齐说明）
-  unavailable: { cooldown: 'transient', disable: false, counts: false },
-  transport: { cooldown: 'transient', disable: false, counts: false },
-  unknown: { cooldown: 'transient', disable: false, counts: false },
+  unavailable: { cooldown: 'transient', counts: false },
+  transport: { cooldown: 'transient', counts: false },
+  unknown: { cooldown: 'transient', counts: false },
   // 模型不属于本供应商：不是账号的错，不冷却也不计数（核心据此换下一个供应商）
-  no_such_model: { cooldown: 0, disable: false, counts: false },
+  no_such_model: { cooldown: 0, counts: false },
 }
 
 /**
@@ -112,10 +121,9 @@ interface CooldownEntry {
   reason: string
 }
 
-/** 连接级禁用/手动暂停记录（键 = uid）。 */
+/** 连接级冷却/手动暂停记录（键 = uid，跨该号所有模型）。 */
 interface UidEntry {
   until: number
-  disabled: boolean
   reason: string
 }
 
@@ -166,7 +174,7 @@ export class AccountPool {
   private supplierId: string
   /** (supplier, model, uid) → 冷却/退避。 */
   private cooldowns = new Map<string, CooldownEntry>()
-  /** uid → 连接级禁用 / 手动暂停。 */
+  /** uid → 连接级冷却 / 手动暂停。 */
   private byUid = new Map<string, UidEntry>()
   private rrCursor = 0
   /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -196,33 +204,29 @@ export class AccountPool {
     return e
   }
 
-  /** 某连接整体状态（禁用/手动暂停）。 */
+  /** 某连接整体状态（连接级冷却/手动暂停）。 */
   private uidState(uid: string): UidEntry {
     let e = this.byUid.get(uid)
     if (!e) {
-      e = { until: 0, disabled: false, reason: '' }
+      e = { until: 0, reason: '' }
       this.byUid.set(uid, e)
     }
     return e
   }
 
-  /** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
-  private uidBlocked(uid: string, now: number): { blocked: boolean; disabled: boolean } {
+  /** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
+  private uidBlocked(uid: string, now: number): boolean {
     const e = this.byUid.get(uid)
-    if (!e) return { blocked: false, disabled: false }
-    if (e.disabled) return { blocked: true, disabled: true }
-    if (e.until > now) return { blocked: true, disabled: false }
-    return { blocked: false, disabled: false }
+    return e !== undefined && e.until > now
   }
 
   /**
    * 给定要试的模型，该连接是否可服务：
-   *  - 未被连接级禁用/手动暂停（跨模型）；
+   *  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
    *  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
    */
   private healthy(uid: string, model: string, now: number): boolean {
-    const b = this.uidBlocked(uid, now)
-    if (b.blocked) return false
+    if (this.uidBlocked(uid, now)) return false
     const c = this.cooldowns.get(this.key(model, uid))
     if (!c) return true
     return c.until <= now
@@ -367,18 +371,19 @@ export class AccountPool {
     return `${this.supplierId}${SEP}${modelId}`
   }
 
-  /** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+  /** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
   noteFailure(uid: string, modelId: string, state: AccountState, message: string): void {
     const rule = RULES[state]
-    // 禁用 / 手动暂停是连接级（登录态问题，跨模型）——但这里只处理规则本身
-    if (rule.disable) {
-      // session_dead：整个连接禁用（跨该号所有模型）
+    if (rule.cooldown === 0) return // no_such_model 等：不冷不记
+    // session_dead 是连接级冷却（登录态问题，跨该号所有模型），到期自愈——
+    // 不再有「永久禁用」：403 分不清凭证死活，误伤号不该被钉死
+    if (state === 'session_dead') {
       const e = this.uidState(uid)
-      e.disabled = true
+      const cd = rule.cooldown
+      e.until = Math.max(e.until, Date.now() + (typeof cd === 'number' ? cd : 0))
       e.reason = message
       return
     }
-    if (rule.cooldown === 0) return // no_such_model 等：不冷不记
     // 冷却/退避：记在 (model, uid) 单元上，不动该号其它模型
     const e = this.entry(modelId, uid)
     e.reason = message
@@ -396,7 +401,7 @@ export class AccountPool {
     e.until = Math.max(e.until, Date.now() + rule.cooldown)
   }
 
-  /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+  /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
   noteSuccess(uid: string, modelId: string): void {
     const e = this.cooldowns.get(this.key(modelId, uid))
     if (e) e.backoffLevel = 0
@@ -408,13 +413,12 @@ export class AccountPool {
     e.until = Date.now() + ms
     e.reason = reason
     // 手动暂停通常是想清掉这个号上的累积惩罚：把它的退避等级清零
-    // （disabled 不可由此解除——需重新登录）
     for (const [k, ce] of this.cooldowns) {
       if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0
     }
   }
 
-  /** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+  /** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
    *
    * 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
    * 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -423,7 +427,6 @@ export class AccountPool {
    */
   decorate(accounts: SupplierAccountNow[], modelId?: string): Array<SupplierAccountNow & {
     cooling: boolean
-    disabled: boolean
     err_count: number
     until?: string
     reason?: string
@@ -431,13 +434,12 @@ export class AccountPool {
     const now = Date.now()
     return accounts.map((a) => {
       const u = this.byUid.get(a.uid)
-      const disabled = u?.disabled ?? false
-      // 连接级手动暂停或禁用也算不可服务；但 disabled 单列，冷却不算它
-      const manualCooling = u !== undefined && !u.disabled && u.until > now
+      // 连接级冷却（session_dead 处置 / 手动暂停）也算 cooling
+      const uidCooling = u !== undefined && u.until > now
 
-      let cooling = manualCooling
-      let maxUntil = manualCooling ? u!.until : 0
-      let reason = manualCooling ? u!.reason : undefined
+      let cooling = uidCooling
+      let maxUntil = uidCooling ? u!.until : 0
+      let reason = uidCooling ? u!.reason : undefined
       let err = 0
       // 遍历本连接在所有模型上的冷却单元（或仅指定模型）
       for (const [k, ce] of this.cooldowns) {
@@ -459,7 +461,6 @@ export class AccountPool {
       return {
         ...a,
         cooling,
-        disabled,
         err_count: err,
         until: cooling && maxUntil > 0 ? new Date(maxUntil).toISOString() : undefined,
         reason: reason !== undefined && reason !== '' ? reason : undefined,

package/src/router/models-cache.test.ts

@@ -613,7 +613,6 @@ test('组合请求不污染无关供应商的账号（no_such_model 不记账）
   const acc = other.s.pool.decorate([{ uid: 'u1', credits: 0, state: 'ok' }])[0]
   assert.equal(acc?.err_count, 0, '不该累计连续错误')
   assert.equal(acc?.cooling, false, '不该被冷却')
-  assert.equal(acc?.disabled, false, '不该被禁用')
 })
 
 /**

package/src/router/types.ts

@@ -14,7 +14,6 @@ export interface SupplierAccount {
   cooling: boolean
   until?: string
   reason?: string
-  disabled: boolean
   err_count?: number
 }
 

package/src/shared.ts

@@ -28,7 +28,6 @@ export interface RouterAccount {
   cooling: boolean
   until?: string
   reason?: string
-  disabled: boolean
   err_count?: number
   /** 所属供应商 id。 */
   supplier?: string

package/src/suppliers/contract.ts

@@ -31,7 +31,7 @@ export interface SupplierEnv {
    * 不报上来，它就会继续留在池里被轮转选中，每次都白撞一次同一个错误。
    *
    * 核心实现 = `pool.noteFailure(uid, model, state, message)`，按该状态的规则
-   * 冷却/禁用。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
+   * 冷却。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
    * 流内 `code=4008`，三个号里两个如此，round-robin 下 2/3 请求直接失败
    * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出轮转。
    *
@@ -46,7 +46,7 @@ export type SupplierFactory = (env: SupplierEnv) => SupplierModule
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
  *
- * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、要不要换号
  * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
  *
  * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
@@ -68,7 +68,7 @@ export type AccountState =
    */
   | 'no_such_model'
 
-/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {
   uid: string
   nickname?: string
@@ -98,7 +98,7 @@ export type ChatOnceResult =
   | { ok: true; stream: ReadableStream<Uint8Array> }
   /** 非流式：核心写 JSON。 */
   | { ok: true; status: number; body: string }
-  /** 失败：核心据此做冷却/禁用/换号。 */
+  /** 失败：核心据此做冷却/换号。 */
   | { ok: false; state: AccountState; message: string }
 
 /** 供应商模块 —— 契约（核心必须，差异化可选）。 */
@@ -120,7 +120,7 @@ export interface SupplierModule {
   readonly apiKeyHint?: string
 
   // ---- 核心（必须） ----
-  /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+  /** 报账号「现在状态」。冷却/错误累计由核心叠加，插件不算这些。 */
   status(): SupplierStatusNow
   /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
   listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[]

package/src/suppliers/loader.ts

@@ -124,7 +124,7 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
     if (isFn((instance as unknown as Record<string, unknown>)[key])) capabilities.add(key)
   }
 
-  // 账号池由核心持有（选号/冷却/禁用/错误累计），插件不参与。
+  // 账号池由核心持有（选号/冷却/错误累计），插件不参与。
   // 挂在 supplier 上：status() 叠加状态与 Router 的 chat 循环共用同一实例。
   // 冷却键带 supplierId（跨供应商同名模型不串），故构造时注入本供应商 id。
   const pool = new AccountPool(instance.id)

package/src/suppliers/registry.test.ts

@@ -30,7 +30,7 @@ function fakeRes(): { status: number; body: unknown; res: never } {
   return { get status() { return out.status }, get body() { return out.body }, res: res as never }
 }
 
-type FakeAccount = { uid: string; disabled?: boolean; credits?: number }
+type FakeAccount = { uid: string; credits?: number }
 
 /** 造一个只带 checkinNow 的假供应商：status() 返回账号列表，checkinNow 按 uid 应答。
  *  accounts 可传函数（每次 status() 重新求值，用来模拟插件后台异步刷积分）。 */
@@ -50,7 +50,6 @@ function fixture(
         nickname: a.uid,
         credits: a.credits ?? 0,
         cooling: false,
-        disabled: a.disabled ?? false,
         err_count: 0,
       })),
     }),
@@ -109,10 +108,10 @@ test('签到：遍历所有链接，逐个调 checkinNow(uid)', async () => {
   assert.deepEqual(body.results?.map((r) => r.uid), ['a', 'b'])
 })
 
-test('签到：禁用链接照样签（禁用由插件自己判定，核心不筛）', async () => {
+test('签到：插件自标 disabled 的链接照样签（筛不筛由插件自己判定，核心不筛）', async () => {
   const seen: string[] = []
   const { body } = await postCheckin(
-    fixture([{ uid: 'a', disabled: true }, { uid: 'b' }], async (uid) => {
+    fixture([{ uid: 'a' }, { uid: 'b' }], async (uid) => {
       seen.push(uid)
       // 插件（如 traework）自己会对禁用链接返回 status:'disabled'
       return uid === 'a' ? { ok: false, status: 'disabled', message: '链接已禁用' } : { ok: true, status: 'ok' }

package/src/suppliers/registry.ts

@@ -66,7 +66,7 @@ function cap(set: Set<string>, key: string): boolean {
 
 /** 账号状态指纹（积分 + 健康），用于判断刷新是否落地。 */
 function fingerprint(accounts: SupplierStatus['accounts']): string {
-  return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}:${a.disabled}`).join('|')
+  return accounts.map((a) => `${a.uid}:${a.credits}:${a.cooling}`).join('|')
 }
 
 /**