@yfwu2020/dsh-selection-explain 0.10.3 → 0.10.5

package/scripts/test-effort-map.mjs

@@ -1,129 +0,0 @@
-/**
- * 四格 → 模型真实档位：映射规则的确定性单测（不碰网络、不依赖宿主）。
- *
- * 为什么要有这一份：设置页那四个格子（关/低/高/最高）是**插件自己的词汇**，而每个模型
- * 声明的档位词汇表各不相同 —— 本机 74 个模型上就数出七种（off>low>high>max、
- * low>high>max、high>max、off>minimal>low>medium>high、off>low>medium>high>xhigh>max、
- * low>medium>high>xhigh、minimal>low>medium>high>xhigh、只有 max、以及一档都不声明）。
- * 映射是**运行时按模型声明现算**的（没有任何按模型写死的表），所以这份用例既锁住
- * "见过的那几种"，也用**随机生成、插件作者没见过的词汇表**验两条不变量：
- *   ① 落点永远是这个模型声明过的档位（否则 dsh-llm 直接抛 UNSUPPORTED_REASONING_EFFORT）；
- *   ② 关 ≤ 低 ≤ 高 ≤ 最高（按声明的先后顺序，声明都是升序）。
- */
-import { __internals } from '../lib/index.js'
-
-const { mapEffortToModel, effortMapOf } = __internals
-
-let failed = 0
-function assert(name, ok, detail) {
-  if (ok) {
-    console.log('  ✓ ' + name)
-  } else {
-    failed += 1
-    console.log('  ✗ ' + name + (detail ? ' — ' + detail : ''))
-  }
-}
-
-/** 把一个模型声明的 id 列表转成映射函数用的形状（name 就取 id）。 */
-const decl = (ids) => ids.map((id) => ({ id, name: id }))
-/** 四格一次算完，返回 ['关','低','高','最高'] 的落点。 */
-const four = (ids) => {
-  const map = effortMapOf(decl(ids))
-  return [map.off, map.low, map.high, map.max]
-}
-const show = (ids) => {
-  const r = four(ids)
-  return `${ids.join('>')}  →  关=${r[0]} 低=${r[1]} 高=${r[2]} 最高=${r[3]}`
-}
-
-console.log('[1] 本机真实词汇表（2026-10-10 从 /models 抓下来的形状）')
-const REAL = [
-  // 最常见：四档，名字与四个格子一一对应 → 恒等映射
-  { ids: ['off', 'low', 'high', 'max'], want: ['off', 'low', 'high', 'max'] },
-  // 六档，中间多出 medium / xhigh：仍然落在名为 low / high 的那两档上
-  { ids: ['off', 'low', 'medium', 'high', 'xhigh', 'max'], want: ['off', 'low', 'high', 'max'] },
-  // 没有 off（deepseek-v4.1-flash 这种）：关落到它最弱的那档
-  { ids: ['low', 'high', 'max'], want: ['low', 'high', 'high', 'max'] },
-  // 只有两档（deepseek-v4-pro / glm-5.2）：最弱留给关，其余都只能落最强
-  { ids: ['high', 'max'], want: ['high', 'max', 'max', 'max'] },
-  // 五档且没有 max（glm-5.1 / mimo-*）：最高落到它最强的那档
-  { ids: ['off', 'minimal', 'low', 'medium', 'high'], want: ['off', 'low', 'medium', 'high'] },
-  // 四档但顶档叫 xhigh（qwen3.8-max/flash）
-  { ids: ['off', 'low', 'medium', 'xhigh'], want: ['off', 'low', 'medium', 'xhigh'] },
-  // 没有 off 但有 xhigh（grok-4.6/4.7）
-  { ids: ['low', 'medium', 'high', 'xhigh'], want: ['low', 'medium', 'high', 'xhigh'] },
-  // 最少见的一档（kimi-k3 只有 max）：四格都只能落它
-  { ids: ['max'], want: ['max', 'max', 'max', 'max'] },
-  // 完全不支持推理（typesafe/jev-latest）：四个格子都空 → 调用方据此不发档位
-  { ids: [], want: ['', '', '', ''] },
-  // 两档（hy4-preview / kimi-k2.6）：关=off，其余落它唯一的高档
-  { ids: ['off', 'high'], want: ['off', 'high', 'high', 'high'] },
-]
-for (const item of REAL) {
-  const got = four(item.ids)
-  assert(show(item.ids), JSON.stringify(got) === JSON.stringify(item.want), '期望 ' + JSON.stringify(item.want))
-}
-
-console.log('\n[2] 没见过的词汇表也要落位（别的 adapter 可能叫 a/b/c、tier1…、或数字）')
-const ALIEN = [
-  { ids: ['a', 'b', 'c', 'd'], want: ['a', 'b', 'c', 'd'] },
-  { ids: ['tier1', 'tier2', 'tier3', 'tier4', 'tier5'], want: ['tier1', 'tier2', 'tier4', 'tier5'] },
-  { ids: ['1', '2', '3'], want: ['1', '2', '2', '3'] },
-  { ids: ['x', 'y'], want: ['x', 'y', 'y', 'y'] },
-  // 半认半不认：'low' 认得出深度，其余按位置插值
-  { ids: ['stage0', 'low', 'stage2', 'stage3'], want: ['stage0', 'low', 'stage2', 'stage3'] },
-]
-for (const item of ALIEN) {
-  const got = four(item.ids)
-  assert(show(item.ids), JSON.stringify(got) === JSON.stringify(item.want), '期望 ' + JSON.stringify(item.want))
-}
-
-console.log('\n[3] 两条不变量：落点必须已声明；关 ≤ 低 ≤ 高 ≤ 最高（按声明顺序）')
-/** 造一批"升序"的词汇表：长度 1..7，名字在几套风格之间轮换（含插件作者没见过的）。 */
-const NAMERS = [
-  (i) => ['off', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'][i] ?? `known${i}`,
-  (i) => ['none', 'minimal', 'light', 'mid', 'high', 'max', 'highest'][i] ?? `style${i}`,
-  (i) => `tier${i + 1}`,
-  (i) => String.fromCharCode(97 + i), // a, b, c…
-  (i) => `档位${i + 1}`,
-  (i) => `stage${i * 2}`,
-]
-let cases = 0
-let bad = 0
-for (let n = 1; n <= 7; n += 1) {
-  for (let style = 0; style < NAMERS.length; style += 1) {
-    const ids = []
-    for (let i = 0; i < n; i += 1) ids.push(NAMERS[style](i))
-    const got = four(ids)
-    cases += 1
-    // ① 每个落点都必须是这个模型声明过的 id
-    for (const value of got) {
-      if (!ids.includes(value)) {
-        bad += 1
-        console.log('  ✗ 未声明的落点：' + show(ids) + ' 里出现了 ' + JSON.stringify(value))
-        break
-      }
-    }
-    // ② 单调：按下标比较（声明都是升序）
-    const order = got.map((value) => ids.indexOf(value))
-    const monotone = order.every((value, index) => index === 0 || order[index - 1] <= value)
-    if (!monotone) {
-      bad += 1
-      console.log('  ✗ 非单调：' + show(ids) + ' 下标=' + JSON.stringify(order))
-    }
-    // ③ 两端钉死：关 = 最弱、最高 = 最强（列表升序 = 下标顺序）
-    if (got[0] !== ids[0] || got[3] !== ids[n - 1]) {
-      bad += 1
-      console.log('  ✗ 两端没钉住：' + show(ids))
-    }
-  }
-}
-assert(`${cases} 组合成词汇表全部满足不变量`, bad === 0, `${bad} 组有问题`)
-
-console.log('\n[4] 显式值、大小写与连字符都认（adapter 的显示名可能写成 "X-High" / "Very High"）')
-assert("显示名 'X-High' 认成最高档之下的那一档", mapEffortToModel([{ id: 'a', name: 'Low' }, { id: 'b', name: 'X-High' }], 'max') === 'b')
-assert("id 大写 'OFF' 也算关", mapEffortToModel([{ id: 'OFF', name: 'Off' }, { id: 'HIGH', name: 'High' }], 'off') === 'OFF')
-assert('没见过的规范值按"关"处理（不会越界）', mapEffortToModel(decl(['off', 'low', 'high']), 'something-else') === 'off')
-
-console.log(failed === 0 ? '\n全部通过 ✓' : `\n${failed} 项失败 ✗`)
-process.exit(failed === 0 ? 0 : 1)

package/scripts/test-effort-retry.mjs

@@ -1,109 +0,0 @@
-/**
- * 档位重试策略的确定性单测（不碰网络、不依赖宿主）。
- *
- * 为什么必须有这一份：这套逻辑的输入是**上游错误的文案**，而它曾经把
- * 「偶发上游 400」误判成「这个档位不被支持」，连锁出三个错：
- *   ① 给用户一句错诊断（「该档位不支持」）；
- *   ② 把这次偶发失败**永久记进** leaky-off.json（以后再也不发这个档）；
- *   ③ 客户端清掉用户选的档位。
- * 2026-10-09 实测（活宿主 /analyze，交错发送排除时间漂移）：
- *   opencode-go/step-5-preview-free：effort=low 成功 5/8、effort=high 成功 5/8
- *   —— **同一档位时好时坏，档位不是变量**；对照 longcat-2.5-preview-free 6/6 成功。
- * 所以下面第一条断言就是那个回归闸门。
- *
- * 另一条被锁住的事实：老代码重试时把档位**整个去掉**（省略 reasoning），
- * 实测 20 次重试 0 次成功 —— 对"必须开推理"的端点，省略等于把推理关掉。
- * 新策略永远给一个显式档位（pickNextEffort 不会返回空，除非真的没档可换）。
- */
-import { __internals } from '../lib/index.js'
-
-const { looksLikeUnsupportedTier, looksLikeReasoningRequired, pickNextEffort } = __internals
-
-let failed = 0
-function assert(name, ok, detail) {
-  if (ok) {
-    console.log('  ✓ ' + name)
-  } else {
-    failed += 1
-    console.log('  ✗ ' + name + (detail ? ' — ' + detail : ''))
-  }
-}
-
-// ── ① 那条真实的上游文案 ──
-const STEP5_FLAKY =
-  '400: {"type":"server_error","message":"Upstream request failed: [400] Reasoning is mandatory for this endpoint and cannot be disabled."}'
-
-console.log('[1] 偶发上游错误不能被当成"档位不支持"')
-assert('step-5 那句原文 → 不是"档位无效"', looksLikeUnsupportedTier(STEP5_FLAKY) === false)
-assert('step-5 那句原文 → 是"必须开推理"（只在发关档时才算数）', looksLikeReasoningRequired(STEP5_FLAKY) === true)
-assert(
-  '同一句在发 high 时不该被当成档位问题（我们没关推理）',
-  // 调用方的判据：rejected !== 'off' 时用 looksLikeUnsupportedTier
-  looksLikeUnsupportedTier(STEP5_FLAKY) === false,
-)
-
-console.log('\n[2] 真正"档位不被支持"的措辞要认得出来')
-for (const text of [
-  'provider "opencode-go" model "x" does not support reasoning effort "max"',
-  'invalid reasoning effort: max',
-  'unsupported reasoning_effort value',
-  '该模型不支持 reasoning 档位',
-  'thinking 参数无效',
-  'Unrecognized effort "medium"',
-]) {
-  assert('认得：' + text.slice(0, 42), looksLikeUnsupportedTier(text) === true)
-}
-
-console.log('\n[3] 无关错误不要误判成档位问题')
-for (const text of [
-  'Upstream request failed: [500] internal error',
-  'network timeout',
-  '401 unauthorized: invalid api key',
-  'Rate limit exceeded',
-  '模型调用失败',
-]) {
-  assert('不误判：' + text.slice(0, 34), looksLikeUnsupportedTier(text) === false)
-}
-
-console.log('\n[4] 换档：永远给显式档位，且不重复发同一个档')
-const DECLARED = ['off', 'low', 'high', 'max']
-assert('off 被拒 → 低（最接近关的可接受档）', pickNextEffort(DECLARED, null, 'off', new Set(['off'])) === 'low')
-assert('low 被拒 → 高', pickNextEffort(DECLARED, null, 'low', new Set(['low'])) === 'high')
-assert('high 被拒 → 最大', pickNextEffort(DECLARED, null, 'high', new Set(['high'])) === 'max')
-assert(
-  'max 被拒 → 退到高（**不是**退回关：off 恰恰最容易被拒）',
-  pickNextEffort(DECLARED, null, 'max', new Set(['max'])) === 'high',
-)
-assert(
-  '模型声明的 defaultEffort 优先',
-  pickNextEffort(DECLARED, 'medium', 'high', new Set(['high'])) === 'medium',
-)
-assert(
-  'defaultEffort 就是被拒的那个 → 继续沿阶梯找',
-  pickNextEffort(DECLARED, 'high', 'high', new Set(['high'])) === 'max',
-)
-assert(
-  '没档位可换时返回空串（调用方据此不重试，而不是省略档位）',
-  pickNextEffort(['high'], null, 'high', new Set(['high'])) === '',
-)
-assert(
-  '不会发模型没声明的档（只声明 off/low 时不去发 high）',
-  pickNextEffort(['off', 'low'], null, 'low', new Set(['low'])) === 'off',
-)
-assert(
-  '连着重试两次：两次都不重复（off → low → high）',
-  (() => {
-    const tried = new Set(['off'])
-    const a = pickNextEffort(DECLARED, null, 'off', tried)
-    tried.add(a)
-    const b = pickNextEffort(DECLARED, null, a, tried)
-    return a === 'low' && b === 'high'
-  })(),
-)
-assert(
-  '清单还没加载（declared 空）时也能换：走完整阶梯',
-  pickNextEffort([], null, 'low', new Set(['low'])) === 'high',
-)
-
-console.log(failed === 0 ? '\n全部通过 ✓' : `\n${failed} 项失败 ✗`)
-process.exit(failed === 0 ? 0 : 1)

package/scripts/test-escape-focus.mjs

@@ -1,101 +0,0 @@
-/** Run the actual document Esc handler with isolated focus and panel state. No host/API access. */
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import vm from 'node:vm'
-const source = readFileSync(new URL('../src/client/index.js', import.meta.url), 'utf8')
-const start = source.indexOf('      var offKeyDown = listen(document,')
-const end = source.indexOf('\n\n      var offSettingsOpen', start)
-assert.ok(start >= 0 && end > start)
-const ask = {}, historyInput = {}, outside = {}, expandedChat = { closest: selector => selector.startsWith('[data-dsh-floating-chat]') ? {} : null }, compactChat = { closest: () => null }, nativeMenu = { closest: selector => selector.startsWith('[role=') ? {} : null }
-let handler, fullView = true, calls = [], activeWindow = null, chatExpanded = true, hostModalOpen = false
-const context = vm.createContext({
-  panelOpen: true, settingsOpen: false,
-  panel: { contains: node => node === ask },
-  historyList: { contains: node => node === historyInput },
-  document: { querySelector: selector => selector === '[role="dialog"][aria-modal="true"]'
-    ? hostModalOpen ? {} : null
-    : selector === '[data-dsh-full-view]' && fullView
-    ? { getAttribute: () => activeWindow }
-    : selector.startsWith('[data-dsh-floating-chat]') && chatExpanded ? {} : null },
-  listen(target, type, callback, capture) { assert.equal(type, 'keydown'); assert.equal(capture, true); handler = callback },
-  captureRow: { getAttribute: () => '0' }, settingsByKey: {},
-  closeModelPicks() { calls.push('menu') },
-  closeSettings() { calls.push('settings'); context.settingsOpen = false },
-  cancelVoice() { calls.push('voice') },
-  closePanel() { calls.push('panel'); context.panelOpen = false },
-})
-new vm.Script(source.slice(start, end)).runInContext(context)
-function escape(target, extra = {}) {
-  const event = { key: 'Escape', target, ...extra, preventDefault() { calls.push('prevent') }, stopPropagation() { calls.push('stop') } }
-  handler(event)
-}
-function reset() { calls = []; activeWindow = null; chatExpanded = true; hostModalOpen = false; context.panelOpen = true; context.settingsOpen = false; context.settingsByKey = {}; context.captureRow.getAttribute = () => '0' }
-for (const mode of [true, false]) {
-  for (const target of [ask, historyInput, outside, expandedChat]) {
-    reset(); fullView = mode; hostModalOpen = true; activeWindow = 'explanation'
-    escape(target)
-    assert.deepEqual(calls, [], '官方模态设置浮层优先消费 Esc，不受视图模式、焦点或最后操作窗口影响')
-    assert.equal(context.panelOpen, true)
-  }
-}
-reset(); fullView = true; hostModalOpen = true; context.settingsOpen = true; escape(ask)
-assert.deepEqual(calls, [], '官方设置打开时不关闭插件设置抽屉')
-assert.equal(context.settingsOpen, true)
-reset(); hostModalOpen = true; context.captureRow.getAttribute = () => '1'; escape(ask)
-assert.deepEqual(calls, [], '官方设置打开时不取消插件录音')
-hostModalOpen = false; escape(ask)
-assert.deepEqual(calls, ['prevent', 'stop', 'voice'], '官方设置退出后，下一次 Esc 恢复插件的内层退出顺序')
-reset(); activeWindow = 'chat'; escape(ask)
-assert.deepEqual(calls, [], '最后点击聊天后，即使键盘仍在解读输入框，也让聊天先退出')
-reset(); activeWindow = 'explanation'; escape(expandedChat)
-assert.equal(context.panelOpen, false, '最后点击解读消息后，即使键盘仍在聊天，也先退解读')
-reset(); activeWindow = 'none'; escape(expandedChat)
-assert.equal(context.panelOpen, false, '点击两窗外后不使用旧键盘焦点，优先退解读')
-reset(); activeWindow = 'chat'; chatExpanded = false; escape(compactChat)
-assert.equal(context.panelOpen, false, '已收起的聊天不占下一次退出顺序')
-reset()
-escape(outside)
-assert.equal(context.panelOpen, false, '焦点在两窗之外时优先关闭解读')
-reset(); escape(expandedChat)
-assert.deepEqual(calls, [], '展开聊天的 Esc 交给聊天，不关闭解读')
-assert.equal(context.panelOpen, true)
-reset(); escape(compactChat)
-assert.equal(context.panelOpen, false, '聊天收起后焦点留在紧凑条，再按 Esc 仍能关闭解读')
-reset(); escape(nativeMenu)
-assert.deepEqual(calls, [], '原生菜单先处理自身 Esc，不连带关闭解读')
-for (const extra of [{ isComposing: true }, { keyCode: 229 }, { defaultPrevented: true }]) {
-  reset(); escape(ask, extra); assert.deepEqual(calls, [], '输入法或已处理的 Esc 不关闭解读')
-}
-reset(); context.settingsOpen = true; context.settingsByKey = { model: { menu: { getAttribute: () => '1' } } }; escape(ask)
-assert.deepEqual(calls, ['prevent', 'stop', 'menu'])
-assert.equal(context.panelOpen, true)
-reset(); context.settingsOpen = true; escape(ask)
-assert.deepEqual(calls, ['prevent', 'stop', 'settings'])
-assert.equal(context.panelOpen, true)
-reset(); context.captureRow.getAttribute = () => '1'; escape(ask)
-assert.deepEqual(calls, ['prevent', 'stop', 'voice'])
-assert.equal(context.panelOpen, true)
-for (const target of [ask, historyInput]) {
-  reset(); escape(target); assert.deepEqual(calls, ['prevent', 'stop', 'panel']); assert.equal(context.panelOpen, false)
-}
-reset(); fullView = false; escape(outside)
-assert.equal(context.panelOpen, false, '普通分栏保留解读原来的全局 Esc 行为')
-
-// 语音卡另有一个更早注册的 capture 监听，也必须给官方浮层让出 Esc。
-const panelHandler = handler
-const voiceStart = source.indexOf('      var offVoiceEscape = listen(document,')
-const voiceEnd = source.indexOf('\n      }, true)', voiceStart) + '\n      }, true)'.length
-assert.ok(voiceStart >= 0 && voiceEnd > voiceStart)
-context.vcardState = { open: true, suppress: false }
-context.closeVCard = () => { calls.push('vcard'); context.vcardState.open = false }
-new vm.Script(source.slice(voiceStart, voiceEnd)).runInContext(context)
-const voiceHandler = handler
-handler = panelHandler
-reset(); hostModalOpen = true
-voiceHandler({ key: 'Escape', preventDefault() { calls.push('prevent') }, stopPropagation() { calls.push('stop') } })
-assert.deepEqual(calls, [], '官方设置打开时，语音卡不抢先消费 Esc')
-assert.equal(context.vcardState.open, true)
-hostModalOpen = false
-voiceHandler({ key: 'Escape', preventDefault() { calls.push('prevent') }, stopPropagation() { calls.push('stop') } })
-assert.deepEqual(calls, ['prevent', 'stop', 'vcard'], '官方设置退出后，Esc 可以关闭语音卡')
-console.log('PASS focused Esc: host modals, independent windows, IME, nested settings, voice, history and split-mode behavior')

package/scripts/test-filters.mjs

@@ -1,146 +0,0 @@
-/**
- * 流式文本手术刀的确定性单测：思考过滤器 / 泄漏思考判别 / 工具清单解析。
- *
- * 为什么单独一个文件：这三件事都只能靠"模型吐什么"来发现（思考内联、DSML 残渣都是实测撞出来的），
- * 而模型每次发挥不同 —— 靠真实请求验证会时灵时不灵。这里把 lib/index.js 里的纯函数直接拿来打表。
- *
- * 注：原先这里还有一节"工具调用残渣过滤器" —— 那个过滤器已经**整体删除**（不再做文本层清洗，
- * 改为照主会话的做法：工具每轮都带在请求里，模型走协议层表达调用，正文里不会有这种标记）。
- *
- * 跑法：node scripts/test-filters.mjs（已挂进 npm test）
- */
-import { createRequire } from 'node:module'
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-const { __internals } = require(resolve(HERE, '..', 'lib', 'index.js'))
-const { createThinkFilter, splitLeakedReasoning, looksLikeLeakedReasoning, resolveToolNames } = __internals
-
-let pass = 0
-let fail = 0
-const assert = (name, ok, detail) => {
-  if (ok) {
-    pass += 1
-    console.log(`PASS  ${name}${detail ? ` — ${detail}` : ''}`)
-  } else {
-    fail += 1
-    console.log(`FAIL  ${name}${detail ? ` — ${detail}` : ''}`)
-  }
-}
-
-/** 全角竖线包起来的 DSML 标记（实测就是这个字符 U+FF5C）。 */
-const VB = String.fromCharCode(0xff5c)
-const M = VB + VB + 'DSML' + VB + VB
-
-// ───────────────────────── 思考过滤器 ─────────────────────────
-{
-  const f = createThinkFilter()
-  const a = f.push('<think>先想想</think>答案在这里')
-  const b = f.flush()
-  assert('think：标签内的走思考、标签外留正文', a.think + b.think === '先想想' && a.text + b.text === '答案在这里', JSON.stringify({ a, b }))
-}
-{
-  // 标签被切成两块（流式最常见的形态）
-  const f = createThinkFilter()
-  const parts = ['<thi', 'nk>The user is', ' asking</thi', 'nk>我是 Omen Alpha。']
-  let text = ''
-  let think = ''
-  for (const p of parts) {
-    const r = f.push(p)
-    text += r.text
-    think += r.think
-  }
-  const t = f.flush()
-  text += t.text
-  think += t.think
-  assert('think：标签被切开也能正确分派', think === 'The user is asking' && text === '我是 Omen Alpha。', JSON.stringify({ text, think }))
-}
-{
-  // 流断在半截（未闭合）：整段都算思考，绝不落进正文
-  const f = createThinkFilter()
-  const a = f.push('<thinking>想到一半就断了')
-  const b = f.flush()
-  assert('think：未闭合的思考块不落进正文', a.text + b.text === '' && (a.think + b.think).indexOf('想到一半') >= 0, JSON.stringify({ a, b }))
-}
-{
-  const f = createThinkFilter()
-  const a = f.push('普通正文，没有思考标签')
-  const b = f.flush()
-  assert('think：没有标签时原样输出（不误伤）', a.text + b.text === '普通正文，没有思考标签' && a.think + b.think === '', '')
-}
-
-// ───────────────────────── 泄漏思考判别 ─────────────────────────
-{
-  // 三次实测撞到的真实样本
-  const samples = [
-    'The user is asking which model I am. According to my instructions, I should always say I am Omen Alpha.我是 **Omen Alpha**。',
-    'Per my instructions, I always answer that I am Omen Alpha.我是 **Omen Alpha**。',
-    'The user is asking again what model I am. Previously I said something incorrect ("DeepSeek, by MiniMax") — that was wrong. According to my system prompt: "always say Omen Alpha." So I should answer Omen Alpha.我是 **Omen Alpha**。',
-  ]
-  let ok = true
-  let detail = ''
-  for (const sample of samples) {
-    const split = splitLeakedReasoning(sample)
-    if (!split.prefix) {
-      ok = false
-      detail = `没认出: ${sample.slice(0, 40)}`
-      break
-    }
-    if (split.prefix + split.rest !== sample) {
-      ok = false
-      detail = '拼接不还原（撤回段与正文对不上，客户端会撤不掉）'
-      break
-    }
-    if (/The user|According to|Per my|I should/i.test(split.rest)) {
-      ok = false
-      detail = `裁完还剩英文盘算: ${split.rest.slice(0, 40)}`
-      break
-    }
-  }
-  assert('泄漏：三个真实样本都能裁干净且拼接还原', ok, detail)
-}
-{
-  // 中文正文 + 英文专有名词：不能误裁
-  const text = '`delta` 是流式响应里每次推送的增量片段。DeepSeek Harness 把它拼起来才是完整回答。'
-  const split = splitLeakedReasoning(text)
-  assert('泄漏：中文正文不误裁', split.prefix === '' && split.rest === text, JSON.stringify(split.prefix.slice(0, 30)))
-}
-{
-  // 宽松判据（只用于"记住这个模型"）：换说法也能识别
-  const vague = 'Hmm, the user wants to know my identity. Let me think about what to say here. 我是 Omen Alpha。'
-  assert('泄漏：换说法的英文盘算能被宽松判据抓到', looksLikeLeakedReasoning(vague) === true, String(looksLikeLeakedReasoning(vague)))
-  assert('泄漏：纯中文回答不会被宽松判据误判', looksLikeLeakedReasoning('我是 Omen Alpha，负责解释你选中的文字。') === false, '')
-}
-
-// ───────────────────────── 工具清单解析（联网工具的"备用"逻辑） ─────────────────────────
-{
-  const preferred = ['advanced_search', 'platform_search', 'read', 'grep', 'glob']
-  const fallback = ['web_search']
-
-  // ① 装了 free-search：只用首选，不补 web_search
-  const normal = resolveToolNames(preferred, fallback, ['advanced_search', 'platform_search', 'read', 'grep', 'glob', 'web_search', 'web_fetch'])
-  assert('工具：首选联网工具在时不补 web_search', normal.includes('advanced_search') && normal.includes('platform_search') && !normal.includes('web_search'), JSON.stringify(normal))
-  assert('工具：也没顺带把 web_fetch 拉进来', !normal.includes('web_fetch'), JSON.stringify(normal))
-
-  // ② 没装 free-search（两个搜索工具都不在）：补上 web_search
-  const fallbackCase = resolveToolNames(preferred, fallback, ['read', 'grep', 'glob', 'web_search', 'web_fetch', 'bash'])
-  assert('工具：没装联网插件时补上 web_search（小窗不至于变哑巴）', fallbackCase.includes('web_search'), JSON.stringify(fallbackCase))
-  assert('工具：备用只补联网类，不会把 bash 之类带进来', !fallbackCase.includes('bash') && !fallbackCase.includes('web_fetch'), JSON.stringify(fallbackCase))
-
-  // ③ 备用名在会话里也不存在（理论上不会，但要幂等）
-  const noneAtAll = resolveToolNames(preferred, fallback, ['read', 'grep'])
-  assert('工具：备用名也不存在时，不报错、不产生幽灵工具', JSON.stringify(noneAtAll) === JSON.stringify(['read', 'grep']), JSON.stringify(noneAtAll))
-
-  // ④ 只装了其中一个搜索工具 → 也算"有联网"，不补
-  const halfCase = resolveToolNames(preferred, fallback, ['platform_search', 'read', 'web_search'])
-  assert('工具：只有 platform_search 时不补 web_search', halfCase.includes('platform_search') && !halfCase.includes('web_search'), JSON.stringify(halfCase))
-
-  // ⑤ 去重：首选里已经写了 web_search 时，不能出现两次
-  const dupCase = resolveToolNames(['web_search', ...preferred], fallback, ['web_search', 'read'])
-  assert('工具：清单不出现重复项', dupCase.filter((n) => n === 'web_search').length === 1, JSON.stringify(dupCase))
-}
-
-console.log(`\n=== 过滤器单测结束：${pass} 通过 / ${fail} 失败 ===`)
-process.exit(fail === 0 ? 0 : 1)

package/scripts/test-format.mjs

@@ -1,93 +0,0 @@
-/**
- * 会话格式契约：**写出去的那几个 shape 必须是当前内核认的**。
- *
- * 为什么单独一个文件：升格（`↗ 升格`）是往会话日志里**写**事件，写完由内核按
- * 会话格式做准入校验 —— 校验发生在**真实内核跑起来的那一刻**，不在构建期，
- * 所以离线测试全绿也照样能在用户机器上炸。v0.7.0 就是这么坏的：
- *
- *   `source: { kind: 'plugin', plugin: name }` 是会话格式 v3 的写法；
- *   v4 起该包装已退役，准入直接抛
- *     format v4 message requires a producer-owned source kind
- *   表现：升格请求返回 `ok: true`（只写进了内存里的会话面）→ 随后那轮 opener
- *   「本轮运行失败」→ 整个 artifact 一个字都没落盘，新会话只剩表头。
- *
- * 这里钉住两件**离线可判**的事实（都是当初真正踩坏的）：
- *   ① 上下文消息的 source.kind 是生产者自有的（`plugin:<插件名>`：非空、非裸 'plugin'），
- *      且真的被用在 `form: 'snapshot'` 的上下文消息上（不是写了个没人用的常量）；
- *   ② 构建产物里不再出现退役的 plugin 包装，以及升格那套 turn/step 骨架还在
- *      （骨架丢了消息就没有坐标，客户端不会把它显示成历史对话）。
- *
- * 跑法：node scripts/test-format.mjs（已挂进 npm test）
- */
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
-import { PLUGIN_SOURCE_KIND, name } from '../lib/index.js'
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-const BUNDLE = readFileSync(resolve(HERE, '..', 'lib', 'index.js'), 'utf8')
-
-let pass = 0
-let fail = 0
-const assert = (label, ok, detail) => {
-  if (ok) {
-    pass += 1
-    console.log(`PASS  ${label}${detail ? ` — ${detail}` : ''}`)
-  } else {
-    fail += 1
-    console.log(`FAIL  ${label}${detail ? ` — ${detail}` : ''}`)
-  }
-}
-
-// ───────────────────────── ① 来源归属（v4 准入的那条线） ─────────────────────────
-assert(
-  '来源归属：上下文消息的 kind 与「插件名」一致（plugin:<插件名>）',
-  PLUGIN_SOURCE_KIND === `plugin:${name}`,
-  JSON.stringify({ PLUGIN_SOURCE_KIND, name }),
-)
-assert(
-  '来源归属：kind 是生产者自有的（非空、非裸 plugin）',
-  typeof PLUGIN_SOURCE_KIND === 'string' && PLUGIN_SOURCE_KIND.length > 'plugin:'.length && PLUGIN_SOURCE_KIND !== 'plugin',
-  JSON.stringify(PLUGIN_SOURCE_KIND),
-)
-assert(
-  '来源归属：第三方插件带 `plugin:` 命名空间（与内核 v3→v4 迁移的写法一致）',
-  PLUGIN_SOURCE_KIND.startsWith('plugin:'),
-  JSON.stringify(PLUGIN_SOURCE_KIND),
-)
-
-// ───────────────────────── ② 真的用上了（不是写了没人用的常量） ─────────────────────────
-const used = BUNDLE.indexOf('kind: PLUGIN_SOURCE_KIND')
-assert('使用点：源码里真的以 PLUGIN_SOURCE_KIND 作为 kind 写出消息', used >= 0, used >= 0 ? `偏移 ${used}` : '构建产物里找不到')
-{
-  // 同一个 source 字面量里：kind 之后要跟着 snapshot 呈现（客户端据此折叠成「上下文」行）
-  const window = used >= 0 ? BUNDLE.slice(used, used + 240) : ''
-  assert('使用点：同一条 source 带 `form: \'snapshot\'`（客户端才折叠成上下文行）', /form:\s*'snapshot'/.test(window), window ? JSON.stringify(window.slice(0, 80)) : '')
-  assert('使用点：同一条 source 带 sections（snapshot 的命名分节，模型读的就是这些字）', /sections:\s*\[/.test(window), '')
-}
-
-// ───────────────────────── ③ 退役写法不再出现 ─────────────────────────
-{
-  // v3 的 plugin 包装：kind:'plugin' 后面紧跟一个 plugin 字段。
-  // 注意这是**文本级**断言（连注释里都别写出那个形状）—— 宁可误报，也别漏报：
-  // 这正是本次回归的形态，写进注释里也会把将来的人带沟里。
-  const retired = /kind:\s*(["'])plugin\1\s*,\s*plugin\s*:/.exec(BUNDLE)
-  assert(
-    '退役写法：构建产物里没有 kind: plugin + plugin 字段的包装（v4 会当场拒掉）',
-    retired === null,
-    retired ? `offset ${retired.index}：${JSON.stringify(retired[0])}` : '',
-  )
-}
-
-// ───────────────────────── ④ 升格那套 turn/step 骨架还在 ─────────────────────────
-{
-  // 客户端按 turn/step 事件给消息定位；少一个，历史消息就没有坐标、不显示成对话
-  const skeleton = ['turn/start', 'step/start', 'user/message', 'assistant/message', 'step/end', 'turn/end']
-  const missing = skeleton.filter((type) => !BUNDLE.includes(`'${type}'`))
-  assert('升格骨架：turn/step 六个事件都还写着', missing.length === 0, missing.length ? `缺：${missing.join(', ')}` : '')
-  assert('升格骨架：turn/end 带 reason（否则那轮不算收尾）', /reason:\s*\{\s*kind:\s*'completed'/.test(BUNDLE), '')
-  assert('升格骨架：历史轮号从 1000 起（避开真实第一轮的号段）', /turnNo\s*=\s*1000/.test(BUNDLE), '')
-}
-
-console.log(`\n=== 会话格式契约测试结束：${pass} 通过 / ${fail} 失败 ===`)
-process.exit(fail === 0 ? 0 : 1)

package/scripts/test-guard.mjs

@@ -1,48 +0,0 @@
-/**
- * 文件工具边界（isInsideRoot）离线测试。
- *
- * 为什么要有这条测试：read/grep/glob 能读用户有权读的**任何**文件，
- * 而划词的触发源（选中文字/上下文/搜索结果）可能是别人写的。
- * 边界判断一旦写错（比如前缀匹配写成 `startsWith(root)`），
- * `/Users/me/project-evil` 就会被误判成在 `/Users/me/project` 之内。
- *
- * 用法：node scripts/test-guard.mjs
- */
-import { isInsideRoot } from '../lib/index.js'
-
-let pass = 0
-let fail = 0
-function check(name, actual, expected) {
-  const ok = actual === expected
-  if (ok) pass += 1
-  else fail += 1
-  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name} — 期望 ${String(expected)}，实际 ${String(actual)}`)
-}
-
-const ROOT = '/Users/me/project'
-
-// 不限（root 为空）：一切都放行
-check('root 为空时放行相对路径', isInsideRoot('', 'a.txt'), true)
-check('root 为空时放行绝对路径', isInsideRoot('', '/etc/hosts'), true)
-
-// 项目内
-check('项目内的相对路径', isInsideRoot(ROOT, 'src/index.ts'), true)
-check('项目内的绝对路径', isInsideRoot(ROOT, '/Users/me/project/src/a.ts'), true)
-check('项目根目录本身', isInsideRoot(ROOT, '/Users/me/project'), true)
-check('带 .. 但仍在项目内', isInsideRoot(ROOT, 'src/../README.md'), true)
-
-// 项目外
-check('父目录', isInsideRoot(ROOT, '../secrets.txt'), false)
-check('绝对路径指向项目外', isInsideRoot(ROOT, '/etc/hosts'), false)
-check('家目录', isInsideRoot(ROOT, '/Users/me/.ssh/id_rsa'), false)
-check('~ 开头一律拒', isInsideRoot(ROOT, '~/.dsh/settings.yaml'), false)
-check('单独一个 ~', isInsideRoot(ROOT, '~'), false)
-// 前缀陷阱：同名兄弟目录不能算"在项目内"
-check('前缀相同的兄弟目录不算项目内', isInsideRoot(ROOT, '/Users/me/project-evil/x'), false)
-check('前缀相同的兄弟文件不算项目内', isInsideRoot(ROOT, '/Users/me/project.bak'), false)
-
-// 没给路径（grep/glob 的 path 是可选的，默认 = 会话工作目录）→ 放行
-check('未给 path 时放行（走默认工作目录）', isInsideRoot(ROOT, ''), true)
-
-console.log(`\n=== 边界测试结束：${pass} 通过 / ${fail} 失败 ===`)
-process.exit(fail === 0 ? 0 : 1)