dsh-context-domains 0.3.6 → 0.4.0

package/lib/compaction.js

@@ -0,0 +1,262 @@
+// 上下文压缩阈值（compaction-basic 的压力线）的运行期接管。
+//
+// 为什么不是「改配置」：compaction-basic 的 config 在装载时被 deepFreeze，而且它挂在
+// preset（@deepseek-ai/dsh-agent-preset）的 isolate 组里 —— profile 的 cordis.patch.yml
+// 只能按 id 命中顶层/group 节点，够不到 preset 内部子节点（详见 ~/.dsh/compaction-threshold.py
+// 的说明）。所以静态改阈值只有两条路：改 preset 文件（要重启）或该脚本（要重启）。
+//
+// 真正决定「压不压」的是 resolveCompactSpec() 算出的 thresholdTokens：
+//   thresholdTokens = floor(min(window * thresholdRatio, window - reservedOutput - headroomTokens))
+// 判定是 `measurement.totalTokens >= thresholdTokens` 就压。于是只要给每个
+// (provider, model) 造一条精确的 modelPolicies 覆盖：
+//   thresholdRatio = 1、headroomTokens = (window - reservedOutput) - budget
+// 解出来就是 min(window, budget) —— 阈值被钉死在用户给的预算上。modelPolicies 在每次
+// compactPressure 里现查（resolveTargetPolicy），所以运行期重写 engine.config 立刻生效：
+// 不重启 dsh、不动 preset 文件、不依赖模型。
+//
+// 预算存在自身 state.json（用户数据，不是部署配置），counter 在会话顶栏最右边。
+const MIN_TOKENS = 200_000
+const MAX_TOKENS = 10_000_000
+const STEP_TOKENS = 100_000
+const DEFAULT_TOKENS = 500_000
+/** 压缩后保留的原文尾巴占阈值的比例（太小等于每轮全summarize，太大压不动）。 */
+const RETAIN_SHARE = 0.25
+/** 引擎扫描周期：preset 是懒挂载的，新会话选到新 preset 时才会出现新引擎。 */
+const SCAN_INTERVAL_MS = 4000
+/** cordis fiber 的「已激活」状态值（与 cordis 内部 _getImpl(strict) 同一判据）。 */
+const FIBER_ACTIVE = 2
+
+export { MIN_TOKENS, MAX_TOKENS, STEP_TOKENS, DEFAULT_TOKENS }
+
+/** 收进 [20 万, 1000 万]，并按千位取整（UI 只以 10 万为步进）。 */
+export function clampBudgetTokens(value) {
+  if (!Number.isFinite(value)) return DEFAULT_TOKENS
+  const rounded = Math.round(value / 1000) * 1000
+  return Math.min(MAX_TOKENS, Math.max(MIN_TOKENS, rounded))
+}
+
+/** 文档里的预算；没写过就是默认值（不静默关掉接管）。 */
+export function budgetOf(doc) {
+  const raw = doc?.compaction?.budgetTokens
+  return Number.isFinite(raw) ? clampBudgetTokens(raw) : DEFAULT_TOKENS
+}
+
+function keyOf(provider, model) {
+  return `${provider}\u0000${model}`
+}
+
+export function createCompactionBudget({ ctx, store, logger }) {
+  const log = (level, message) => {
+    const fn = logger?.[level]
+    if (typeof fn === 'function') fn.call(logger, `[context-domains] ${message}`)
+  }
+
+  /** engine -> 接管前的原生 config（deepFrozen，只读参照）。 */
+  const patched = new Map()
+  /** "provider\0model" -> {window, reserved} | {error} */
+  const targets = new Map()
+  /** engine -> 上次写进去的签名（预算 + policy 表没变就不重写，避免每 4s 换一次 config 对象） */
+  const signatures = new WeakMap()
+  let timer
+
+  const llm = () => {
+    try {
+      return ctx.get('llm')
+    } catch {
+      return undefined
+    }
+  }
+
+  /** 服务表里所有活着的 compaction 引擎（跨 isolate realm，所以按符号扫 store）。 */
+  function liveEngines() {
+    const bag = ctx.reflect?.store
+    const live = new Set()
+    if (bag === undefined || bag === null) return live
+    for (const key of Object.getOwnPropertySymbols(bag)) {
+      const impl = bag[key]
+      if (impl === undefined || impl.name !== 'compaction') continue
+      if (impl.ctx?.fiber?.state !== FIBER_ACTIVE) continue
+      const value = impl.value
+      if (value === undefined || typeof value.compactPressure !== 'function') continue
+      live.add(value)
+    }
+    return live
+  }
+
+  /** 把预算翻译成该模型的一条精确 policy。 */
+  function policyFor(key, entry, budget) {
+    if (entry.error !== undefined) return undefined
+    const capacity = entry.window - entry.reserved
+    if (!(capacity > 0)) return undefined
+    const [provider, model] = key.split('\u0000')
+    const threshold = Math.min(budget, capacity)
+    const retain = Math.max(1, Math.floor(threshold * RETAIN_SHARE))
+    return {
+      provider,
+      model,
+      thresholdRatio: 1,
+      headroomTokens: Math.max(0, capacity - budget),
+      retainTokens: Math.min(retain, Math.max(1, threshold - 1)),
+    }
+  }
+
+  function apply(engine) {
+    const base = patched.get(engine)
+    if (base === undefined) return
+    const budget = budgetOf(store.document())
+    const policies = []
+    for (const [key, entry] of targets) {
+      const policy = policyFor(key, entry, budget)
+      if (policy !== undefined) policies.push(policy)
+    }
+    const signature = `${budget}|${JSON.stringify(policies)}`
+    if (signatures.get(engine) === signature) return
+    signatures.set(engine, signature)
+    const ours = new Set(policies.map((policy) => keyOf(policy.provider, policy.model)))
+    const inherited = Array.isArray(base.modelPolicies)
+      ? base.modelPolicies.filter((policy) => !ours.has(keyOf(policy.provider, policy.model)))
+      : []
+    engine.config = { ...base, modelPolicies: [...inherited, ...policies] }
+  }
+
+  function applyAll() {
+    for (const engine of patched.keys()) apply(engine)
+  }
+
+  /** 学一条 (provider, model) 的窗口；学不到就记下原因，降级回该模型的原生阈值。 */
+  async function learn(target) {
+    if (target === null || typeof target !== 'object') return
+    const provider = target.provider
+    const model = target.model
+    if (typeof provider !== 'string' || provider === '' || typeof model !== 'string' || model === '') return
+    const key = keyOf(provider, model)
+    const known = targets.get(key)
+    // 失败过的目标给 30s 冷却后重试（适配器可能只是暂时没就绪）
+    if (known !== undefined) {
+      if (known.error === undefined) return
+      if (Date.now() - (known.at ?? 0) < 30_000) return
+      targets.delete(key)
+    }
+    const service = llm()
+    if (service === undefined) {
+      targets.set(key, { error: 'llm 服务不可见，无法解析模型窗口', at: Date.now() })
+      return
+    }
+    try {
+      const info = await service.resolveModelInfo(provider, model)
+      const window = info?.context?.contextWindow
+      if (!Number.isInteger(window) || window <= 0) {
+        targets.set(key, { error: '模型没有声明 contextWindow', at: Date.now() })
+        return
+      }
+      targets.set(key, { window, reserved: Number.isFinite(info.defaultMaxTokens) ? info.defaultMaxTokens : 0 })
+      applyAll()
+    } catch (error) {
+      targets.set(key, { error: error?.message ?? String(error), at: Date.now() })
+    }
+  }
+
+  /**
+   * 装上包装，一次就够。
+   *
+   * 包 compactPressure 而不是换个引擎实现：它同时被自动压缩（isBeforeStep）、模型切换
+   * 和 compactIfNeeded 三处调用，包一层就全覆盖；而且这里是唯一能拿到 header.config
+   * 的地方 —— 模型路由只有走到这一步才知道，窗口也因此才能按需解析。
+   */
+  function patch(engine) {
+    if (patched.has(engine)) return false
+    const original = engine.compactPressure
+    if (typeof original !== 'function') return false
+    patched.set(engine, engine.config)
+    engine.compactPressure = async function compactPressureWithBudget(agent, header, signal, requireBelowThreshold) {
+      try {
+        await learn(header?.config)
+      } catch (error) {
+        log('warn', `compaction budget: model info lookup failed: ${error?.message ?? error}`)
+      }
+      return original.call(engine, agent, header, signal, requireBelowThreshold)
+    }
+    return true
+  }
+
+  /** 扫一遍：摘掉死引擎、装上新引擎、按当前预算重写所有引擎的 policy 表。 */
+  function refresh() {
+    const live = liveEngines()
+    for (const engine of [...patched.keys()]) if (!live.has(engine)) patched.delete(engine)
+    let added = 0
+    for (const engine of live) if (patch(engine)) added += 1
+    applyAll()
+    if (added > 0) log('info', `compaction budget: installed on ${patched.size} engine(s)`)
+    return status()
+  }
+
+  function status() {
+    const budget = budgetOf(store.document())
+    const rows = []
+    const degraded = []
+    for (const [key, entry] of targets) {
+      const [provider, model] = key.split('\u0000')
+      if (entry.error !== undefined) {
+        degraded.push({ provider, model, reason: entry.error })
+        continue
+      }
+      const capacity = entry.window - entry.reserved
+      rows.push({
+        provider,
+        model,
+        contextWindow: entry.window,
+        reservedTokens: entry.reserved,
+        thresholdTokens: Math.min(budget, Math.max(0, capacity)),
+        clamped: budget > capacity,
+      })
+    }
+    if (patched.size === 0) degraded.push({ reason: '没有在线的 compaction 引擎（preset 还没挂载）' })
+    if (llm() === undefined) degraded.push({ reason: 'llm 服务不可见，预算未接管' })
+    return {
+      budgetTokens: budget,
+      tokens: Math.round(budget / STEP_TOKENS),
+      stepTokens: STEP_TOKENS,
+      minTokens: MIN_TOKENS,
+      maxTokens: MAX_TOKENS,
+      engines: patched.size,
+      targets: rows,
+      degraded,
+    }
+  }
+
+  return {
+    status,
+    refresh,
+    /** 会话起来就重扫一次：新 preset 的引擎是随会话挂载的。 */
+    kick() {
+      try {
+        refresh()
+      } catch (error) {
+        log('warn', `compaction budget refresh failed: ${error?.message ?? error}`)
+      }
+    },
+    start() {
+      refresh()
+      timer = setInterval(() => {
+        try {
+          refresh()
+        } catch (error) {
+          log('warn', `compaction budget scan failed: ${error?.message ?? error}`)
+        }
+      }, SCAN_INTERVAL_MS)
+      if (typeof timer?.unref === 'function') timer.unref()
+      return () => {
+        if (timer !== undefined) clearInterval(timer)
+        // 还回原生 config：插件被卸载/热更时不留一个「预算已接管」的假象
+        for (const [engine, base] of patched) {
+          try {
+            engine.config = base
+          } catch {
+            /* 引擎可能已经跟着 preset 一起没了 */
+          }
+        }
+        patched.clear()
+      }
+    },
+  }
+}

package/lib/http.js

@@ -1,6 +1,7 @@
 // HTTP API：Client 半边没有 typert 代码生成，所以走同源 fetch + 前缀路由
 // （dsh-file-activity / horon-web 同款）。全部端点前置信任栅栏。
 import { randomUUID } from 'node:crypto'
+import { clampBudgetTokens, MAX_TOKENS, MIN_TOKENS, STEP_TOKENS } from './compaction.js'
 import { domainCounts, requestedMembers, selectionFor, unassigned } from './resolve.js'
 import { estimateTokens } from './config.js'
 import { VERSION } from './version.js'
@@ -54,7 +55,7 @@ function normalizeMembers(raw) {
 }
 
 export function registerHttp(ctx, deps) {
-  const { store, config, applier, logger } = deps
+  const { store, config, applier, budget, logger } = deps
   const log = (level, message) => {
     const fn = logger?.[level]
     if (typeof fn === 'function') fn.call(logger, `[context-domains] ${message}`)
@@ -136,6 +137,8 @@ export function registerHttp(ctx, deps) {
         skills: live.skills.items.filter((item) => !managedSkillSet.has(item.name)).length,
         tools: live.tools.items.filter((item) => !managedToolSet.has(item.name)).length,
       },
+      // 压缩阈值：counter 在顶栏最右边，值来自这里（全局，不是会话级）
+      compaction: budget?.status?.() ?? null,
       discoverComplete: live.skills.complete === true,
       degraded: status.degraded ?? [],
     }
@@ -187,6 +190,7 @@ export function registerHttp(ctx, deps) {
         domains: store.document().domains.length,
         sessions: Object.keys(store.document().sessions).length,
         agents: applier.entries.size,
+        compaction: budget?.status?.() ?? null,
       })
     },
 
@@ -252,6 +256,29 @@ export function registerHttp(ctx, deps) {
       ok(res, out)
     },
 
+    /**
+     * 压缩阈值：客户端顶栏 counter 写这里。
+     * tokens 是「单位 10 万」的整数（最低 2 = 20 万），budgetTokens 是绝对值；两者都可。
+     */
+    async 'POST /compaction'(_req, res, _url, body) {
+      const fromTokens = Number.isFinite(body.tokens) ? body.tokens * STEP_TOKENS : undefined
+      const requested = Number.isFinite(body.budgetTokens) ? body.budgetTokens : fromTokens
+      if (requested === undefined) return fail(res, 400, 'bad-request', 'tokens or budgetTokens is required')
+      const budgetTokens = clampBudgetTokens(requested)
+      await store.mutate((doc) => {
+        doc.compaction = { budgetTokens, at: Date.now() }
+      }, 'compaction')
+      budget?.refresh?.()
+      ok(res, {
+        budgetTokens,
+        tokens: Math.round(budgetTokens / STEP_TOKENS),
+        stepTokens: STEP_TOKENS,
+        minTokens: MIN_TOKENS,
+        maxTokens: MAX_TOKENS,
+        status: budget?.status?.() ?? null,
+      })
+    },
+
     async 'GET /domains'(_req, res) {
       const doc = store.document()
       const merged = await readCatalogAll(ctx)
@@ -318,7 +345,8 @@ export function registerHttp(ctx, deps) {
             icon: typeof body.icon === 'string' ? body.icon : undefined,
             description: typeof body.description === 'string' ? body.description : undefined,
             members,
-            defaultOn: body.defaultOn === true,
+            // 新建默认启用：建域的意图就是「要用它」，默认值别再让人多勾一次
+            defaultOn: typeof body.defaultOn === 'boolean' ? body.defaultOn : true,
             order: doc.domains.length,
           }
           doc.domains.push(domain)

package/lib/runtime.js

@@ -1,7 +1,8 @@
-// 组装：store ↔ 目录 ↔ 施加层 ↔ HTTP。这里是唯一知道所有部件的地方。
+// 组装：store ↔ 目录 ↔ 施加层 ↔ 压缩预算 ↔ HTTP。这里是唯一知道所有部件的地方。
 import { normalizeConfig } from './config.js'
 import { createStore } from './store.js'
 import { createApplier } from './apply.js'
+import { createCompactionBudget } from './compaction.js'
 import { registerHttp } from './http.js'
 import { stateFile, dataDir } from './paths.js'
 
@@ -10,18 +11,24 @@ export async function createRuntime(ctx, rawConfig) {
   const store = createStore({ file: stateFile(), logger: ctx.logger })
   await store.load()
 
+  const budget = createCompactionBudget({ ctx, store, logger: ctx.logger })
   const applier = createApplier({ ctx, config, store, logger: ctx.logger })
-  const http = registerHttp(ctx, { store, config, applier, logger: ctx.logger })
+  const http = registerHttp(ctx, { store, config, applier, budget, logger: ctx.logger })
+
+  // 压缩阈值接管：引擎随 preset 懒挂载，所以启动 + 每 4s 扫一次（见 lib/compaction.js）
+  ctx.effect(() => budget.start(), 'context-domains: compaction budget')
 
   // 会话生命周期：agent 出现就装，消失就撤（插件自己的 effect 也持有它，双保险）
   ctx.on('agent/created', async ({ agent }) => {
+    budget.kick()
     await applier.attach(agent)
     ctx.effect(() => () => applier.detach(agent.id))
   })
   ctx.on('agent/disposed', ({ agent }) => applier.detach(agent.id))
 
-  // 领域/选择变更 → 所有在线会话重算
-  store.onChange(() => {
+  // 领域/选择变更 → 所有在线会话重算（压缩预算写入不需要重装工具/skill，跳过）
+  store.onChange((_doc, reason) => {
+    if (reason === 'compaction') return
     void applier.reapplyAll()
   })
 
@@ -34,5 +41,5 @@ export async function createRuntime(ctx, rawConfig) {
 
   ctx.logger?.info?.(`[context-domains] ready · state=${stateFile()} · dir=${dataDir()}`)
 
-  return { store, applier, http, config }
+  return { store, applier, http, budget, config }
 }

package/lib/store.js

@@ -10,7 +10,8 @@ const VERSION = 1
 const SESSION_TTL_MS = 30 * 24 * 3600 * 1000 // 会话覆盖保留 30 天
 
 export function emptyDocument() {
-  return { version: VERSION, domains: [], sessions: {}, updatedAt: 0 }
+  // compaction：压缩阈值预算（用户数据，与领域同库；没写过就是 {}，读侧回落默认值）
+  return { version: VERSION, domains: [], sessions: {}, compaction: {}, updatedAt: 0 }
 }
 
 function asStringArray(value) {
@@ -87,6 +88,14 @@ export function normalizeDocument(raw) {
     const normalized = normalizeSession(value)
     if (normalized !== undefined) doc.sessions[sessionId] = normalized
   }
+  // v0.4 起：压缩阈值预算。缺失/非法一律回落 {}（读侧给默认值），不阻止插件启动
+  const compaction = raw.compaction !== null && typeof raw.compaction === 'object' ? raw.compaction : {}
+  if (Number.isFinite(compaction.budgetTokens)) {
+    doc.compaction = {
+      budgetTokens: Math.round(compaction.budgetTokens),
+      at: Number.isFinite(compaction.at) ? compaction.at : 0,
+    }
+  }
   doc.updatedAt = Number.isFinite(raw.updatedAt) ? raw.updatedAt : 0
   return doc
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context-domains",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "DSH 上下文领域：把一个领域里的 skill 与 tool 归成一块，在会话顶部一键整块开关，设置页里维护领域成员",
   "type": "module",
   "main": "index.js",