dsh-plugin-prompt-tool 3.0.1 → 3.1.0

package/engine/context-pruner.mjs

@@ -0,0 +1,64 @@
+import { makeSessionReference } from './retrieval-reference.mjs'
+
+const PRUNE_MARKER = '\n\n[... tool result middle pruned ...]\n\n'
+
+/** 官方裁剪算法不变，只在本次生成marker的Unicode位置附来源。 */
+function referencedContent(content, headChars, reference) {
+  const result = [...content]
+  let consumed = 0
+  for (let index = 0; index < result.length; index++) {
+    const block = result[index]
+    if (block.type !== 'text') continue
+    const points = [...block.text]
+    if (consumed + points.length <= headChars) { consumed += points.length; continue }
+    const offset = headChars - consumed
+    if (points.slice(offset, offset + [...PRUNE_MARKER].length).join('') !== PRUNE_MARKER) return null
+    result[index] = { ...block, text: points.slice(0, offset).join('') + PRUNE_MARKER + `[source: ${JSON.stringify(reference)}]\n` + points.slice(offset + [...PRUNE_MARKER].length).join('') }
+    return result
+  }
+  return null
+}
+
+export function createProvenancePruner(PrunerClass, { sourceModuleId, isActive = () => true, signalOf = () => undefined, makeReference = makeSessionReference } = {}) {
+  return class ProvenancePruner extends PrunerClass {
+    pruneSession(session, signal = signalOf()) {
+      const check = () => {
+        signal?.throwIfAborted()
+        if (!isActive()) throw new Error('context-provenance: pruner released')
+      }
+      check()
+      const events = session.snapshotEvents()
+      const bySeq = new Map(events.map(event => [event.seq, event]))
+      const candidates = [...new Set(session.surface.nodes)].map(seq => bySeq.get(seq)).filter(event => event?.type === 'tool/result')
+      const pruned = []
+      let charsRemoved = 0
+      for (const event of candidates) {
+        check()
+        const seq = event.seq, original = session.deriveEventMessage(event)
+        let content = super.pruneContent(original.content)
+        if (content === null) continue
+        const charsBefore = this.measureContent(original.content)
+        try {
+          const reference = makeReference(sourceModuleId, session.id, events, [seq])
+          const cited = referencedContent(content, this.config.headChars, reference)
+          if (!cited || this.measureContent(cited) > this.config.thresholdChars || this.measureContent(cited) >= charsBefore) throw new Error('reference exceeds pruning budget')
+          content = cited
+        } catch (error) {
+          this.ctx.logger?.warn?.(`context-provenance: pruned without reference (${String(error?.message ?? error)})`)
+        }
+        const charsAfter = this.measureContent(content)
+        if (charsAfter > this.config.thresholdChars || charsAfter >= charsBefore) throw new Error('context-provenance: invalid prune result')
+        const shadowedTokenCount = this.ctx.tokenMeter.estimateMessage(original)
+        check()
+        session.append('compaction/prune', { shadowedRange: { start: seq, end: seq }, shadowedSeqs: [seq], shadowedTokenCount })
+        check()
+        const replacement = session.append('tool/result', { ...event.data, message: { ...original, content } }, {
+          surfaceOp: { op: 'replace', startSeq: seq, endSeq: seq }, sourceEventSeqs: [seq],
+        })
+        pruned.push({ originalSeq: seq, replacementSeq: replacement.seq, callId: original.source.callId, charsBefore, charsAfter })
+        charsRemoved += charsBefore - charsAfter
+      }
+      return { pruned, charsRemoved }
+    }
+  }
+}

package/engine/context-routing.mjs

@@ -0,0 +1,45 @@
+import { Context } from '@deepseek-ai/cordis'
+
+/** 只路由声明Agent，原provider的方法和其它监听器保持原所有权。 */
+export function routeContextRuntime(ctx, agent, runtime) {
+  let active = true
+  const disposers = []
+  for (const service of ['compaction', 'toolResultPruner']) {
+    if (!runtime[service]) continue
+    const dependency = ctx.inject([service], dependent => {
+      // 已发布Fiber.store公开了这次依赖快照的精确provider身份。
+      const owner = dependent.fiber.store[service].fiber
+      const carriers = new WeakMap()
+      const offDispatch = service === 'compaction' ? dependent.on('internal/dispatch', (_mode, event, args, carrier) => {
+        if (!active || !['agent/pre-step', 'agent/request-error', 'agent/request'].includes(event)
+          || args[0]?.agent !== agent || !carrier) return
+        if (carriers.has(carrier)) return
+        const original = carrier[Context.filter]
+        const filter = function (candidate) {
+          return (!original || original.call(this, candidate)) && (!active || candidate.fiber !== owner)
+        }
+        carriers.set(carrier, original)
+        carrier[Context.filter] = filter
+      }) : () => {}
+      const offGet = dependent.on('internal/get', (_consumer, key, _error, next) => {
+        const original = next()
+        if (!active || key !== service || !original) return original
+        return new Proxy(original, {
+          get(target, property) {
+            const method = target[property]
+            if (typeof method !== 'function') return method
+            return (...args) => {
+              const subject = service === 'toolResultPruner' ? args[0] : property === 'compactRegion' ? args[2] : args[0]
+              const selected = service === 'toolResultPruner' ? subject === agent.session : subject === agent
+              if (active && selected && typeof runtime[service][property] === 'function') return runtime[service][property](...args)
+              return method.apply(target, args)
+            }
+          },
+        })
+      }, { prepend: true })
+      return () => { offDispatch(); offGet() }
+    })
+    disposers.push(() => dependency.dispose())
+  }
+  return () => { active = false; for (const dispose of disposers) void dispose() }
+}

package/engine/context-summary.mjs

@@ -0,0 +1,80 @@
+import { makeSessionReference } from './retrieval-reference.mjs'
+
+// shortcut: Basic alpha.2 未公开导出frameSummary，升级官方framing时同步此版本化快照。
+const CHECKPOINT_OPEN = 'This is an automatically generated checkpoint condensing an earlier span of the conversation to free up context. Treat the captured context as established background and build on it without restating it. Continue the task directly from the messages that follow, without acknowledging this checkpoint.\n\n<compacted-summary>'
+export function frameSummary(summary) {
+  return [{ type: 'text', text: CHECKPOINT_OPEN }, ...summary, { type: 'text', text: '</compacted-summary>' }]
+}
+const framed = summary => ({
+  id: 'context-provenance-budget', role: 'user', source: { kind: 'compact-checkpoint', compactionId: 'context-provenance-budget' },
+  content: frameSummary(summary),
+})
+
+function sourceSnapshot(input, session, meter) {
+  const events = session.snapshotEvents(), bySeq = new Map(events.map(event => [event.seq, event]))
+  const nodes = session.surface.nodes.map(seq => {
+    const event = bySeq.get(seq)
+    if (!event) throw new Error('source event missing')
+    return { seq, message: session.deriveEventMessage(event) }
+  })
+  let messages = input.messages
+  const head = nodes[0]?.message
+  // Basic 把system头作为缓存前缀再加一次；真正选中system时后面仍保留它。
+  if (head?.role === 'system' && messages[0]?.id === head.id) messages = messages.slice(1)
+  if (!messages.length || messages.some(message => typeof message.id !== 'string' || !message.id)) throw new Error('source message identity unavailable')
+  const matches = []
+  for (let start = 0; start < nodes.length; start++) {
+    if (nodes[start].message?.id !== messages[0].id) continue
+    let position = 0
+    for (let end = start; end < nodes.length; end++) {
+      const message = nodes[end].message
+      if (message !== null) {
+        if (message?.id !== messages[position]?.id) break
+        position++
+      }
+      if (position !== messages.length) continue
+      // 空投影可能属于区间也可能不属于；没有真实事务端点时不猜。
+      if (nodes[start - 1]?.message === null || nodes[end + 1]?.message === null) throw new Error('source span ambiguous')
+      matches.push(nodes.slice(start, end + 1).map(node => node.seq))
+      break
+    }
+  }
+  if (matches.length !== 1) throw new Error('source span unavailable or ambiguous')
+  const seqs = matches[0], measured = meter.measure(session).nodes
+  if (measured.length !== nodes.length || measured.some((node, index) => node.seq !== nodes[index].seq)) throw new Error('source token surface changed')
+  const selected = new Set(seqs)
+  const tokens = measured.filter(node => selected.has(node.seq)).reduce((total, node) => total + node.tokens, 0)
+  if (!Number.isFinite(tokens) || tokens <= 0) throw new Error('source token budget unavailable')
+  return { events, seqs, tokens }
+}
+
+export function createProvenanceCompaction(BasicClass, { sourceModuleId, isActive = () => true, signalOf = () => undefined, makeReference = makeSessionReference } = {}) {
+  return class ProvenanceCompaction extends BasicClass {
+    async summarize(input, agent, signal = signalOf(agent)) {
+      const check = () => {
+        signal?.throwIfAborted()
+        if (!isActive(agent)) throw new DOMException('context-provenance: compaction released', 'AbortError')
+      }
+      const warn = message => { try { this.ctx.logger?.warn?.('context-provenance: summary without reference (' + message + ')') } catch { /* 诊断不能使原本可用的压缩失败。 */ } }
+      check()
+      let snapshot
+      try { snapshot = sourceSnapshot(input, agent.session, this.ctx.tokenMeter) } catch (error) { warn(String(error?.message ?? error)) }
+      const result = await super.summarize(input, agent, signal)
+      check()
+      if (!snapshot) return result
+      try {
+        const reference = makeReference(sourceModuleId, agent.session.id, snapshot.events, snapshot.seqs)
+        const summary = [{ type: 'text', text: `[source: ${JSON.stringify(reference)}]\n` }, ...result.summary]
+        const tokens = this.ctx.tokenMeter.estimateMessage(framed(summary))
+        if (!Number.isFinite(tokens) || tokens >= snapshot.tokens) {
+          warn('reference exceeds shrink budget')
+          return result
+        }
+        return { ...result, summary }
+      } catch (error) {
+        warn(String(error?.message ?? error))
+        return result
+      }
+    }
+  }
+}

package/engine/fillers.mjs

@@ -1,13 +1,14 @@
 /**
  * fillers — 引擎内置的动态填充器(strategy=placeholder 的数据源)。
- * 全部遵循同一铁律:服务缺失或列表失败时返回 null(跳过该配置),绝不伤及会话。
+ * 按本次求值读取宿主能力；失败由填充器或调用方诊断并跳过该配置。
  */
 
 import { getService, parseToolNames } from './shared.mjs'
+import { toolScopeSnapshot } from './tool-scope.mjs'
 import { machinePaths } from './machine-paths.mjs'
 import { SAFE_ENV_KEYS } from './env-safety.mjs'
 import { createInstructionHintResolver } from './instruction-hint.mjs'
-import { DISCOVERY_SERVICE } from './service-names.mjs'
+import { DISCOVERY_SERVICE, SOUL_SELF_SERVICE } from './service-names.mjs'
 
 const name = 'prompt-config-engine'
 
@@ -16,7 +17,22 @@ function explicitTemplate(config) {
   return texts.length > 0 ? texts.join('\n\n') : typeof config.params?.text === 'string' ? config.params.text : ''
 }
 
-/** 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。 */
+/**
+ * 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。
+ * RESIDENT_TOOLS 只列**当前可见**的常驻工具：部署层名单可以登记替换提供方（如 dsh-ops 的
+ * ops_bash），但该插件未必安装；向模型宣告一个不存在的常驻工具会把「解锁」变成错误前提。
+ * 观测到工具面但一个常驻名都不在时（requireMatch 全缺/放宽场景）跳过提示；
+ * 观测不到工具面（服务缺失或读取失败）才回落声明名单——「没看到」不等于「都没有」。
+ */
+function visibleToolNames(ctx, agent) {
+  try {
+    const tools = getService(ctx, 'tools')
+    if (tools === undefined || typeof tools.schemas !== 'function') return undefined
+    return new Set(toolScopeSnapshot(tools, agent).visible.map((schema) => schema?.name))
+  } catch {
+    return undefined
+  }
+}
 function createToolCatalogResolver(config) {
   if (config.params?.templateEvaluation === true) throw new TypeError('tool-catalog is read-only and does not support templateEvaluation')
   if (typeof config.params?.action !== 'string' || config.params.action.trim().length === 0) {
@@ -28,12 +44,20 @@ function createToolCatalogResolver(config) {
     const source = config.toolCatalogSource
     if (source === undefined) throw new TypeError('tool-catalog requires a same-rule tool-visibility action')
     const deny = new Set(source.deny ?? [])
-    const resident = [...new Set(source.allow)].filter(tool => !deny.has(tool))
+    const declared = [...new Set(source.allow)].filter(tool => !deny.has(tool))
     const adapter = source.discovery === undefined ? undefined
       : getService(ctx, DISCOVERY_SERVICE)?.get?.(agent, source.discovery.kind)
     if (source.discovery !== undefined && typeof adapter?.tool !== 'string') {
       throw new Error(`tool-catalog discovery adapter ${source.discovery.kind} is unavailable`)
     }
+    let resident = declared
+    const visible = visibleToolNames(ctx, agent)
+    if (visible !== undefined) {
+      const present = declared.filter((name) => visible.has(name))
+      // 观测到全缺时不宣告任何常驻工具：与 requireMatch 放宽同源，避免「解锁」建在错误前提上。
+      if (present.length === 0) return null
+      resident = present
+    }
     return { text, variables: { RESIDENT_TOOLS: resident.join(', '), DISCOVERY_TOOL: adapter?.tool ?? '' } }
   }
 }
@@ -163,12 +187,21 @@ function createSkillCatalogResolver(config) {
   }
 }
 
+function createSoulSelfResolver(config) {
+  return ({ ctx, agent, signal }) => {
+    const service = getService(ctx, SOUL_SELF_SERVICE)
+    if (typeof service?.render !== 'function') throw new Error('SELF dependency missing')
+    return { text: service.render(config.sourceModuleId, agent, signal) }
+  }
+}
+
 /** 动态填充器:strategy=placeholder 时按 fill 键在注入点填充内容。 */
 export const FILLERS = {
   'instruction-hint': (config) => createInstructionHintResolver(config),
   'env-facts': (config) => createEnvFactsResolver(config),
   'skill-catalog': (config) => createSkillCatalogResolver(config),
   'tool-catalog': (config) => createToolCatalogResolver(config),
+  'soul-self': (config) => createSoulSelfResolver(config),
 }
 
 export function createPlaceholderResolver(config) {

package/engine/generation-recovery-coordinator.mjs

@@ -0,0 +1,40 @@
+import { historyEvents } from './history.mjs'
+
+const visible = content => Array.isArray(content) && content.some(block => block.type !== 'reasoning' && (block.type !== 'text' || block.text?.trim()))
+
+/** 候选只在 durable turn/end 后发布；流与结算共用官方 turn/step。 */
+export function recoveryCoordinator(ctx, agent, config, options, isActive) {
+  let frame
+  let emitted
+  const offRequest = ctx.on('agent/request', (payload, next) => {
+    if (payload.agent !== agent) return next()
+    frame = { turn: payload.turn, step: payload.step, signal: payload.signal, visible: false }
+    return next()
+  })
+  const offEvent = ctx.on('session/event', (session, event) => {
+    if (!isActive() || session.id !== agent.session.id || !frame) return
+    const data = event.data ?? {}
+    if (event.type === 'assistant/message' && data.turn === frame.turn) {
+      if (data.step !== frame.step) return
+      frame.visible = visible(data.message?.content)
+      if (data.interrupted) frame.interrupted = true
+    }
+    if (event.type !== 'turn/end' || data.turn !== frame.turn || frame.signal?.aborted || frame.interrupted) return
+    if (data.reason?.kind !== 'completed' && data.reason?.kind !== 'no-visible-output') return
+    const execution = `${frame.turn}:${frame.step}`
+    if (execution === emitted || (!frame.reason && (!config.recoverEmpty || frame.visible))) return
+    emitted = execution
+    const candidate = { sessionId: session.id, execution, turn: frame.turn, step: frame.step, reason: frame.reason ?? 'empty-final-step', signal: frame.signal }
+    options.onRecoveryCandidate?.(candidate)
+    options.recover?.(candidate)
+  })
+  return {
+    mark(reason) { if (frame && !frame.signal?.aborted) frame.reason = reason },
+    dispose() { offRequest(); offEvent() },
+    // 迟到idle回调不能跨过新的用户执行边界。
+    unchanged(candidate) {
+      const latest = historyEvents(agent.session).findLast(event => event.type === 'turn/start')
+      return !latest || latest.data?.turn === candidate.turn
+    },
+  }
+}

package/engine/generation-recovery-maintenance.mjs

@@ -0,0 +1,18 @@
+/** 维护窗口与范围选择归上下文runtime，这里只决定是否允许扩大范围。 */
+export async function recoveryMaintenance(runtime, signal, allowFullFallback, valid, report) {
+  if (!runtime) { report('context runtime unavailable; recovery stopped'); return null }
+  let result
+  try {
+    result = await runtime.compactRecovery(signal)
+  } catch (error) {
+    if (!valid() || error?.name === 'AbortError' || error?.code === 'ABORTED') return null
+    if (!allowFullFallback) { report(`regional maintenance failed; recovery stopped (${String(error?.message ?? error)})`); return null }
+    result = await runtime.compactNow(signal)
+  }
+  if (!valid()) return null
+  if (result === null || !Array.isArray(result?.shadowedSeqs) || result.shadowedSeqs.length === 0) {
+    report('maintenance no-op; recovery stopped')
+    return null
+  }
+  return result
+}

package/engine/generation-recovery.mjs

@@ -0,0 +1,153 @@
+import { bool, defineConfig, enumOf, int, passthrough } from './fields.mjs'
+import { capabilityAudience } from './agent-capability.mjs'
+import { recoveryCoordinator } from './generation-recovery-coordinator.mjs'
+import { pluginMessage } from './layers.mjs'
+import { recoveryMaintenance } from './generation-recovery-maintenance.mjs'
+
+export const name = 'generation-recovery'
+export const inject = ['llm']
+
+const recoveryLimit = passthrough((value, plugin, field) => {
+  if (value === undefined) return 0
+  if (!Number.isSafeInteger(value) || value < 0 || value > 1000) throw new TypeError(`${plugin}: ${field} must be an integer from 0 to 1000`)
+  return value
+})
+
+export const configContract = defineConfig({
+  enabled: bool({ default: false }),
+  audience: enumOf(['all', 'main', 'subagent'], { default: 'all' }),
+  textRepeatChars: int({ min: 3, default: 4096 }),
+  reasoningRepeatChars: int({ min: 3, default: 8192 }),
+  silentReasoningChars: int({ min: 0, default: 0 }),
+  recoverEmpty: bool({ default: false }),
+  mainRecoveryLimit: recoveryLimit,
+  subagentRecoveryLimit: recoveryLimit,
+  maintenanceCompression: bool({ default: false }),
+  allowFullFallback: bool({ default: false }),
+  maxCycleChars: passthrough((value, plugin, field) => {
+    if (value === undefined) return 256
+    if (!Number.isSafeInteger(value) || value < 1 || value > 1024) throw new TypeError(`${plugin}: ${field} must be an integer from 1 to 1024`)
+    return value
+  }),
+})
+
+// 逐 Unicode 字符比较周期，内存只随最长周期增长，不保留整段推理。
+function repeatDetector(threshold, maxCycle) {
+  const tail = new Array(maxCycle)
+  const matches = new Float64Array(maxCycle + 1)
+  let seen = 0
+  return text => {
+    let offset = 0
+    for (const char of text) {
+      offset += char.length
+      let repeated = false
+      for (let period = 1; period <= Math.min(seen, maxCycle); period++) {
+        const needed = Math.max(threshold - period, 2 * period)
+        matches[period] = tail[(seen - period) % maxCycle] === char ? Math.min(matches[period] + 1, needed) : 0
+        if (matches[period] >= needed) repeated = true
+      }
+      tail[seen % maxCycle] = char
+      seen++
+      if (repeated) return offset
+    }
+    return undefined
+  }
+}
+
+export function apply(ctx, raw, options = {}) {
+  const { agent } = options
+  const config = configContract.parse(raw, name)
+  if (!config.enabled || typeof agent?.session?.id !== 'string') return
+  if (config.audience !== 'all' && config.audience !== capabilityAudience(agent)) return
+  let active = true
+  const report = message => ctx.logger?.warn?.(`${name}: ${message}`)
+  const limit = capabilityAudience(agent) === 'subagent' ? config.subagentRecoveryLimit : config.mainRecoveryLimit
+  const coordinator = recoveryCoordinator(ctx, agent, config, { ...options, recover(candidate) {
+    if (!limit) return
+    if (!options.recoveryState) { report('persistent recovery state unavailable; automatic recovery disabled'); return }
+    try {
+      const claimed = options.recoveryState.claim(agent.session.id, candidate.execution, limit)
+      if (!claimed.claimed) { report(`recovery unavailable (${claimed.used}/${limit})`); return }
+      void (async () => {
+        try {
+          await agent.whenIdle()
+          const valid = () => active && !candidate.signal?.aborted && coordinator.unchanged(candidate)
+          if (!valid()) return
+          let maintenance
+          if (config.maintenanceCompression) {
+            maintenance = await recoveryMaintenance(options.contextRuntimeOf?.(agent), candidate.signal, config.allowFullFallback, valid, report)
+            if (!maintenance) return
+          }
+          if (!valid()) return
+          const text = '上一轮输出因异常重复或仅有推理而未完成。请停止重复，检查已完成的工作，并给出有效结果或明确说明阻塞原因。'
+            + (maintenance ? `\n维护压缩已完成，实际来源事件：${maintenance.shadowedSeqs.join(',')}。` : '')
+          agent.followup(pluginMessage('generation-recovery', text, '恢复异常生成'))
+        } catch (error) { report(String(error?.message ?? error)) }
+      })()
+    } catch (error) { report(String(error?.message ?? error)) }
+  } }, () => active)
+  const stop = ctx.effect(() => () => { active = false })
+  const off = ctx.on('llm/stream', (options, next) => {
+    if (!active || options.signal?.aborted || options.purpose !== undefined || options.sessionId !== agent.session.id) return next()
+    return (async function* () {
+      const detectors = {
+        text: repeatDetector(config.textRepeatChars, config.maxCycleChars),
+        reasoning: repeatDetector(config.reasoningRepeatChars, config.maxCycleChars),
+      }
+      const open = new Map()
+      const closed = new Set()
+      const finalized = new Set()
+      let hasToolCall = false
+      let visibleText = false
+      let reasoningChars = 0
+      for await (const chunk of next()) {
+        if (finalized.has(chunk.index)) continue
+        if (!active || options.signal?.aborted) { yield chunk; continue }
+        if (chunk.type === 'tool-call-delta' || chunk.blockType === 'tool-call' || chunk.block?.type === 'tool-call') hasToolCall = true
+        if (chunk.type === 'block-start') open.set(chunk.index, { type: chunk.blockType, text: '' })
+        if (chunk.type === 'block-end') { open.delete(chunk.index); closed.add(chunk.index) }
+        const kind = chunk.type === 'text-delta' ? 'text' : chunk.type === 'reasoning-delta' ? 'reasoning' : undefined
+        if (kind === undefined || closed.has(chunk.index)) { yield chunk; continue }
+        if (!open.has(chunk.index)) open.set(chunk.index, { type: kind, text: '' })
+        // 已闭合工具也要保留原始finish语义，不把工具回合伪装成普通stop。
+        const safe = !hasToolCall && [...open.values()].every(block => block.type === 'text' || block.type === 'reasoning')
+        if (kind === 'text' && chunk.text.trim()) visibleText = true
+        let cutoff = safe ? detectors[kind](chunk.text) : undefined
+        let cause = 'repeated-' + kind
+        if (safe && kind === 'reasoning' && !visibleText && config.silentReasoningChars > 0) {
+          const chars = [...chunk.text]
+          const remaining = config.silentReasoningChars - reasoningChars
+          reasoningChars += chars.length
+          if (remaining > 0 && remaining <= chars.length) {
+            const silentCutoff = chars.slice(0, remaining).join('').length
+            if (cutoff === undefined || silentCutoff < cutoff) { cutoff = silentCutoff; cause = 'silent-reasoning' }
+          }
+        }
+        const text = cutoff === undefined ? chunk.text : chunk.text.slice(0, cutoff)
+        const block = open.get(chunk.index)
+        if (block !== undefined) block.text += text
+        yield cutoff === undefined ? chunk : { ...chunk, text }
+        if (cutoff === undefined) continue
+        if (!active || options.signal?.aborted) {
+          const remainder = chunk.text.slice(cutoff)
+          if (remainder) yield { ...chunk, text: remainder }
+          continue
+        }
+        for (const [index, value] of open) {
+          if (!active || options.signal?.aborted) break
+          finalized.add(index)
+          yield { type: 'block-end', index, block: value }
+        }
+        if (!active || options.signal?.aborted) {
+          const remainder = chunk.text.slice(cutoff)
+          if (!finalized.has(chunk.index) && remainder) yield { ...chunk, text: remainder }
+          continue
+        }
+        coordinator.mark(cause)
+        yield { type: 'finish', reason: { kind: 'stop' } }
+        return
+      }
+    })()
+  })
+  return () => { stop(); off(); coordinator.dispose() }
+}

package/engine/host-package.mjs

@@ -49,3 +49,16 @@ export function resolveHostPackage(id, entry, self) {
 export async function importHostPackage(id, entry, self) {
   return import(pathToFileURL(resolveHostPackage(id, entry, self)).href)
 }
+
+/** 允许从宿主解析的官方能力包；版本随宿主（alpha/rc 均可），不在插件内做精确匹配。 */
+export const HOST_CAPABILITY_PACKAGES = Object.freeze([
+  '@deepseek-ai/dsh-compaction-basic',
+  '@deepseek-ai/dsh-compaction-tool-result-pruner',
+  '@deepseek-ai/dsh-compaction',
+  '@deepseek-ai/dsh-llm',
+])
+
+export async function importHostCapability(id) {
+  if (!HOST_CAPABILITY_PACKAGES.includes(id)) throw new Error(`host capability not declared: ${id}`)
+  return importHostPackage(id)
+}

package/engine/layers.d.mts

@@ -0,0 +1,4 @@
+import type { UserMessage } from '@deepseek-ai/dsh-llm'
+
+/** 已有提示词引擎通知消息；使用宿主当前的插件来源契约。 */
+export function pluginMessage(prefix: string, text: string, summary: string): UserMessage