@dsh-plugins/dsh-llm-hub 1.5.3 → 1.5.5

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 本项目遵循 [Semantic Versioning](https://semver.org/lang/zh-CN/)。
 
+## [1.5.5] - 2026-09-27
+
+### 🪧 路由卡：每条候选的能力 chip（思考 + 多模态）
+
+之前 routing 卡里只把「多模态」用一个 `👁` emoji 标在 model id 后面，**思考档位完全没标** —— 用户必须查文档才能知道这个模型能思考、能用哪些 effort。这一版把这条缝上：
+
+- **`routingCatalogOf()`**（`lib/index.js:2789`）每个 model 多带一条 `reasoning: { levels: [{ id, name }, …] } | null`，从 settings 的 `reasoningEfforts` 抽出；键名是人话（`off` / `low` / `high` / `max`），值是适配器认的 effort id，`null` 值的档位（强制思考、不能关的 `off`）不进 chip 文本。
+- **`routing card`**（`lib/client.js` RoutingCard）：
+  - 每个候选后面追加两枚 chip（仅在能力存在时出现）：`💭 思考 low/high/max`、`👁 图像`；思考档位 >3 个时折成 `low/medium/high+2`。
+  - 多模态 chip 之前是裸 emoji，现在与思考 chip 共用一套样式（`.dsh-llm-hub-routing__reasoning / __multimodal`），按 `state-info` / `state-success` 主题色上边框 —— 一眼分得清「能干什么」。
+  - 添加候选的下拉 `<option>` 同步带 `💭 … 👁` 后缀（同一 catalog 数据源）。
+- **i18n**：`routeMultimodalShort` / `routeReasoningShort` / `routeReasoningTip` 加进 zh + en；思考档位的 tooltip 列出 `name → id` 的映射，方便排查 `off: null` 之类的「明明配置了 off 却不能用」的情况。
+- **测试**：`test/client-cards.test.mjs` 的多模态 chip 用例改成查新类名（`dsh-llm-hub-routing__multimodal`），`node --test` 131 项全过。
+
+数据真源仍是 settings —— 不打网关、不改路由逻辑，只是把已经在那儿的事实亮出来。
+
+## [1.5.4] - 2026-09-27
+
+### 🛡️ 智能路由接管的两处加固（1.5.0 的补丁）
+
+1.5.0 让 `smart` 模式用 `agent/request` waterfall 真实改写请求的 provider/model。
+两处会在真机上把会话打挂的边界，这一版补上：
+
+#### 未注册 / 未探测到的 provider 不当路由目标
+
+- **病灶**：`stateFor` 把「不认识这个 provider」与「探测结果是 unknown」都折成
+  `unknown`，而 `unknown` 在裁决里是**可用**的（首次路由需要它兜底）。于是配置里
+  写错一个 provider 名（或该 provider 还没注册）时，接管会把请求指向一个不存在的
+  adapter，请求以 `NO_ADAPTER` 直接失败 —— 比不接管更糟。
+- **修法**：新增 `routableStateFor` —— 探测表里查不到的 provider 一律视为
+  `unavailable`，候选被跳过、路由保持 fail-open（不动原配置）。手动模式下的建议
+  列表仍用旧的 `stateFor`（那里 unknown 是诚实的信息，不是路由目标）。
+- **验证**：`test/host-routing-groups.test.mjs` 覆盖组解析与裁决；`node --test`
+  120 项全过。
+
+#### 首次请求预热可用性探测
+
+- **病灶**：生产环境里可用性探测此前只由客户端触发（打开设置页 / 下拉重探）。
+  开机后如果没人开设置页，探测表是空的 → smart 模式全部候选被判 `unavailable`
+  → 路由长期静默不生效，表现为「开了智能模式但一直在用原模型」。
+- **修法**：`agent/request` 里若 `baseVerdicts` 为空，后台热一把
+  `ensureAvailabilityFresh()`（不阻塞当次请求），这次仍 fail-open 走原配置。
+
+**没做**：没有发布任何新功能，也没有改配置格式 —— `groups` / `mode` / `activeGroup`
+与切组入口（composer 路由 chip）与 1.5.0–1.5.3 完全一致。
+
 ## [1.5.3] - 2026-09-26
 
 ### 🛂 工程纪律对齐

package/lib/client.js

@@ -77,6 +77,10 @@ window.__ModuleLoader__.load({
 		const ROUTING_STATE_URL = '/api/dsh-llm-hub/routing/state'
 		/** 路由组切换：POST { mode?, activeGroup? }，持久化进 settings。 */
 		const ROUTING_SELECT_URL = '/api/dsh-llm-hub/routing/select'
+		/** 可路由目录：settings 里已配置的 provider 与模型（离线读，不打网关）。 */
+		const ROUTING_CATALOG_URL = '/api/dsh-llm-hub/routing/catalog'
+		/** 路由组编辑保存：POST { groups, mode?, activeGroup? }。 */
+		const ROUTING_CONFIG_URL = '/api/dsh-llm-hub/routing/config'
 		/** 模型别名：把长 id 显示成短名（人话）。 */
 		const ALIASES_URL = '/api/dsh-llm-hub/aliases'
 		const BILLING_MODE_URL = '/api/dsh-llm-hub/billing-mode'
@@ -172,6 +176,34 @@ window.__ModuleLoader__.load({
 				routeChipLastRoute: '最近实际',
 				routeChipReasonNone: '候选全部不可用',
 				routeChipFailOpen: '路由失败时按原配置发出',
+				routeRuleTitle: '规则',
+				routeRuleText: '按组内顺序取第一个可用；探测失败或额度耗尽的自动跳过；全不可用则保持原样（fail-open）。顺序即优先级 —— 固定成本（包月/订阅）放前面，按量付费放后面兜底。',
+				routeSmartNotice: '已接管：输入框的模型下拉只作参考，实际请求按本卡规则走（实时结果见聊天框左侧 chip）。',
+				routeManualNotice: '未接管：请求还是用你在模型下拉里选的；点「智能路由」才按本卡规则自动切。',
+				routeEditHint: '编辑后点保存写入 settings.dsh-llm-hub.routing',
+				routeSave: '保存',
+				routeSaved: '已保存',
+				routeSaveFailed: '保存失败',
+				routeAddCandidate: '+ 添加候选',
+				routeAddProvider: '提供方',
+				routeAddModel: '模型',
+				routeAdd: '添加',
+				routeNewGroup: '+ 新建组',
+				routeDeleteGroup: '删除该组',
+				routeUp: '上移',
+				routeDown: '下移',
+				routeRemove: '移除',
+				routeGroupLabelPlaceholder: '组名（公司 / 个人）',
+				routeActiveTag: '当前组',
+				routeSetActive: '设为当前组',
+				routePrimaryTag: '主力',
+				routeFallbackTag: '备',
+				routeNoCatalog: '读不到 provider 目录 —— 先在设置里配好 provider 再来加候选',
+				routeDropped: '有配置被忽略',
+				routeMultimodalTip: '多模态：输入含图像等非文本模态（来自 settings 的模态声明）',
+				routeMultimodalShort: '图像',
+				routeReasoningTip: '思考链：该模型声明的推理档位（来自 settings 的 reasoningEfforts）',
+				routeReasoningShort: '思考',
 				aliasesMissing: '尚未配置别名',
 				heroTitle: 'LLM 矩阵概览',
 				heroProviders: '活跃提供方',
@@ -296,6 +328,34 @@ window.__ModuleLoader__.load({
 				routeChipLastRoute: 'Last used',
 				routeChipReasonNone: 'All candidates unavailable',
 				routeChipFailOpen: 'Falls back to your selection when routing fails',
+				routeRuleTitle: 'Rule',
+				routeRuleText: 'First usable candidate in group order wins; failed probes and exhausted quotas are skipped; if none is usable the original selection is kept (fail-open). Order is priority — fixed-cost plans first, metered pay-as-you-go last.',
+				routeSmartNotice: 'Takeover is on: the composer model dropdown is only a reference; requests follow this card (live result shows in the chip beside the composer).',
+				routeManualNotice: 'Not taking over: requests still use the model you picked in the dropdown. Switch to Smart routing to auto-select.',
+				routeEditHint: 'Save writes settings.dsh-llm-hub.routing',
+				routeSave: 'Save',
+				routeSaved: 'Saved',
+				routeSaveFailed: 'Save failed',
+				routeAddCandidate: '+ Add candidate',
+				routeAddProvider: 'Provider',
+				routeAddModel: 'Model',
+				routeAdd: 'Add',
+				routeNewGroup: '+ New group',
+				routeDeleteGroup: 'Delete group',
+				routeUp: 'Move up',
+				routeDown: 'Move down',
+				routeRemove: 'Remove',
+				routeGroupLabelPlaceholder: 'Group name (work / personal)',
+				routeActiveTag: 'active',
+				routeSetActive: 'Set active',
+				routePrimaryTag: 'primary',
+				routeFallbackTag: 'alt',
+				routeNoCatalog: 'No provider directory — configure a provider first',
+				routeDropped: 'Some entries ignored',
+				routeMultimodalTip: 'Multimodal: accepts non-text input such as images (from the modality declared in settings)',
+				routeMultimodalShort: 'vision',
+				routeReasoningTip: 'Reasoning chain: effort levels declared by this model (from settings.reasoningEfforts)',
+				routeReasoningShort: 'think',
 				aliasesMissing: 'no aliases configured',
 				heroTitle: 'LLM Matrix Overview',
 				heroProviders: 'Active providers',
@@ -537,6 +597,21 @@ window.__ModuleLoader__.load({
 				'border-radius:3px;border:.5px solid var(--dsw-alias-border-l2);',
 				'background:transparent;font-size:10px;color:var(--dsw-alias-label-secondary)}',
 				'.dsh-llm-hub-routing__name{color:var(--dsw-alias-label-primary);font-weight:600}',
+				// capability 标识：思考 / 多模态。两枚 chip 同形，左思考、右图像；
+				// 边色走 state 提示色，跟健康状态 chip 区分开 —— 一个说「能干什么」，
+				// 一个说「能不能用」。
+				'.dsh-llm-hub-routing__reasoning,.dsh-llm-hub-routing__multimodal{',
+				'display:inline-flex;align-items:center;height:16px;padding:0 6px;',
+				'border-radius:3px;font-size:10px;line-height:14px;font-weight:500;',
+				'background:transparent;cursor:help}',
+				// 思考：走 warn 主题色（消耗更多 token、需要警觉）
+				'.dsh-llm-hub-routing__reasoning{',
+				'border:.5px solid var(--dsw-alias-state-warn-primary);',
+				'color:var(--dsw-alias-state-warn-primary)}',
+				// 多模态：走 success 主题色（输入更丰富 = 好）
+				'.dsh-llm-hub-routing__multimodal{',
+				'border:.5px solid var(--dsw-alias-state-success-primary);',
+				'color:var(--dsw-alias-state-success-primary)}',
 				'.dsh-llm-hub-routing__suggestion{color:var(--dsw-alias-state-warn-primary);padding-top:2px}',
 				'.dsh-llm-hub-routing__reason{color:var(--dsw-alias-state-error-primary);padding-top:2px}',
 				// composer 快切 chip（conversation.input.left）
@@ -567,6 +642,30 @@ window.__ModuleLoader__.load({
 				'.dsh-llm-hub-route__group-name{font-weight:600;font-size:11px}',
 				'.dsh-llm-hub-route__state{font-size:10px;color:var(--dsw-alias-label-secondary);max-width:150px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
 				'.dsh-llm-hub-route__hint{font-size:10px;color:var(--dsw-alias-label-tertiary)}',
+				'.dsh-llm-hub-route__order{font-size:10px;color:var(--dsw-alias-label-secondary);',
+				'font-family:ui-monospace,SFMono-Regular,monospace;word-break:break-all;line-height:1.4}',
+				// 智能路由编辑器（设置页路由卡）
+				'.dsh-llm-hub-routing__modes{display:flex;gap:4px;margin-left:auto}',
+				'.dsh-llm-hub-routing__rule{display:flex;gap:6px;align-items:flex-start;font-size:10.5px;line-height:1.5;',
+				'color:var(--dsw-alias-label-secondary);padding:6px 8px;border-radius:6px;background:var(--dsw-alias-bg-layer-2)}',
+				'.dsh-llm-hub-routing__rule-tag{flex:none;font-weight:600;color:var(--dsw-alias-label-primary)}',
+				'.dsh-llm-hub-routing__now{font-size:11px;color:var(--dsw-alias-label-primary);font-weight:600}',
+				'.dsh-llm-hub-routing__groups{display:flex;flex-direction:column;gap:6px;margin-top:8px}',
+				'.dsh-llm-hub-routing__group{border:.5px solid var(--dsw-alias-border-l1);border-radius:6px;padding:6px 8px;display:flex;flex-direction:column;gap:5px}',
+				'.dsh-llm-hub-routing__group.is-active{border-color:var(--dsw-alias-state-warn-primary)}',
+				'.dsh-llm-hub-routing__group-top{display:flex;align-items:center;gap:6px;flex-wrap:wrap}',
+				'.dsh-llm-hub-routing__group-toggle{border:0;background:0 0;padding:0;cursor:pointer;font:inherit;font-size:11px;color:var(--dsw-alias-label-secondary)}',
+				'.dsh-llm-hub-routing__group-label{flex:1;min-width:110px;box-sizing:border-box;height:22px;padding:0 6px;border-radius:4px;',
+				'border:.5px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font:inherit;font-size:11px}',
+				'.dsh-llm-hub-routing__group-state{font-size:10.5px;color:var(--dsw-alias-label-secondary);max-width:210px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+				'.dsh-llm-hub-routing__candidates{display:flex;flex-direction:column;gap:3px;padding-top:2px}',
+				'.dsh-llm-hub-routing__add{display:flex;align-items:center;gap:5px;flex-wrap:wrap;font-size:10.5px;color:var(--dsw-alias-label-secondary);padding-top:4px}',
+				'.dsh-llm-hub-routing__select{box-sizing:border-box;height:22px;padding:0 4px;border-radius:4px;border:.5px solid var(--dsw-alias-border-l1);',
+				'background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font:inherit;font-size:11px;max-width:170px}',
+				'.dsh-llm-hub-routing__actions{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding-top:6px;border-top:.5px solid var(--dsw-alias-border-l1);margin-top:8px}',
+				'.dsh-llm-hub-routing__hint{font-size:10px;color:var(--dsw-alias-label-tertiary)}',
+				'.dsh-llm-hub-routing__mm{display:inline-flex;align-items:center;margin-left:4px;font-size:10px;cursor:help;',
+				'color:var(--dsw-alias-state-success-primary,#10b981)}',
 				// Hero 全景统计大横条
 				'.dsh-llm-hub-hero{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:6px;margin:12px 0 6px 0}',
 				'.dsh-llm-hub-hero__card{display:flex;flex-direction:column;gap:2px;padding:8px 10px;border-radius:6px;border:.5px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-2,rgba(255,255,255,.02));backdrop-filter:blur(6px)}',
@@ -1649,7 +1748,15 @@ window.__ModuleLoader__.load({
 				},
 					h('span', { className: 'dsh-llm-hub-route__group-top' },
 						h('span', { className: 'dsh-llm-hub-route__group-name' }, group.label ?? group.id),
-						h('span', { className: 'dsh-llm-hub-route__state' }, stateText(group)))))) : null
+						h('span', { className: 'dsh-llm-hub-route__state' }, stateText(group))),
+					// 顺序即优先级：把候选按组内顺序摊出来（① = 主力），让人一眼看到
+					// 「智能」到底怎么个智能法，而不是只有一个 wouldRoute 结果。
+					h('span', { className: 'dsh-llm-hub-route__order' },
+						(group.candidates ?? []).map((candidate, index) => `${index === 0 ? '①' : index === 1 ? '②' : index === 2 ? '③' : `(${index + 1})`}${candidate.provider}/${candidate.model}${candidate.state === 'unavailable' ? '✗' : ''}`).join(' → ')),
+					group.reason !== null && group.reason !== undefined && group.wouldRoute === null
+						? h('span', { className: 'dsh-llm-hub-route__hint' }, group.reason)
+						: null)),
+				h('div', { className: 'dsh-llm-hub-route__hint' }, t('routeRuleText'))) : null
 			return h('div', { className: 'dsh-llm-hub-route' },
 				h('button', {
 					type: 'button',
@@ -1685,56 +1792,314 @@ window.__ModuleLoader__.load({
 		 */
 		function RoutingCard(props) {
 			const t = typeof props.t === 'function' ? props.t : fallbackT
-			const [report, setReport] = React.useState(null)
-			const query = React.useCallback((active) => {
-				fetch(ROUTING_URL, {
-					method: 'POST',
-					headers: { 'content-type': 'application/json', accept: 'application/json' },
-					body: JSON.stringify({ active: typeof active === 'string' && active.length > 0 ? active : null })
-				})
-					.then((res) => res.json())
-					.then((body) => { setReport(body !== null && typeof body === 'object' ? body : null) })
-					.catch(() => setReport(null))
+			const [state, setState] = React.useState(null)
+			const [catalog, setCatalog] = React.useState([])
+			// draft 是编辑器的工作副本：[{ id, label, candidates: [{provider, model}] }]，
+			// candidates[0] = 主力（primary），其余是 fallback —— 与 settings 形态一一对应。
+			const [draft, setDraft] = React.useState(null)
+			const [activeGroup, setActiveGroup] = React.useState('')
+			const [expanded, setExpanded] = React.useState('')
+			const [picker, setPicker] = React.useState({ provider: '', model: '' })
+			const [busy, setBusy] = React.useState(false)
+			const [notice, setNotice] = React.useState(null)
+			// 保存过/刚拉回的 draft 指纹：用它判断「脏」，避免后台刷新把用户正在编辑的内容冲掉。
+			const [savedKey, setSavedKey] = React.useState('')
+			// label 归一成「空 = null」：草稿里是 ''，服务端回的是 null，不归一会永远显示「未保存」。
+			const draftKeyOf = (report) => JSON.stringify((report?.groups ?? []).map((group) => [
+				group.id,
+				group.label ? group.label : null,
+				(group.candidates ?? []).map((candidate) => `${candidate.provider}/${candidate.model}`)
+			]))
+			const draftFrom = (report) => (report.groups ?? []).map((group) => ({
+				id: group.id,
+				label: group.label ?? '',
+				candidates: group.candidates.map((candidate) => ({ provider: candidate.provider, model: candidate.model }))
+			}))
+			// force=true 只用在一处：保存成功后的回读 —— 那时服务端就是权威。
+			// 其余时候（挂载、切模式、轮询）保留用户正在编辑的草稿。
+			const adopt = React.useCallback((report, force) => {
+				setState(report)
+				setActiveGroup(report.activeGroup)
+				setSavedKey(draftKeyOf(report))
+				setDraft((prev) => (force === true || prev === null ? draftFrom(report) : prev))
 			}, [])
-			React.useEffect(() => { query(null) }, [query])
-			if (report === null) {
+			const loadState = React.useCallback(() => {
+				fetch(ROUTING_STATE_URL, { headers: { accept: 'application/json' } })
+					.then((res) => res.json())
+					.then((body) => { if (body !== null && typeof body === 'object' && body.ok === true) adopt(body) })
+					.catch(() => {})
+			}, [adopt])
+			React.useEffect(() => {
+				loadState()
+				fetch(ROUTING_CATALOG_URL, { headers: { accept: 'application/json' } })
+					.then((res) => res.json())
+					.then((body) => { if (body !== null && typeof body === 'object' && body.ok === true && Array.isArray(body.providers)) setCatalog(body.providers) })
+					.catch(() => {})
+			}, [loadState])
+			if (state === null) {
 				return h('div', { className: 'dsh-llm-hub-routing' },
 					h('div', { className: 'dsh-llm-hub-routing__head' },
 						h('span', { className: 'dsh-llm-hub-routing__title' }, t('routingTitle')),
 						h('span', null, t('routingLoading'))))
 			}
-			if (report.ok !== true) return null
-			const candidates = Array.isArray(report.candidates) ? report.candidates : []
-			if (candidates.length === 0) {
-				return null
-			}
 			ensureStyle()
-			const active = report.active
-			const recommendation = report.recommendation
-			const activeKey = active === null ? null : `${active.provider}/${active.model}`
-			const recKey = recommendation === null ? null : `${recommendation.provider}/${recommendation.model}`
-			const showSuggestion = recommendation !== null && recKey !== activeKey
-			const chipClass = (state) => `dsh-llm-hub-health__chip dsh-llm-hub-health__chip--${state ?? 'unknown'}`
-			const head = h('div', { className: 'dsh-llm-hub-routing__head' },
+			const isSmart = state.mode === 'smart'
+			const groups = draft ?? []
+			const isDirty = draft !== null && draftKeyOf({ groups: groups.map((group) => ({ id: group.id, label: group.label, candidates: group.candidates })) }) !== savedKey
+			const post = (url, payload) => fetch(url, {
+				method: 'POST',
+				headers: { 'content-type': 'application/json', accept: 'application/json' },
+				body: JSON.stringify(payload)
+			}).then((res) => res.json())
+			const setMode = (mode) => {
+				setNotice(null)
+				post(ROUTING_SELECT_URL, { mode })
+					.then((body) => { if (body?.ok === true) adopt(body, true) })
+					.catch(() => setNotice('fail'))
+			}
+			const markActive = (id) => {
+				setActiveGroup(id)
+				setNotice(null)
+				post(ROUTING_SELECT_URL, { activeGroup: id })
+					.then((body) => { if (body?.ok === true) adopt(body) })
+					.catch(() => setNotice('fail'))
+			}
+			const save = () => {
+				if (groups.length === 0) return
+				setBusy(true)
+				setNotice(null)
+				post(ROUTING_CONFIG_URL, { groups, activeGroup })
+					.then((body) => {
+						if (body?.ok === true) { adopt(body, true); setNotice('saved') }
+						else setNotice('fail')
+					})
+					.catch(() => setNotice('fail'))
+					.finally(() => setBusy(false))
+			}
+			// ── 草稿编辑（全部是纯函数式更新，不碰服务端；保存才落盘）──
+			const editGroup = (id, mutate) => setDraft(groups.map((group) => (group.id === id ? mutate(group) : group)))
+			const moveCandidate = (id, index, delta) => editGroup(id, (group) => {
+				const next = [...group.candidates]
+				const target = index + delta
+				if (target < 0 || target >= next.length) return group
+				const [item] = next.splice(index, 1)
+				next.splice(target, 0, item)
+				return { ...group, candidates: next }
+			})
+			const removeCandidate = (id, index) => editGroup(id, (group) => ({ ...group, candidates: group.candidates.filter((_, i) => i !== index) }))
+			const addCandidate = (id) => {
+				const provider = picker.provider
+				const model = picker.model
+				if (provider === '' || model === '') return
+				editGroup(id, (group) => ({ ...group, candidates: [...group.candidates, { provider, model }] }))
+				setPicker({ provider: '', model: '' })
+			}
+			const addGroup = () => {
+				let index = groups.length + 1
+				let id = `group-${index}`
+				while (groups.some((group) => group.id === id)) { index += 1; id = `group-${index}` }
+				setDraft([...groups, { id, label: '', candidates: [] }])
+				setExpanded(id)
+			}
+			const removeGroup = (id) => {
+				setDraft(groups.filter((group) => group.id !== id))
+				if (expanded === id) setExpanded('')
+			}
+			const stateChipClass = (value) => `dsh-llm-hub-health__chip dsh-llm-hub-health__chip--${value ?? 'unknown'}`
+			/**
+			 * 一个候选是否多模态（输入含 text 之外的模态，典型是 image）。
+			 *
+			 * 数据来自目录接口的 `input` 字段（settings 里本来就有）；目录读不到时
+			 * 返回 undefined —— UI 不标而不是瞎猜。
+			 */
+			const isMultimodal = (provider, modelId) => {
+				const entry = catalog.find((item) => item.id === provider)
+				const model = Array.isArray(entry?.models) ? entry.models.find((item) => item.id === modelId) : undefined
+				const input = Array.isArray(model?.input) ? model.input : []
+				return input.length > 0 && input.some((kind) => kind !== 'text')
+			}
+			/**
+			 * 一个候选的推理档位列表（来自 settings 的 reasoningEfforts 字段）；
+			 * 没声明推理能力时返回 undefined —— UI 不标。
+			 * 返回的是档位对象的浅拷贝（UI 用），外面别 mutate。
+			 */
+			const reasoningLevels = (provider, modelId) => {
+				const entry = catalog.find((item) => item.id === provider)
+				const model = Array.isArray(entry?.models) ? entry.models.find((item) => item.id === modelId) : undefined
+				const levels = Array.isArray(model?.reasoning?.levels) ? model.reasoning.levels : []
+				return levels.length > 0 ? levels : undefined
+			}
+			/**
+			 * 推理档位的人话短文本：超 3 个档位时压成 `a/b/c+2`，避免长列表把行挤爆。
+			 */
+			const reasoningShort = (levels) => {
+				if (levels === undefined) return ''
+				const names = levels.map((level) => level.name)
+				if (names.length <= 3) return names.join('/')
+				return `${names.slice(0, 3).join('/')}+${names.length - 3}`
+			}
+			// 「现在会路由到哪」：smart 模式看 lastDecision（真实请求），否则按组顺序的推演。
+			const resolvedText = () => {
+				if (isSmart) {
+					const decision = state.lastDecision
+					if (decision?.to) return `${t('routeChipLastRoute')}: ${decision.to.provider}/${decision.to.model}`
+					return decision?.reason ?? t('routeChipFailOpen')
+				}
+				const group = state.groups.find((item) => item.id === activeGroup) ?? state.groups[0]
+				if (group?.wouldRoute) return `${t('routeChipWouldRoute')}: ${group.wouldRoute.provider}/${group.wouldRoute.model}`
+				return group?.reason ?? t('routeChipReasonNone')
+			}
+			const header = h('div', { className: 'dsh-llm-hub-routing__head' },
 				h('span', { className: 'dsh-llm-hub-routing__title' }, t('routingTitle')),
-				active !== null
-					? h('span', { className: 'dsh-llm-hub-routing__active' },
-						`${t('routingActive')}: ${activeKey}`,
-						h('span', { className: chipClass(active.state) }, active.state === 'available' ? '可用' : '不可用'))
-					: h('span', null, t('routingUnconfigured')))
-			const rows = candidates.map((entry) => h('div', { key: `${entry.provider}/${entry.model}`, className: 'dsh-llm-hub-routing__row' },
-				h('span', { className: 'dsh-llm-hub-routing__role' }, entry.role === 'primary' ? t('routingPrimary') : t('routingFallback')),
-				h('span', { className: 'dsh-llm-hub-routing__name' }, `${entry.provider}/${entry.model}`),
-				h('span', { className: chipClass(entry.state) }, entry.state === 'available' ? '可用' : '不可用')))
+				h('div', { className: 'dsh-llm-hub-routing__modes' },
+					h('button', {
+						type: 'button',
+						className: `dsh-llm-hub-route__mode${isSmart ? ' is-on' : ''}`,
+						onClick: () => { if (!isSmart) setMode('smart') }
+					}, `⚡ ${t('routeChipModeSmart')}`),
+					h('button', {
+						type: 'button',
+						className: `dsh-llm-hub-route__mode${!isSmart ? ' is-on' : ''}`,
+						onClick: () => { if (isSmart) setMode('manual') }
+					}, t('routeChipModeManual'))))
+			const rule = h('div', { className: 'dsh-llm-hub-routing__rule' },
+				h('span', { className: 'dsh-llm-hub-routing__rule-tag' }, t('routeRuleTitle')),
+				h('span', null, t('routeRuleText')))
+			const noticeLine = h('div', { className: 'dsh-llm-hub-routing__reason' },
+				isSmart ? t('routeSmartNotice') : t('routeManualNotice'))
+			const nowLine = h('div', { className: 'dsh-llm-hub-routing__now' }, resolvedText())
+			const groupRows = groups.map((group, groupIndex) => {
+				const live = state.groups.find((item) => item.id === group.id)
+				const isOpen = expanded === group.id
+				const candidates = group.candidates
+				return h('div', { key: group.id, className: `dsh-llm-hub-routing__group${activeGroup === group.id ? ' is-active' : ''}` },
+					h('div', { className: 'dsh-llm-hub-routing__group-top' },
+						h('button', {
+							type: 'button',
+							className: 'dsh-llm-hub-routing__group-toggle',
+							onClick: () => setExpanded(isOpen ? '' : group.id)
+						}, `${isOpen ? '▾' : '▸'} ${groupIndex + 1}`),
+						h('input', {
+							className: 'dsh-llm-hub-routing__group-label',
+							value: group.label ?? '',
+							placeholder: t('routeGroupLabelPlaceholder'),
+							onChange: (event) => editGroup(group.id, (current) => ({ ...current, label: event.target.value }))
+						}),
+						live?.wouldRoute
+							? h('span', { className: 'dsh-llm-hub-routing__group-state' }, `${live.wouldRoute.provider}/${live.wouldRoute.model}`)
+							: h('span', { className: 'dsh-llm-hub-routing__group-state' }, live?.reason ?? t('routeChipReasonNone')),
+						activeGroup === group.id
+							? h('span', { className: 'dsh-llm-hub-routing__role' }, t('routeActiveTag'))
+							: h('button', {
+								type: 'button',
+								className: 'dsh-llm-hub-foot__link',
+								onClick: () => markActive(group.id)
+							}, t('routeSetActive'))),
+					isOpen
+						? h('div', { className: 'dsh-llm-hub-routing__candidates' },
+							...candidates.map((candidate, index) => {
+								const liveCandidate = live?.candidates?.find((item) => item.provider === candidate.provider && item.model === candidate.model)
+								const multimodal = isMultimodal(candidate.provider, candidate.model)
+								const reasoning = reasoningLevels(candidate.provider, candidate.model)
+								const reasoningTip = reasoning === undefined
+									? undefined
+									: `${t('routeReasoningTip')}\n${reasoning.map((level) => `  · ${level.name} → ${level.id}`).join('\n')}`
+								return h('div', { key: `${candidate.provider}/${candidate.model}/${index}`, className: 'dsh-llm-hub-routing__row' },
+									h('span', { className: 'dsh-llm-hub-routing__role' }, index === 0 ? t('routePrimaryTag') : `${t('routeFallbackTag')}${index}`),
+									h('span', { className: 'dsh-llm-hub-routing__name' }, `${candidate.provider}/${candidate.model}`),
+									reasoning !== undefined
+										? h('span', {
+											key: 'reasoning',
+											className: 'dsh-llm-hub-routing__reasoning',
+											title: reasoningTip
+										}, `💭 ${t('routeReasoningShort')} ${reasoningShort(reasoning)}`)
+										: null,
+									multimodal === true
+										? h('span', {
+											key: 'multimodal',
+											className: 'dsh-llm-hub-routing__multimodal',
+											title: t('routeMultimodalTip')
+										}, '👁 ' + t('routeMultimodalShort'))
+										: null,
+									h('span', { className: stateChipClass(liveCandidate?.state) }, liveCandidate?.state === 'available' ? '可用' : (liveCandidate?.state === 'unknown' ? '未探明' : '不可用')),
+									h('button', { type: 'button', className: 'dsh-llm-hub-foot__link', title: t('routeUp'), onClick: () => moveCandidate(group.id, index, -1) }, '↑'),
+									h('button', { type: 'button', className: 'dsh-llm-hub-foot__link', title: t('routeDown'), onClick: () => moveCandidate(group.id, index, 1) }, '↓'),
+									h('button', { type: 'button', className: 'dsh-llm-hub-foot__link', title: t('routeRemove'), onClick: () => removeCandidate(group.id, index) }, '✕'))
+							}),
+							h('div', { className: 'dsh-llm-hub-routing__add' },
+								h('span', null, t('routeAddProvider')),
+								catalog.length > 0
+									? h('select', {
+										className: 'dsh-llm-hub-routing__select',
+										value: picker.provider,
+										onChange: (event) => {
+											const provider = event.target.value
+											const entry = catalog.find((item) => item.id === provider)
+											setPicker({ provider, model: entry?.models?.[0]?.id ?? '' })
+										}
+									},
+										h('option', { value: '' }, '—'),
+										...catalog.map((entry) => h('option', { key: entry.id, value: entry.id }, `${entry.displayName ?? entry.id}`)))
+									// 目录读不到（host 还没重启 / settings 里没有 provider）时退回手输 ——
+									// 不让「拉不到目录」变成「编辑不了」。
+									: h('input', {
+										className: 'dsh-llm-hub-routing__select',
+										placeholder: 'provider',
+										value: picker.provider,
+										onChange: (event) => setPicker({ provider: event.target.value, model: picker.model })
+									}),
+								h('span', null, t('routeAddModel')),
+								catalog.find((item) => item.id === picker.provider) !== undefined
+									? h('select', {
+										className: 'dsh-llm-hub-routing__select',
+										value: picker.model,
+										onChange: (event) => setPicker({ provider: picker.provider, model: event.target.value })
+									},
+										h('option', { value: '' }, '—'),
+										...((catalog.find((item) => item.id === picker.provider)?.models) ?? []).map((model) => {
+											const multimodal = Array.isArray(model?.input) && model.input.some((kind) => kind !== 'text')
+											const reasoningLevels = Array.isArray(model?.reasoning?.levels) ? model.reasoning.levels : []
+											const flags = []
+											if (reasoningLevels.length > 0) flags.push(`💭 ${reasoningShort(reasoningLevels)}`)
+											if (multimodal === true) flags.push('👁')
+											return h('option', { key: model.id, value: model.id }, flags.length === 0 ? model.id : `${model.id}  ${flags.join(' ')}`)
+										}))
+									: h('input', {
+										className: 'dsh-llm-hub-routing__select',
+										placeholder: 'model',
+										value: picker.model,
+										onChange: (event) => setPicker({ provider: picker.provider, model: event.target.value })
+									}),
+								h('button', {
+									type: 'button',
+									className: 'dsh-llm-hub-btn',
+									onClick: () => addCandidate(group.id)
+								}, t('routeAdd'))),
+							catalog.length === 0 ? h('div', { className: 'dsh-llm-hub-routing__rule' }, t('routeNoCatalog')) : null,
+							h('button', {
+								type: 'button',
+								className: 'dsh-llm-hub-foot__link',
+								onClick: () => removeGroup(group.id)
+							}, t('routeDeleteGroup')))
+						: null)
+			})
+			const footer = h('div', { className: 'dsh-llm-hub-routing__actions' },
+				h('button', { type: 'button', className: 'dsh-llm-hub-btn', onClick: addGroup }, t('routeNewGroup')),
+				h('button', {
+					type: 'button',
+					className: 'dsh-llm-hub-btn',
+					disabled: busy || !isDirty,
+					onClick: save
+				}, isDirty ? t('routeSave') : t('routeSaved')),
+				notice === 'fail' ? h('span', { className: 'dsh-llm-hub-routing__reason' }, t('routeSaveFailed')) : null,
+				h('span', { className: 'dsh-llm-hub-routing__hint' }, t('routeEditHint')))
 			return h('div', { className: 'dsh-llm-hub-routing' },
-				head,
-				h('div', { className: 'dsh-llm-hub-routing__rows' }, rows),
-				showSuggestion
-					? h('div', { className: 'dsh-llm-hub-routing__suggestion' }, `${t('routingSuggestion')}: ${recKey}`)
-					: null,
-				recommendation === null && candidates.length > 0
-					? h('div', { className: 'dsh-llm-hub-routing__reason' }, t('routingNoRecommendation'))
-					: null)
+				header,
+				rule,
+				noticeLine,
+				nowLine,
+				h('div', { className: 'dsh-llm-hub-routing__groups' }, groupRows),
+				footer)
 		}
 
 		/**

package/lib/index.js

@@ -169,13 +169,18 @@ const WARNING_CHECK_PATH = '/api/dsh-llm-hub/warning/check'
 /**
  * 智能路由建议：把当前可用性 + 用户声明的 fallback 顺序折成「该用哪个」。
  *
- * **不做自动切换** —— DSH 的 `conversation.input.model` 是 single + user-controlled
- * slot（`replaceRisk: shadows-shipped-ui`），没有供插件改的 setter；强行覆盖会
- * 撞 README 红线。这条路由返回的是**建议**，真值为用户在 UI 里点一下。
+ * 1.5.0 起语义升级：这条路由仍然只**建议**（composer 的 `conversation.input.model`
+ * 是 single + user-controlled slot，插件不碰它）；真正的自动接管走
+ * `agent/request` waterfall（见本文件「智能路由组 + 模式接管」段）—— manual 模式
+ * 下这里就是全部，smart 模式下这里变成「读一眼路由现状」的视图。
  *
- * 请求体：当前已激活用户的 provider/model（如 'modelgo' / 'gpt-4o'），返回：
+ * 请求体：当前已激活的 provider/model（如 'modelgo' / 'gpt-4o'），可选 `group`
+ * 指定组；返回：
  *   {
  *     ok: true,
+ *     mode: 'manual'|'smart',
+ *     activeGroup: 'company',
+ *     groups: [{ id, label, candidateCount }, ...],
  *     active: { provider, model, state: 'available'|'unknown'|'unavailable' },
  *     candidates: [{ provider, model, state, ... }, ...],   // 主 → fallback → 备用
  *     recommendation: { provider, model } | null,            // 第一个 available 的
@@ -197,6 +202,16 @@ const ROUTING_STATE_PATH = '/api/dsh-llm-hub/routing/state'
  * `dsh-llm-hub.routing` 段 —— 状态持久化，重启不丢。
  */
 const ROUTING_SELECT_PATH = '/api/dsh-llm-hub/routing/select'
+/**
+ * 路由组编辑：`GET /api/dsh-llm-hub/routing/catalog` 列可路由的 provider 与模型，
+ * `POST /api/dsh-llm-hub/routing/config` 整体写回 `routing.groups`。
+ *
+ * 为什么要这两条：1.5.0 只给了 composer 的切组 chip，配置本身仍只能手改
+ * settings.yaml —— 「有入口、没闭环」。设置页的路由卡用 catalog 渲染候选选择器，
+ * 用 config 落盘编辑结果。
+ */
+const ROUTING_CATALOG_PATH = '/api/dsh-llm-hub/routing/catalog'
+const ROUTING_CONFIG_PATH = '/api/dsh-llm-hub/routing/config'
 /** 插件自有的 settings 命名空间（1.5.0 起注册）—— routing / warning / aliases 都住这里。 */
 const HUB_NS = 'dsh-llm-hub'
 /** 模型别名：客户端渲染 model id 时显示短名（典型场景：deepseek-reasoner → 推理）。 */
@@ -343,6 +358,80 @@ export function pickSmartRoute(entries, stateFor, active) {
 	return { to: { provider: winner.provider, model: winner.model }, reason: null, switched: true }
 }
 
+/**
+ * 校验并规范化「路由组编辑」提交的 groups（真源，供 config 路由与测试共用）。
+ *
+ * 两种输入形态都收，因为两种调用方都在：
+ *   - `candidates: [a, b, c]` —— 顺序数组，**首个即主力**。设置页编辑器提交的就是
+ *     这个形态（UI 里对用户呈现的是「有序候选列表」，不区分 primary/fallback 概念）；
+ *   - `primary: 'a/b', fallbacks: [...]` —— settings 落盘形态，手工调用方友好。
+ *   两者同时出现时以 `candidates` 为准（它是更精确的顺序表达）。
+ *
+ * 判据：
+ *   - 组 id：非空、去重（后出现的重名组丢弃）、最长 64；
+ *   - label 可选，纯空白视为没有；
+ *   - primary / fallbacks[] 必须是合法 `provider/model`；非法项**过滤**而不是
+ *     整单拒绝 —— 用户手敲错一行不应该让整次保存失败（UI 会把合法项显示出来）；
+ *   - 没有 primary 也没有 fallback 的组丢弃（空组无法路由）；
+ *   - 上限：≤ 20 组、每组 ≤ 20 个候选（防呆，手抖粘贴不会把 settings 撑爆）。
+ *
+ * @param {unknown} raw - 客户端提交的 groups 数组。
+ * @returns {{ groups: Array, dropped: string[] }} 规范化结果与被丢弃项的原因说明。
+ */
+export function normalizeRoutingGroupsInput(raw) {
+	const dropped = []
+	if (!Array.isArray(raw)) return { groups: [], dropped: ['groups 不是数组'] }
+	/**
+	 * 候选的两种写法都收：字符串 `'provider/model'`（settings 落盘形态）与对象
+	 * `{ provider, model }`（编辑器 / 状态接口形态）。对象经此折回字符串再走同一套
+	 * 正则校验 —— 只有一份合法性判据。
+	 * @param value - 一个候选。
+	 * @returns {{ provider: string, model: string } | undefined}
+	 */
+	const asEntry = (value) => {
+		if (typeof value === 'string') return parseRouteEntryPure(value)
+		if (value !== null && typeof value === 'object') {
+			const provider = typeof value.provider === 'string' ? value.provider.trim() : ''
+			const model = typeof value.model === 'string' ? value.model.trim() : ''
+			if (provider === '' || model === '') return undefined
+			return parseRouteEntryPure(`${provider}/${model}`)
+		}
+		return undefined
+	}
+	/** 非法项的说明文本：对象要展开，否则日志里只有 [object Object]。 */
+	const describe = (value) => (typeof value === 'string' ? value : JSON.stringify(value))
+	const groups = []
+	const seen = new Set()
+	for (const item of raw) {
+		if (groups.length >= 20) { dropped.push('超过 20 组，其余忽略'); break }
+		if (item === null || typeof item !== 'object') { dropped.push('组不是对象'); continue }
+		const id = typeof item.id === 'string' ? item.id.trim().slice(0, 64) : ''
+		if (id === '') { dropped.push('组缺少 id'); continue }
+		if (seen.has(id)) { dropped.push(`组 id 重复：${id}`); continue }
+		// candidates[]（编辑器形态）优先；否则读 primary + fallbacks[]（落盘形态）。
+		const ordered = Array.isArray(item.candidates) ? item.candidates : null
+		const rawPrimary = ordered === null ? item.primary : ordered[0]
+		const rawFallbacks = ordered === null ? item.fallbacks : ordered.slice(1)
+		const primary = asEntry(rawPrimary) ?? null
+		const fallbacks = []
+		for (const entry of Array.isArray(rawFallbacks) ? rawFallbacks : []) {
+			if (fallbacks.length >= 20) { dropped.push(`组 ${id} 的 fallback 超过 20 个`); break }
+			const parsed = asEntry(entry)
+			if (parsed !== undefined) fallbacks.push(parsed)
+			else dropped.push(`组 ${id} 的非法候选被忽略：${describe(entry)}`)
+		}
+		if (primary === null && fallbacks.length === 0) { dropped.push(`组 ${id} 没有任何合法候选`); continue }
+		seen.add(id)
+		groups.push({
+			id,
+			label: typeof item.label === 'string' && item.label.trim() !== '' ? item.label.trim().slice(0, 32) : null,
+			primary,
+			fallbacks
+		})
+	}
+	return { groups, dropped }
+}
+
 /** 路由配置从 settings 哪一段读 —— 顶层 dsh-llm-hub 段下，与 warning 同级。 */
 const ROUTING_KEY = 'routing'
 /** 探针结论的保鲜期；过期后下次读取顺手在后台重探，不阻塞下拉。 */
@@ -2473,6 +2562,23 @@ export function apply(ctx) {
 		return 'unknown'
 	}
 
+	/**
+	 * 路由目标专线的可用性：**探测表里没有的 provider 视为不可用**。
+	 *
+	 * `stateFor` 把「不认识这个 provider」和「探测结果是 unknown」都折成 unknown，
+	 * 后者可以路由，前者路由过去只会撞 NO_ADAPTER —— 请求直接失败。所以智能路由
+	 * 用这一版：配置里写错 provider 名 / 该 provider 还没注册时，候选被跳过，
+	 * 路由保持 fail-open（不动原配置），而不是把会话打挂。
+	 * @param provider - provider id。
+	 * @returns 'available' | 'unknown' | 'unavailable'。
+	 */
+	const routableStateFor = (provider) => {
+		for (const verdict of baseVerdicts.values()) {
+			if (verdict.provider === provider) return verdict.state
+		}
+		return 'unavailable'
+	}
+
 	/**
 	 * 路由解析：给客户端返回「该用哪个 + 原因」（1.5.0 起按组解析）。
 	 * @param active - 客户端 POST 进来的当前已激活 (provider, model)。
@@ -2572,7 +2678,7 @@ export function apply(ctx) {
 				...(group.primary !== null ? [group.primary] : []),
 				...group.fallbacks
 			]
-			const winner = pickSmartRoute(candidates, (provider) => stateFor(provider, ''), null)
+			const winner = pickSmartRoute(candidates, (provider) => routableStateFor(provider), null)
 			return {
 				id: group.id,
 				label: group.label,
@@ -2629,6 +2735,179 @@ export function apply(ctx) {
 		}
 	}
 
+	/**
+	 * 可路由目录：settings 里已配置的 provider 与各自的模型 id（离线，不打网关）。
+	 *
+	 * 数据源是**配置段**而不是 `ctx.llm.listProviders()`：后者会被本插件的隐藏
+	 * 过滤器影响，拿它当候选来源会「隐藏了就再也加不回来」。
+	 * @returns {{ providers: Array<{ id, displayName, ns, models: string[] }> }}
+	 */
+	/**
+	 * 从 settings 里的一个 model 条目读输入模态。
+	 *
+	 * 两种字段名都收：llm-deepseek 段写 `inputModalities: [text, image]`，
+	 * llm-pi-ai 段写 `input: [text, image]`。读不到时为空数组 —— 空数组表示
+	 * 「不知道」，UI 不标（而不是猜一个）。
+	 * @param model - settings 里的 model 条目对象。
+	 * @returns {string[]}
+	 */
+	const modalitiesOf = (model) => {
+		const raw = Array.isArray(model?.inputModalities) ? model.inputModalities : (Array.isArray(model?.input) ? model.input : [])
+		return raw.filter((item) => typeof item === 'string')
+	}
+
+	/**
+	 * 从 settings 里的一个 model 条目读推理（reasoning）能力。
+	 *
+	 * 形态是 `{ off: null, low: 'low', high: 'high', max: 'max' }`：键名 = 人类可读
+	 * 的档位名，值 = 适配器真正认的 effort id（`null` 表示「这个档位不开放」，
+	 * 比如 `off: null` 就是该模型强制思考、不能关）。模型没有这条字段时返回 null
+	 * —— UI 不标，而不是猜一个（用户没声明「能思考」就当不能）。
+	 *
+	 * 只暴露非空档位；off/null 这类「不可用」档位不进 chip 文本，免得显示「思考 · off」
+	 * 自相矛盾。
+	 * @param model - settings 里的 model 条目对象。
+	 * @returns {{ levels: Array<{ id: string, name: string }> } | null}
+	 */
+	const reasoningOf = (model) => {
+		const efforts = model?.reasoningEfforts
+		if (efforts === null || typeof efforts !== 'object') return null
+		const levels = []
+		for (const [name, id] of Object.entries(efforts)) {
+			if (id === null || id === undefined || id === '') continue
+			levels.push({ id: String(id), name: String(name) })
+		}
+		if (levels.length === 0) return null
+		return { levels }
+	}
+
+	/**
+	 * 可路由目录：settings 里已配置的 provider 与各自的模型 id（离线，不打网关）。
+	 *
+	 * 数据源是**配置段**而不是 `ctx.llm.listProviders()`：后者会被本插件的隐藏
+	 * 过滤器影响，拿它当候选来源会「隐藏了就再也加不回来」。
+	 *
+	 * 每个模型带两条 capability 事实：
+	 *   · `input: string[]` —— 输入模态（text / image …）；空数组表示「不知道」。
+	 *   · `reasoning: { levels: [{ id, name }, …] } | null` —— 推理档位；
+	 *     非空 = 模型能思考，UI 标「思考 · low/high/max」；null = 不标。
+	 * 这两条都是 settings 里原本就有的事实（2026-09-27 用户反馈），不亮出来
+	 * 用户就只能靠背 —— 「这个模型支持多模态吗」「它能思考吗」每次都得查文档。
+	 * @returns {{ providers: Array<{ id, displayName, ns, models: Array<{ id, input: string[], reasoning: object | null }> }> }}
+	 */
+	const routingCatalogOf = () => {
+		const out = []
+		for (const [id, profile] of piaiProviders()) {
+			const models = (Array.isArray(profile.models) ? profile.models : [])
+				.map((model) => (model !== null && typeof model === 'object' && typeof model.id === 'string' ? { id: model.id, input: modalitiesOf(model), reasoning: reasoningOf(model) } : undefined))
+				.filter((model) => model !== undefined)
+			out.push({
+				id,
+				displayName: typeof profile.displayName === 'string' && profile.displayName.trim() !== '' ? profile.displayName : id,
+				ns: PIAI_NS,
+				models
+			})
+		}
+		const deepseek = sectionOf()
+		if (deepseek !== undefined) {
+			const models = (Array.isArray(deepseek.models) ? deepseek.models : [])
+				.map((model) => (model !== null && typeof model === 'object' && typeof model.id === 'string' ? { id: model.id, input: modalitiesOf(model), reasoning: reasoningOf(model) } : undefined))
+				.filter((model) => model !== undefined)
+			out.push({
+				id: DEEPSEEK_PROVIDER,
+				displayName: typeof deepseek.displayName === 'string' && deepseek.displayName.trim() !== '' ? deepseek.displayName : 'DeepSeek 官方直连',
+				ns: NS,
+				models
+			})
+		}
+		out.sort((a, b) => a.id.localeCompare(b.id))
+		return { providers: out }
+	}
+
+	/** 写回整份路由组（设置页编辑器保存路径），并返回最新状态。 */
+	const applyRoutingConfig = async (payload) => {
+		const settings = ctx.get('settings')
+		if (settings === undefined || hubRegistered !== true) {
+			return { ok: false, error: 'settings 命名空间 dsh-llm-hub 尚未就绪 —— 稍后重试' }
+		}
+		const normalized = normalizeRoutingGroupsInput(payload?.groups)
+		if (normalized.groups.length === 0) {
+			return { ok: false, error: '至少需要一组有效候选（provider/model）', dropped: normalized.dropped }
+		}
+		const current = routingObjOf()
+		// 生效组若在新配置里没了，落到第一组 —— 不让 settings 里留一个悬空的 activeGroup。
+		const requested = typeof payload?.activeGroup === 'string' ? payload.activeGroup.trim() : ''
+		const fallbackActive = normalized.groups.some((group) => group.id === requested)
+			? requested
+			: (normalized.groups.some((group) => group.id === current.activeGroup) ? current.activeGroup : normalized.groups[0].id)
+		const mode = payload?.mode === 'smart' || payload?.mode === 'manual'
+			? payload.mode
+			: (current.mode === 'smart' ? 'smart' : 'manual')
+		try {
+			await settings.update(HUB_NS, {
+				routing: {
+					...current,
+					mode,
+					activeGroup: fallbackActive,
+					groups: normalized.groups.map((group) => ({
+						id: group.id,
+						...(group.label !== null ? { label: group.label } : {}),
+						...(group.primary !== null ? { primary: `${group.primary.provider}/${group.primary.model}` } : {}),
+						fallbacks: group.fallbacks.map((entry) => `${entry.provider}/${entry.model}`)
+					}))
+				}
+			})
+			return { ok: true, dropped: normalized.dropped, ...smartStateOf() }
+		} catch (error) {
+			return { ok: false, error: `写不进 settings（${error?.message ?? error}）` }
+		}
+	}
+
+	ctx.effect(() => ctx.webServer.register({
+		kind: 'exact',
+		path: ROUTING_CATALOG_PATH,
+		handler: (request, response) => {
+			if (request.method !== 'GET' && request.method !== 'HEAD') {
+				response.writeHead(405, { allow: 'GET, HEAD' })
+				response.end()
+				return
+			}
+			if (!sameOrigin(request)) {
+				sendJson(response, 403, { ok: false, error: 'cross-origin reads are refused' })
+				return
+			}
+			if (request.method === 'HEAD') {
+				response.writeHead(200, { 'content-type': 'application/json; charset=utf-8' })
+				response.end()
+				return
+			}
+			sendJson(response, 200, { ok: true, ...routingCatalogOf() })
+		}
+	}), 'dsh-llm-hub: routing catalog route')
+
+	ctx.effect(() => ctx.webServer.register({
+		kind: 'exact',
+		path: ROUTING_CONFIG_PATH,
+		handler: async (request, response) => {
+			if (request.method !== 'POST') {
+				response.writeHead(405, { allow: 'POST' })
+				response.end()
+				return
+			}
+			if (!sameOrigin(request)) {
+				sendJson(response, 403, { ok: false, error: 'cross-origin writes are refused' })
+				return
+			}
+			const payload = await readPostBody(request)
+			if (payload === null) {
+				sendJson(response, 400, { ok: false, error: '请求内容不是合法 JSON' })
+				return
+			}
+			const result = await applyRoutingConfig(payload)
+			sendJson(response, result.ok === true ? 200 : 400, result)
+		}
+	}), 'dsh-llm-hub: routing config route')
+
 	ctx.effect(() => ctx.webServer.register({
 		kind: 'exact',
 		path: ROUTING_STATE_PATH,
@@ -2688,13 +2967,16 @@ export function apply(ctx) {
 			if (config === null || typeof config !== 'object') return config
 			const state = routingGroupsOf()
 			if (state.mode !== 'smart' || state.groups.length === 0) return config
+			// 探测表空 = 还没人探过。后台热一把（不阻塞这次请求），这次照 fail-open 走原配
+			// —— 否则「刚开机就发请求」会让智能路由一直等到用户开设置页才生效。
+			if (baseVerdicts.size === 0) ensureAvailabilityFresh()
 			const group = state.groups.find((candidate) => candidate.id === state.activeGroup) ?? state.groups[0]
 			const candidates = [
 				...(group.primary !== null ? [group.primary] : []),
 				...group.fallbacks
 			]
 			const active = { provider: config.provider, model: config.model }
-			const decision = pickSmartRoute(candidates, (provider) => stateFor(provider, ''), active)
+			const decision = pickSmartRoute(candidates, (provider) => routableStateFor(provider), active)
 			lastSmartDecision.at = Date.now()
 			lastSmartDecision.group = group.id
 			lastSmartDecision.from = active

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-plugins/dsh-llm-hub",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "DSH 模型管理层：网关可达性探测、模型目录拉取、DeepSeek + MiniMax/智谱/Moonshot/StepFun 余额与配额、本月用量统计、余额预警、Provider 健康看板，再把本机装好的 codex / claude / agy 注册成子代理（装了才出现）。零运行时依赖，不改动 DSH 安装。",
   "type": "module",
   "main": "lib/index.js",

package/scripts/prepublish-gate.mjs

@@ -1,92 +1,249 @@
 #!/usr/bin/env node
 /**
- * prepublish-gate —— 在 `npm publish` 之前把三条硬契约拦在本地。
+ * prepublish-gate —— 发版前的机械门禁（四条契约）
  *
- * 为什么是门禁而不是文档:
- *   2026-09-26 推 1.5.0 时, CHANGELOG 写了、assets/ 落了、版本号 bump 了,
- *   但 package.json 的 files 数组忘了加 'assets' —— 推上 npm 后 122kB
- *   tarball 不含 3 张 SVG, 从 npm 读 CHANGELOG.md 的人看不到截图。
- *   同样那次, 1.5.1 推上去时 publish.yml 在「GH Release」那一步挂了:
- *   CHANGELOG 里没 [1.5.1] 段, 脚本 process.exit(1), 整个 job 标红。
- *   npm publish 已经过 —— 1.5.1 在 npm 上, 但 GH Release 没建, 走到 README
- *   想挂 release link 时发现 404。
+ * 🔴 这个文件是**拷贝**，真源在 CortexOS：
+ *      CortexOS/scripts/release-gate/prepublish-gate.mjs
+ *    同步检查：`node $CORTEXOS_ROOT/scripts/check-release-gate-sync.mjs`
+ *    改逻辑请改真源，然后跑同步脚本把各仓拷一遍 —— 不要在各仓就地改。
  *
- *   两条都是「约定没做成门禁」。本脚本把三条契约变成前置门:
- *     1. tarball 必含 paths in MUST_INCLUDE
- *     2. CHANGELOG 顶部必含 '## [<当前 package.json version>]' 段
- *     3. assets/ 目录里至少有一张 .svg 推广图 (不允许空目录占位)
+ * 为什么是门禁而不是文档：2026-09-26 一天里给 dsh-llm-hub 发了 1.5.0/1.5.1/1.5.2/1.5.3
+ * 四个版本号，用户可感知的变化只有 1.5.0 一个；同一轮还漏了 bloom-theme 的 assets
+ * （README 引用 11 个相对路径截图、tarball 里 0 个 → npm 页面上全是坏图；那 11 张合计
+ * 10MB，正确修法是换成图床直链而不是把 10MB 塞进每个安装包）。共同点是
+ * 「约定没做成门禁」，所以把判据做成能跑的：
  *
- *   任一条挂了: process.exit(1) + stderr 一行指明错在哪。
+ *   契约 1 产物完整性 —— package.json 必须在；`files` 里每个字面量条目至少命中一个文件；
+ *                       main / types / exports / dsh 引用的相对路径文件必须存在。
+ *   契约 2 图片引用   —— README 里以**相对路径**引用的 assets/* 必须在 tarball 里。
+ *                       否则 npm 页面上是坏图（bloom-theme 就是这么坏的）。
+ *                       只认 `](assets/…)` 与 `src="assets/…"`，不认 URL 里的 assets/
+ *                       （raw.githubusercontent 那种在 npm 上照样能显示，不算坏图）。
+ *   契约 3 CHANGELOG  —— 存在 CHANGELOG.md 时，必含 `## [<当前 version>]` 段。
+ *   契约 4 发版语义   —— 运行期载荷必须与上一个已发布版本**不同**。
+ *                       见 docs/rules/release-semantics.md；ALLOW_METADATA_ONLY=1 是逃生舱。
  *
- *   `npm publish` 调用 prepublishOnly 时, 本脚本非零退出 → publish 整体
- *   失败, tarball 不会被推上 registry, 也就不会出现「npm 上了但本地行为
- *   与预期不一致」的漂移。
+ * 任一条挂了 → exit 1 + stderr 指明错在哪、怎么修。
  */
-import { readFileSync } from 'node:fs'
+import { readFileSync, mkdtempSync, rmSync, readdirSync, statSync, existsSync } from 'node:fs'
 import { execFileSync } from 'node:child_process'
-import { dirname, join } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { tmpdir } from 'node:os'
+import { createHash } from 'node:crypto'
+
+const GATE_VERSION = 1
 
 const here = dirname(fileURLToPath(import.meta.url))
 const pkgRoot = dirname(here)
 
 const pkg = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8'))
 const version = pkg.version
-
-const MUST_INCLUDE = [
-  'package.json',
-  'cordis.patch.yml',
-  'lib/client.js',
-  'lib/index.js',
-  'lib/harness.js',
-  'README.md',
-  'LICENSE'
-]
-
-const ASSETS_MIN = 1 // 至少一张 .svg, 防止目录被空提交
-
 const errors = []
 
-// ── 1. tarball 路径断言 ────────────────────────────────────────────────────
+// ── 0. 打包清单 ────────────────────────────────────────────────────────────
 let packFiles
 try {
   const out = execFileSync('npm', ['pack', '--dry-run', '--json'], {
-    cwd: pkgRoot,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'inherit']
+    cwd: pkgRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit']
   })
   packFiles = JSON.parse(out)[0].files.map(f => f.path)
 } catch (err) {
   console.error('[prepublish-gate] npm pack --dry-run 失败:', err.message)
   process.exit(2)
 }
+const inPack = (p) => packFiles.includes(p)
+
+// ── 1. 产物完整性 ──────────────────────────────────────────────────────────
+if (!inPack('package.json')) errors.push('tarball 里没有 package.json')
+
+// files[] 里的字面量条目（不含 glob）必须命中至少一个文件
+for (const entry of pkg.files ?? []) {
+  if (/[*?[\]{}!]/.test(entry)) continue            // glob 跳过
+  const e = entry.replace(/\/$/, '')
+  const hit = packFiles.some(f => f === e || f.startsWith(e + '/'))
+  if (!hit) {
+    errors.push(`package.json#files 声明了 '${entry}'，但 tarball 里一个文件都没有\n  → 条目过期或文件被删/被 ignore`)
+  }
+}
+
+// main / types / module / bin / exports / dsh.bundle 引用的路径必须在 tarball 里。
+// 只走这几个字段，因为 package.json 里别的字符串不是路径 —— 典型陷阱：
+// `dsh.client.platform: "web"` 和 `dsh.client.inject: ["@deepseek-ai/..."]`
+// 一旦被当成路径就会误报。
+const entryPaths = new Set()
+const addPath = (v) => {
+  if (typeof v !== 'string' || v === '') return
+  if (/^[a-z][a-z0-9+.-]*:/i.test(v) || v.startsWith('/')) return   // URL / 绝对路径
+  entryPaths.add(v.replace(/^\.\//, ''))
+}
+const walkStrings = (v) => {
+  if (typeof v === 'string') addPath(v)
+  else if (v && typeof v === 'object') for (const x of Object.values(v)) walkStrings(x)
+}
+for (const field of ['main', 'types', 'module', 'bin', 'exports']) walkStrings(pkg[field])
+if (pkg.dsh && typeof pkg.dsh === 'object') walkStrings(pkg.dsh.bundle)
+
+for (const p of entryPaths) {
+  if (!inPack(p)) {
+    errors.push(`package.json 的入口字段引用了 '${p}'，但 tarball 里没有\n  → 装包的人会在 require/import 时直接失败`)
+  }
+}
+
+// ── 2. README 里相对引用的 assets/* 必须在 tarball 里 ──────────────────────
+const readmes = ['README.md', 'README.en.md', 'README.zh.md', 'README.zh-CN.md']
+  .filter(f => existsSync(join(pkgRoot, f)))
 
-const missing = MUST_INCLUDE.filter(p => !packFiles.includes(p))
-if (missing.length > 0) {
-  errors.push(`tarball 缺少必含文件: ${missing.join(', ')}\n  → 在 package.json 'files' 数组里列出, 或确认文件实际存在`)
+const referencedAssets = new Set()
+for (const f of readmes) {
+  const text = readFileSync(join(pkgRoot, f), 'utf8')
+  // 只认相对引用：](assets/x) 与 src="assets/x"。URL 里的 assets/ 不算。
+  for (const m of text.matchAll(/\]\((assets\/[^)\s]+)\)/g)) referencedAssets.add(m[1])
+  for (const m of text.matchAll(/src=["'](assets\/[^"']+)["']/g)) referencedAssets.add(m[1])
 }
 
-// ── 2. assets/ 目录必含至少一张 SVG ─────────────────────────────────────────
-const assetSvgs = packFiles.filter(p => p.startsWith('assets/') && p.endsWith('.svg'))
-if (assetSvgs.length < ASSETS_MIN) {
-  errors.push(`tarball assets/ 里 .svg < ${ASSETS_MIN}: 找到 ${assetSvgs.length} 张\n  → 在 assets/ 下放图, 并确认 package.json 'files' 含 'assets'`)
+const missingAssets = [...referencedAssets].filter(a => existsSync(join(pkgRoot, a)) && !inPack(a))
+if (missingAssets.length > 0) {
+  errors.push(
+    `README 引用了 ${missingAssets.length} 个 assets 文件，但 tarball 里没有 —— npm 页面上会是坏图:\n` +
+    missingAssets.slice(0, 5).map(a => `    · ${a}`).join('\n') +
+    (missingAssets.length > 5 ? `\n    …（共 ${missingAssets.length} 个）` : '') +
+    `\n  → 二选一：(a) 把 'assets' 加进 package.json 的 'files'（图小就用这个）；` +
+    `\n                (b) 把 README 改成图床绝对 URL 并确认真能打开（图大就用这个，别把十几 MB 塞进每个安装包）`
+  )
 }
 
-// ── 3. CHANGELOG 顶部必含 '## [<当前 version>]' 段 ─────────────────────────
+// ── 3. CHANGELOG 必须有当前版本段 ──────────────────────────────────────────
+// 标题写法各仓不一（`## [1.5.3]` / `## 3.7.0 (2026-09-16)` /
+// `## [0.14.0](compare-link) (2026-09-25)` / `## v0.14.0`），
+// 只认「二级标题 + 版本号本身」，不强制 keep-a-changelog 的方括号。
+// 版本号后用负向前瞻收尾，避免 0.14.0 命中 0.14.01 这种前缀。
 const changelogPath = join(pkgRoot, 'CHANGELOG.md')
-let changelogText
-try {
-  changelogText = readFileSync(changelogPath, 'utf8')
-} catch (err) {
-  errors.push(`CHANGELOG.md 读取失败: ${err.message}`)
-  changelogText = ''
+if (existsSync(changelogPath)) {
+  const text = readFileSync(changelogPath, 'utf8')
+  const esc = version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const heading = new RegExp(`^##\\s*\\[?v?${esc}(?![\\d.])`, 'm')
+  if (!heading.test(text)) {
+    errors.push(
+      `CHANGELOG.md 缺少当前版本（${version}）的二级标题段\n` +
+      `  → 发版正文（GitHub Release / npm 页）直接取这一段；缺了会出现「npm 上了 / Release 没建」的漂移`
+    )
+  }
+}
+
+// ── 4. 发版语义：运行期载荷必须与上一已发布版本不同 ────────────────────────
+//
+// 「运行期载荷」= tarball 里**除了文档/元数据/开发工具之外**的每一个文件，
+// 外加 package.json 的运行期字段。判据要能机械执行 —— 不用「CHANGELOG 里有没有
+// feat/fix 关键字」这种启发式（自省段落里出现一个「修」字就会误放行）。
+//
+// 详见 docs/rules/release-semantics.md。
+const EXCLUDE = [
+  /^readme(\.[^/]*)?$/i,
+  /^changelog(\.[^/]*)?$/i,
+  /^(license|notice|contributing)(\.[^/]*)?$/i,
+  /^docs\//i,
+  /^assets\//i,
+  /^scripts\//i,
+  /^\.github\//i,
+  /^\.githooks\//i,
+  /^tsconfig[^/]*\.json$/i,
+  /^(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$/i,
+  /^(screenshots\.json|llms\.txt|dev_notes[^/]*)$/i,
+  /^(\.npmignore|\.gitignore|\.gitattributes)$/i
+]
+const isRuntime = (p) => !EXCLUDE.some(re => re.test(p))
+
+const RUNTIME_PKG_FIELDS = [
+  'name', 'type', 'main', 'module', 'types', 'exports', 'bin', 'dsh', 'files',
+  'dependencies', 'peerDependencies', 'optionalDependencies', 'engines'
+]
+
+/** 运行期载荷指纹: 排序后的 "路径:哈希" 列表。 */
+function runtimeFingerprint(root, list) {
+  const entries = []
+  for (const rel of list) {
+    if (!isRuntime(rel)) continue
+    if (rel === 'package.json') continue
+    try {
+      entries.push([rel, createHash('sha256').update(readFileSync(join(root, rel))).digest('hex')])
+    } catch { /* 目录项或读不到，跳过 */ }
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+    const runtimePkg = {}
+    for (const f of RUNTIME_PKG_FIELDS) {
+      if (manifest[f] !== undefined) runtimePkg[f] = manifest[f]
+    }
+    entries.push(['package.json(运行期字段)', createHash('sha256').update(JSON.stringify(runtimePkg)).digest('hex')])
+  } catch { /* 读不到是别处的问题 */ }
+  return entries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+}
+
+if (process.env.ALLOW_METADATA_ONLY === '1') {
+  console.warn('[prepublish-gate] ⚠️  ALLOW_METADATA_ONLY=1 —— 跳过契约 4（纯文档/元数据版本）')
+} else {
+  try {
+    const raw = execFileSync('npm', ['view', pkg.name, 'versions', '--json'], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore']
+    })
+    const parsed = JSON.parse(raw)
+    const list = Array.isArray(parsed) ? parsed : [parsed]
+    const previous = list.filter(v => v !== version).pop()
+
+    if (previous === undefined) {
+      console.log(`[prepublish-gate]   · 契约 4: ${pkg.name} 尚无更早版本, 跳过载荷比对`)
+    } else {
+      const tarballUrl = execFileSync('npm', ['view', `${pkg.name}@${previous}`, 'dist.tarball'], {
+        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore']
+      }).trim()
+      const stage = mkdtempSync(join(tmpdir(), 'prepublish-gate-'))
+      try {
+        const tgz = join(stage, 'prev.tgz')
+        const res = await fetch(tarballUrl)
+        if (!res.ok) throw new Error(`下载 ${previous} tarball 失败: HTTP ${res.status}`)
+        const { writeFileSync } = await import('node:fs')
+        writeFileSync(tgz, Buffer.from(await res.arrayBuffer()))
+        execFileSync('tar', ['-xzf', tgz, '-C', stage], { stdio: 'ignore' })
+        const prevRoot = join(stage, 'package')
+
+        const before = runtimeFingerprint(prevRoot, collectAllFiles(prevRoot))
+        const after = runtimeFingerprint(pkgRoot, packFiles)
+        if (JSON.stringify(before) === JSON.stringify(after)) {
+          errors.push(
+            `运行期载荷与上一个已发布版本 ${previous} **完全相同** —— 这个 semver 号没有承载任何用户可感知的变化\n` +
+            `  → 本次只动了: ${packFiles.filter(p => !isRuntime(p)).slice(0, 6).join(', ') || '(仅 package.json 非运行期字段)'}\n` +
+            `  → semver 是对用户的契约: 流程修补 / 元数据修正 / 自省笔记不该占版本号（docs/rules/release-semantics.md）。\n` +
+            `     确实要发纯文档版时显式设 ALLOW_METADATA_ONLY=1`
+          )
+        } else {
+          console.log(`[prepublish-gate]   · 契约 4: 运行期载荷相对 ${previous} 有变化（${before.length} 项比对）`)
+        }
+      } finally {
+        rmSync(stage, { recursive: true, force: true })
+      }
+    }
+  } catch (err) {
+    // 网络/registry 不可用时不阻断发版：门禁不该因为一次查询失败就卡住真实发布。
+    console.warn(`[prepublish-gate] ⚠️  契约 4 未能执行（不阻断）: ${err.message}`)
+  }
 }
 
-if (changelogText) {
-  const expectedHeader = `## [${version}]`
-  if (!changelogText.includes(expectedHeader)) {
-    errors.push(`CHANGELOG.md 缺少 '${expectedHeader}' 段\n  → publish.yml 的 release body 直接 grep 这一行; 缺了 GH Release 创建会失败, npm 上却有版本号, 出现「npm 上了 / Release 没建」的漂移`)
+/** 递归收集目录下所有文件（相对路径），用于对上一版本解包目录做指纹。 */
+function collectAllFiles(root) {
+  const out = []
+  const walk = (rel) => {
+    const abs = rel ? join(root, rel) : root
+    let st
+    try { st = statSync(abs) } catch { return }
+    if (st.isDirectory()) {
+      for (const e of readdirSync(abs)) walk(rel ? join(rel, e) : e)
+    } else {
+      out.push(rel)
+    }
   }
+  walk('')
+  return out
 }
 
 // ── 报告 ──────────────────────────────────────────────────────────────────
@@ -100,6 +257,7 @@ if (errors.length > 0) {
   process.exit(1)
 }
 
-console.log(`[prepublish-gate] ✓ @${pkg.name}@${version} 三条契约通过`)
-console.log(`[prepublish-gate]   · tarball: ${packFiles.length} 个文件, 含 ${assetSvgs.length} 张 assets/*.svg`)
-console.log(`[prepublish-gate]   · CHANGELOG 含 '## [${version}]' 段`)
+console.log(`[prepublish-gate] ✓ ${pkg.name}@${version} 四条契约通过（gate v${GATE_VERSION}）`)
+console.log(`[prepublish-gate]   · tarball ${packFiles.length} 个文件；运行期载荷 ${packFiles.filter(isRuntime).length} 个`)
+if (referencedAssets.size > 0) console.log(`[prepublish-gate]   · README 引用的 ${referencedAssets.size} 个 assets 均在包内`)
+console.log(`[prepublish-gate]   · CHANGELOG 含当前版本段`)