dsh-router-core 0.3.10 → 0.3.12

package/src/data-dir.ts

@@ -0,0 +1,46 @@
+/**
+ * 落盘路径解析 —— dsh-router 所有持久化路径的唯一来源。
+ *
+ * 以前写的是相对路径 `data/state.json`：**落盘位置跟着 `process.cwd()` 跑**。
+ * 不在 `~/.dsh/profiles/web` 里 `dsh web` 启动，state.json / supplier-config.json
+ * / keys.json / usage.json 就会静默写进另一个目录（面板显示空配置），切回原目录
+ * 启动又「回来」——用户看到的是「配置丢了」。所以这里一律产出绝对路径。
+ */
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * 本 profile 的目录。
+ *
+ * 宿主把配置树锚点 `ctx.baseUrl` 挂在每个插件的 context 上，它正是 profile
+ * 目录（`cordis.yml` 所在处）——不用猜、也不用像 dsh-market 那样嗅探 argv。
+ * 兜底只服务「宿主没给锚点」的冷启动（单测、非常规宿主）：沿用今天的事实
+ * 标准 `web` profile。
+ */
+export function profileDirOf(baseUrl?: string): string {
+  if (typeof baseUrl === 'string' && baseUrl !== '') {
+    try {
+      // 尾部斜杠留给 join 吸收是隐式的，这里显式归一：调用方拿到的是干净目录。
+      return resolve(fileURLToPath(baseUrl))
+    } catch {
+      // 不是 file: URL（或不可解析）——落到兜底分支
+    }
+  }
+  return join(dshHome(), 'profiles', 'web')
+}
+
+/** 数据目录：state.json / supplier-config.json / keys.json / auths/ 都在这里。 */
+export function dataDirOf(baseUrl?: string): string {
+  return join(profileDirOf(baseUrl), 'data')
+}
+
+/** `$DSH_HOME`（支持 `~` 前缀），缺省 `~/.dsh`。 */
+function dshHome(): string {
+  const raw = process.env.DSH_HOME
+  if (raw === undefined || raw.trim() === '') return join(homedir(), '.dsh')
+  const value = raw.trim()
+  if (value === '~') return homedir()
+  if (value.startsWith('~/') || value.startsWith('~\\')) return resolve(homedir(), value.slice(2))
+  return resolve(value)
+}

package/src/ext/contract.ts

@@ -0,0 +1,115 @@
+/**
+ * 扩展 (Ext) 通用契约 —— dsh-router 的「扩展插件」扩展点（不是供应商）。
+ *
+ * 分工（2026-09 重构：核心只做管理，不做拦截）：
+ *   - **dsh-router 核心 = 管理面**：持有 `router.ext` 注册表（发现）、渲染面板与
+ *     `/router/api/ext`（展示）、代存开关与插件数据（`router.extStore` →
+ *     `<dataDir>/ext.json`）。核心**不挂 `tools/execute`、不裁决、不改写**。
+ *   - **扩展插件 = 执行面**：自己挂监听、自己问 `isEnabled`、自己按 ready 裁决、
+ *     自己短路执行。怎么改一条命令是插件的**私事**，不在本契约里。
+ *
+ * 为什么把拦截从核心挪走：
+ *   `tools/execute` 是任何插件都能自己挂的 around-dispatch waterfall（插件 ctx 不在
+ *   agent scope 下就能收到全部派发）。核心代挂只在一个消费者（rtk）时是纯亏损：为留
+ *   40 行委派逻辑，付了共享表 + inject 广播 + 契约两处同步的代价。核心归位成管理面
+ *   后，扩展插件与 dsh-router 只在**注册表 + 存储**两处耦合。
+ *
+ * ponytail: 天花板 —— 核心代挂原本顺带解决「多个扩展插件各自挂监听会互相踩 / 顺序
+ *   不可控」。这个保护现在没了；目前只有 rtk 一家消费，无所谓。**第二家 ext 出现时
+ *   要重新收敛顺序**（升级路径：核心暴露一个按顺序委派的共享工具方法，而不是收回拦截）。
+ *
+ * 契约要点：
+ *   - 扩展器只有**声明**（id / name / description）+ `getState()`；核心拿这些渲染面板。
+ *   - `getState()` 只报**运行时事实**（ready 是否可用、detail 说明），不报开关。
+ *   - **开关与数据归核心持久化**（`router.extStore` → `<dataDir>/ext.json`），插件不自己
+ *     file IO —— 落盘位置由核心锚定（不跟 cwd 跑），读写经核心，插件无状态。
+ */
+import type { Context } from '@deepseek-ai/cordis'
+
+/** 扩展器唯一 id（注册键）。 */
+export type ExtId = string
+
+/**
+ * 扩展器当前状态（**运行时事实**，由插件现算，不持久化）。
+ *
+ * 注意：`enabled` 不在这里 —— 开关状态归核心持久化（`<dataDir>/ext.json`），
+ * 插件只负责做事 + 报自己是否可用。核心把两者合并后再给面板用。
+ */
+export interface ExtState {
+  /** 运行时是否就绪（如 RTK 二进制是否可用）；false 时即使开启也不生效。 */
+  ready: boolean
+  /** 不就绪时的一句话说明（如「本机未装 rtk」），面板红字显示。 */
+  detail?: string
+}
+
+/**
+ * 注册到 `router.ext` 表的扩展器实现。核心（面板/API）只认这几个成员，
+ * 插件可以携带更多内部状态。
+ */
+export interface RouterExt {
+  /** 扩展器 id，也是 `router.ext` 表里的注册键。 */
+  readonly id: ExtId
+  /** 面板显示名（如「RTK」）。 */
+  readonly name: string
+  /** 面板副标题说明。 */
+  readonly description?: string
+  /** 当前运行时状态（ready + 不就绪时的说明）。 */
+  getState(): ExtState
+  /** 卸载清理（表删除时由 dsh-router 调用，可选）。 */
+  dispose?(): void
+}
+
+/** 面板/API 用的一条扩展器信息 = 核心存的开关 + 插件报的运行时事实。 */
+export interface ExtInfo {
+  id: string
+  name: string
+  description?: string
+  /** 核心持久化的开关（默认关）。 */
+  enabled: boolean
+  /** 插件报的运行时就绪状态。 */
+  ready: boolean
+  /** 不就绪时的说明（面板红字）。 */
+  detail?: string
+}
+
+/** `router.ext` 共享聚合表：`{ [extId]: RouterExt }`（同一 live 对象可追加）。 */
+export interface RouterExtService {
+  [extId: string]: RouterExt
+}
+
+/**
+ * 扩展的存储面（核心 provide，插件 inject）。
+ *
+ * 插件**不自己 file IO**：落盘位置由核心用 `dataDirOf(ctx.baseUrl)` 锚定（不跟
+ * process.cwd() 跑），读写都经核心，同一文件、同一次原子写。
+ *
+ * 落盘形状：`<dataDir>/ext.json` = `{ "<id>": { "enabled": boolean, "data": unknown } }`
+ */
+export interface ExtStoreService {
+  /** 是否开启（未记录过 = 默认关）。 */
+  isEnabled(id: string): boolean
+  /** 置开关（面板/API 调）。 */
+  setEnabled(id: string, enabled: boolean): void
+  /** 读插件自己的数据块（没有 = undefined）。 */
+  readData<T = unknown>(id: string): T | undefined
+  /** 写插件自己的数据块（覆盖；与 enabled 同文件原子落盘）。 */
+  writeData(id: string, value: unknown): void
+}
+
+/** 读取当前 router.ext 表（同一 live 对象，可追加）——扩展插件用它注册自己。 */
+export function currentExts(ctx: Context): RouterExtService | undefined {
+  const c = ctx as unknown as {
+    get?: (key: string) => unknown
+    router?: { ext?: RouterExtService }
+  }
+  return (c.get?.('router.ext') ?? c.router?.ext) as RouterExtService | undefined
+}
+
+/** 读取扩展存储服务——扩展插件用它读开关、读写自己存的数据。 */
+export function currentExtStore(ctx: Context): ExtStoreService | undefined {
+  const c = ctx as unknown as {
+    get?: (key: string) => unknown
+    router?: { extStore?: ExtStoreService }
+  }
+  return (c.get?.('router.extStore') ?? c.router?.extStore) as ExtStoreService | undefined
+}

package/src/ext/store.test.ts

@@ -0,0 +1,144 @@
+/**
+ * 扩展开关存储测试 —— 开关状态归核心持久化(`<dataDir>/ext.json`)。
+ *
+ * 锁定的契约:
+ *   - 默认关(没记录过 = 关)
+ *   - 开启 → 落盘,新实例(模拟重启)读到
+ *   - 按 id 隔离,互不影响
+ *   - 坏数据读盘不炸
+ *   - 重复设同值不写盘
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { ExtStore } from './store.ts'
+
+/** 每个用例一个独立数据目录(stateFile 推导出 ext.json)。 */
+function tempStore(preload?: unknown): { store: ExtStore; file: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'dshr-ext-'))
+  const stateFile = join(dir, 'state.json')
+  if (preload !== undefined) writeFileSync(join(dir, 'ext.json'), JSON.stringify(preload))
+  return { store: new ExtStore(stateFile), file: join(dir, 'ext.json') }
+}
+
+test('默认关', () => {
+  const { store } = tempStore()
+  assert.equal(store.isEnabled('rtk'), false)
+})
+
+test('开启 → 落盘,重开还在', () => {
+  const { store, file } = tempStore()
+  store.setEnabled('rtk', true)
+  const raw = JSON.parse(readFileSync(file, 'utf8')) as { rtk?: { enabled: boolean } }
+  assert.equal(raw.rtk?.enabled, true)
+  // 新实例 = 模拟重启
+  assert.equal(new ExtStore(join(file, '..', 'state.json')).isEnabled('rtk'), true)
+})
+
+test('关回去 → 落盘 false', () => {
+  const { store, file } = tempStore()
+  store.setEnabled('rtk', true)
+  store.setEnabled('rtk', false)
+  assert.equal(new ExtStore(join(file, '..', 'state.json')).isEnabled('rtk'), false)
+})
+
+test('按 id 隔离,互不影响', () => {
+  const { store } = tempStore()
+  store.setEnabled('rtk', true)
+  assert.equal(store.isEnabled('rtk'), true)
+  assert.equal(store.isEnabled('other'), false)
+})
+
+test('坏数据读盘不炸,当没配置过', () => {
+  const { store: s1 } = tempStore({ rtk: { enabled: 'yes' } })
+  assert.equal(s1.isEnabled('rtk'), false)
+  const { store: s2 } = tempStore({ rtk: null })
+  assert.equal(s2.isEnabled('rtk'), false)
+  const { store: s3 } = tempStore([])
+  assert.equal(s3.isEnabled('rtk'), false)
+})
+
+/** 造一个带旧 enhance.json 的目录(模拟升级前的状态)。 */
+function legacyStore(enabled: boolean): { store: ExtStore; file: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'dshr-ext-legacy-'))
+  writeFileSync(join(dir, 'enhance.json'), JSON.stringify({ enabled }))
+  const stateFile = join(dir, 'state.json')
+  return { store: new ExtStore(stateFile), file: join(dir, 'ext.json') }
+}
+
+test('迁移:旧 enhance.json 开着 → 新 ext.json 里 rtk 开', () => {
+  const { store, file } = legacyStore(true)
+  assert.equal(store.isEnabled('rtk'), true)
+  const raw = JSON.parse(readFileSync(file, 'utf8')) as { rtk?: { enabled: boolean } }
+  assert.equal(raw.rtk?.enabled, true)
+})
+
+test('迁移:旧文件关着 → 不迁移(保持默认关)', () => {
+  const { store, file } = legacyStore(false)
+  assert.equal(store.isEnabled('rtk'), false)
+  assert.equal(existsSync(file), false)
+})
+
+test('迁移:已有新配置时不覆盖', () => {
+  const { store: s1, file } = tempStore()
+  s1.setEnabled('rtk', false)
+  // 往同目录塞一个「开着」的旧文件,不应覆盖已经明确存过的新配置
+  writeFileSync(join(file, '..', 'enhance.json'), JSON.stringify({ enabled: true }))
+  const s2 = new ExtStore(join(file, '..', 'state.json'))
+  assert.equal(s2.isEnabled('rtk'), false)
+})
+
+test('空 id 不落盘(连文件都不建)', () => {
+  const { store, file } = tempStore()
+  store.setEnabled('', true)
+  assert.equal(store.isEnabled(''), false)
+  assert.equal(existsSync(file), false, '空 id 应直接拒绝,不创建文件')
+})
+
+// ---- data 槽:给插件的通用抽屉(2026-09 加) ----
+
+test('data:没存过 → undefined;写后能读回', () => {
+  const { store } = tempStore()
+  assert.equal(store.readData('rtk'), undefined)
+  store.writeData('rtk', { hits: 3 })
+  assert.deepEqual(store.readData('rtk'), { hits: 3 })
+})
+
+test('data:落盘 + 重启还在(与 enabled 同一文件)', () => {
+  const { store, file } = tempStore()
+  store.setEnabled('rtk', true)
+  store.writeData('rtk', { hits: 3 })
+  const raw = JSON.parse(readFileSync(file, 'utf8')) as { rtk?: { enabled: boolean; data?: { hits: number } } }
+  assert.equal(raw.rtk?.enabled, true)
+  assert.deepEqual(raw.rtk?.data, { hits: 3 })
+  const revived = new ExtStore(join(file, '..', 'state.json'))
+  assert.equal(revived.isEnabled('rtk'), true)
+  assert.deepEqual(revived.readData('rtk'), { hits: 3 })
+})
+
+test('data:写 data 不冲掉 enabled,置 enabled 不冲掉 data', () => {
+  const { store, file } = tempStore()
+  store.setEnabled('rtk', true)
+  store.writeData('rtk', { hits: 1 })
+  assert.equal(store.isEnabled('rtk'), true, '写 data 不能把开关冲掉')
+  store.setEnabled('rtk', false)
+  assert.deepEqual(store.readData('rtk'), { hits: 1 }, '置开关不能把 data 冲掉')
+  const revived = new ExtStore(join(file, '..', 'state.json'))
+  assert.equal(revived.isEnabled('rtk'), false)
+  assert.deepEqual(revived.readData('rtk'), { hits: 1 })
+})
+
+test('data:按 id 隔离', () => {
+  const { store } = tempStore()
+  store.writeData('rtk', { hits: 1 })
+  assert.deepEqual(store.readData('other'), undefined)
+})
+
+test('data:空 id 不落盘', () => {
+  const { store, file } = tempStore()
+  store.writeData('', { x: 1 })
+  assert.equal(store.readData(''), undefined)
+  assert.equal(existsSync(file), false)
+})

package/src/ext/store.ts

@@ -0,0 +1,125 @@
+/**
+ * 扩展存储 —— **开关状态与插件数据都归核心持久化**,插件不自己 file IO。
+ *
+ * 落盘 `<dataDir>/ext.json`,按扩展器 id 存:
+ *   `{ "rtk": { "enabled": true, "data": { ...插件自己的东西... } } }`
+ *
+ * 为什么归核心:跟 `supplier-config.json` 一个道理——开关是用户对**核心面板**的操作,
+ * 不该由扩展插件各自决定存哪、怎么存(否则每个插件长一份互相不一致的实现,核心也无
+ * 从统一裁决「能不能开」)。插件变薄:只报自己是否可用(`ready`)+ 做事。
+ *
+ * `data` 槽是给插件的通用抽屉(2026-09 加):插件不再为了存一点状态而自己开数据目录,
+ * 统一经 `router.extStore` service 读写,落盘位置仍由核心锚定(不跟 cwd 跑)。
+ *
+ * 写法与核心其他存储一致:先写 `.tmp` 再 `rename` 原子覆盖(避免写一半崩掉留坏文件),
+ * 权限 600;持久化失败不阻断。
+ */
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+interface ExtFile {
+  [extId: string]: { enabled: boolean; data?: unknown }
+}
+
+interface Entry {
+  enabled: boolean
+  data: unknown
+}
+
+/** 扩展开关 + 插件数据存储。 */
+export class ExtStore {
+  private fp = ''
+  private byId: Record<string, Entry> = {}
+
+  constructor(stateFile: string) {
+    this.fp = stateFile ? join(dirname(stateFile), 'ext.json') : ''
+    this.load()
+    // 一次性迁移:开关早期由扩展插件自己写在 `enhance.json`(单文件、无法按 id 区分),
+    // 现在归核心按 id 存 `ext.json`。把旧值搬过来,避免用户已开的开关掉回关。
+    // 旧文件保留不删(不可逆操作留给人工),迁移只发生在新文件还没有时。
+    this.migrateLegacy()
+  }
+
+  private migrateLegacy(): void {
+    if (this.fp === '') return
+    if (Object.keys(this.byId).length > 0) return // 已有新配置,不覆盖
+    const legacy = join(dirname(this.fp), 'enhance.json')
+    let enabled = false
+    try {
+      const f = JSON.parse(readFileSync(legacy, 'utf8')) as { enabled?: unknown }
+      enabled = f.enabled === true
+    } catch {
+      return // 没有旧文件 / 读不了 → 无需迁移
+    }
+    if (!enabled) return
+    // 旧格式只有一个开关,当时唯一的扩展器就是 rtk。
+    this.byId.rtk = { enabled: true, data: undefined }
+    this.save()
+  }
+
+  private load(): void {
+    if (this.fp === '') return
+    let raw: string
+    try {
+      raw = readFileSync(this.fp, 'utf8')
+    } catch {
+      return
+    }
+    try {
+      const f = JSON.parse(raw) as ExtFile
+      for (const [id, v] of Object.entries(f)) {
+        if (id === '' || v === null || typeof v !== 'object') continue
+        if (typeof v?.enabled !== 'boolean') continue
+        this.byId[id] = { enabled: v.enabled, data: v.data }
+      }
+    } catch {
+      // 损坏则用默认关
+    }
+  }
+
+  private save(): void {
+    if (this.fp === '') return
+    try {
+      const dir = dirname(this.fp)
+      if (dir !== '' && dir !== '.') mkdirSync(dir, { recursive: true })
+      const out: ExtFile = {}
+      for (const [id, e] of Object.entries(this.byId)) {
+        // 没数据的不写 data 键,保持文件干净(旧格式兼容)。
+        out[id] = e.data === undefined ? { enabled: e.enabled } : { enabled: e.enabled, data: e.data }
+      }
+      const raw = JSON.stringify(out, null, 2)
+      const tmp = this.fp + '.tmp'
+      writeFileSync(tmp, raw, { mode: 0o600 })
+      renameSync(tmp, this.fp)
+    } catch {
+      // 持久化失败不阻断
+    }
+  }
+
+  /** 是否开启(未记录过 = 默认关)。 */
+  isEnabled(id: string): boolean {
+    return this.byId[id]?.enabled === true
+  }
+
+  setEnabled(id: string, enabled: boolean): void {
+    if (id === '') return
+    const cur = this.byId[id]
+    if (cur?.enabled === enabled) return
+    this.byId[id] = { enabled, data: cur?.data }
+    this.save()
+  }
+
+  /** 读插件自己存的数据块(没存过 = undefined)。 */
+  readData<T = unknown>(id: string): T | undefined {
+    if (id === '') return undefined
+    return this.byId[id]?.data as T | undefined
+  }
+
+  /** 写插件自己的数据块(覆盖;与 enabled 同一文件落盘)。 */
+  writeData(id: string, value: unknown): void {
+    if (id === '') return
+    const cur = this.byId[id]
+    this.byId[id] = { enabled: cur?.enabled === true, data: value }
+    this.save()
+  }
+}

package/src/index.ts

@@ -30,7 +30,7 @@
  * active library key. `/router/api/*` is same-origin, no auth.
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
-import { join, dirname } from 'node:path'
+import { join } from 'node:path'
 import { ROUTER_API_BASE, type RouterPeriod } from './shared.ts'
 import { Router } from './router/index.ts'
 import { RouterAdapter } from './llm/adapter.ts'
@@ -40,6 +40,9 @@ import { supplierRoutes } from './suppliers/registry.ts'
 import type { SupplierEnv, SupplierModule } from './suppliers/contract.ts'
 import { SupplierConfigStore } from './supplier-config.ts'
 import { CredentialStore } from './credential-store.ts'
+import { dataDirOf, profileDirOf } from './data-dir.ts'
+import { ExtStore } from './ext/store.ts'
+import type { ExtInfo, ExtStoreService, RouterExt, RouterExtService } from './ext/contract.ts'
 
 /**
  * Plugin identity for cordis.yml rows — 必须与 package.json 的 name 一致。
@@ -129,12 +132,18 @@ export function apply(rawContext: unknown): void {
     logger: { info: (message: string) => void; warn: (message: string) => void }
     effect: (fn: () => () => void, label?: string) => void
     inject: (services: string[], callback: (sctx: unknown) => void) => void
+    /** 配置树锚点 = profile 目录（宿主注入），用来把数据钉在 profile 里。 */
+    baseUrl?: string
   }
   const log = (msg: string): void => ctx.logger.info(`[dsh-router] ${msg}`)
 
-  const stateFile = 'data/state.json'
+  // 数据目录必须是绝对路径：相对路径会让落盘位置跟着 process.cwd() 跑，
+  // 从别的目录启动就静默换一套空配置（见 src/data-dir.ts）。
+  const dataDir = dataDirOf(ctx.baseUrl)
+  const stateFile = join(dataDir, 'state.json')
+  log(`data dir: ${dataDir}`)
   const store = new SupplierConfigStore(stateFile)
-  const credentials = new CredentialStore(join(dirname(stateFile), 'auths'))
+  const credentials = new CredentialStore(join(dataDir, 'auths'))
   const router = new Router(stateFile, store, log)
 
   const keys = new KeysStore(stateFile)
@@ -178,8 +187,18 @@ export function apply(rawContext: unknown): void {
   // 单装 dsh-router-codebuddy 时表永不出现，codebuddy 就一直不生效）。
   ctx.provide('router.suppliers', {})
 
+  // ---- 扩展 (Ext)：router.ext 注册表 + router.extStore 存储 ----
+  // 核心只做**管理面**：发现（注册表）、展示（面板/API）、代存开关与插件数据。
+  // 拦截 tools/execute / 裁决 enabled+ready / 短路执行全部归扩展插件自己 —— 见
+  // ext/contract.ts 文件头。同 router.suppliers 模式：核心持有空表，扩展插件经
+  // ctx.inject 追加进同一个 live 对象。
+  const exts: Record<string, unknown> = {}
+  ctx.provide('router.ext', exts)
+  // 开关 + 插件数据归核心持久化(<dataDir>/ext.json);插件经此 service 读写,不自己 file IO。
+  const extStore = new ExtStore(stateFile)
+  ctx.provide('router.extStore', extStore as unknown as ExtStoreService)
+
   // 内置 + 用户 + 外部插件供应商（异步加载，完成后注册路由 + 加入路由器）
-  const dataDir = dirname(stateFile)
   const registerLoaded = (loaded: LoadedSupplier): void => {
     loadedSuppliers.push(loaded)
     router.add(loaded.supplier)
@@ -222,7 +241,8 @@ export function apply(rawContext: unknown): void {
   })
   void (async () => {
     try {
-      const userDir = join(join(process.env.HOME ?? '', '.dsh', 'profiles', 'web'), 'suppliers')
+      // 用户供应商目录也在 profile 里：跟着 baseUrl 走，别硬编码 `web`。
+      const userDir = join(profileDirOf(ctx.baseUrl), 'suppliers')
       const { suppliers, errors } = await loadSuppliers({
         builtinDir: join(import.meta.dirname, 'suppliers'), // 内置 js（opencode 等）
         userDir,
@@ -297,6 +317,7 @@ export function apply(rawContext: unknown): void {
           id: s.id,
           name: s.name,
           icon: loaded?.supplier.icon,
+          apiKeyHint: loaded?.supplier.apiKeyHint,
           capabilities: loaded ? [...loaded.capabilities] : [],
           source: loaded?.source ?? 'external',
         }
@@ -439,6 +460,56 @@ export function apply(rawContext: unknown): void {
     writeJson(res, 200, { ok: true, requireApiKey: keys.requireApiKey })
   })
 
+  // ---- 扩展 (Ext)：扩展器列表 + 开关 ----
+  route(`${ROUTER_API_BASE}/ext`, async (req, res) => {
+    if (req.method === 'PATCH') {
+      let body: { id?: unknown; enabled?: unknown }
+      try {
+        body = JSON.parse(await readBody(req, 64 << 10)) as { id?: unknown; enabled?: unknown }
+      } catch {
+        writeJson(res, 400, { ok: false, error: 'invalid JSON body' })
+        return
+      }
+      const ext = typeof body.id === 'string' ? exts[body.id] as RouterExtService[string] : undefined
+      if (!ext) {
+        writeJson(res, 404, { ok: false, error: 'extension not found' })
+        return
+      }
+      if (typeof body.enabled !== 'boolean') {
+        writeJson(res, 400, { ok: false, error: 'enabled must be a boolean' })
+        return
+      }
+      const wantOn = body.enabled
+      // 开启自检：不可用(ready !== true)的扩展**不能开启成功**——即使绕过面板
+      // 直连 API 也会被拒。由扩展器报告就绪状态,核心据此裁决。
+      if (wantOn && typeof ext.getState === 'function') {
+        const st = ext.getState()
+        if (st?.ready !== true) {
+          writeJson(res, 409, { ok: false, error: st?.detail ?? 'extension not ready' })
+          return
+        }
+      }
+      // 开关归核心持久化。
+      extStore.setEnabled(ext.id, body.enabled)
+    }
+    const list: ExtInfo[] = Object.values(exts as RouterExtService)
+      .map((raw): ExtInfo | undefined => {
+        const e = raw as RouterExt
+        if (!e || typeof e.id !== 'string' || e.id === '') return undefined
+        const st = typeof e.getState === 'function' ? e.getState() : { ready: false }
+        return {
+          id: e.id,
+          name: e.name ?? e.id,
+          ...(e.description !== undefined ? { description: e.description } : {}),
+          enabled: extStore.isEnabled(e.id),
+          ready: st?.ready === true,
+          ...(st?.detail !== undefined ? { detail: st.detail } : {}),
+        }
+      })
+      .filter((e): e is ExtInfo => e !== undefined)
+    writeJson(res, 200, { ok: true, enhancers: list })
+  })
+
   // ---- 概览看板：用量统计 ----
 
   /** 解析并校验周期参数（不接受任意字符串）。 */
@@ -504,10 +575,26 @@ export function apply(rawContext: unknown): void {
         return combos.map((c) => ({ id: c.name }))
       }))
       // adapter：模型目录自动带出组合；对话转发到本插件 /v1（组合路由在 /v1 内完成）。
+      // 带上组合的上下文窗口：没有它 dsh 的自动压缩算不出阈值、会静默关闭。
       disposers.push(ctx.llm.registerAdapter(['router'], new RouterAdapter('http://localhost:3080/v1', {
-        comboModels: async () => (await router.combos()).map((c) => ({ id: c.name })),
+        comboModels: async () => (await router.combos()).map((c) => {
+          const w = router.comboContextWindow(c)
+          return { id: c.name, ...(w !== undefined ? { contextWindow: w } : {}) }
+        }),
       })))
       log('llm provider (Router) + discovery + adapter registered ok')
+      // 预热模型缓存：`comboContextWindow` 只读缓存、不打上游，缓存空着就
+      // 报不出窗口。这里后台填一次，让第一次 resolveModel 就有值。
+      // 失败无所谓（下次 modelsOf 还会拉），不能冒出来。
+      void (async () => {
+        for (const c of await router.combos()) {
+          for (const ref of c.models) {
+            const at = ref.indexOf(',')
+            if (at < 0) continue
+            try { await router.modelsOf(ref.slice(0, at)) } catch { /* 单家失败不连坐 */ }
+          }
+        }
+      })().catch(() => {})
     } catch (err) {
       ctx.logger.warn(`[dsh-router] llm registration failed: ${(err as Error).message}`)
     }
@@ -539,6 +626,14 @@ export function apply(rawContext: unknown): void {
 
   ctx.effect(
     () => () => {
+      // 注册表里的扩展器（插件自己 inject 的清理会摘键；这里兜底 dispose 仍在表里的）。
+      for (const raw of Object.values(exts as RouterExtService)) {
+        try {
+          ;(raw as RouterExt)?.dispose?.()
+        } catch {
+          // 卸载清理失败不影响其他清理
+        }
+      }
       for (const dispose of disposers.splice(0)) dispose()
       router.dispose() // 内部会 flush 用量统计（防抖中的计数不能丢）
     },

package/src/llm/adapter.test.ts

@@ -526,3 +526,20 @@ test('模型目录：resolveModel 对每个组合声明推理等级（off/low/hi
   const b = await adapter.resolveModel('router', 'c-b')
   assert.equal(b.name, 'c-b')
 })
+
+/**
+ * 上下文窗口透传 —— dsh 的自动压缩靠 `resolveModel().context.contextWindow`
+ * 算阈值（默认用到 80% 触发）。缺失时 dsh-compaction-basic 抛错并静默关闭
+ * 自动压缩，上下文会一路涨到模型硬上限才炸。
+ */
+test('resolveModel 透传组合的 contextWindow（自动压缩才能算阈值）', async () => {
+  const adapter = new RouterAdapter('http://x', { comboModels: async () => [
+    { id: 'c-a', contextWindow: 1_000_000 },
+    { id: 'c-b' }, // 没拿到窗口
+  ] })
+  const a = await adapter.resolveModel('router', 'c-a')
+  assert.deepEqual(a.context, { contextWindow: 1_000_000 }, '有就报')
+
+  const b = await adapter.resolveModel('router', 'c-b')
+  assert.equal(b.context, undefined, '没拿到就不声明 context，绝不填一个假窗口')
+})

package/src/llm/adapter.ts

@@ -23,7 +23,13 @@ import { mergeUsage, normalizeUsage, toTokenUsage, type UsageTokens } from '../r
 
 /** 模型目录来源：组合。 */
 export interface RouterAdapterSource {
-  comboModels: () => Promise<Array<{ id: string; name?: string }>>
+  /**
+   * 组合列表。`contextWindow` 可选，但**必须尽量给**——自动压缩靠它算阈值
+   * （`dsh-compaction-basic` 在 `context` 缺失时直接抛错并静默关闭自动压缩，
+   * 于是上下文会一路涨到模型硬上限才炸）。
+   * 组合背后是异构供应商时给**最小的那个**（保守，宁可早压缩）。
+   */
+  comboModels: () => Promise<Array<{ id: string; name?: string; contextWindow?: number }>>
 }
 
 /**
@@ -401,6 +407,7 @@ export class RouterAdapter extends LlmAdapter {
       provider: 'router',
       id: model,
       name,
+      ...(found?.contextWindow !== undefined ? { context: { contextWindow: found.contextWindow } } : {}),
       reasoning: { efforts: ROUTER_REASONING_EFFORTS, defaultEffort: ReasoningEffortId('high') },
     }
   }