@yolk_vat-y/dsh-project-memory 0.5.6 → 0.5.8

package/src/index-pipeline.js

@@ -0,0 +1,119 @@
+// 索引一个文件的**唯一**实现。
+//
+// 这段逻辑以前在 index_repo（批量）、watch（轮询）、lazy（fs/observed 懒索引）里各抄一份，
+// 三份随后各自打补丁、已经漂移：index_repo 多一道冗余的 dump 预检、体积超限时删旧记录，
+// 而 watch/lazy 保留旧记录；terms 回填与单次读盘的写法也各不相同。
+// 现在「这个文件该不该读、读出来该写什么条目」只在这里定义一次；
+// 调用方只保留自己的编排（批量计数、watch 的 mtime 快照、lazy 的根解析与副作用）。
+import { statSync } from 'node:fs'
+import { isSupportedCode, isSupportedDoc, readFileForIndex } 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'
+
+/** 不索引的后缀。 */
+export const UNSUPPORTED = 'unsupported'
+/** 代码文件超过 maxFileSizeMb：读盘成本不抵符号表收益。 */
+export const OVERSIZE = 'oversize'
+/** 内容哈希未变，且无需回填词项。 */
+export const UNCHANGED = 'unchanged'
+/** 文档不可索引（dump / 抽取返回 null）→ 从 store 移除。 */
+export const DROP = 'drop'
+/** 有内容要写入 store。 */
+export const WRITE = 'write'
+
+/** 后缀 → 'code' | 'doc' | null。 */
+export function fileKind(ext) {
+  if (isSupportedCode(ext)) return 'code'
+  if (isSupportedDoc(ext)) return 'doc'
+  return null
+}
+
+function exceedsSizeCap(kind, size, config) {
+  return kind === 'code' && !!config.maxFileSizeMb && size > config.maxFileSizeMb * 1024 * 1024
+}
+
+/**
+ * 读取 + 判重 + 抽条目。抛出的异常（读盘失败、PDF 解析失败……）由调用方按各自策略处理：
+ * index_repo 收进 failures 汇总，watch 去重打印并可重试，lazy 记一行日志。
+ *
+ * @returns {{key: string, hash?: string, size?: number, type?: string, entries?: object[]}}
+ *   key 为 UNSUPPORTED / OVERSIZE / UNCHANGED / DROP / WRITE 之一。
+ * @param {object} args
+ * @param {number} [args.size] 调用方已 statSync 时传入，避免重复 stat。
+ * @param {boolean} [args.force] index_repo 的 reindex：忽略哈希跳过。
+ */
+export async function planFileIndex({ rel, filePath, kind, config, record, existingEntries = [], size, force = false }) {
+  if (!kind) return { key: UNSUPPORTED }
+  const fileSize = typeof size === 'number' ? size : statSync(filePath).size
+  if (exceedsSizeCap(kind, fileSize, config)) return { key: OVERSIZE }
+
+  // 单次读盘：同一 buffer 供内容哈希与正文解码使用（未变更的文件不解码）。
+  const { hash, buffer } = readFileForIndex(filePath)
+  // 旧 store 的 doc 条目缺 terms → 即使哈希未变也重抽一次（一次性回填）。
+  const backfill = kind === 'doc' && docEntriesNeedBackfill(existingEntries)
+  if (!force && record && record.sha256 === hash && !backfill) return { key: UNCHANGED }
+
+  if (kind === 'code') {
+    return { key: WRITE, hash, size: fileSize, type: 'code', entries: scanSymbols(rel, filePath, buffer.toString('utf8')) }
+  }
+  // dump 判定在 buildDocEntries 内部（唯一真源）：不可索引的文档返回 null。
+  const entries = await buildDocEntries(rel, filePath, {
+    chunkChars: config.chunkChars,
+    maxChunks: config.maxChunksPerFile,
+    maxFileSizeMb: config.maxFileSizeMb,
+    maxPdfPages: config.maxPdfPages,
+  })
+  return entries === null ? { key: DROP } : { key: WRITE, hash, size: fileSize, type: 'doc', entries }
+}
+
+/**
+ * plan → 落盘用的更新记录。只接受 DROP / WRITE：UNCHANGED / OVERSIZE 由调用方自己跳过，
+ * 误传会直接抛错——静默写进一条 entries=undefined 的记录才是真正的坑。
+ * `expectedHash` 是 CAS 基准：扫描之后文件又被改动时，commit 会拒绝这次写入，
+ * 调用方据此回滚自己的快照（见 commitFileUpdates 的返回值）。
+ */
+export function toFileUpdate(rel, plan, record) {
+  if (plan.key === DROP) return { rel, drop: true }
+  if (plan.key !== WRITE) throw new Error(`toFileUpdate: unexpected plan key ${plan.key}`)
+  return {
+    rel,
+    expectedHash: record?.sha256 ?? null,
+    hash: plan.hash,
+    size: plan.size,
+    type: plan.type,
+    entries: plan.entries,
+  }
+}
+
+/**
+ * 一批更新一次性落盘：写入 / 移除 → 清掉本轮未见到的旧条目 → 重建链接。
+ * 单事务的好处是 store 只 save 一次，watch 每轮不会反复重写。
+ *
+ * @returns {{stale: string[], removed: number}} stale 是 CAS 失败（并发改动）的 rel，
+ *   调用方应让它们保持「未落快照」状态，下一轮重试。
+ */
+export function commitFileUpdates(store, { updates, unseen = null, link = true }) {
+  const stale = []
+  let removed = 0
+  store.commit((s) => {
+    for (const update of updates) {
+      if (update.drop) {
+        s.removeFile(update.rel)
+        continue
+      }
+      if (!s.applyFileUpdate(update.rel, update)) stale.push(update.rel)
+    }
+    if (unseen) {
+      for (const rel of Object.keys(s.files)) {
+        if (!unseen.has(rel)) {
+          s.removeFile(rel)
+          removed++
+        }
+      }
+    }
+    if (link) linkEntries(s)
+  })
+  return { stale, removed }
+}

package/src/index.js

@@ -14,9 +14,7 @@ import { listTasksTool, selectTaskTool, archiveTaskTool, showTaskPanelTool } fro
 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'
+import { workflowCommandDefinition } from './commands/workflow.js'
 
 export const name = 'dsh-project-memory'
 export const inject = ['llm', 'tools']
@@ -90,6 +88,24 @@ export const Config = Schema.object({
     // 同一条 insight 在本会话里重复注入的冷却（pre-step 步数）。0（默认）= 正文没变就不再注入：
     // 注入消息留在会话历史里（宿主只追加不压缩），整块重发只是重复占位。>0 用于外部裁剪历史的场景。
     reinjectItemsAfter: Schema.number().default(0),
+    // --- 准入旋钮（0.5.8 起补声明）---
+    // 下面这些键自 S2/S4 起就在 cfgEngine / cfgAudit 里生效、README 也一直写着，但**从未**在
+    // Schema 里声明过：走 cordis.patch.yml 配它们会被宿主按「not a declared property」拒掉，
+    // 等于文档里的旋钮是假的。默认值以 cfgEngine 的兜底值为准（那里是权威，这里只负责暴露）。
+    gateCooldownSteps: Schema.number().default(2),
+    maxItemsPerSession: Schema.number().default(12),
+    maxItemCharsPerSession: Schema.number().default(4000),
+    hintMinCoverage: Schema.number().default(0.45),
+    hintMinMatched: Schema.number().default(2),
+    hintMinSupport: Schema.number().default(0.15),
+    legacyScope: Schema.union(['filter', 'ignore']).default('filter'),
+    auditLog: Schema.boolean().default(true),
+    auditMaxBytes: Schema.number().default(262144),
+    // 影子记录（admission-shadow.jsonl）：**每步**一行，含全部候选的判据特征与场景。
+    // 主审计只在真的注入时写，静默步零痕迹 → 无法离线重放"换个阈值会怎样"，也攒不出样本。
+    // 只写盘、不进 prompt、不花 token，所以默认开。
+    shadowLog: Schema.boolean().default(true),
+    shadowMaxBytes: Schema.number().default(2097152),
   }).default({}),
 })
 
@@ -123,15 +139,15 @@ export function apply(ctx, config) {
   ctx.tools.register(archiveTaskTool(config, { llm: ctx.llm, ctx }))
   ctx.tools.register(showTaskPanelTool(config))
 
-  // /tasks、/task、/insight 用户命令（宿主 commands 服务存在时注册，feature-detect 降级）
+  // /tasks：唯一的用户命令（合并自原 /tasks、/task、/insight —— 宿主命令只要注册就会
+  // 出现在 `/` 菜单的「指令」组里且无法隐藏，三条命令就是三行去不掉的原始行）。
+  // 切换/归档/审核等动作作为子动词，由面板按钮经 remote.commands.execute 驱动。
   try {
     ctx.inject(['commands'], (commandsCtx) => {
-      commandsCtx.commands.register(tasksCommandDefinition(config, ctx))
-      commandsCtx.commands.register(taskCommandDefinition(config, ctx))
-      commandsCtx.commands.register(insightCommandDefinition(config, ctx))
+      commandsCtx.commands.register(workflowCommandDefinition(config, ctx))
     })
   } catch (err) {
-    console.error(`[dsh-project-memory] /tasks,/task,/insight registration skipped: ${err.message}`)
+    console.error(`[dsh-project-memory] /tasks registration skipped: ${err.message}`)
   }
 
   ctx.tools.register(indexDocTool(ctx, config))

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']
@@ -134,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()
@@ -162,6 +180,45 @@ export function mergeInto(existing, base, cfg, nowIso) {
   return existing
 }
 
+/**
+ * 使用记账：条目被**真正用到**时更新活跃度——注入进了上下文，或被 `query_memory` 命中。
+ *
+ * 为什么必须有：`applyDecay` / `pruneItems` 判活跃度只看 `lastHitAt || updatedAt || createdAt`，
+ * 而 `lastHitAt` 此前只由 merge/reinforce 写（= 模型又写了一条相近的知识）。于是一条天天被注入、
+ * 但从没人重写它的教训，`decayDays`（默认 90）之后会被自动归档、再也不会被推送——**用得最多的
+ * 反而等于没人用过**。这是行为缺陷，不是调优问题。
+ *
+ * 记账**不参与任何注入判据**：它只影响活跃度/衰减，以及离线训练样本的标签。
+ * 语义是"曝光次数"而非"被采纳次数"——更强的信号（模型是否真的照着做了）需要另外的回路。
+ * 只记非归档条目（归档件本来就召回不到）。返回实际加一的条数，调用方据此决定是否落盘。
+ * @returns {number} 被加一的条目数
+ */
+export function recordHit({ store, globalStore, ids, nowIso } = {}) {
+  const want = new Set((ids || []).filter(Boolean))
+  if (!want.size) return 0
+  const now = nowIso || new Date().toISOString()
+  let n = 0
+  const touch = (items) => {
+    let c = 0
+    for (const it of items || []) {
+      if (!it || it.archived || !want.has(it.id)) continue
+      it.hitCount = num(it.hitCount, 0) + 1
+      it.lastHitAt = now
+      c++
+    }
+    n += c
+    return c
+  }
+  if (store && typeof store.insightItems === 'function') {
+    const items = store.insightItems()
+    if (touch(items)) store.replaceInsightItems(items) // 标脏；落盘由调用方决定
+  }
+  if (globalStore && typeof globalStore.items === 'function') {
+    if (touch(globalStore.items())) globalStore.markDirty()
+  }
+  return n
+}
+
 export function reinforceOnly(existing, base, nowIso) {
   const now = nowIso || new Date().toISOString()
   existing.sourceTaskIds = unionStrings(existing.sourceTaskIds, base.sourceTaskIds)
@@ -210,9 +267,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++
@@ -221,7 +281,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
@@ -300,7 +364,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
   }
 
@@ -475,16 +543,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)
@@ -514,16 +580,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)
@@ -531,6 +595,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
@@ -538,17 +604,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()
@@ -564,7 +632,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/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

package/src/readiness.js

@@ -82,7 +82,16 @@ export function buildReadinessContext(input = {}) {
   const humanText = String(input.humanText ?? input.query ?? '')
   const actionText = String(input.actionText || '')
   const actions = new Set([...(input.actions || []), ...detectActions(humanText), ...detectActions(actionText)])
-  const paths = new Set([...(input.paths || []), ...extractPaths(actionText), ...extractPaths(humanText)])
+  // 人类消息里提到的路径 = **动手前的写意图**（"帮我改 src/x.js"）；动作文本里的路径不区分读写，
+  // 读一个文件不该算写目标（否则 `read README.md` 会命中 writes:['README.md']）。
+  // 两者对外仍合并成 `paths`（兼容既有语义），写通道单看 humanPaths。
+  // 调用方若已带 humanPaths（injectForStep 构建后再传给 buildInjection），以它为准，
+  // 否则退回 paths —— 避免把上一次算出来的并集（含读路径）再当写意图。
+  const humanPaths = new Set([
+    ...(Array.isArray(input.humanPaths) ? input.humanPaths : (input.paths || [])),
+    ...extractPaths(humanText),
+  ])
+  const paths = new Set([...humanPaths, ...extractPaths(actionText)])
   // 动作平面（S1）：结构化调用优先；没有结构化调用时对 actionText 跑一遍 shell 规则兜底。
   const fromText = activityFromText(actionText)
   const ops = new Set([...(input.ops || []), ...fromText.ops])
@@ -97,6 +106,7 @@ export function buildReadinessContext(input = {}) {
     actionText,
     actions: [...actions],
     paths: [...paths],
+    humanPaths: [...humanPaths],
     ops: [...ops],
     targets: [...targets],
     hosts: [...hosts],
@@ -209,6 +219,10 @@ export function intentText(text) {
     .replace(/“[^”\n]*”/g, ' ')
     .replace(/[A-Za-z]:\\[^\s"']*/g, ' ')
     .replace(/(?:[A-Za-z0-9_.@-]+\/)+[A-Za-z0-9_.@-]+/g, ' ')
+    // 带扩展名的**非 ASCII 文件名**（`石啸天-记忆方向调研.pptx` / `docs/面试演示-王金鹏.md`）：
+    // 只挡 ASCII 路径不够——中文文件名整块留下，"调研""面试"这类子串照样触发 when.intents，
+    // 正是引号剥离要防的那类假阳性。ASCII 裸名（如 de-TODO.md）保持原语义，不在这里动。
+    .replace(/\S*[^\x00-\x7F]\S*\.[A-Za-z][A-Za-z0-9]{0,7}\b/g, ' ')
     // 仓库里的裸文件名（README / CHANGELOG …）也是语料，不是意图
     .replace(/\b(?:README|CHANGELOG|LICENSE|AGENTS|CONTRIBUTING|Dockerfile|Makefile)\b/g, ' ')
     .replace(/\s+/g, ' ')
@@ -301,10 +315,14 @@ export function matchTrigger(trigger, ctx) {
   for (const op of when.ops || []) {
     if (op && (ctx?.ops || []).includes(String(op))) return `op:${op}`
   }
+  // 写目标 = 已观察到的结构化写调用 ∪ 人类消息里提到的路径（动手前的写意图）。
+  // DSH 没有工具执行前拦截钩子，动手前唯一能拿到的写意图就是人类消息里的路径；
+  // 但动作文本里的**读**路径不算（`read README.md` 不是"即将写 README.md"）。
+  const writeTargets = [...(ctx?.targets || []), ...(ctx?.humanPaths || [])]
   for (const w of when.writes || []) {
     // 扩展名/泛名 glob 在这里被硬性忽略：`*.pptx` 这类条件只能撒谎，不能收窄。
     if (!w || isDroppableGlob(w)) continue
-    if (matchAnyPath(w, ctx?.targets)) return `write:${w}`
+    if (matchAnyPath(w, writeTargets)) return `write:${w}`
   }
   const intent = ctx?.intent ?? ctx?.humanText ?? ''
   for (const it of when.intents || []) {
@@ -355,6 +373,9 @@ export function normalizeTrigger(it, opts = {}) {
   // （实测：那样会让 D 场景一次多出 6 条假阳性）。
   const intents = []
   for (const k of t.keywords || []) if (isIntentWord(k)) intents.push(String(k))
+  // 旧 `symbols` 也走文本平面：不归一就等于静默丢掉一个作者写下的触发面
+  // （README 承诺 keywords/symbols/actions/paths/scope 都会迁移）。与 keywords 同一把准入尺子。
+  for (const s of t.symbols || []) if (isIntentWord(s)) intents.push(String(s))
   const when = {}
   if (ops.size) when.ops = [...ops].sort()
   if (writes.length) when.writes = [...new Set(writes)]
@@ -463,6 +484,9 @@ export function relativeHits(scored, { ratioMin = 0.5 } = {}) {
   const list = (scored || []).filter((r) => r && Number.isFinite(r.score) && r.score > 0)
   if (!list.length) return []
   const top = list[0].score
-  const floor = top * (typeof ratioMin === 'number' && ratioMin > 0 ? ratioMin : 0.5)
+  // 显式的 0 表示"关掉相对门槛"（只剩 score>0）；未给/非法值才回退 0.5。
+  // 旧写法 `ratioMin > 0 ? ratioMin : 0.5` 把 0 当成"没配"，配置上无法关闭。
+  const ratio = typeof ratioMin === 'number' && Number.isFinite(ratioMin) ? ratioMin : 0.5
+  const floor = top * Math.max(0, Math.min(1, ratio))
   return list.filter((r) => r.score >= floor)
 }