memory-eternal 0.9.23 → 0.10.2

package/lib/capture.js

@@ -19,10 +19,114 @@ export const DEDUP_THRESHOLD = 0.62
 /** 参与语义去重的近邻卡片数上限（控制 token）。 */
 export const DEDUP_NEIGHBORS = 8
 
+/**
+ * 蒸馏输出 token 上限的默认值（issue #18）。
+ *
+ * 旧默认 900 与 system prompt 要求的「300-800 字正文」不匹配：中文 800 字本身就逼近 900 token，
+ * 再叠加 JSON 结构开销与超长会话输入，轻易撞上限 → 输出被截断 → 旧代码把它误报成
+ * UNPARSEABLE_OUTPUT，最终落一张 raw 噪声卡。2000 给正文留出余量（仍是单次调用的量级）。
+ */
+export const DEFAULT_CAPTURE_MAX_TOKENS = 2000
+
+/** 蒸馏输出上限的硬顶（与 api.js 的 NUM_RANGE.captureMaxTokens 一致）。 */
+export const MAX_CAPTURE_MAX_TOKENS = 4000
+
 // 沉淀预筛：仅当对话含「可复用」信号时才调用 LLM，避免对纯闲聊/寒暄发起昂贵的 LLM 判定。
 const DURABLE_SIGNALS = /(#{1,3}\s|```|\[\[|\]|\(https?:|\.(md|ts|js|py|json|yml|yaml|sh|sql)\b|`|\b\d{2,}\b|选择|决定|采用|方案|结论|原因|根因|问题|解决|修复|报错|错误|教训|架构|设计|配置|部署|流程|步骤|算法|原理|函数|接口|参数|命令|依赖|版本|坑|踩|优化|性能|数据库|索引|模型|token|推荐|偏好|约定|规范)/
 
-/** 判断一段对话是否值得送 LLM 判定（省 token 的启发式预筛）。 */
+// -- 入料噪声闸门（P0 修复）--------------------------------------------------
+//
+// 背景：turn-stopping 抓的是「本会话新增的 user/assistant 消息」，而 DSH 会把
+// 大量**运行时注入**伪装成 user 消息塞进会话：环境快照、team 广播、teammate 原文、
+// 工具使用说明（`# create-hook`）、文件片段（"g libs."）。旧实现全部当正文喂给模型，
+// 于是待审队列里出现「用户：<system-reminder> You are teammate」这类垃圾卡。
+// 这里只做**机械剥离**，不做价值判断（价值判断仍归模型 + 审核中心）。
+
+/** 运行时注入的段落标记：成对出现，整段剥掉。 */
+const NOISE_BLOCKS = [
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/gi,
+  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/gi,
+  /<system-reminder>[\s\S]*?<\/system-reminder>/gi,
+  /<team-[a-z-]+>[\s\S]*?<\/team-[a-z-]+>/gi,
+  /<teammate[^>]*>[\s\S]*?<\/teammate>/gi,
+  /<agent-message[^>]*>[\s\S]*?<\/agent-message>/gi,
+  /<user-prompt-submit-hook>[\s\S]*?<\/user-prompt-submit-hook>/gi,
+  /<command-[a-z-]+>[\s\S]*?<\/command-[a-z-]+>/gi,
+  /\[Tool use: [^\]]*\]/gi,
+]
+/** 运行时注入的行前缀：整行丢掉。 */
+const NOISE_LINE = /^\s*(相关上下文|Current runtime context|Runtime context|Approval prompts are disabled|DSH file policy|Current DSH file policy|You are a teammate|Team Lead|Teammate |Subagent |Note: the user|系统提示|环境快照)[：:]?/i
+/** 工具/命令使用说明的标题行（`# create-hook`、`## `codex create-hook``）。 */
+const TOOL_DOC_HEADING = /^\s*#{1,4}\s*`?[a-z][a-z0-9-]{2,40}`?\s*$/i
+
+/** 段落级剥离：去掉注入块、注入行、工具说明标题行，并在相邻行间插入换行（保持行结构）。 */
+export function stripRuntimeNoise(text) {
+  let out = String(text || '')
+  // 注入块整段删除（不留新行：相邻两行必须重新贴合，否则会粘出「A用户：B」这种错位文本）
+  for (const re of NOISE_BLOCKS) out = out.replace(re, '')
+  const kept = []
+  for (const line of out.split('\n')) {
+    if (NOISE_LINE.test(line) || TOOL_DOC_HEADING.test(line)) continue
+    kept.push(line)
+  }
+  return kept.join('\n').trim()
+}
+
+/**
+ * 剥掉运行时注入块之后是否**什么都不剩**（最可靠的注入特征：整段就是被标签包起来的注入）。
+ * `[\s\S]*?` 非贪婪匹配，长注入块也能正确剥掉；旧的 `hasUsableContent` 用「≥120 字」近似，
+ * 对长度超过 120 的注入块会失效（例如整段 teammate 原文），这里直接按「剥完是否为空」判定。
+ */
+function isPureInjection(text) {
+  let out = String(text || '')
+  for (const re of NOISE_BLOCKS) out = out.replace(re, '')
+  return out.replace(/[\s\-*_`]+/g, '').length === 0
+}
+
+/**
+ * 判定「这段文本像不像被截断的片段」——用于挡住碎片卡。
+ * 现象来源：DSH 注入的上下文块被从中间切开，得到 `` chema-form` 当 external `` 这种标题。
+ * 保守起见只在**明确可疑**时返回 true：以标点/反引号开头，或以 `、-`、`(`、`/` 等
+ * 明显未完结字符结尾。
+ */
+export function looksTruncated(text) {
+  const t = String(text || '').trim()
+  if (!t) return true
+  if (/^[`'"）)】」》.,，。;；:：\-–—/\\|>]/.test(t)) return true
+  if (/[（(【「《,，、:：;；\-–—/\\|]$/.test(t)) return true
+  return false
+}
+
+/** 过滤掉碎片行与注入行：抽标题 / 摘要前先用一次。 */
+function dropFragmentLines(text) {
+  return String(text || '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l && !looksTruncated(l))
+    .join('\n')
+}
+
+/**
+ * 剥离噪声后的正文是否还够「像一次真实对话」。
+ *
+ * 为什么不用固定 120 字门槛：真实对话常常是短行列表（每行几十字），按「逐行丢碎片 +
+ * 总量 ≥120」会**误杀**这类正常记录（tests/capture-route.test.mjs 的 189 字短行会话就被
+ * 误判过）。这里改成「事实量 + 噪声占比」双判据：
+ *   1. 剥完至少还剩 60 字事实内容（挡住纯注入 / 极短寒暄）；
+ *   2. 剥掉的部分不能超过原文的 85%（挡住「主体都是注入、只带一句人话」的轮次）。
+ * 真实内容被误伤的成本远高于偶尔放进一条噪声（噪声还有审核中心兜底）。
+ */
+export function hasUsableContent(text) {
+  const raw = String(text || '').trim()
+  if (raw.length < 60) return false
+  if (isPureInjection(raw)) return false // 整段都是注入块（无论多长）一律不算内容
+  const stripped = stripRuntimeNoise(raw)
+  if (stripped.length < 60) return false
+  if (raw.length > 120 && stripped.length / raw.length < 0.15) return false
+  return true
+}
+
+/** 判断一段（已剥离噪声的）对话是否值得交 LLM 判定（省 token 的启发式预筛）。 */
 export function looksDurable(text) {
   const t = String(text || '')
   if (t.trim().length < 120) return false
@@ -32,6 +136,42 @@ export function looksDurable(text) {
   return items >= 2 && t.trim().length >= 160
 }
 
+/**
+ * 从正文里取一个「像标题」的片段（降级原文卡 / 无 LLM 场景用）。
+ *
+ * 旧实现是 `text.slice(0, 40)`：一句话被硬切，于是出现 `` chema-form` 当 external ``
+ * 这种从半截开始的标题，审核中心根本没法判断（P0 修复）。这里：
+ * 1. 取第一行非碎片文本；2. 去掉 `用户：` / `助手：` 说话人前缀与 markdown 记号；
+ * 3. 优先在首个句读（。！？；!?;）处断句；4. 仍以 `、和/` 这类连接性字符结尾就再截一点。
+ */
+export function deriveTitle(text, maxLen = 60) {
+  const lines = dropFragmentLines(text).split('\n')
+  const firstLine = lines[0] || String(text || '').trim()
+  let t = cleanTitleLine(firstLine)
+  // 首行是 "# T" 这种过短的装饰性标题时，往后找第一句真正像标题的话（上限 5 行，避免扫全文）。
+  if (!isUsableTitle(t)) {
+    for (const line of lines.slice(1, 6)) {
+      const cand = cleanTitleLine(line)
+      if (isUsableTitle(cand)) { t = cand; break }
+    }
+  }
+  if (!t) return ''
+  const cut = t.search(/[。！？；!?;]/)
+  if (cut >= 4) t = t.slice(0, cut)
+  if (t.length > maxLen) t = t.slice(0, maxLen)
+  t = t.replace(/[、,，和与\/\\\-–—:：]+$/, '').trim()
+  return t
+}
+
+/** 单行清洗：去说话人前缀、markdown 记号、压缩空白。 */
+function cleanTitleLine(line) {
+  return String(line || '')
+    .replace(/^(用户|助手|user|assistant)\s*[:：]\s*/i, '')
+    .replace(/^[#>\-*\s]+/, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
 /**
  * 用当前模型把一段对话压缩成知识卡（或判定不值得保存 / 应追加到已有卡）。
  * @param llm - dsh 的 llm 服务（ctx.get('llm')）
@@ -57,6 +197,7 @@ export async function summarizeTurn(llm, route, conversation, opts = {}) {
 export async function summarizeTurnDetailed(llm, route, conversation, opts = {}) {
   const text = String(conversation || '').trim()
   if (text.length < 120) return { skip: 'too-short' } // 太短，没有沉淀价值
+  if (!hasUsableContent(text)) return { skip: 'noisy' } // 剥离注入噪声后没剩多少真实内容（P0 噪声闸门）
   if (!looksDurable(text)) return { skip: 'not-durable' } // 启发式预筛：无可复用信号则跳过 LLM 判定（省 token）
 
   const existing = Array.isArray(opts.existing) ? opts.existing.slice(0, DEDUP_NEIGHBORS) : []
@@ -89,13 +230,17 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
     source: { kind: 'plugin', plugin: 'memory-eternal' },
   })]
 
+  const maxTokens = opts.maxTokens ?? DEFAULT_CAPTURE_MAX_TOKENS
+  // #15：route.reasoningEffort === null 表示该 provider 明确声明不支持 reasoning effort，
+  // 此时**不传**这个字段（传了会被 LLM 层硬校验拒绝，等于每次沉淀先白烧一次调用）。
+  const effort = route.reasoningEffort === undefined ? 'off' : route.reasoningEffort
   const options = {
     provider: route.provider,
     model: route.model,
     messages,
     system,
-    maxTokens: opts.maxTokens ?? 900,
-    reasoningEffort: 'off',
+    maxTokens,
+    ...(effort ? { reasoningEffort: effort } : {}),
     purpose: 'memory-capture',
     signal: opts.signal ?? AbortSignal.timeout(45000),
   }
@@ -111,10 +256,24 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
       },
     }
   }
+  // #18 根因 1：撞到输出上限时 finish.kind === 'max-tokens'（dsh-llm 的 FinishReasonMap）。
+  // 旧实现只认 error/aborted，于是截断的 JSON 一路落到 parseCaptureJson 上被误报成
+  // UNPARSEABLE_OUTPUT —— 真实原因（输出被截断）被完全掩盖。这里给独立错误码。
+  if (finish.kind === 'max-tokens') {
+    return {
+      failure: {
+        code: 'MAX_TOKENS',
+        message: `输出撞到 maxTokens=${maxTokens} 上限被截断（不是解析失败）：调大「蒸馏输出上限」captureMaxTokens，或缩短会话输入`,
+      },
+    }
+  }
   const out = assembler.blocks().filter((b) => b.type === 'text').map((b) => b.text).join('').trim()
   const parsed = parseCaptureJson(out)
   if (!parsed) {
-    return { failure: { code: 'UNPARSEABLE_OUTPUT', message: out ? '模型输出无法解析为 JSON：' + out.slice(0, 160) : '模型返回空文本' } }
+    const why = out ? '模型输出无法解析为 JSON' : '模型返回空文本'
+    // 括号没闭合 = 截断的强特征：即便宿主没给 max-tokens finish，也把方向指对（#18 建议 1）
+    const hint = out && looksTruncatedJson(out) ? '（JSON 括号未闭合，疑似输出被截断）' : ''
+    return { failure: { code: 'UNPARSEABLE_OUTPUT', message: why + hint + (out ? '：' + out.slice(0, 160) : '') } }
   }
   return { card: parsed }
 }
@@ -186,6 +345,30 @@ async function importLlmHelpers() {
   }
 }
 
+/**
+ * 判断一段文本的 JSON 结构是否**没闭合**（截断的强特征，issue #18 建议 1）。
+ * 只做括号/引号配对扫描，不解析；用于把「疑似被截断」和「模型乱输出」区分开。
+ */
+export function looksTruncatedJson(text) {
+  const s = String(text || '').trim()
+  if (!s) return false
+  let depth = 0
+  let inStr = false
+  let esc = false
+  for (const ch of s) {
+    if (inStr) {
+      if (esc) esc = false
+      else if (ch === '\\') esc = true
+      else if (ch === '"') inStr = false
+      continue
+    }
+    if (ch === '"') inStr = true
+    else if (ch === '{' || ch === '[') depth++
+    else if (ch === '}' || ch === ']') depth--
+  }
+  return depth > 0 || inStr
+}
+
 export function parseCaptureJson(text) {
   if (!text) return null
   // 去掉可能的 ```json 围栏
@@ -215,6 +398,26 @@ export function parseCaptureJson(text) {
   const title = String(parsed.title || '').trim().slice(0, 80)
   const body = String(parsed.body || '').trim()
   if (!title || body.length < 20) return null
+  // 标题体检（P0 噪声闸门）：标题必须是「像标题」的一句话（去掉标点后 ≥4 字、不以标点/反引号开头、
+  // 不被截断）。糊掉的标题会让审核中心无法判断，也会在召回结果里变成噪声。
+  // 但**不放行垃圾标题、也不吞掉正文**：标题不合格时从正文首行派生一个，派生不出来才算无效。
+  if (!isUsableTitle(title)) {
+    const derived = deriveTitle(body)
+    if (!isUsableTitle(derived)) return null
+    return finishCard(parsed, derived, body)
+  }
+  return finishCard(parsed, title, body)
+}
+
+/** 标题是否「像标题」：≥4 个字母/数字字符，且不是碎片（错位开头 / 未完结结尾）。 */
+export function isUsableTitle(title) {
+  const t = String(title || '').trim()
+  if (!t || looksTruncated(t)) return false
+  return t.replace(/[^\p{L}\p{N}]/gu, '').length >= 4
+}
+
+/** 组装最终卡片对象（标题已体检通过）。 */
+function finishCard(parsed, title, body) {
   const kind = ['project', 'knowledge', 'content', 'prompt', 'business', 'tool', 'mistake'].includes(parsed.kind) ? parsed.kind : 'knowledge'
   const tags = Array.isArray(parsed.tags)
     ? parsed.tags.map((t) => String(t).trim().slice(0, 30)).filter(Boolean).slice(0, 8)
@@ -222,20 +425,30 @@ export function parseCaptureJson(text) {
   return { save: true, title, kind, tags, body }
 }
 
-/** 从会话事件里提取「增量片段」的可读对话文本（用户 + 助手）。 */
+/**
+ * 从会话事件里提取「增量片段」的可读对话文本（用户 + 助手）。
+ *
+ * 每条消息先过 `stripRuntimeNoise`：DSH 注入的环境快照 / team 广播 / teammate 原文 /
+ * 工具说明都不是用户的真实表达，混进来会变成垃圾卡（P0 修复）。剥离后为空的消息直接丢。
+ */
 export function extractLastTurn(events, _turn) {
   const lines = []
+  const push = (role, raw) => {
+    const text = stripRuntimeNoise(raw)
+    if (!text) return
+    lines.push(`${role}：${text}`)
+  }
   const pushMessage = (event) => {
     const data = event.data || event
     const message = data.message || data
-    const role = message.role
+    const role = message.role === 'user' ? '用户' : '助手'
     const content = message.content
     if (Array.isArray(content)) {
       for (const block of content) {
-        if (block.type === 'text' && block.text) lines.push(`${role === 'user' ? '用户' : '助手'}：${block.text}`)
+        if (block.type === 'text' && block.text) push(role, block.text)
       }
     } else if (typeof content === 'string' && content) {
-      lines.push(`${role === 'user' ? '用户' : '助手'}：${content}`)
+      push(role, content)
     }
   }
   for (const event of events) {
@@ -247,10 +460,10 @@ export function extractLastTurn(events, _turn) {
       if (type === 'assistant/message') pushMessage(data)
       else if (data.chunk?.content) {
         const content = data.chunk.content
-        if (typeof content === 'string') lines.push(`助手：${content}`)
+        if (typeof content === 'string') push('助手', content)
         else if (Array.isArray(content)) {
           for (const block of content) {
-            if (block.type === 'text' && block.text) lines.push(`助手：${block.text}`)
+            if (block.type === 'text' && block.text) push('助手', block.text)
           }
         }
       }
@@ -371,25 +584,76 @@ export async function routeCandidates(llm, opts = {}) {
   try {
     const providers = llm.listProviders() || []
     if (!providers.length) return out
+    // 候选按「能力」排序：明确不支持 reasoning effort 的往后放（#15 问题 2）。
+    // 注意**不删除**它们 —— 不传 reasoningEffort 之后它们完全可能正常出卡，
+    // 而删掉它们会让「候选全不支持」的机器直接没有兜底（见 #15 的实测：四个网关全不支持）。
+    const push = (provider, model, modelInfo) => {
+      if (!provider || !provider.id || !model) return
+      if (out.some((r) => r.provider === provider.id)) return
+      const entry = { provider: provider.id, model }
+      if (!supportsReasoningEffort(provider, modelInfo)) entry.reasoningEffort = null
+      out.push(entry)
+    }
+    const modelsOf = async (id) => {
+      const list = await llm.listModels(id)
+      return Array.isArray(list) ? list : []
+    }
     if (want) {
       const hit = providers.find((p) => p && p.id === want)
       if (hit) {
-        const models = (await llm.listModels(hit.id)) || []
+        const models = await modelsOf(hit.id)
         const model = wantModel || (models[0] && models[0].id)
-        if (model) out.push({ provider: hit.id, model })
+        push(hit, model, models.find((m) => m && m.id === model) || null)
       }
     }
+    const rest = []
     for (const p of providers) {
       if (!p || !p.id || out.some((r) => r.provider === p.id)) continue
-      const models = (await llm.listModels(p.id)) || []
+      const models = await modelsOf(p.id)
       const model = (p.id === want && wantModel) || (models[0] && models[0].id)
-      if (model) out.push({ provider: p.id, model })
+      if (!model) continue
+      rest.push({ p, model, info: models.find((m) => m && m.id === model) || null })
+    }
+    // Array.prototype.sort 是稳定的：能力相同的候选保持原有的「注册顺序」语义
+    rest.sort((a, b) => Number(!supportsReasoningEffort(a.p, a.info)) - Number(!supportsReasoningEffort(b.p, b.info)))
+    for (const r of rest) {
       if (out.length >= limit) break
+      push(r.p, r.model, r.info)
     }
   } catch { /* 路由解析失败按空列表返回，由调用方兜底 */ }
   return out
 }
 
+/**
+ * 该 provider/model 是否**明确声明**不支持 reasoning effort（#15 问题 2）。
+ *
+ * DSH 的 LLM 层会按 provider 声明的能力硬校验：声明不支持时，请求里带上
+ * reasoningEffort 会在发出前/发出时以 UNSUPPORTED_REASONING_EFFORT 失败。
+ * 声明位置随版本而异（provider.compat / provider.capabilities / 模型条目的 reasoning），
+ * 这里全部读一遍；**未知一律按「支持」处理**，避免把能力推断错成功能退化。
+ *
+ * @param {object|null} providerInfo llm.listProviders() 的条目
+ * @param {object|null} [modelInfo]  llm.listModels() 的对应条目
+ * @returns {boolean}
+ */
+export function supportsReasoningEffort(providerInfo, modelInfo = null) {
+  const flag = (o) => {
+    if (!o || typeof o !== 'object') return undefined
+    if (typeof o.supportsReasoningEffort === 'boolean') return o.supportsReasoningEffort
+    if (o.compat && typeof o.compat.supportsReasoningEffort === 'boolean') return o.compat.supportsReasoningEffort
+    if (o.capabilities && typeof o.capabilities.supportsReasoningEffort === 'boolean') return o.capabilities.supportsReasoningEffort
+    return undefined
+  }
+  const fromProvider = flag(providerInfo)
+  if (fromProvider === false) return false
+  const fromModel = flag(modelInfo)
+  if (fromModel === false) return false
+  // 模型条目自带 reasoning 能力表且**为空** → 该模型没有可选 effort，等于不支持
+  const reasoning = modelInfo && modelInfo.reasoning
+  if (reasoning && Array.isArray(reasoning.efforts) && reasoning.efforts.length === 0) return false
+  return true
+}
+
 /** 解析当前模型路由：显式配置优先，其次第一个 provider 的首个模型（保持旧行为作兜底）。 */
 export async function resolveRoute(llm, opts = {}) {
   const list = await routeCandidates(llm, opts)