@yolk_vat-y/dsh-project-memory 0.5.3 → 0.5.5

package/src/doc-index.js

@@ -0,0 +1,71 @@
+// 文档索引的结构化词项（纯规则、确定性；索引期不调用任何模型）。
+//
+// 动机：检索只吃 title/keywords/summary/sourcePath（util/search.js 的 weightedFieldText），
+// 而 summary 为了注入预算被压到 300 字符 —— 一个 3000 字符的 chunk 有九成内容检索不到。
+// 这里把「注入用的短摘要」和「检索用的词项」拆开：summary 仍然短，terms 覆盖整个 chunk。
+//
+// 纯规则、确定性、可重放：tokenizeRaw（拉丁词 + CJK bigram）→ 去停用词/纯数字 → 词频排序 → 截断。
+import { tokenizeRaw } from './util/search.js'
+
+export const MAX_TERMS = 160
+export const MAX_KEYWORDS = 8
+
+const STOPWORDS = new Set([
+  'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'any', 'can', 'had', 'her', 'was', 'one',
+  'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'its', 'new', 'now', 'old', 'see', 'two',
+  'way', 'who', 'boy', 'did', 'use', 'that', 'this', 'with', 'from', 'they', 'will', 'would', 'there',
+  'their', 'what', 'about', 'which', 'when', 'make', 'like', 'time', 'just', 'know', 'take', 'into',
+  'your', 'some', 'them', 'than', 'then', 'only', 'come', 'over', 'also', 'back', 'after', 'other',
+  'many', 'most', 'such', 'even', 'much', 'more', 'been', 'were', 'have', 'each', 'does', 'doing',
+  'should', 'could', 'these', 'those', 'being', 'where', 'while', 'because', 'before', 'between',
+  'under', 'again', 'further', 'once', 'here', 'both', 'few', 'same', 'too', 'very', 'own', 'off',
+  'per', 'via', 'etc', 'see', 'note', 'used', 'using', 'uses', 'may', 'must', 'shall',
+])
+
+/** 一个 token 是否值得作为检索词项。 */
+function isUseful(token) {
+  if (token.length < 2) return false
+  if (STOPWORDS.has(token)) return false
+  if (/^\d+$/.test(token)) return false
+  return true
+}
+
+/**
+ * 整个 chunk 的字面词项（唯一、按词频排序、有上限）。
+ * @returns {string[]} 词项数组（已去重）
+ */
+export function extractTerms(text, { max = MAX_TERMS } = {}) {
+  const counts = new Map()
+  for (const token of tokenizeRaw(text)) {
+    if (!isUseful(token)) continue
+    counts.set(token, (counts.get(token) || 0) + 1)
+  }
+  return [...counts.entries()]
+    .sort((a, b) => b[1] - a[1] || b[0].length - a[0].length || a[0].localeCompare(b[0]))
+    .slice(0, max)
+    .map(([token]) => token)
+}
+
+/**
+ * 结构化的检索词项串（用于 entry.terms，并入 BM25 的检索文本）。
+ */
+export function extractTermText(text, { max = MAX_TERMS } = {}) {
+  return extractTerms(text, { max }).join(' ')
+}
+
+/**
+ * 规则化关键词：标题重复一次以取得小幅加权（替代此前依赖 LLM 的 5–10 个关键词）。
+ */
+export function extractKeywords(title, text, { max = MAX_KEYWORDS } = {}) {
+  const source = title ? `${title} ${title} ${text}` : text
+  return extractTerms(source, { max })
+}
+
+/**
+ * 旧 store 的 doc 条目没有 `terms`：需要一次定向回填，否则内容哈希未变的文件会被跳过，
+ * 新的检索覆盖不会生效。只对 doc 条目判断，code 条目（符号表）不需要 terms。
+ */
+export function docEntriesNeedBackfill(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return true
+  return entries.some((e) => e && e.type === 'doc' && typeof e.terms !== 'string')
+}

package/src/doc-pipeline.js

@@ -2,9 +2,10 @@ import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { stat } from 'node:fs/promises'
 import { looksLikeDump, readTextFile } from './util/fs.js'
+import { summarizeText } from './util/text.js'
 import { parsePdf } from './parsers/pdfjs-parser.js'
 import { chunkText } from './chunker.js'
-import { extractDocEntry } from './llm.js'
+import { extractKeywords, extractTermText } from './doc-index.js'
 
 export async function extractTextFromFile(filePath, { maxFileSizeMb = 50, maxPdfPages = 1000 } = {}) {
   const ext = path.extname(filePath).toLowerCase()
@@ -21,43 +22,37 @@ export async function extractTextFromFile(filePath, { maxFileSizeMb = 50, maxPdf
   return readTextFile(filePath, maxFileSizeMb ? maxFileSizeMb * 1024 * 1024 : Infinity)
 }
 
-const DOC_CONCURRENCY = 4
-
-export async function buildDocEntries(llm, a, b, c) {
-  // Backward compatible: old signature (llm, filePath, opts) or new (llm, relPath, filePath, opts)
-  const [relPath, filePath, opts] = c === undefined ? [a, a, b] : [a, b, c]
+/**
+ * 文档分片 → 记忆条目（索引期不调用任何模型：纯规则、确定性、可重放）。
+ *
+ * 注入用 summary 与检索用 terms 分离：
+ *   - summary：≤300 字符，进上下文，保持小预算；
+ *   - terms：整个 chunk 的字面词项，只进 BM25 检索文本，不进注入。
+ * 于是「chunk 只有前 300 字符可检索」的旧限制被移除，且没有任何 LLM 调用。
+ * 函数签名里刻意没有 llm —— 索引期零 LLM 由构造保证，而不是靠 catch。
+ */
+export async function buildDocEntries(relPath, filePath, opts = {}) {
   const text = await extractTextFromFile(filePath, opts)
   if (looksLikeDump(text)) return null
-  
+
   // Compute content hash for update detection
   const hash = createHash('sha256').update(text).digest('hex').slice(0, 16)
-  
+
   const chunks = chunkText(text, opts.chunkChars, opts.maxChunks)
-  const metas = new Array(chunks.length)
-  let cursor = 0
-  await Promise.all(
-    Array.from({ length: Math.min(DOC_CONCURRENCY, chunks.length) }, () =>
-      (async () => {
-        while (cursor < chunks.length) {
-          const i = cursor++
-          metas[i] = await extractDocEntry(llm, chunks[i], filePath)
-        }
-      })(),
-    ),
-  )
-  return metas.map((meta, i) => ({
+  return chunks.map((chunk, i) => ({
     id: `${relativeId(relPath)}#${i}`,
     sourcePath: relPath,
-    sourceLine: chunks[i].line,
+    sourceLine: chunk.line,
     type: 'doc',
-    title: meta.title,
-    summary: meta.summary,
-    blindSpots: meta.blindSpots || '',
-    keywords: meta.keywords,
+    title: chunk.title || relPath,
+    summary: summarizeText(chunk.text),
+    blindSpots: '',
+    keywords: extractKeywords(chunk.title, chunk.text),
+    terms: extractTermText(chunk.text),
     hash,
   }))
 }
 
 function relativeId(filePath) {
   return String(filePath).replace(/[\\/:\s]/g, '_')
-}
+}

package/src/index.js

@@ -13,6 +13,7 @@ import { setupTaskbridge } from './setup/taskbridge.js'
 import { listTasksTool, selectTaskTool, archiveTaskTool, showTaskPanelTool } from './tools/task-tools.js'
 import { lessonTool } from './tools/lesson-tools.js'
 import { installAutoInject } from './auto-inject.js'
+import { rememberRoute } from './llm-route.js'
 import { tasksCommandDefinition } from './commands/tasks.js'
 import { taskCommandDefinition } from './commands/task-actions.js'
 import { insightCommandDefinition } from './commands/insight-actions.js'
@@ -29,6 +30,14 @@ export const Config = Schema.object({
   maxPdfPages: Schema.number().default(1000),
   llmQueryExpansion: Schema.boolean().default(false),
   expansionCount: Schema.number().default(6),
+  // 辅助 LLM 调用的路由覆写 —— **索引期零 LLM**，这里的路由只服务于召回期可选项
+  // （llmQueryExpansion 查询扩展）与反思期（reflection.enabled）。
+  // 未设置时：工具调用取当前会话 header 的 provider/model；后台路径取最近一次会话路由（request/header）。
+  // 两者都拿不到时明确走回退并记录 degraded（不静默）。
+  llm: Schema.object({
+    provider: Schema.string(),
+    model: Schema.string(),
+  }).default({}),
   lazyIndexing: Schema.boolean().default(true),
   autoIndexOnFirstUse: Schema.boolean().default(false),
   watch: Schema.boolean().default(true),
@@ -40,7 +49,7 @@ export const Config = Schema.object({
     // 任务成为会话绑定（select_task / /task switch）时，把任务步骤推成宿主 todo/write 快照
     syncHostOnAdopt: Schema.boolean().default(true),
   }).default({}),
-  // v0.5 单一 insight 实体：分层去重/强化/提升/容量/归档（详见 PLAN-v0.5.0.md）
+  // v0.5 单一 insight 实体：分层去重/强化/提升/容量/归档
   insight: Schema.object({
     dedupOverlap: Schema.number().default(0.7),
     reinforceBand: Schema.number().default(0.65),
@@ -51,7 +60,7 @@ export const Config = Schema.object({
     decayDays: Schema.number().default(90),
     globalFile: Schema.string(),
   }).default({}),
-  // PR 1b：反思管线（LLM 消费点，默认关）。产出只写 task 级草稿，见 PLAN §3
+  // 反思管线（召回期可选 LLM 消费点，默认关）。产出只写 task 级草稿。
   reflection: Schema.object({
     enabled: Schema.boolean().default(false),
     cooldownMs: Schema.number().default(1800000),
@@ -63,7 +72,24 @@ export const Config = Schema.object({
     enabled: Schema.boolean().default(true),
     entryOn: Schema.boolean().default(true),
     maxTokens: Schema.number().default(400),
-    relevanceMin: Schema.number().default(0.25),
+    entryMaxInsights: Schema.number().default(6),
+    // 提示通道的相对阈值（层内最高分的比例）——出厂判据
+    signalMinRatio: Schema.number().default(0.5),
+    // resident 任务卡最多显示几个「编辑中」文件
+    editedMax: Schema.number().default(3),
+    // 模型自己维护清单且之后没有新人类消息时，不把任务卡回声给模型
+    skipEchoSelfTodo: Schema.boolean().default(true),
+    // ⚠️ 旧兼容闸门，**刻意不给默认值**：cfgEngine 以「relevanceMin 是否为 number」选分支，
+    // 一旦有默认值就会永远走旧的绝对 overlap 判据——而它对长消息实测只有 0.014~0.057，
+    // 必然过不了，相对阈值 signalMinRatio 就变成死代码。只有用户显式配置才保留旧行为。
+    relevanceMin: Schema.number(),
+    // 预算审计日志（stderr）**默认 off**：终端是用户可见面，而"预算挤掉低优先级条目"是
+    // 正常降级、不是故障——默认打印会让一次 dsh web 启动刷出多行，用户的第一反应是卸载插件。
+    // off（默认，永不打印）/ once（每个会话最多一行，首次出现丢弃时）/ all（丢弃组合每变化一次一行，作者排查）
+    budgetLog: Schema.union(['off', 'once', 'all']).default('off'),
+    // 同一条 insight 在本会话里重复注入的冷却（pre-step 步数）。0（默认）= 正文没变就不再注入：
+    // 注入消息留在会话历史里（宿主只追加不压缩），整块重发只是重复占位。>0 用于外部裁剪历史的场景。
+    reinjectItemsAfter: Schema.number().default(0),
   }).default({}),
 })
 
@@ -88,6 +114,10 @@ export function apply(ctx, config) {
 
   // TaskBridge：任务实体 + 宿主 todo 同步
   setupTaskbridge(ctx, config)
+  // 跟踪会话路由（request/header 事件），为无会话上下文的召回期可选 LLM（查询扩展 / 反思）兜底
+  ctx.on('session/event', (session, event) => {
+    if (event?.type === 'request/header') rememberRoute(session)
+  })
   ctx.tools.register(listTasksTool(config))
   ctx.tools.register(selectTaskTool(config, { llm: ctx.llm, ctx }))
   ctx.tools.register(archiveTaskTool(config, { llm: ctx.llm, ctx }))

package/src/insight-store.js

@@ -98,10 +98,12 @@ export function normalizeInsight(raw, extra = {}) {
     if (Array.isArray(raw[f]) && raw[f].length) ins[f] = [...new Set(raw[f].map((x) => String(x)))]
   }
   if (raw.trigger && typeof raw.trigger === 'object') {
-    const tr = { keywords: Array.isArray(raw.trigger.keywords) ? raw.trigger.keywords.map(String) : [] }
-    if (Array.isArray(raw.trigger.symbols)) tr.symbols = raw.trigger.symbols.map(String)
-    if (Array.isArray(raw.trigger.scope)) tr.scope = raw.trigger.scope.map(String)
-    if (tr.keywords.length) ins.trigger = tr
+    // 所有 kind 通用：keywords / symbols / actions / paths / scope（actions/paths 见 src/readiness.js）
+    const tr = {}
+    for (const f of ['keywords', 'symbols', 'actions', 'paths', 'scope']) {
+      if (Array.isArray(raw.trigger[f]) && raw.trigger[f].length) tr[f] = raw.trigger[f].map(String)
+    }
+    if (Object.keys(tr).length) ins.trigger = tr
   }
   return ins
 }

package/src/lazy.js

@@ -3,6 +3,7 @@ import { tmpdir } from 'node:os'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { isSupportedCode, isSupportedDoc, memoryRootFor, readFileForIndex, relativePath, storeKey } from './util/fs.js'
 import { buildDocEntries } from './doc-pipeline.js'
+import { docEntriesNeedBackfill } from './doc-index.js'
 import { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
 import { ProjectMemoryStore } from './store.js'
@@ -98,7 +99,8 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   } catch {
     return false
   }
-  if (existing && existing.sha256 === hash) return false
+  // 旧 store 的 doc 条目缺 terms → 一次性回填（即使哈希未变）
+  if (existing && existing.sha256 === hash && !(isSupportedDoc(ext) && docEntriesNeedBackfill(store.entries[rel]))) return false
 
   if (watchManager) {
     watchManager.addRoot(root)
@@ -115,7 +117,7 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
       return true
     })
   } else {
-    entries = await buildDocEntries(ctx.llm, rel, filePath, {
+    entries = await buildDocEntries(rel, filePath, {
       chunkChars: config.chunkChars,
       maxChunks: config.maxChunksPerFile,
       maxFileSizeMb: config.maxFileSizeMb,

package/src/link.js

@@ -28,7 +28,8 @@ export function linkEntries(store) {
   let links = 0
   for (const doc of docs) {
     const linked = new Set()
-    const haystack = `${doc.title || ''} ${doc.summary || ''} ${doc.keywords ? doc.keywords.join(' ') : ''}`.toLowerCase()
+    // 结构词项也参与链接：terms 覆盖整个 chunk，符号在后半段被提及时同样能链上（与检索同源）
+    const haystack = `${doc.title || ''} ${doc.summary || ''} ${doc.terms || ''} ${doc.keywords ? doc.keywords.join(' ') : ''}`.toLowerCase()
     for (const [, entry] of symbolByName) {
       const hit = entry.re ? entry.re.test(haystack) : haystack.includes(entry.lower)
       for (const s of entry.syms) {

package/src/llm-route.js

@@ -0,0 +1,95 @@
+// 辅助 LLM 调用的路由解析（仅召回期可选：查询扩展 / 反思）。
+//
+// 背景：宿主 LlmRuntime.stream 要求 provider/model 必填，缺失即抛 NO_ADAPTER。
+// 本模块负责：
+//   1) 从工具 exec / 会话 / 配置解析出 (provider, model)；
+//   2) 把「无法路由 / 调用失败」记成可见的 degraded 记录，而不是静默降级。
+//
+// 解析优先级（与宿主 compaction summarizer 同序，再补一条后台 hint）：
+//   config.llm 显式覆写 > exec 会话 requestHeader().config > exec agent options >
+//   最近一次 request/header 事件记下的路由（后台 watch/lazy 兜底）。
+//
+// 登记规则：路由只影响辅助调用走哪个模型，不改变检索/排序行为。
+
+/** 最近一次在会话里观察到的路由，供无 exec 的后台索引（watch/lazy）兜底。 */
+let routeHint = null
+
+/** 无法路由 / 调用失败留下的可见痕迹：code -> { code, reason, at, count }。 */
+const degraded = new Map()
+
+function normalize(provider, model, source) {
+  if (typeof provider !== 'string' || !provider) return null
+  if (typeof model !== 'string' || !model) return null
+  return { provider, model, source }
+}
+
+function routeFromSession(session) {
+  try {
+    const config = session?.requestHeader?.()?.config
+    return normalize(config?.provider, config?.model, 'session')
+  } catch {
+    return null
+  }
+}
+
+/** 记下会话当前路由，作为后台索引的兜底。由 request/header 事件驱动。 */
+export function rememberRoute(session) {
+  const route = routeFromSession(session)
+  if (route) routeHint = { provider: route.provider, model: route.model }
+}
+
+/** 显式配置的路由（config.llm.provider + config.llm.model 同时存在才算）。 */
+function routeFromConfig(config) {
+  return normalize(config?.llm?.provider, config?.llm?.model, 'config')
+}
+
+/**
+ * 解析一次辅助 LLM 调用的路由。
+ * @param exec - 工具执行上下文（可含 agent.session / agent.options），可为空。
+ * @param config - 插件配置（可含 llm 覆写）。
+ * @returns {{provider: string, model: string, source: string}|null}
+ */
+export function resolveRoute(exec, config) {
+  const configured = routeFromConfig(config)
+  if (configured) return configured
+
+  const fromExecSession = routeFromSession(exec?.agent?.session)
+  if (fromExecSession) return fromExecSession
+
+  const options = exec?.agent?.options
+  const fromOptions = normalize(options?.provider, options?.model, 'agent')
+  if (fromOptions) return fromOptions
+
+  if (routeHint) return { ...routeHint, source: 'session-hint' }
+  return null
+}
+
+/**
+ * 记录一次降级（允许降级，不允许静默）。同一 code 只打印一次，避免逐 chunk 刷屏；
+ * 计数与最近原因保留下来，供 memory_stats / 测试读取。
+ */
+export function noteDegraded(code, reason) {
+  const at = new Date().toISOString()
+  const prev = degraded.get(code)
+  if (prev) {
+    prev.count += 1
+    prev.at = at
+    prev.reason = reason
+    return prev
+  }
+  const record = { code, reason, at, count: 1 }
+  degraded.set(code, record)
+  console.warn(`[dsh-project-memory] degraded ${code}: ${reason}`)
+  return record
+}
+
+/** 当前累计的降级记录（快照，按 code 去重）。 */
+export function degradedList() {
+  return [...degraded.values()].map((d) => ({ ...d }))
+}
+
+/** 测试用：清空路由 hint 与降级记录。 */
+export function resetRouteState() {
+  routeHint = null
+  degraded.clear()
+}

package/src/llm.js

@@ -1,5 +1,7 @@
+// 辅助 LLM 调用（**仅召回期 / 反思期，按需可选**；索引期不调用任何模型）。
+// chatText 是唯一的宿主调用出口：provider/model 必填，缺失时显式抛错，由调用方决定回退并记 degraded。
 import { BlockAssembler, createUserMessage } from '@deepseek-ai/dsh-llm'
-import { tokenize } from './util/search.js'
+import { noteDegraded } from './llm-route.js'
 
 function systemMessage(text) {
   return { role: 'system', content: [{ type: 'text', text }] }
@@ -13,24 +15,19 @@ function textOf(message) {
     .join('\n')
 }
 
-const MAX_SUMMARY = 300
-
-export function summarizeText(text, max = MAX_SUMMARY) {
-  const flat = String(text || '').replace(/\s+/g, ' ').trim()
-  if (!flat) return ''
-  if (flat.length <= max) return flat
-  const clip = max - 1
-  const clipped = flat.slice(0, clip)
-  const lastBreak = Math.max(clipped.lastIndexOf('。'), clipped.lastIndexOf('.'), clipped.lastIndexOf(';'))
-  return lastBreak > clip * 0.4 ? clipped.slice(0, lastBreak + 1) : clipped + '…'
-}
-
-export async function chatText(llm, system, user, { timeoutMs = 120000 } = {}) {
+export async function chatText(llm, system, user, { timeoutMs = 120000, route } = {}) {
+  // provider/model 是宿主 GenerateOptions 的必填项，缺失时 LlmRuntime 抛 NO_ADAPTER。
+  // 这里显式失败（由调用方决定回退并记 degraded），不让异常悄悄消失。
+  if (!route?.provider || !route?.model) {
+    throw new Error('auxiliary LLM call requires an explicit provider/model route')
+  }
   const assembler = new BlockAssembler()
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(), timeoutMs)
   try {
     for await (const chunk of llm.stream({
+      provider: route.provider,
+      model: route.model,
       messages: [systemMessage(system), createUserMessage({ content: [{ type: 'text', text: user }] })],
       signal: controller.signal,
     })) {
@@ -72,8 +69,13 @@ function parseJson(text, validate) {
   return null
 }
 
-export async function expandQuery(llm, query, count = 6) {
+/** 召回期可选的查询扩展（默认关；开启时才需要 provider/model 路由）。 */
+export async function expandQuery(llm, query, count = 6, { route } = {}) {
   if (!llm) return [query]
+  if (!route) {
+    noteDegraded('llm.expand.no-route', 'no provider/model route for query expansion; search uses the raw query')
+    return [query]
+  }
   const system =
     'You are a search-query expander for a codebase/document memory search engine. ' +
     'Given a user query, return a STRICT JSON array of alternative search queries that ' +
@@ -81,57 +83,14 @@ export async function expandQuery(llm, query, count = 6) {
     'code identifier guesses, and narrower/longer phrasings. Include the original query first. ' +
     'Output only the JSON array of strings, no fences, no commentary.'
   try {
-    const raw = await chatText(llm, system, `Query: "${query}"\n\nReturn the JSON array.`)
+    const raw = await chatText(llm, system, `Query: "${query}"\n\nReturn the JSON array.`, { route })
     const parsed = parseJsonArray(raw)
     if (Array.isArray(parsed) && parsed.length) {
       const variants = parsed.map(String).filter((s) => s.trim()).slice(0, count)
       if (variants.length) return variants
     }
-  } catch {
-    // fall through to the raw query
+  } catch (err) {
+    noteDegraded('llm.expand.failed', `query expansion LLM call failed: ${err?.message || err}`)
   }
   return [query]
 }
-
-export async function extractDocEntry(llm, chunk, sourcePath) {
-  const system =
-    'You are a project-documentation indexer. Given a chunk of a project document, ' +
-    'return a STRICT JSON object with exactly four fields: ' +
-    '"title" (short section title, string), ' +
-    '"summary" (3-5 sentence dense summary of what this section covers, ' +
-    'mentioning concrete names, decisions, constraints, and key technical details), ' +
-    '"blindSpots" (string describing what this summary does NOT cover, ' +
-    'e.g. "未覆盖：部署细节、性能基准、v0.2 前 API", empty string if none), ' +
-    '"keywords" (array of 5-10 searchable strings: ' +
-    'cover the document\'s own language AND English equivalents, ' +
-    'so a query in either language can match). ' +
-    'Do not include markdown fences, do not add commentary, output only the JSON object.'
-
-  const user =
-    `Document: ${sourcePath}\nSection: ${chunk.title || '(untitled)'}\n\n` +
-    `Content:\n${chunk.text.slice(0, 6000)}\n\nReturn the JSON object.`
-
-  const fallback = () => ({
-    title: chunk.title || sourcePath,
-    summary: summarizeText(chunk.text),
-    blindSpots: '',
-    keywords: tokenize(chunk.title).slice(0, 5),
-  })
-
-  if (!llm) return fallback()
-
-  try {
-    const raw = await chatText(llm, system, user)
-    const parsed = parseStructuredJson(raw)
-    if (!parsed || typeof parsed.summary !== 'string' || !parsed.summary.trim()) return fallback()
-    const kw = Array.isArray(parsed.keywords) ? parsed.keywords.map(String).filter((k) => k).slice(0, 8) : []
-    return {
-      title: typeof parsed.title === 'string' && parsed.title.trim() ? parsed.title.trim() : chunk.title || sourcePath,
-      summary: summarizeText(parsed.summary.trim()),
-      blindSpots: typeof parsed.blindSpots === 'string' ? parsed.blindSpots.trim() : '',
-      keywords: kw.length ? kw : tokenize(chunk.title).slice(0, 5),
-    }
-  } catch {
-    return fallback()
-  }
-}

package/src/parsers/pdfjs-parser.js

@@ -25,6 +25,9 @@ const PDFJS_OPTIONS = {
   isEvalSupported: false,
   useWorkerFetch: false,
   useWorker: false,
+  // 0 = ERRORS。损坏/线性化缺失的 PDF 会让 pdf.js 打 "Warning: Indexing all PDF objects"
+  // 之类的告警——那是它自己的恢复路径，对使用者没有可操作性，静音。
+  verbosity: 0,
 }
 
 function buildMarkdown(pages) {