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

package/src/insight-store.js

@@ -10,6 +10,7 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import { normalizedTokenOverlap, findBestOverlapMatch, insightMatchText } from './similarity.js'
+import { backfillDerivedTriggers } from './readiness.js'
 
 export const INSIGHT_KINDS = ['lesson', 'decision', 'procedure', 'experience']
 export const INSIGHT_SCOPES = ['task', 'project', 'global']
@@ -98,11 +99,31 @@ 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') {
-    // 所有 kind 通用：keywords / symbols / actions / paths / scope（actions/paths 见 src/readiness.js）
+    // 所有 kind 通用。准入化 schema：when（唯一触发面）/ guard（只收窄）/ prevents（准入条件）；
+    // 旧字段 keywords / symbols / actions / paths / scope 继续接受（readiness 会内存内迁移）。
     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)
     }
+    const when = raw.trigger.when
+    if (when && typeof when === 'object') {
+      const w = {}
+      for (const f of ['ops', 'writes', 'intents']) {
+        if (Array.isArray(when[f]) && when[f].length) w[f] = when[f].map(String)
+      }
+      if (Object.keys(w).length) tr.when = w
+    }
+    const guard = raw.trigger.guard
+    if (guard && typeof guard === 'object') {
+      const g = {}
+      for (const f of ['paths', 'not_paths', 'hosts', 'tags']) {
+        if (Array.isArray(guard[f]) && guard[f].length) g[f] = guard[f].map(String)
+      }
+      if (Object.keys(g).length) tr.guard = g
+    }
+    if (typeof raw.trigger.prevents === 'string' && raw.trigger.prevents.trim()) {
+      tr.prevents = raw.trigger.prevents.trim()
+    }
     if (Object.keys(tr).length) ins.trigger = tr
   }
   return ins
@@ -114,6 +135,23 @@ export function unionStrings(base = [], add = []) {
   return [...out]
 }
 
+/**
+ * 跨 scope 移动（promote/demote）时保留"使用痕迹"。
+ *
+ * 提升/降级只改 scope，不该清零命中数、创建时间，也不该丢掉 `triggerDerived`
+ * （提示通道拿它当检索词）。这些字段不在 {@link normalizeInsight} 的白名单里，
+ * 必须显式带回——否则每次移动都会让条目"看起来从没被用过"，global 层更是每次都丢派生词。
+ * @param {object} copy - 已归一化到新 scope 的副本
+ * @param {object} src - 原条目
+ */
+export function carryUsageFields(copy, src) {
+  copy.hitCount = num(src.hitCount, 0)
+  if (src.lastHitAt) copy.lastHitAt = src.lastHitAt
+  if (src.createdAt) copy.createdAt = src.createdAt
+  if (src.triggerDerived) copy.triggerDerived = src.triggerDerived
+  return copy
+}
+
 /** 把 base 合并进既有条目（content 加固、成员/文件/符号并集、置信取高、记命中）。 */
 export function mergeInto(existing, base, cfg, nowIso) {
   const now = nowIso || new Date().toISOString()
@@ -190,9 +228,12 @@ export function applyDecay(items, cfg, nowIso) {
   const limit = Date.parse(now) - cfg.decayDays * DAY_MS
   let archived = 0
   for (const it of items) {
-    if (it.archived) continue
-    if ((it.hitCount || 0) > 0) continue
-    if (it.lastHitAt && Date.parse(it.lastHitAt) <= limit) {
+    if (!it || it.archived) continue
+    // 用"最近活动"而不是 lastHitAt：lastHitAt 只由 merge/reinforce 写，而那两处同时把
+    // hitCount 加一。旧实现先 `hitCount > 0 → continue`，于是 lastHitAt 分支永远不可达，
+    // decayDays 实际是个死开关。activityOf 退到 updatedAt/createdAt，没命中过的条目也能衰减。
+    const last = activityOf(it)
+    if (last && last <= limit) {
       it.archived = true
       it.updatedAt = now
       archived++
@@ -201,7 +242,11 @@ export function applyDecay(items, cfg, nowIso) {
   return archived
 }
 
-/** 超限先物理删归档里最不活跃的，再归档最不活跃的（下一轮被删），直到回落到上限。 */
+/**
+ * 超限按"最不活跃"物理删除，直到回落到上限。已有 archived 条目优先被删。
+ * 注意：没有归档可删时，本轮归档的条目会在同一次调用的后续循环里被删掉——
+ * `archived` 计数表示"先归档、随即被删"，不是"留下了软删副本"。
+ */
 export function pruneItems(items, max, nowIso) {
   const now = nowIso || new Date().toISOString()
   let removed = 0
@@ -280,7 +325,11 @@ export class GlobalStore {
   }
 
   load() {
-    if (!this.doc) this.doc = normalizeDoc(readJson(this.file, null))
+    if (!this.doc) {
+      this.doc = normalizeDoc(readJson(this.file, null))
+      // 与 project 级一致：global 条目也要补派生 trigger（提示通道用它提升召回；确定性、幂等）。
+      if (backfillDerivedTriggers(this.doc)) this.markDirty()
+    }
     return this
   }
 
@@ -455,16 +504,14 @@ export function promoteAllTasksToProject(store, globalStore, cfg, now) {
         promoted++
         continue
       }
-      const moved = {
-        ...normalizeInsight(ins, { scope: 'project', source: ins.source, nowIso: now }),
-        id: ins.id,
-        draft: false,
-        confidence: num(ins.confidence, cfg.promoteConfidence),
-        hitCount: ins.hitCount || 0,
-        lastHitAt: ins.lastHitAt,
-        createdAt: ins.createdAt || now,
-        movedFrom: { scope: 'task', id: ins.id, at: now },
-      }
+      const moved = carryUsageFields(
+        normalizeInsight(ins, { scope: 'project', source: ins.source, nowIso: now }),
+        ins,
+      )
+      moved.id = ins.id
+      moved.draft = false
+      moved.confidence = num(ins.confidence, cfg.promoteConfidence)
+      moved.movedFrom = { scope: 'task', id: ins.id, at: now }
       pjItems.push(moved)
       store.replaceInsightItems(pjItems)
       removeFromTask(store, ins.id)
@@ -494,16 +541,14 @@ export function promoteProjectToGlobal(store, globalStore, cfg, now) {
     if (glHit && glHit.score >= cfg.dedupOverlap) {
       mergeInto(glHit.item, { sourceTaskIds: ins.sourceTaskIds, files: ins.files, symbols: ins.symbols, tags: ins.tags, confidence: ins.confidence }, cfg, now)
     } else {
-      const movedIns = {
-        ...normalizeInsight(ins, { scope: 'global', source: ins.source, nowIso: now }),
-        id: ins.id,
-        draft: false,
-        confidence: num(ins.confidence, cfg.promoteConfidence),
-        hitCount: ins.hitCount || 0,
-        lastHitAt: ins.lastHitAt,
-        createdAt: ins.createdAt || now,
-        movedFrom: { scope: 'project', id: ins.id, at: now },
-      }
+      const movedIns = carryUsageFields(
+        normalizeInsight(ins, { scope: 'global', source: ins.source, nowIso: now }),
+        ins,
+      )
+      movedIns.id = ins.id
+      movedIns.draft = false
+      movedIns.confidence = num(ins.confidence, cfg.promoteConfidence)
+      movedIns.movedFrom = { scope: 'project', id: ins.id, at: now }
       glItems.push(movedIns)
     }
     items.splice(items.indexOf(ins), 1)
@@ -511,6 +556,8 @@ export function promoteProjectToGlobal(store, globalStore, cfg, now) {
   }
   if (moved) {
     store.replaceInsightItems(items)
+    // 提升只增不减 global：不在这里收口，maxGlobalProcedures 就形同虚设。
+    pruneItems(globalStore.items(), cfg.maxGlobalProcedures, now)
     globalStore.markDirty()
   }
   return moved
@@ -518,17 +565,19 @@ export function promoteProjectToGlobal(store, globalStore, cfg, now) {
 
 // ---- 降级（反向，PR3 UI 使用；现在提供最小实现） ----
 
-export function demoteToProject(store, globalStore, id, nowIso) {
+export function demoteToProject(store, globalStore, id, nowIso, cfg = cfgInsight({})) {
   if (!globalStore) return { ok: false, error: 'global 存储未初始化' }
   const now = nowIso || new Date().toISOString()
   const idx = globalStore.items().findIndex((i) => i.id === id)
   if (idx === -1) return { ok: false, error: `global 无此条目: ${id}` }
   const ins = globalStore.items()[idx]
   const items = store.insightItems()
-  const copy = normalizeInsight(ins, { scope: 'project', nowIso: now })
+  const copy = carryUsageFields(normalizeInsight(ins, { scope: 'project', nowIso: now }), ins)
   copy.id = `${ins.id}_d${Date.now().toString(36)}`
   copy.movedFrom = { scope: 'global', id: ins.id, at: now }
   items.push(copy)
+  // 降级只增不减 project：同样要收口 maxProject。
+  pruneItems(items, cfg.maxProject, now)
   store.replaceInsightItems(items)
   globalStore.items().splice(idx, 1)
   globalStore.markDirty()
@@ -544,7 +593,7 @@ export function demoteToTask(store, taskId, id, nowIso) {
   if (idx === -1) return { ok: false, error: `project 无此条目: ${id}` }
   const ins = items[idx]
   if (!Array.isArray(task.insights)) task.insights = []
-  const copy = normalizeInsight(ins, { scope: 'task', nowIso: now })
+  const copy = carryUsageFields(normalizeInsight(ins, { scope: 'task', nowIso: now }), ins)
   copy.id = `${ins.id}_d${Date.now().toString(36)}`
   copy.movedFrom = { scope: 'project', id: ins.id, at: now }
   task.insights.push(copy)

package/src/lazy.js

@@ -1,11 +1,8 @@
 import path from 'node:path'
 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 { memoryRootFor, relativePath, storeKey } from './util/fs.js'
+import { DROP, OVERSIZE, UNCHANGED, commitFileUpdates, fileKind, planFileIndex, toFileUpdate } from './index-pipeline.js'
 import { ProjectMemoryStore } from './store.js'
 import { onFileObserved } from './enhancer.js'
 
@@ -78,70 +75,42 @@ export function findProjectRoot(filePath, ceiling = path.resolve(tmpdir())) {
 }
 
 export async function indexFile(ctx, config, filePath, watchManager = null) {
-  const ext = path.extname(filePath).toLowerCase()
-  if (!isSupportedDoc(ext) && !isSupportedCode(ext)) return false
+  const kind = fileKind(path.extname(filePath).toLowerCase())
+  if (!kind) return false
   const root = findProjectRoot(filePath)
   if (!root) return false
 
   const memoryDir = memoryRootFor(root, config.memoryDir)
   const store = new ProjectMemoryStore(memoryDir).load()
   const rel = storeKey(relativePath(root, filePath))
-  const existing = store.fileRecord(rel)
-  let hash
+  const record = store.fileRecord(rel)
+
   let size
-  let buffer
-  let entries
+  let plan
   try {
-    if (isSupportedCode(ext) && config.maxFileSizeMb && statSync(filePath).size > config.maxFileSizeMb * 1024 * 1024) {
-      return false
-    }
-    ;({ hash, size, buffer } = readFileForIndex(filePath))
+    size = statSync(filePath).size
+    plan = await planFileIndex({ rel, filePath, kind, config, record, existingEntries: store.entries[rel], size })
   } catch {
     return false
   }
-  // 旧 store 的 doc 条目缺 terms → 一次性回填（即使哈希未变）
-  if (existing && existing.sha256 === hash && !(isSupportedDoc(ext) && docEntriesNeedBackfill(store.entries[rel]))) return false
+  if (plan.key === UNCHANGED || plan.key === OVERSIZE) return false
 
   if (watchManager) {
     watchManager.addRoot(root)
     store.addWatch(root)
   }
 
-  if (isSupportedCode(ext)) {
-    entries = scanSymbols(rel, filePath, buffer.toString('utf8'))
+  if (plan.key !== DROP && plan.type === 'code') {
     onFileObserved(store, rel, filePath, config, root)
-    return store.commit((s) => {
-      s.markFile(rel, { sha256: hash, size, type: 'code', indexedAt: new Date().toISOString() })
-      s.setEntries(rel, entries)
-      linkEntries(s)
-      return true
-    })
-  } else {
-    entries = await buildDocEntries(rel, filePath, {
-      chunkChars: config.chunkChars,
-      maxChunks: config.maxChunksPerFile,
-      maxFileSizeMb: config.maxFileSizeMb,
-      maxPdfPages: config.maxPdfPages,
-    })
-    if (entries === null) {
-      return store.commit((s) => {
-        s.removeFile(rel)
-        return false
-      })
-    }
-    return store.commit((s) => {
-      s.markFile(rel, { sha256: hash, size, type: 'doc', indexedAt: new Date().toISOString() })
-      s.setEntries(rel, entries)
-      linkEntries(s)
-      return true
-    })
   }
+  commitFileUpdates(store, { updates: [toFileUpdate(rel, plan, record)] })
+  return plan.key !== DROP
 }
 
 export function codeFirst(paths) {
   return [...paths].sort((a, b) => {
-    const aCode = isSupportedCode(path.extname(a).toLowerCase()) ? 0 : 1
-    const bCode = isSupportedCode(path.extname(b).toLowerCase()) ? 0 : 1
+    const aCode = fileKind(path.extname(a).toLowerCase()) === 'code' ? 0 : 1
+    const bCode = fileKind(path.extname(b).toLowerCase()) === 'code' ? 0 : 1
     return aCode - bCode
   })
 }

package/src/link.js

@@ -39,7 +39,16 @@ export function linkEntries(store) {
         if (linked.size > before) links++
       }
     }
-    doc.linkedSymbols = linked.size ? [...linked] : undefined
+    const before = Array.isArray(doc.linkedSymbols) ? doc.linkedSymbols.join('\u0000') : ''
+    const next = [...linked]
+    if (before === next.join('\u0000')) continue
+    doc.linkedSymbols = next.length ? next : undefined
+    // 链接是在**符号**落盘那一刻算出来的，此时 doc 的 shard 往往不是脏的；不标脏就只存在于内存，
+    // 下次进程启动重新加载后链接全部丢失（"文档先索引、符号后到"的正常顺序）。
+    if (typeof store.markFile === 'function' && typeof store.fileRecord === 'function' && doc.sourcePath) {
+      const record = store.fileRecord(doc.sourcePath)
+      if (record) store.markFile(doc.sourcePath, record)
+    }
   }
   return links
 }

package/src/ops.js

@@ -0,0 +1,210 @@
+// 动作平面（PLAN S1）：把"这一步在做什么"从工具调用解析成有限的 op + 写目标 + 主机环境。
+//
+// 为什么不能继续用文本匹配：语料（路径、命令、被读文件正文）里的字符串可以冒充动作。
+// 实测病征是 `keyword:rm` 命中 `dcterms`、`keyword:pptx` 命中一个文件扩展名。
+// op 与 target 是低维、可枚举、可审计的：不随文本长度变化，也不会被正文污染。
+//
+// 分工：ops.js 只负责"把调用读成什么动作"，不负责决定注入什么（那是 readiness/auto-inject）。
+// 刻意不 import readiness：readiness 要 import 本模块的 op 闭集，反向依赖会造成循环。
+
+/** 带扩展名的路径 token（与 readiness.extractPaths 同规则；这里就地实现以免循环依赖）。 */
+const PATH_TOKEN = /(?:[A-Za-z0-9_.@-]+\/)*[A-Za-z0-9_.@-]+\.[A-Za-z][A-Za-z0-9]{0,7}\b/g
+
+function extractPaths(text) {
+  const s = String(text || '')
+  if (!s) return []
+  return [...new Set([...s.matchAll(PATH_TOKEN)].map((m) => m[0]))]
+}
+
+/** op 闭集。新增一个 op 必须同时想清楚：它是动作，不是话题。 */
+export const OP_IDS = [
+  'file-write',
+  'file-delete',
+  'shell-run',
+  'git-commit',
+  'git-push',
+  'release',
+  'npm-publish',
+  'deploy',
+  'migrate',
+  'go-public',
+  'render-doc',
+  'index-doc',
+  'read-image',
+  'fetch-web',
+  'run-bench',
+  'query-memory',
+]
+
+/**
+ * 兜底 op：它们描述的是"发生了某类操作"，信息量低、假阳性高。
+ * 允许写进 `when.ops`，但自检会 warn——兜底 op 只该命中兜底级记忆。
+ */
+export const FALLBACK_OPS = new Set(['shell-run', 'file-write', 'query-memory'])
+
+/**
+ * 弱 op：日常动作。它本身不构成边界（每天都在提交），所以当条目**已经有更精确的 writes**
+ * 时，迁移会把弱 op 丢掉——留着它只会把"改这个文件时"扩大成"任何一次提交时"。
+ * 实测：`git-commit` 让一条"别删内部文档"的教训在发版场景里被注入。
+ */
+export const WEAK_OPS = new Set([...FALLBACK_OPS, 'git-commit', 'git-push'])
+
+/** 旧 action id → op。旧值里有一批从来没进过 ACTION_LEXICON 的死值，这里给它们一个归宿。 */
+export const LEGACY_ACTION_ALIAS = {
+  'git-add': 'git-commit',
+  'npm-pack': 'npm-publish',
+  'release': 'release',
+  'generate-pptx': 'render-doc',
+  'render': 'render-doc',
+  'read-image': 'read-image',
+  'web-fetch': 'fetch-web',
+  'benchmark': 'run-bench',
+  'cleanup': 'file-delete',
+  'delete': 'file-delete',
+  'recover': null, // 没有对应动作：恢复是意图，不是工具动作
+  'research': null,
+  'survey': null,
+  'interview-prep': null,
+  'write-resume': null,
+  'report-metrics': null,
+  'write-docs': null,
+}
+
+const WRITE_TOOLS = new Set(['write', 'edit', 'multi_edit', 'apply_patch', 'str_replace', 'create_file', 'notebook_edit'])
+const READ_IMAGE_TOOLS = new Set(['read_image'])
+const INDEX_TOOLS = new Set(['index_doc', 'index_repo', 'watch_repo'])
+const FETCH_TOOLS = new Set(['web_fetch', 'web_search'])
+const SHELL_TOOLS = new Set(['bash', 'shell', 'pwsh', 'powershell', 'run', 'exec', 'job_run'])
+const QUERY_TOOLS = new Set(['query_memory', 'recall'])
+
+/** bash 命令 → op。顺序有意义：先具体后兜底。 */
+const SHELL_OP_RULES = [
+  [/\bnpm\s+(publish|pack)\b/, 'npm-publish'],
+  [/\bnpm\s+version\b/, 'release'],
+  [/\bgit\s+tag\b/, 'release'],
+  [/\bgit\s+push\b/, 'git-push'],
+  [/\bgit\s+(commit|add)\b/, 'git-commit'],
+  [/\bgit\s+(checkout|restore|reset)\b/, 'file-write'],
+  // `\brm\b` 而不是 `rm\s+-[rf]`：后者被 `\b` 卡在 'rm -rf' 的 r 后面（f 还是词字符），永远匹配不上。
+  [/\b(rm|git\s+rm|unlink|rmdir|shred)\b/, 'file-delete'],
+  [/\b(kubectl|docker\s+push|systemctl\s+restart|pm2\s+(deploy|restart)|vercel|netlify\s+deploy)\b/, 'deploy'],
+  [/\b(migrate|alembic|prisma\s+migrate|db:migrate)\b/, 'migrate'],
+  // 注意：只认"渲染器"，不认 .pptx 扩展名——否则给 pptx 改个时间戳也会命中"做 PPT"
+  [/(pptxgenjs|soffice|libreoffice|render\.sh|marp|pandoc|slidev)/, 'render-doc'],
+  [/(bench\.mjs|\bbench(mark)?\b)/, 'run-bench'],
+  [/\b(curl|wget|web_fetch)\b/, 'fetch-web'],
+]
+
+/** 会改动文件系统的 shell 动作前缀：只有这些命令的路径才算"写目标"。 */
+const SHELL_WRITE_RE = /\b(rm|rmdir|unlink|shred|mv|cp|touch|tee|truncate|mkdir)\b|>>?\s*\S|\bsed\s+-i\b/
+
+const WSL_HINT_RE = /\/mnt\/[a-z]\//i
+
+function safeJson(text) {
+  if (typeof text !== 'string' || !text.trim()) return null
+  try {
+    const v = JSON.parse(text)
+    return v && typeof v === 'object' ? v : null
+  } catch {
+    return null
+  }
+}
+
+function argsFields(argsText) {
+  const obj = safeJson(argsText)
+  if (!obj) return {}
+  const pick = (...keys) => keys
+    .map((k) => obj[k])
+    .filter((v) => typeof v === 'string' && v)
+    .join(' ')
+  return {
+    command: pick('command', 'cmd', 'script', 'code'),
+    path: pick('file_path', 'path', 'file', 'target', 'notebook_path'),
+  }
+}
+
+/** bash 命令 → { ops, targets, hosts }。 */
+export function classifyShellCommand(command) {
+  const cmd = String(command || '')
+  const ops = []
+  if (cmd) {
+    for (const [re, op] of SHELL_OP_RULES) {
+      if (re.test(cmd) && !ops.includes(op)) ops.push(op)
+    }
+  }
+  if (!ops.length) ops.push('shell-run')
+  const targets = SHELL_WRITE_RE.test(cmd) ? extractPaths(cmd) : []
+  const hosts = WSL_HINT_RE.test(cmd) || /\b(powershell|pwsh|cmd)\.exe\b/i.test(cmd) ? ['wsl'] : []
+  return { ops, targets, hosts }
+}
+
+/**
+ * 一次工具调用 → { ops, targets, hosts }。
+ * @param {string} name 工具名
+ * @param {string} argsText 工具参数（JSON 字符串或裸文本）
+ */
+export function classifyToolCall(name, argsText) {
+  const tool = String(name || '').toLowerCase()
+  const { command, path } = argsFields(argsText)
+  if (SHELL_TOOLS.has(tool)) return classifyShellCommand(command || String(argsText || ''))
+  if (READ_IMAGE_TOOLS.has(tool)) return { ops: ['read-image'], targets: [], hosts: [] }
+  if (INDEX_TOOLS.has(tool)) return { ops: ['index-doc'], targets: [], hosts: [] }
+  if (FETCH_TOOLS.has(tool)) return { ops: ['fetch-web'], targets: [], hosts: [] }
+  if (QUERY_TOOLS.has(tool)) return { ops: ['query-memory'], targets: [], hosts: [] }
+  if (WRITE_TOOLS.has(tool)) {
+    const targets = path ? [path, ...extractPaths(path)] : []
+    const hosts = targets.some((t) => WSL_HINT_RE.test(t)) ? ['wsl'] : []
+    return { ops: ['file-write'], targets: [...new Set(targets)], hosts }
+  }
+  return { ops: [], targets: [], hosts: [] }
+}
+
+/**
+ * 把一组已观察到的工具调用合成这一个线程的动态面。
+ * @param {{name?: string, arguments?: string}[]} calls
+ */
+export function activityFromCalls(calls) {
+  const ops = new Set()
+  const targets = new Set()
+  const hosts = new Set()
+  for (const call of calls || []) {
+    const r = classifyToolCall(call?.name, call?.arguments)
+    for (const op of r.ops) ops.add(op)
+    for (const t of r.targets) targets.add(t)
+    for (const h of r.hosts) hosts.add(h)
+  }
+  return { ops: [...ops], targets: [...targets], hosts: [...hosts] }
+}
+
+/**
+ * 没拿到结构化调用时的兜底：直接对一段文本跑 shell 规则。
+ * 用于 `actionText` 形式的就绪上下文（测试与老宿主），以及人类消息里的动作词。
+ */
+export function activityFromText(text) {
+  const s = String(text || '')
+  if (!s) return { ops: [], targets: [], hosts: [] }
+  const lines = s.split('\n').filter(Boolean)
+  const ops = new Set()
+  const targets = new Set()
+  const hosts = new Set()
+  for (const line of lines) {
+    // 先按"工具调用"解析（`edit {"file_path":"..."}`）：结构化参数比正则猜命令可靠得多。
+    const call = /^\s*([A-Za-z_][\w-]*)\s+(\{[\s\S]*\})\s*$/.exec(line)
+    const r = call ? classifyToolCall(call[1], call[2]) : classifyShellCommand(line)
+    // 纯文本行里没有 shell 动作时不要退化成 shell-run（那是噪音源）
+    if (r.ops.length === 1 && r.ops[0] === 'shell-run' && !/\b\w+\s+-/.test(line)) continue
+    for (const op of r.ops) ops.add(op)
+    for (const t of r.targets) targets.add(t)
+    for (const h of r.hosts) hosts.add(h)
+  }
+  return { ops: [...ops], targets: [...targets], hosts: [...hosts] }
+}
+
+/** 旧 action id（含死值）→ op；无法映射返回 null。 */
+export function opForLegacyAction(action) {
+  const a = String(action || '')
+  if (!a) return null
+  if (OP_IDS.includes(a)) return a
+  if (a in LEGACY_ACTION_ALIAS) return LEGACY_ACTION_ALIAS[a]
+  return null
+}

package/src/parsers/pdfjs-parser.js

@@ -60,9 +60,8 @@ export async function parsePdf(filePath, { pages = null, maxPages = 1000, backen
   const data = new Uint8Array(await readFile(filePath))
   const { getDocument } = await loadPdfjs()
   const loadingTask = getDocument({ data, ...PDFJS_OPTIONS })
-  const doc = await loadingTask.promise
-
   try {
+    const doc = await loadingTask.promise
     const total = doc.numPages
     if (total > maxPages) {
       throw new Error(`PDF has ${total} pages, over the maxPages limit of ${maxPages}`)
@@ -112,9 +111,8 @@ export async function parsePdfInfo(filePath, maxPages = 1000) {
   const data = new Uint8Array(await readFile(filePath))
   const { getDocument } = await loadPdfjs()
   const loadingTask = getDocument({ data, ...PDFJS_OPTIONS })
-  const doc = await loadingTask.promise
-
   try {
+    const doc = await loadingTask.promise
     if (doc.numPages > maxPages) {
       throw new Error(`PDF has ${doc.numPages} pages, over the maxPages limit of ${maxPages}`)
     }

package/src/project-profile.js

@@ -17,11 +17,18 @@ function depsOf(manifest, fields) {
   const tags = new Set()
   for (const f of fields) {
     const deps = manifest && manifest[f]
-    if (deps && typeof deps === 'object') {
-      for (const name of Object.keys(deps)) {
-        tags.add(name.toLowerCase())
-        if (name.startsWith('@')) tags.add(name.split('/')[1].toLowerCase())
-      }
+    if (!deps || typeof deps !== 'object') continue
+    for (const name of Object.keys(deps)) {
+      if (typeof name !== 'string' || !name) continue
+      tags.add(name.toLowerCase())
+      if (!name.startsWith('@')) continue
+      // scoped 包名 `@scope/pkg`：要加的是 **scope**（`vue`），不是包名段（`compiler-sfc`）。
+      // 旧写法 `name.split('/')[1]` 让 `@vue/*` 项目永远拿不到 `vue` tag，
+      // trigger.scope:['vue'] / legacy scope 过滤会把最相关的那条 procedure 静默判死；
+      // 而 `@malformed`（没有 `/`）会在这里抛错，异常被 collectTags 整个吞掉 → 全项目 tags 清零。
+      const parts = name.slice(1).split('/')
+      if (parts[0]) tags.add(parts[0].toLowerCase())
+      if (parts[1]) tags.add(parts[1].toLowerCase())
     }
   }
   return tags