@yfwu2020/dsh-selection-explain 0.10.4 → 0.10.6

package/scripts/test-prompt.mjs

@@ -1,193 +0,0 @@
-/**
- * 提示词契约测试 —— 保护提示词里的**关键约束**不被静默删除。
- *
- * 为什么需要它：提示词是产品行为的主要来源（两节结构、结论条、音标规则、来源判断、
- * 网页模式要求…），但它们只是字符串常量，改动时**没有类型检查也没有编译错误**。
- * 以前唯一的"验证"是手工看 PROMPTS.md，而那份快照会过期。这里把关键约束写成断言：
- * 谁误删了，CI 直接红。
- *
- * 读取方式：优先直接 import src/prompts.ts（Node ≥ 22.14 的类型剥离支持直接加载 .ts，
- * 与 GitHub Actions 的 Node 22.14 一致，无需编译步骤）；如果运行环境的 Node 太旧、
- * 不支持类型剥离，则回退到"读源码文本 + 解析数组字面量"，保证测试在任何 Node 上都能跑。
- */
-import { readFileSync } from 'node:fs'
-import { resolve, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-const PROMPTS_TS = resolve(HERE, '..', 'src', 'prompts.ts')
-
-const NAMES = [
-  'PROMPT_HEAD',
-  'TRANSLATION_PROMPT',
-  'CODE_PROMPT',
-  'DETAIL_PROMPT',
-  'CHAT_SYSTEM_PROMPT',
-]
-
-/** 回退方案：从源码文本里解析 `export const X = [ '...', ... ].join('\n')`。 */
-function loadFromSource() {
-  const src = readFileSync(PROMPTS_TS, 'utf8')
-  const out = {}
-  for (const name of NAMES) {
-    const re = new RegExp(`export const ${name} = \\[([\\s\\S]*?)\\]\\.join\\('\\\\n'\\)`)
-    const m = src.match(re)
-    if (!m) throw new Error(`回退解析失败：找不到 ${name}`)
-    const body = m[1]
-    // 元素既可能是字符串字面量，也可能是别的常量（片段复用），后者需要展开
-    const parts = []
-    const reElem = /'((?:[^'\\]|\\.)*)'|([A-Z_]+)/g
-    let em
-    while ((em = reElem.exec(body)) !== null) {
-      if (em[1] !== undefined) parts.push(em[1].replace(/\\'/g, "'").replace(/\\n/g, '\n'))
-      else parts.push(out[em[2]] ?? '')
-    }
-    out[name] = parts.join('\n')
-  }
-  return out
-}
-
-let P
-let loader = 'import src/prompts.ts（Node 类型剥离）'
-try {
-  P = await import(PROMPTS_TS)
-} catch (error) {
-  loader = `源码文本解析回退（类型剥离不可用：${error && error.message}）`
-  P = loadFromSource()
-}
-const { CHAT_SYSTEM_PROMPT, CODE_PROMPT, DETAIL_PROMPT, PROMPT_HEAD, TRANSLATION_PROMPT } = P
-console.log(`提示词来源：${loader}\n`)
-
-let failed = 0
-let passed = 0
-const assert = (label, ok, extra) => {
-  console.log(`${ok ? 'PASS' : 'FAIL'}  ${label}${extra ? ' — ' + extra : ''}`)
-  if (ok) passed += 1
-  else failed += 1
-}
-const has = (text, ...needles) => needles.every((n) => text.includes(n))
-
-// ───────────────────────── 公共前言 ─────────────────────────
-assert('人设：跨领域解读专家（含领域判断要求）', has(PROMPT_HEAD, '跨领域', '先判断【选中文字】实际属于哪个领域'))
-assert('人设：领域判断是内部动作，不许写出来', has(PROMPT_HEAD, '不要把判断过程写出来'))
-assert('人设：说明用户消息的形态（会话背景 + 选中文字）', has(PROMPT_HEAD, '【会话背景】', '【选中文字】'))
-
-// ───────────────────────── 翻译 / 解读（首轮）─────────────────────────
-assert('翻译提示词拼进了公共前言', TRANSLATION_PROMPT.startsWith(PROMPT_HEAD))
-assert(
-  '翻译：只输出一个章节（不许前言结语）',
-  has(TRANSLATION_PROMPT, '本轮只输出一个章节', '不要输出其它章节', '不要前言与结语'),
-)
-assert(
-  '结构契约：含英文 → 标题 `## 翻译`',
-  has(TRANSLATION_PROMPT, '## 翻译'),
-  '客户端按此标题切分渲染，改标题会同时破坏渲染',
-)
-assert(
-  '结构契约：全中文 → 标题 `## 解读`',
-  has(TRANSLATION_PROMPT, '## 解读'),
-)
-assert(
-  '结论条：固定写成引用行「在本句中：」',
-  has(TRANSLATION_PROMPT, '> 在本句中：'),
-  '面板据此渲染成高亮结论条，格式不能丢',
-)
-assert(
-  '音标规则：单词要标 IPA，且拿不准宁可不标',
-  has(TRANSLATION_PROMPT, '音标', 'IPA') && /拿不准就不写|宁可不标/.test(TRANSLATION_PROMPT),
-)
-assert(
-  '词义规则：词性与义项缩进两个空格作为子项',
-  has(TRANSLATION_PROMPT, '缩进两个空格'),
-)
-assert(
-  '语言自适应：按"有没有需要翻译的英文"分情形，只出一种',
-  has(TRANSLATION_PROMPT, '有没有需要翻译的英文') && has(TRANSLATION_PROMPT, '情形一', '情形二'),
-)
-
-// ───────────────────────── 代码注释（首轮）─────────────────────────
-assert('代码提示词拼进了公共前言', CODE_PROMPT.startsWith(PROMPT_HEAD))
-assert('结构契约：代码模式标题 `## 注释`', has(CODE_PROMPT, '## 注释'))
-assert(
-  '代码模式：原代码逐字不变、注释插在语句前',
-  has(CODE_PROMPT, '原代码') && /逐字不变|原样/.test(CODE_PROMPT),
-)
-
-// ───────────────────────── 详解（第二阶段）─────────────────────────
-assert('详解提示词拼进了公共前言', DETAIL_PROMPT.startsWith(PROMPT_HEAD))
-assert(
-  '详解：只输出 `## 详解` 一节',
-  has(DETAIL_PROMPT, '## 详解', '不要输出「## 翻译」或其它章节'),
-)
-assert(
-  '详解：要求先判断这段文字的来源（真实内容 vs 示例/测试/引用）',
-  has(DETAIL_PROMPT, '真实对话/正文', '示例', '测试用例', '演示输出', '引用别人的话'),
-  '早期缺这条时，示例句会被当成真实陈述解释',
-)
-assert('详解：单词仍带音标', has(DETAIL_PROMPT, '音标', 'IPA'))
-
-// ───────────────────────── 追问（小窗对话）─────────────────────────
-assert(
-  '追问：不要求两节结构，问什么答什么',
-  has(CHAT_SYSTEM_PROMPT, '用户问什么就答什么', '不必把话题拉回选中文字'),
-)
-assert(
-  '追问：不许重复前情已给的翻译/详解',
-  has(CHAT_SYSTEM_PROMPT, '不用重复', '一句话带过'),
-)
-assert(
-  '追问：网页模式要给完整单文件 HTML（内联样式与脚本）',
-  has(CHAT_SYSTEM_PROMPT, '完整的单文件 HTML', '```html', '样式和脚本都内联'),
-  '小窗会当场渲染成可交互页面，只给片段就渲染不出来',
-)
-assert(
-  '追问：【引用 N】块要当成提问材料（不许认成上一轮回答）',
-  has(CHAT_SYSTEM_PROMPT, '【引用 N】', '当成提问的一部分来答'),
-  '小窗的「❝ 引用」把引用拼进用户消息，模型得知道那不是它自己的前情',
-)
-assert(
-  '追问：【引用处上下文】要被当成判断依据（引用部分用【】标出）',
-  has(CHAT_SYSTEM_PROMPT, '【引用处上下文】', '被引用的部分用【】标出'),
-  '主界面/网页的引用自带"当时所在的那一组对话 ± 一组"，模型要知道那是上下文而不是正文',
-)
-assert(
-  '追问：只写出处的引用要在本轮上下文里找得到它',
-  has(CHAT_SYSTEM_PROMPT, '小窗第 2 轮回答', '本来就在本轮上下文里'),
-  '小窗自己的对话不重复进引用块，靠出处标签指路',
-)
-
-// ───────────────────────── 卫生检查（防低级事故）─────────────────────────
-const ALL = [PROMPT_HEAD, TRANSLATION_PROMPT, CODE_PROMPT, DETAIL_PROMPT, CHAT_SYSTEM_PROMPT].join('\n')
-assert(
-  '没有未替换的占位符（{{…}} / ${…} / TODO）',
-  !/\{\{[^}]*\}\}|\$\{[^}]*\}|TODO/.test(ALL),
-)
-assert(
-  '没有残留的调试口吻（console.log / debugger）',
-  !/console\.log|debugger/.test(ALL),
-)
-assert(
-  '提示词不是空串（防止整体被清空）',
-  ALL.length > 2000,
-  `总长 ${ALL.length}`,
-)
-
-// ───────────────────────── 防复活：已弃用的规则不得重新接回 ─────────────────────────
-// TWO_LAYER_RULE（「专业 + 说人话、别套模板」的写作规则）**已弃用**：提示词瘦身时
-// 把"别写成同一个模子"那五条写法砍掉了，只留两条硬约束（只出 `## 详解` 一节 + 音标）。
-// 它曾作为常量残留（只定义、不使用），已于 2026-09-24 删除。
-// 这条断言防止有人把那段文字重新塞回提示词里 —— 那是被明确废弃的设计。
-{
-  const resurrected = [TRANSLATION_PROMPT, CODE_PROMPT, DETAIL_PROMPT, CHAT_SYSTEM_PROMPT].some((p) =>
-    p.includes('别写成同一个模子') || p.includes('**写法：内容有要求，形式随内容走。**'),
-  )
-  assert(
-    '已弃用的「两层写法规则」没有被重新塞回提示词',
-    !resurrected,
-    resurrected ? '检测到已废弃规则的原文，请确认是否有意恢复该设计' : '符合当前设计（该规则已弃用并删除）',
-  )
-}
-
-console.log(`\n=== 提示词契约测试结束：${passed} 通过 / ${failed} 失败 ===`)
-if (failed > 0) process.exitCode = 1
-process.exit(process.exitCode ?? 0)

package/scripts/test-route-cache.mjs

@@ -1,138 +0,0 @@
-/**
- * /route 的会话级短缓存。
- *
- * 为什么单测它：跟随状态下**小窗一开着**客户端就每 2 秒问一次 /route，
- * 而 host 侧解析"本会话在用哪个模型"要 readSession —— 那会把整份日志重放成 Session、
- * 再逐条深拷贝一遍（本机实测 1.5MB 会话一次 80~125ms）。不缓存等于每 2 秒重放一次日志。
- *
- * 验的是三条：
- *   ① 事件没涨（live 会话的 seq 不变）→ 不重读，直接回缓存；
- *   ② seq 涨了但离上次重读太近 → 先扛住（防"主会话在连续对话时每拍重放"）；
- *   ③ 用户动作路径（/models、/ping、analyze）不吃缓存 —— 必须是此刻那一份。
- *
- * 用法：node scripts/test-route-cache.mjs
- */
-import assert from 'node:assert/strict'
-import { createServer } from 'node:http'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { apply } from '../lib/index.js'
-
-const home = await mkdtemp(join(tmpdir(), 'dsh-route-cache-'))
-const previousHome = process.env.DSH_HOME
-process.env.DSH_HOME = home
-
-/** 会话自己记的模型选择（每次"主会话换模型"都改它 + 让 seq 涨一格）。 */
-let selection = { provider: 'p1', model: 'm-fast' }
-/** live 会话的事件数（Session.seq = 日志长度，append 一次涨一格）。 */
-let liveSeq = 12
-/** readSession 被真正调用了几次 —— 缓存命中就该一次都不涨。 */
-let reads = 0
-
-const services = {
-  llm: { listProviders: () => [{ id: 'p1', models: [{ id: 'm-fast' }] }] },
-  agentDefaultModel: { currentSelection: () => ({ provider: 'p9', model: 'm-global' }) },
-  sessions: { get: () => ({ header: { cwd: '/fixture' }, seq: liveSeq }) },
-  sessionQuery: {
-    readSurface: async () => ({ events: [] }),
-    readSession: async () => {
-      reads += 1
-      return {
-        events: [
-          { type: 'user/message', data: {} },
-          { type: 'model/selection', data: { provider: 'p1', model: 'm-old' } },
-          { type: 'assistant/message', data: {} },
-          { type: 'model/selection', data: selection },
-        ],
-      }
-    },
-  },
-}
-
-const routes = new Map()
-const ctx = {
-  llm: services.llm,
-  get: (name) => services[name],
-  on: () => () => {},
-  effect: (fn) => fn(),
-  logger: { info() {}, warn() {} },
-  webServer: { register: (route) => { routes.set(route.path, route.handler); return () => routes.delete(route.path) } },
-}
-apply(ctx, {})
-
-const server = createServer((req, res) => {
-  const handler = routes.get(new URL(req.url, 'http://localhost').pathname)
-  if (!handler) { res.writeHead(404); res.end(); return }
-  Promise.resolve(handler(req, res)).catch((error) => {
-    console.error(error)
-    if (!res.headersSent) res.writeHead(500)
-    res.end()
-  })
-})
-await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
-const origin = 'http://127.0.0.1:' + server.address().port
-
-let passed = 0
-let failed = 0
-function check(label, ok, detail) {
-  if (ok) { passed += 1; console.log(`PASS  ${label}${detail ? ' — ' + detail : ''}`) }
-  else { failed += 1; console.log(`FAIL  ${label}${detail ? ' — ' + detail : ''}`) }
-}
-const route = async () => (await fetch(`${origin}/selection-explain/api/route?sessionId=session-1`)).json()
-const models = async () => (await fetch(`${origin}/selection-explain/api/models?sessionId=session-1`)).json()
-
-try {
-  // ① 第一次：真读一次
-  const first = await route()
-  check('第一次 /route 真读会话，拿到本会话的模型',
-    first.ok === true && first.model === 'm-fast' && reads === 1,
-    `model=${first.model} reads=${reads}`)
-
-  // ① 事件没涨（seq 不变）→ 命中缓存，一次都不重读
-  const second = await route()
-  const third = await route()
-  check('事件没涨时不重读会话日志（seq 没变 → 结论不可能变）',
-    second.model === 'm-fast' && third.model === 'm-fast' && reads === 1,
-    `reads=${reads}`)
-
-  // ② seq 涨了，但离上次重读太近 → 先扛住（挡住"主会话连续对话时每 2 秒重放一次"）
-  selection = { provider: 'p1', model: 'm-strong' }
-  liveSeq += 1
-  const throttled = await route()
-  check('seq 刚涨、距上次重读不足下限时不重读（防重放风暴）',
-    throttled.model === 'm-fast' && reads === 1,
-    `model=${throttled.model} reads=${reads}`)
-
-  // ② 过了下限 → 重读，跟上新模型
-  await new Promise((resolve) => setTimeout(resolve, 3200))
-  const caught = await route()
-  check('过了最短间隔后重读并跟上新模型',
-    caught.model === 'm-strong' && reads === 2,
-    `model=${caught.model} reads=${reads}`)
-
-  // ③ 用户动作路径不吃缓存：/models 每次都直读（刚换完模型划词不能按旧模型解析）
-  selection = { provider: 'p2', model: 'm-other' }
-  liveSeq += 1
-  const beforeModels = reads
-  await models()
-  await models()
-  check('/models（用户动作路径）每次都直读，不走缓存',
-    reads === beforeModels + 2,
-    `reads=${beforeModels} → ${reads}`)
-
-  // ③ 直读顺手把结论种进缓存（seq 对得上）→ 紧接着的轮询不必再读一遍
-  const seeded = await route()
-  check('直读种进缓存后，轮询不再重复读（seq 对得上就是同一个结论）',
-    seeded.model === 'm-other' && reads === beforeModels + 2,
-    `model=${seeded.model} reads=${reads}`)
-} finally {
-  server.closeAllConnections()
-  await new Promise((resolve) => server.close(resolve))
-  if (previousHome === undefined) delete process.env.DSH_HOME
-  else process.env.DSH_HOME = previousHome
-  await rm(home, { recursive: true, force: true })
-}
-
-console.log(`=== /route 缓存测试结束：${passed} 通过 / ${failed} 失败 ===`)
-if (failed > 0) process.exitCode = 1

package/scripts/test-settings-behavior.mjs

@@ -1,188 +0,0 @@
-/** Exercise setting effects through the real plugin HTTP handlers in disposable storage. */
-import assert from 'node:assert/strict'
-import {createServer} from 'node:http'
-import {mkdtemp, mkdir, readFile, rm, writeFile} from 'node:fs/promises'
-import {tmpdir} from 'node:os'
-import {join} from 'node:path'
-import {apply} from '../lib/index.js'
-
-const home=await mkdtemp(join(tmpdir(),'dsh-settings-behavior-'))
-const oldHome=process.env.DSH_HOME
-process.env.DSH_HOME=home
-await mkdir(join(home,'selection-explain'))
-await writeFile(join(home,'selection-explain/settings.json'),JSON.stringify({values:{maxTokens:1234,temperature:0.4,resultCacheTtlMs:600000,historyMaxEntries:0}}))
-const longSelection='长'.repeat(4500)+'末尾标记'
-await writeFile(join(home,'selection-explain/history.json'),JSON.stringify({entries:[{key:'existing-long',text:longSelection}]}))
-const routes=new Map(), calls=[], executions=[]
-let mode='answer', toolPath='inside.txt', checks=0, serial=0
-const events=[]
-for(let i=1;i<=10;i++){
-  events.push({type:'user/message',data:{role:'user',source:{kind:'user'},content:[{type:'text',text:`Q${String(i).padStart(2,'0')} `+'甲'.repeat(300)}]}})
-  events.push({type:'assistant/message',data:{message:{content:[{type:'text',text:`A${String(i).padStart(2,'0')} `+'乙'.repeat(300)}]}}})
-}
-const llm={listProviders:()=>[{id:'fixture',name:'Fixture'}],listModels:async()=>[{id:'a',name:'A'},{id:'b',name:'B'}],
-  async *stream(options){
-    calls.push(options)
-    if(mode==='timeout'){
-      await new Promise((resolve,reject)=>{
-        if(options.signal.aborted)reject(new DOMException('aborted','AbortError'))
-        else options.signal.addEventListener('abort',()=>reject(new DOMException('aborted','AbortError')),{once:true})
-      })
-    }
-    const tool=mode==='unexpected-tools'?(options.tools?.[0]??{name:'read'}):mode==='unlisted-tool'?{name:'grep'}:options.tools?.[0]
-    // 工具结果消息的 shape 跟运行时版本有关，两种都要认（见下面 textOfBlocks 的注释）
-    const hasResult=options.messages.some(m=>m.role==='tool'||(m.content||[]).some(b=>b.type==='tool-result'))
-    if(tool && (mode==='unexpected-tools' || mode==='unlisted-tool' || mode==='repeat-tools' || mode==='one-tool' && !hasResult)){
-      yield {type:'block-start',index:0,blockType:'tool-call'}
-      yield {type:'tool-call-delta',index:0,id:'call-'+calls.length,name:tool.name,argumentsDelta:JSON.stringify({file_path:toolPath})}
-      yield {type:'block-end',index:0,block:{type:'tool-call',id:'call-'+calls.length,name:tool.name,arguments:JSON.stringify({file_path:toolPath})}}
-      yield {type:'finish',reason:{kind:'tool-calls'}}
-    }else{
-      yield {type:'text-delta',index:0,text:'这是验证设置行为的回答，内容完整。'}
-      yield {type:'finish',reason:{kind:'stop'}}
-    }
-  },
-}
-const registry={schemas:()=>['read','grep','web_search','platform_search'].map(name=>({name,description:name,parameters:{type:'object',properties:{}}})),
-  async execute(input){executions.push(input);return {content:[{type:'text',text:'工具结果'.repeat(400)}],isError:false}}}
-const services={llm,tools:registry,agentDefaultModel:{currentSelection:()=>({provider:'fixture',model:'a'})},sessions:{get:()=>({header:{cwd:'/fixture/project'}})},
-  sessionQuery:{readSurface:async()=>({events}),readSession:async()=>({events:[]})}}
-const ctx={llm,get:name=>services[name],on(){return ()=>{}},effect:fn=>fn(),logger:{info(){},warn(){}},
-  webServer:{register(route){routes.set(route.path,route.handler);return ()=>routes.delete(route.path)}}}
-apply(ctx,{})
-const server=createServer((req,res)=>{
-  const handler=routes.get(new URL(req.url,'http://localhost').pathname)
-  if(!handler){res.writeHead(404);res.end();return}
-  Promise.resolve(handler(req,res)).catch(error=>{console.error(error);if(!res.headersSent)res.writeHead(500);res.end()})
-})
-await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve))
-const origin='http://127.0.0.1:'+server.address().port
-async function json(path,body){const r=await fetch(origin+'/selection-explain/api/'+path,body?{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(body)}:{});return r.json()}
-async function set(values){const result=await json('settings',{values});assert.equal(result.ok,true);assert.deepEqual(result.rejected,[]);return result}
-async function analyze(body={}){
-  const start=calls.length
-  const r=await fetch(origin+'/selection-explain/api/analyze',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({text:'probe-'+(++serial),refresh:true,sessionId:'fixture-session',...body})})
-  const text=await r.text()
-  const chunks=text.split('\n').filter(s=>s.startsWith('data: ')).map(s=>JSON.parse(s.slice(6)))
-  return {status:r.status,text,chunks,calls:calls.slice(start)}
-}
-function check(label,fn){try{fn();checks++;console.log('PASS '+label)}catch(error){console.error('FAIL '+label);throw error}}
-/**
- * 取一段消息里的**全部文本**（含嵌在工具结果里的）。
- *
- * 工具结果消息的 shape 随运行时版本不同，两种都得认：
- *   · `dsh-llm@0.1.7-rc.x`（本机运行时）：`role:'tool'`，`content` 就是 `[{type:'text',…}]`；
- *   · `dsh-llm@0.1.5-rc.3`（`devDependencies` 里那份、也是 peer 范围的下界，**CI 装的就是它**）：
- *     `role:'user'`，`content` 是 `[{type:'tool-result', content:[{type:'text',…}]}]` —— 嵌一层。
- * 只认顶层 `type:'text'` 的话，在 CI 上"工具结果里有没有『已截断』"会**假失败**
- * （v0.8.3 发布时实测踩到：截断标记明明在，只是藏在 tool-result 块里）。
- */
-function textOfBlocks(blocks){return (blocks||[]).flatMap(b=>b.type==='text'?[String(b.text)]:(b.type==='tool-result'?textOfBlocks(b.content):[]))}
-function prompt(call){return (call?.messages||[]).filter(m=>m.role!=='system').flatMap(m=>textOfBlocks(m.content)).join('\n')}
-function background(call){const text=prompt(call);return text.includes('【会话背景】')?text.split('【会话背景】')[1].split('上面是会话背景')[0]:''}
-try{
-  await json('history',{key:'startup',text:'启动时历史设置'})
-  const initialHistory=await json('history')
-  check('首次直接保存历史也读取已持久化的设置',()=>assert.deepEqual(initialHistory.entries.map(e=>e.key),['existing-long']))
-  const loadedLong=await json('history?key=existing-long')
-  check('加载已有长划词历史不会按旧默认截断',()=>assert(loadedLong.entry.text===longSelection,`实际保存 ${loadedLong.entry.text.length} 字，期望 ${longSelection.length} 字`))
-  await json('settings')
-  await set({historyMaxEntries:20})
-  await set({provider:'fixture',model:'b',translationReasoningEffort:'max',reasoningEffort:'low',chatReasoningEffort:'off',tools:false})
-  for(const [label,body,effort] of [['首轮',{stage:'translation'},'max'],['次轮',{stage:'detail'},'low'],['追问',{question:'继续解释'},'off']]){
-    const r=await analyze(body)
-    check(label+'实际采用同一模型与对应思考强度',()=>{assert.equal(r.calls[0].model,'b');assert.equal(r.calls[0].reasoningEffort,effort)})
-  }
-  check('隐藏的输出上限、温度仍进入模型调用',()=>{assert.equal(calls[0].maxTokens,1234);assert.equal(calls[0].temperature,0.4)})
-  await set({maxSelectionChars:20})
-  const over=await analyze({text:'长'.repeat(21)})
-  check('选中文字上限拒绝过长请求',()=>assert.equal(over.status,413))
-  await set({maxSelectionChars:6000})
-  const longer=await analyze({text:'长'.repeat(4500)})
-  check('调高选中文字上限后 host 接受超过旧默认的文字',()=>assert.equal(longer.status,200))
-  await json('history',{key:'saved-long',text:longSelection})
-  const savedLong=await json('history?key=saved-long')
-  check('保存长划词历史保留选中文字及末尾',()=>assert(savedLong.entry.text===longSelection,`实际保存 ${savedLong.entry.text.length} 字，期望 ${longSelection.length} 字`))
-  await set({maxContextChars:200,sessionContext:false})
-  const local=await analyze({context:'局'.repeat(400)})
-  check('局部上下文按上限截断',()=>{assert(prompt(local.calls[0]).includes('局'.repeat(200)));assert(!prompt(local.calls[0]).includes('局'.repeat(201)))})
-  check('关闭会话背景后不注入会话消息',()=>assert.equal(background(local.calls[0]),''))
-  await set({sessionContext:true,sessionContextFastMessages:2,sessionContextMaxMessages:4,sessionContextMaxChars:0})
-  const fast=await analyze({text:'Q09',stage:'translation'})
-  const detail=await analyze({text:'Q09',stage:'detail'})
-  const chat=await analyze({text:'Q09',question:'继续'})
-  const count=r=>(background(r.calls[0]).match(/(?:▶\s*)?(?:用户|助手)：/g)||[]).length
-  check('首轮按设置取两条背景消息',()=>assert.equal(count(fast),2))
-  check('次轮与追问按设置取四条背景消息',()=>{assert.equal(count(detail),4);assert.equal(count(chat),4)})
-  await set({sessionContextMaxChars:1000})
-  const cap=await analyze({text:'Q09',stage:'detail'})
-  check('会话上下文字符上限改变实际注入量',()=>assert(background(cap.calls[0]).length<background(detail.calls[0]).length))
-  await set({quoteContextRounds:0,quoteContextMaxCharsPerTurn:200,quoteContextMaxChars:6000})
-  const quote0=await json('quote-context',{text:'Q05',sessionId:'fixture-session'})
-  await set({quoteContextRounds:2,quoteContextMaxCharsPerTurn:2000})
-  const quote2=await json('quote-context',{text:'Q05',sessionId:'fixture-session'})
-  check('引用上下文轮数控制实际取出的轮数',()=>{assert.equal(quote0.rounds,1);assert.equal(quote2.rounds,5)})
-  check('引用单条消息上限控制长消息裁剪',()=>{assert(quote0.context.length<600);assert(quote2.context.includes('甲'.repeat(300)))})
-  await set({quoteContextMaxChars:600})
-  const quoteCap=await json('quote-context',{text:'Q05',sessionId:'fixture-session'})
-  check('引用总字符上限减少上下文并保留引用',()=>{assert(quoteCap.context.length<quote2.context.length);assert(quoteCap.context.includes('【Q05】'))})
-  await set({tools:true,maxToolRounds:1,toolNames:'read',fallbackToolNames:'web_search',toolReadRoot:'/fixture/project',toolResultMaxChars:200})
-  mode='one-tool'; toolPath='/fixture/project/inside.txt'
-  const tool=await analyze()
-  check('工具允许列表控制提供给模型的工具',()=>assert.deepEqual(tool.calls[0].tools.map(t=>t.name),['read','web_search']))
-  check('工具返回字符上限作用于回灌模型的结果',()=>{const next=prompt(tool.calls[1]);assert(next.includes('已截断'));assert(!next.includes('工具结果'.repeat(60)))})
-  const beforeDenied=executions.length;toolPath='/fixture/outside.txt'
-  const denied=await analyze()
-  check('指定文件目录拒绝目录外调用',()=>{assert.equal(executions.length,beforeDenied);assert(denied.text.includes('越界已拒绝'))})
-  await set({toolReadRoot:''});toolPath='/fixture/outside.txt'
-  const beforeDefault=executions.length;await analyze()
-  check('文件目录留空时按会话工作目录限制',()=>assert.equal(executions.length,beforeDefault))
-  await set({toolReadRoot:'*'});await analyze()
-  check('文件目录星号允许跨目录调用',()=>assert.equal(executions.length,beforeDefault+1))
-  await set({toolNames:'unavailable',fallbackToolNames:'web_search'})
-  const fallback=await analyze()
-  check('首选工具不可用时加入备用搜索工具',()=>assert.deepEqual(fallback.calls[0].tools.map(t=>t.name),['web_search']))
-  await set({tools:false})
-  const noTools=await analyze()
-  check('关闭工具调用后模型拿不到工具',()=>assert.equal(noTools.calls[0].tools,undefined))
-  await set({tools:true,maxToolRounds:0})
-  const zero=await analyze()
-  check('调用轮数为零时不提供工具',()=>assert.equal(zero.calls[0].tools,undefined))
-  await set({maxToolRounds:1});mode='repeat-tools'
-  const beforeRounds=executions.length;await analyze()
-  check('调用轮数为一时只执行一轮工具',()=>assert.equal(executions.length-beforeRounds,1))
-  mode='unexpected-tools'
-  const beforeUnexpected=executions.length;await analyze()
-  check('收尾轮即使返回工具调用也不突破轮数上限',()=>assert.equal(executions.length-beforeUnexpected,1))
-  await set({maxToolRounds:0})
-  const beforeZeroUnexpected=executions.length;await analyze()
-  check('轮数为零时即使返回工具调用也不执行',()=>assert.equal(executions.length,beforeZeroUnexpected))
-  await set({maxToolRounds:1,tools:false})
-  const beforeDisabledUnexpected=executions.length;await analyze()
-  check('关闭工具后即使返回工具调用也不执行',()=>assert.equal(executions.length,beforeDisabledUnexpected))
-  await set({tools:true,toolNames:'read',fallbackToolNames:''});mode='unlisted-tool'
-  const beforeUnlisted=executions.length;await analyze()
-  check('模型返回未允许的工具也不执行',()=>assert.equal(executions.length,beforeUnlisted))
-  mode='answer';await set({tools:false})
-  const cacheText='cache-probe';const first=await analyze({text:cacheText,refresh:false});const second=await analyze({text:cacheText,refresh:false})
-  check('隐藏缓存设置后仍复用相同请求的结果',()=>{assert(first.calls.length>0);assert.equal(second.calls.length,0);assert(second.chunks.some(c=>c.cached===true))})
-  await set({historyMaxEntries:1})
-  await json('history',{key:'one',text:'一',turns:[]});await json('history',{key:'two',text:'二',turns:[]})
-  const history=await json('history')
-  check('历史保留段数实际淘汰旧对话',()=>assert.deepEqual(history.entries.map(e=>e.key),['two']))
-  await set({historyMaxEntries:0});await json('history',{key:'three',text:'三'})
-  const unchangedHistory=await json('history')
-  check('历史上限为零停止新保存并保留已有记录',()=>assert.deepEqual(unchangedHistory.entries.map(e=>e.key),['two']))
-  await set({timeoutMs:5000});mode='timeout'
-  const started=Date.now(), timed=await analyze()
-  check('生成时限实际取消模型流',()=>{assert(timed.chunks.some(c=>c.type==='error'&&c.message.includes('超时')));assert(Date.now()-started>=4900);assert(Date.now()-started<9000)})
-  mode='answer';await set({maxRequestsPerMinute:1})
-  const rate=await analyze()
-  check('每分钟请求上限实际拒绝超限请求',()=>assert.equal(rate.status,429))
-  console.log(`全部 ${checks} 项实际行为验证通过`)
-}finally{
-  server.closeAllConnections();await new Promise(resolve=>server.close(resolve))
-  await new Promise(resolve=>setTimeout(resolve,900))
-  if(oldHome===undefined)delete process.env.DSH_HOME;else process.env.DSH_HOME=oldHome
-  await rm(home,{recursive:true,force:true})
-}

package/scripts/test-settings-host.mjs

@@ -1,48 +0,0 @@
-/** Run client integration against the real plugin in an isolated settings/history directory. */
-import { createServer } from 'node:http'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { spawn } from 'node:child_process'
-import { apply } from '../lib/index.js'
-
-const temp = await mkdtemp(join(tmpdir(), 'dsh-settings-test-'))
-const previous = process.env.DSH_HOME
-process.env.DSH_HOME = temp
-const routes = new Map()
-const llm = {
-  listProviders: () => [{ id: 'fixture', name: 'Fixture' }],
-  listModels: async () => [{ id: 'fixture', name: 'Fixture' }],
-  async *stream() {
-    yield { type: 'text-delta', text: '这是测试模型的回答：所选文字表达了当前上下文中的意思。\n\n具体含义可结合前后文理解。' }
-    yield { type: 'finish', reason: { kind: 'stop' } }
-  },
-}
-const ctx = {
-  llm,
-  get: name => name === 'llm' ? llm : name === 'agentDefaultModel' ? {currentSelection: () => ({provider: 'fixture', model: 'fixture'})} : undefined,
-  on() { return () => {} }, effect(fn) { return fn() }, logger: {info() {}, warn() {}},
-  webServer: { register(route) { routes.set(route.path, route.handler); return () => routes.delete(route.path) } },
-}
-apply(ctx, {})
-const server = createServer((req, res) => {
-  const handler = routes.get(new URL(req.url, 'http://localhost').pathname)
-  if (!handler) { res.writeHead(404); res.end(); return }
-  Promise.resolve(handler(req, res)).catch(error => { console.error(error); if (!res.headersSent) res.writeHead(500); res.end() })
-})
-await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
-try {
-  const origin = 'http://127.0.0.1:' + server.address().port
-  const result = await new Promise(resolve => {
-    const child = spawn(process.execPath, ['scripts/test-client.mjs'], { stdio: 'inherit', env: {...process.env, SEL_ORIGIN: origin, SEL_SETTINGS_ONLY: '1'} })
-    child.on('exit', resolve)
-  })
-  process.exitCode = result ?? 1
-} finally {
-  server.closeAllConnections()
-  await new Promise(resolve => server.close(resolve))
-  // Allow the plugin's debounced writes to complete before removing the fixture.
-  await new Promise(resolve => setTimeout(resolve, 500))
-  if (previous === undefined) delete process.env.DSH_HOME; else process.env.DSH_HOME = previous
-  await rm(temp, {recursive: true, force: true})
-}