memory-eternal 0.9.23 → 0.10.0

package/lib/capture-run.js

@@ -1,126 +1,134 @@
-// 记忆核心 · 独立进程沉淀管线（MCP / CLI / hooks 共用）。
-//
-// 复刻 index.js runCapture 的判定链（预筛→配额→LLM 蒸馏→新建/追加→词法兜底），
-// 但 LLM 来源是 lib/llm-openai.js 的 OpenAI 兼容适配器而非 DSH llm 服务。
-// 未配置 LLM 时降级：跳过蒸馏，直接把原文写成一张卡（kind/tool 或调用方指定），
-// 保证「无 LLM 环境也能沉淀，只是不压缩」。
-
-import path from 'node:path'
-import os from 'node:os'
-import fs from 'node:fs'
-import { captureCard, captureUpdate, pickNeighbors, summarizeTurnDetailed, routeCandidates } from './capture.js'
-import { resolveVaultDir, defaultVaultRoot } from './vault-resolve.js'
-import { createLlmFromEnv } from './llm-openai.js'
-
-/**
- * 解析当前 vault 目录。
- *
- * 优先级必须与宿主 index.js 的 vaultDir() **完全一致**：
- *   MEMORY_VAULT_DIR → activeVault 命中 vaultProfiles → vaultDir → 默认 ~/.dsh/memory-vault。
- * 旧实现只认 MEMORY_VAULT_DIR / 默认路径，于是用户在宿主里切库后，CLI / MCP / hooks /
- * 独立 web / sweep 仍然写默认库 —— 同一台机器上记忆被劈成两份（dsh-memory-eternal#5）。
- *
- * @param {NodeJS.ProcessEnv} [env]
- * @returns {string} 绝对路径
- */
-export function defaultVaultDir(env = process.env) {
-  if (env.MEMORY_VAULT_DIR && env.MEMORY_VAULT_DIR.trim()) return path.resolve(env.MEMORY_VAULT_DIR.trim())
-  try {
-    const cfg = readConfig(env) || {}
-    // 与宿主共用同一套解析（含 match.workspace 的按项目选库）
-    return resolveVaultDir({
-      env,
-      profiles: cfg.vaultProfiles,
-      activeVault: cfg.activeVault,
-      configured: cfg.vaultDir,
-    }).root
-  } catch { /* 读不到共享配置就回落默认库 */ }
-  return defaultVaultRoot(env)
-}
-
-// 读取 DSH 设置的完整配置（写入的共享文件），使独立 web / MCP hook 捕获与 DSH 设置同步。
-const CONFIG_FILE = 'memory-eternal-config.json'
-export function configFilePath(env = process.env) {
-  return path.join(env.DSH_HOME || path.join(os.homedir(), '.dsh'), CONFIG_FILE)
-}
-function readConfig(env = process.env) {
-  try {
-    return JSON.parse(fs.readFileSync(configFilePath(env), 'utf8'))
-  } catch { return null }
-}
-function splitList(x) { return (Array.isArray(x) ? x : String(x || '').split(',')).map((s) => String(s).trim()).filter(Boolean) }
-
-/**
- * 沉淀一段对话文本到 vault。
- * @returns {Promise<{ok:boolean, action:'created'|'appended'|'skipped'|'failed', path?:string, reason?:string, degraded?:boolean}>}
- */
-export async function runStandaloneCapture(vaultRoot, text, { source = '', llm, env = process.env, minChars = 120 } = {}) {
-  const clean = String(text || '').trim()
-  if (clean.length < minChars) return { ok: false, action: 'skipped', reason: 'text too short' }
-
-  // 自动审核：共享配置文件(DSH)优先，其次 env，默认 all（独立进程无 DSH settings）
-  const resolveAuditStatus = (kind, sub) => {
-    const shared = readConfig(env)
-    const mode = shared?.auditMode || env.MEMORY_AUDIT_MODE || 'all'
-    const agents = shared?.auditExemptAgents ? splitList(shared.auditExemptAgents) : splitList(env.MEMORY_AUDIT_EXEMPT_AGENTS || '')
-    const kinds = shared?.auditExemptKinds ? splitList(shared.auditExemptKinds) : splitList(env.MEMORY_AUDIT_EXEMPT_KINDS || '')
-    if (mode === 'none') return 'approved'
-    if (agents.includes('__all__') || agents.includes(sub)) return 'approved'
-    if (kinds.includes('__all__') || kinds.includes(kind)) return 'approved'
-    return 'pending'
-  }
-
-  const llmClient = llm ?? createLlmFromEnv(env)
-  // 与宿主同样的候选路由：显式配置优先，其余按注册顺序兜底（别写死 providers[0]，见 issue #3）
-  const routes = llmClient ? await routeCandidates(llmClient, { provider: shared?.captureProvider, model: shared?.captureModel }) : []
-  const route = routes[0] ?? null
-
-  // 有 LLM：蒸馏判定链（与 DSH 侧一致）
-  if (llmClient && route) {
-    try {
-      const neighbors = await pickNeighbors(vaultRoot, { title: '', body: clean.slice(0, 400) }, 8)
-      const detailed = await summarizeTurnDetailed(llmClient, route, clean, { existing: neighbors, signal: AbortSignal.timeout(45000) })
-      const result = detailed.card
-      // 独立进程也必须把真实失败暴露出来（走 stderr），别再静默降级成「无输出」
-      if (detailed.failure) {
-        process.stderr.write(`[memory-eternal] 蒸馏失败（${route.provider}/${route.model}）：${detailed.failure.code} ${detailed.failure.message}\n`)
-      }
-      if (result && result.save === true) {
-        if (result.append_to) {
-          await captureUpdate(vaultRoot, result.append_to, result.update, { threshold: 0.62 })
-          return { ok: true, action: 'appended', path: result.append_to }
-        }
-        const card = { kind: result.kind, title: result.title, tags: result.tags, body: result.body, source, status: resolveAuditStatus(result.kind, source || 'agent'), submittedBy: source || 'agent', severity: 'info', reason: 'AI 自动沉淀（蒸馏卡）' }
-        const out = await captureCard(vaultRoot, card, { threshold: 0.62 })
-        if (out.ok) return { ok: true, action: 'created', path: out.path ?? out.rel }
-        if (out.duplicate) {
-          await captureUpdate(vaultRoot, out.duplicate.path, `${result.title}：${result.body.slice(0, 400)}`, { threshold: 0.62 })
-          return { ok: true, action: 'appended', path: out.duplicate.path }
-        }
-        return { ok: false, action: 'failed', reason: String(out.reason || 'write failed') }
-      }
-      if (result && result.save === false) return { ok: true, action: 'skipped', reason: 'model judged not durable' }
-    } catch (error) {
-      // LLM 失败 → 落入降级路径，不能让一次网络抖动丢掉沉淀
-    }
-  }
-
-  // 降级：无 LLM（或 LLM 调用失败）→ 原文卡（kind 默认 content，dedup 开）
-  const out = await captureCard(vaultRoot, {
-    kind: 'content',
-    title: clean.replace(/\s+/g, ' ').slice(0, 40) || '未命名记录',
-    tags: ['raw'],
-    body: clean,
-    source: source || 'manual',
-    status: resolveAuditStatus('content', source || 'agent'),
-    submittedBy: source || 'agent',
-    severity: 'info',
-    reason: 'AI 自动沉淀（原文卡）',
-  }, { threshold: 0.62 })
-  if (out.ok) return { ok: true, action: 'created', path: out.path ?? out.rel, degraded: true }
-  if (out.duplicate) {
-    await captureUpdate(vaultRoot, out.duplicate.path, clean.slice(0, 400), { threshold: 0.62 })
-    return { ok: true, action: 'appended', path: out.duplicate.path, degraded: true }
-  }
-  return { ok: false, action: 'failed', reason: String(out.reason || 'write failed') }
-}
+// 记忆核心 · 独立进程沉淀管线（MCP / CLI / hooks 共用）。
+//
+// 复刻 index.js runCapture 的判定链（预筛→配额→LLM 蒸馏→新建/追加→词法兜底），
+// 但 LLM 来源是 lib/llm-openai.js 的 OpenAI 兼容适配器而非 DSH llm 服务。
+// 未配置 LLM 时降级：跳过蒸馏，直接把原文写成一张卡（kind/tool 或调用方指定），
+// 保证「无 LLM 环境也能沉淀，只是不压缩」。
+
+import path from 'node:path'
+import os from 'node:os'
+import fs from 'node:fs'
+import { captureCard, captureUpdate, pickNeighbors, summarizeTurnDetailed, routeCandidates, stripRuntimeNoise, hasUsableContent, deriveTitle, isUsableTitle } from './capture.js'
+import { resolveVaultDir, defaultVaultRoot } from './vault-resolve.js'
+import { createLlmFromEnv } from './llm-openai.js'
+
+/**
+ * 解析当前 vault 目录。
+ *
+ * 优先级必须与宿主 index.js 的 vaultDir() **完全一致**：
+ *   MEMORY_VAULT_DIR → activeVault 命中 vaultProfiles → vaultDir → 默认 ~/.dsh/memory-vault。
+ * 旧实现只认 MEMORY_VAULT_DIR / 默认路径，于是用户在宿主里切库后，CLI / MCP / hooks /
+ * 独立 web / sweep 仍然写默认库 —— 同一台机器上记忆被劈成两份（dsh-memory-eternal#5）。
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string} 绝对路径
+ */
+export function defaultVaultDir(env = process.env) {
+  if (env.MEMORY_VAULT_DIR && env.MEMORY_VAULT_DIR.trim()) return path.resolve(env.MEMORY_VAULT_DIR.trim())
+  try {
+    const cfg = readConfig(env) || {}
+    // 与宿主共用同一套解析（含 match.workspace 的按项目选库）
+    return resolveVaultDir({
+      env,
+      profiles: cfg.vaultProfiles,
+      activeVault: cfg.activeVault,
+      configured: cfg.vaultDir,
+    }).root
+  } catch { /* 读不到共享配置就回落默认库 */ }
+  return defaultVaultRoot(env)
+}
+
+// 读取 DSH 设置的完整配置（写入的共享文件），使独立 web / MCP hook 捕获与 DSH 设置同步。
+const CONFIG_FILE = 'memory-eternal-config.json'
+export function configFilePath(env = process.env) {
+  return path.join(env.DSH_HOME || path.join(os.homedir(), '.dsh'), CONFIG_FILE)
+}
+function readConfig(env = process.env) {
+  try {
+    return JSON.parse(fs.readFileSync(configFilePath(env), 'utf8'))
+  } catch { return null }
+}
+function splitList(x) { return (Array.isArray(x) ? x : String(x || '').split(',')).map((s) => String(s).trim()).filter(Boolean) }
+
+/**
+ * 沉淀一段对话文本到 vault。
+ * @returns {Promise<{ok:boolean, action:'created'|'appended'|'skipped'|'failed', path?:string, reason?:string, degraded?:boolean}>}
+ */
+export async function runStandaloneCapture(vaultRoot, text, { source = '', llm, env = process.env, minChars = 120 } = {}) {
+  // 入料噪声闸门（P0）：先剥运行时注入（环境快照 / team 广播 / teammate 原文 / 工具说明），
+  // 再判断是否还有真实内容。此处是 MCP memory_capture / CLI / hooks 的共同入口。
+  const clean = stripRuntimeNoise(text)
+  if (clean.length < minChars) return { ok: false, action: 'skipped', reason: 'text too short' }
+  if (!hasUsableContent(clean)) return { ok: false, action: 'skipped', reason: 'text is runtime noise' }
+  const title = deriveTitle(clean)
+  if (!isUsableTitle(title)) return { ok: false, action: 'skipped', reason: 'cannot derive a usable title' }
+
+  // 自动审核：共享配置文件(DSH)优先，其次 env，默认 all（独立进程无 DSH settings）
+  // 注：`shared` 原先在回调里局部读取，第 80 行的路由兜底却引用了外层同名变量 → ReferenceError
+  // 被下面的 try/catch 静默吞掉，导致 captureProvider/captureModel 在本进程从不生效。这里提到函数级。
+  const shared = readConfig(env)
+  const resolveAuditStatus = (kind, sub) => {
+    const mode = shared?.auditMode || env.MEMORY_AUDIT_MODE || 'all'
+    const agents = shared?.auditExemptAgents ? splitList(shared.auditExemptAgents) : splitList(env.MEMORY_AUDIT_EXEMPT_AGENTS || '')
+    const kinds = shared?.auditExemptKinds ? splitList(shared.auditExemptKinds) : splitList(env.MEMORY_AUDIT_EXEMPT_KINDS || '')
+    if (mode === 'none') return 'approved'
+    if (agents.includes('__all__') || agents.includes(sub)) return 'approved'
+    if (kinds.includes('__all__') || kinds.includes(kind)) return 'approved'
+    return 'pending'
+  }
+
+  const llmClient = llm ?? createLlmFromEnv(env)
+  // 与宿主同样的候选路由：显式配置优先，其余按注册顺序兜底（别写死 providers[0]，见 issue #3）
+  const routes = llmClient ? await routeCandidates(llmClient, { provider: shared?.captureProvider, model: shared?.captureModel }) : []
+  const route = routes[0] ?? null
+
+  // 有 LLM：蒸馏判定链（与 DSH 侧一致）
+  if (llmClient && route) {
+    try {
+      const neighbors = await pickNeighbors(vaultRoot, { title: '', body: clean.slice(0, 400) }, 8)
+      const detailed = await summarizeTurnDetailed(llmClient, route, clean, { existing: neighbors, signal: AbortSignal.timeout(45000) })
+      const result = detailed.card
+      // 独立进程也必须把真实失败暴露出来（走 stderr），别再静默降级成「无输出」
+      if (detailed.failure) {
+        process.stderr.write(`[memory-eternal] 蒸馏失败（${route.provider}/${route.model}）：${detailed.failure.code} ${detailed.failure.message}\n`)
+      }
+      if (result && result.save === true) {
+        if (result.append_to) {
+          await captureUpdate(vaultRoot, result.append_to, result.update, { threshold: 0.62 })
+          return { ok: true, action: 'appended', path: result.append_to }
+        }
+        const card = { kind: result.kind, title: result.title, tags: result.tags, body: result.body, source, status: resolveAuditStatus(result.kind, source || 'agent'), submittedBy: source || 'agent', severity: 'info', reason: 'AI 自动沉淀（蒸馏卡）' }
+        const out = await captureCard(vaultRoot, card, { threshold: 0.62 })
+        if (out.ok) return { ok: true, action: 'created', path: out.path ?? out.rel }
+        if (out.duplicate) {
+          await captureUpdate(vaultRoot, out.duplicate.path, `${result.title}：${result.body.slice(0, 400)}`, { threshold: 0.62 })
+          return { ok: true, action: 'appended', path: out.duplicate.path }
+        }
+        return { ok: false, action: 'failed', reason: String(out.reason || 'write failed') }
+      }
+      if (result && result.save === false) return { ok: true, action: 'skipped', reason: 'model judged not durable' }
+    } catch (error) {
+      // LLM 失败 → 落入降级路径，不能让一次网络抖动丢掉沉淀
+    }
+  }
+
+  // 降级：无 LLM（或 LLM 调用失败）→ 原文卡（kind 默认 content，dedup 开）
+  // 标题用 deriveTitle 派生（不再 slice 硬切）；正文用剥离噪声后的 clean。
+  const out = await captureCard(vaultRoot, {
+    kind: 'content',
+    title,
+    tags: ['raw'],
+    body: clean,
+    source: source || 'manual',
+    status: resolveAuditStatus('content', source || 'agent'),
+    submittedBy: source || 'agent',
+    severity: 'info',
+    reason: 'AI 自动沉淀（原文卡）',
+  }, { threshold: 0.62 })
+  if (out.ok) return { ok: true, action: 'created', path: out.path ?? out.rel, degraded: true }
+  if (out.duplicate) {
+    await captureUpdate(vaultRoot, out.duplicate.path, clean.slice(0, 400), { threshold: 0.62 })
+    return { ok: true, action: 'appended', path: out.duplicate.path, degraded: true }
+  }
+  return { ok: false, action: 'failed', reason: String(out.reason || 'write failed') }
+}

package/lib/capture.js

@@ -22,7 +22,99 @@ export const DEDUP_NEIGHBORS = 8
 // 沉淀预筛：仅当对话含「可复用」信号时才调用 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 +124,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 +185,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) : []
@@ -215,6 +344,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 +371,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 +406,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)
           }
         }
       }