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

package/cordis.patch.yml

@@ -10,4 +10,10 @@
         lazyIndexing: true
         autoIndexOnFirstUse: false
         watch: true
-        watchInterval: 15
+        watchInterval: 15
+        # 危险根护栏（家目录 / 文件系统根 / 系统与包管理器前缀整体扫描会吃满内存）。
+        # 自动路径永远不越权；true 只放开**显式**带 root 的工具调用。
+        allowUnsafeRoots: false
+        # 单次扫描上限；截断会报告，且不会删除未扫到的条目。
+        maxScanFiles: 20000
+        maxScanDepth: 12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Persistent project memory for dsh agents: index docs (PDF/Markdown/text) and code symbols into a searchable per-workspace store, recall them with cited sources, and keep experience entries (problems -> solutions) searchable on demand.",
   "type": "module",
   "main": "src/index.js",
@@ -18,8 +18,9 @@
     "url": "https://github.com/00080000/dsh-project-memory.git"
   },
   "scripts": {
-    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs && node test/host-contract.test.mjs && node test/llm-route.test.mjs && node test/doc-index.test.mjs && node test/client-hints.test.mjs && node test/recall.test.mjs && node test/readiness.test.mjs && node test/insight-derive.test.mjs && node test/readiness-eval.test.mjs && node test/ops.test.mjs && node test/injection-audit.test.mjs && node test/injection-budget.test.mjs && node test/injection-scenarios.test.mjs && node test/bugfix-0.5.7.test.mjs",
+    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs && node test/host-contract.test.mjs && node test/llm-route.test.mjs && node test/doc-index.test.mjs && node test/client-hints.test.mjs && node test/recall.test.mjs && node test/readiness.test.mjs && node test/insight-derive.test.mjs && node test/readiness-eval.test.mjs && node test/ops.test.mjs && node test/injection-audit.test.mjs && node test/injection-budget.test.mjs && node test/injection-scenarios.test.mjs && node test/bugfix-0.5.7.test.mjs && node test/client-icons.test.mjs && node test/client-slash.test.mjs && node test/workflow-command.test.mjs && node test/client-session-id.test.mjs && node test/task-view.test.mjs && node test/root-guards.test.mjs",
     "eval:injection": "node test/injection-scenarios.test.mjs",
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.client.json",
     "selfcheck:triggers": "node test/injection-scenarios.test.mjs --selfcheck",
     "bench": "node scripts/bench.mjs",
     "bench:synthetic": "node scripts/bench-synthetic.mjs",
@@ -92,10 +93,7 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-ui-primitives",
-        "@deepseek-ai/dsh-client-ui-slots",
-        "@deepseek-ai/dsh-client-store"
+        "@deepseek-ai/dsh-client-locale"
       ],
       "platform": "web"
     }

package/scripts/bench-synthetic.mjs

@@ -90,7 +90,7 @@ async function coldIndex(root, config) {
   const store = new ProjectMemoryStore(storeDir)
   // 首次 load 会读盘（若已存在），这里传入一个全新实例以贴近真实冷启动
   store.load()
-  const files = walkDir(root)
+  const { files } = walkDir(root)
   const seen = new Set()
   let updated = 0
   const fileUpdates = []
@@ -234,7 +234,7 @@ async function main() {
   {
     const root = tmpd('pm-sym-')
     generateCorpus(root, FILES)
-    const files = walkDir(root).filter((f) => f.endsWith('.js'))
+    const files = walkDir(root).files.filter((f) => f.endsWith(".js"))
     const times = []
     const n = Math.min(files.length, 500)
     for (let i = 0; i < n; i++) {
@@ -256,7 +256,7 @@ async function main() {
     generateCorpus(root, FILES)
     const { store, report } = await coldIndex(root, config)
     void report
-    const files = walkDir(root).filter((f) => f.endsWith('.js'))
+    const files = walkDir(root).files.filter((f) => f.endsWith(".js"))
     const times = []
     const n = Math.min(files.length, 50)
     for (let i = 0; i < n; i++) {

package/scripts/bench.mjs

@@ -123,7 +123,7 @@ const kb = (n) => `${(n / 1024).toFixed(1)} KB`
 const mb = (n) => `${(n / 1024 / 1024).toFixed(2)} MB`
 
 // ---------- 1. 扫描 ----------
-const all = walkDir(root)
+const { files: all } = walkDir(root)
 const targets = []
 let skippedPdf = 0
 for (const abs of all) {

package/src/audit.js

@@ -14,6 +14,12 @@ import path from 'node:path'
 export const AUDIT_FILE = 'injection-audit.jsonl'
 const DEFAULT_MAX_BYTES = 256 * 1024
 
+// 影子记录：与主审计**分开一个文件**。主审计只记"真的注入了"的步，静默步（包括对照组那种
+// "本该零注入"的步）完全不落痕，于是日志回答不了"换个阈值/换个判据会怎样"。影子记录每步都写，
+// 带全部候选的特征与判据结果，用来 (a) 离线重放任一阈值、(b) 攒"特征 → 该不该注入"的训练样本。
+export const SHADOW_FILE = 'admission-shadow.jsonl'
+const DEFAULT_SHADOW_MAX_BYTES = 2 * 1024 * 1024
+
 /** 审计配置：默认开（观测是这个插件唯一的仪表盘），显式 `auditLog: false` 才关。 */
 export function cfgAudit(config) {
   const c = (config && config.autoContext) || {}
@@ -27,6 +33,63 @@ export function auditFileFor(memoryDir) {
   return path.join(memoryDir, AUDIT_FILE)
 }
 
+/** 影子记录配置：默认开（它只写盘、不进 prompt、不花 token），显式 `shadowLog: false` 才关。 */
+export function cfgShadow(config) {
+  const c = (config && config.autoContext) || {}
+  return {
+    enabled: c.shadowLog !== false,
+    maxBytes: typeof c.shadowMaxBytes === 'number' && c.shadowMaxBytes > 0 ? c.shadowMaxBytes : DEFAULT_SHADOW_MAX_BYTES,
+  }
+}
+
+export function shadowFileFor(memoryDir) {
+  return path.join(memoryDir, SHADOW_FILE)
+}
+
+/**
+ * 一步的影子记录（纯函数，可单测）。与主审计的差别只有两点，但都是关键：
+ *  - **每步都写**（含零注入的静默步与对照组），所以"没注入"也留下了可复盘的事实；
+ *  - 带**全部候选**的判据特征（cov/matched/support/relative）与场景（query/ops/writes），
+ *    所以能离线回答"阈值换成 0.40 会注入什么"、并攒出"特征 → 该不该注入"的样本。
+ * @param {object} input { sessionId, root, step, query, ops, writes, reasons, candidates, silence }
+ */
+export function shadowRecordFrom(input) {
+  const reasons = Array.isArray(input.reasons) ? input.reasons : []
+  const candidates = Array.isArray(input.candidates) ? input.candidates : []
+  return {
+    at: new Date().toISOString(),
+    session: input.sessionId || null,
+    root: input.root || null,
+    step: typeof input.step === 'number' ? input.step : null,
+    // 人类消息截断保存：没有它就判不了"这次注入该不该"——标签要能回放到当时的场景。
+    query: typeof input.query === 'string' ? input.query.slice(0, 300) : '',
+    ops: (Array.isArray(input.ops) ? input.ops : []).slice(0, 12),
+    writes: (Array.isArray(input.writes) ? input.writes : []).slice(0, 12),
+    injected: reasons.map((r) => ({ id: r.id, channel: r.channel, why: r.why })),
+    candidates,
+    silence: input.silence || null,
+  }
+}
+
+/**
+ * 追加一行影子记录。返回是否写入成功（仅供测试断言）。与主审计同约定：任何异常一律吞掉，
+ * 绝不影响宿主请求。
+ */
+export function appendShadowAudit(memoryDir, record, cfg) {
+  const c = cfg || {}
+  if (c.enabled === false) return false
+  if (!memoryDir || !record) return false
+  try {
+    mkdirSync(memoryDir, { recursive: true })
+    const file = shadowFileFor(memoryDir)
+    rotateIfOversized(file, c.maxBytes || DEFAULT_SHADOW_MAX_BYTES)
+    appendFileSync(file, `${JSON.stringify(record)}\n`)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * 一次注入的审计记录（纯函数，可单测）。字段刻意保持"能直接回答两个问题"：
  * 注入了什么（injected）、为什么没注入别的（dropped）。

package/src/auto-inject.js

@@ -8,19 +8,52 @@
 import { createHash } from 'node:crypto'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { ProjectMemoryStore } from './store.js'
-import { memoryRootFor } from './util/fs.js'
+import { hasProjectMarker, isUnsafeRoot, memoryRootFor, resolveProjectMemoryRoot } from './util/fs.js'
+import { textOf } from './util/text.js'
+import { stepContent } from './util/task-view.js'
 import { insightMatchText, normalizedTokenOverlap } from './similarity.js'
 import { BoundedMap, SessionCache } from './util/session-cache.js'
-import { cfgInsight, GlobalStore, defaultGlobalFile } from './insight-store.js'
+import { cfgInsight, GlobalStore, defaultGlobalFile, recordHit } from './insight-store.js'
 import { projectTags } from './project-profile.js'
 import { rankEntriesMergedScored } from './util/search.js'
 import { insightToEntry, insightScoringText } from './recall.js'
 import { buildReadinessContext, hintQueryText, idfCoverage, matchTrigger, normalizeTrigger, relativeHits } from './readiness.js'
 import { activityFromCalls } from './ops.js'
-import { appendInjectionAudit, auditRecordFrom, cfgAudit } from './audit.js'
+import { appendInjectionAudit, appendShadowAudit, auditRecordFrom, cfgAudit, cfgShadow, shadowRecordFrom } from './audit.js'
 
 export const INJECT_MARK = '[Memory Inject]'
 
+/**
+ * 本插件在 `message.source` 上声明的生产者 kind。
+ *
+ * 会话格式 v4 起 `MessageSourceMap` 是「每个生产者声明自己的 kind」的可合并联合类型，
+ * **没有** `plugin` 这个兜底 kind：宿主的 `assertV4MessageSources` / `assertV4SourceRowAdmission`
+ * 会直接拒绝 `kind === 'plugin'` 的消息（`session-format-v3-to-v4/src/message-sources.ts`），
+ * 而拒绝发生在编码落盘那一刻 —— 于是整轮运行失败。
+ *
+ * 值选 `plugin:<包名>` 是因为这正是宿主自己的 v3→v4 迁移对本插件历史消息的改写结果
+ * （`rewritePluginSource`：第三方插件 → `plugin:${plugin}`，并丢弃 `plugin` 字段）。
+ * 新写的消息与迁移后的旧消息因此是**同一个生产者身份**，自激闸门（见 isOwnInjection）不需要按新旧分叉。
+ */
+export const SOURCE_KIND = 'plugin:dsh-project-memory'
+
+/**
+ * 这条消息是不是本插件自己注入的？
+ *
+ * 三种写法都要认，因为同一条历史消息在不同阶段形状不同：
+ *   - `plugin:dsh-project-memory` —— 现在写的，也是 v3→v4 迁移改写老消息的结果；
+ *   - `project-memory` —— 保留的别名：将来若再换 kind，自激闸门不会因此失效；
+ *   - `plugin: 'dsh-project-memory'` —— 迁移前内存里尚未落盘的旧形状（老宿主 / 测试夹具）。
+ * @param {object|undefined|null} source - message.source
+ * @returns {boolean}
+ */
+export function isOwnInjection(source) {
+  if (!source || typeof source !== 'object') return false
+  return source.kind === SOURCE_KIND
+    || source.kind === 'project-memory'
+    || source.plugin === 'dsh-project-memory'
+}
+
 /**
  * 注入正文的最小可用长度：预算塞不下这么多就宁可不注入（记 dropped）。
  * 与其输出 `- [ins_xxx] procedure ` 这种 stub，不如保持沉默——stub 只消耗 token 不传递信息。
@@ -67,9 +100,13 @@ export function cfgEngine(config) {
     // 每会话条目注入的上限（条数 / 字符）：预算只能是上限，不是目标。
     maxItemsPerSession: typeof c.maxItemsPerSession === 'number' && c.maxItemsPerSession >= 0 ? c.maxItemsPerSession : 12,
     maxItemCharsPerSession: typeof c.maxItemCharsPerSession === 'number' && c.maxItemCharsPerSession >= 0 ? c.maxItemCharsPerSession : 4000,
-    // 提示通道的**绝对**下限（IDF 加权覆盖率）：相对阈值分不出"有信号"和"矮子里拔将军"。
-    // null = 关闭（回到只有相对阈值的老行为）。
-    hintMinCoverage: typeof c.hintMinCoverage === 'number' && c.hintMinCoverage >= 0 ? c.hintMinCoverage : 0.3,
+    // 提示通道的**绝对**覆盖底线（IDF 加权覆盖率）：相对阈值分不出"有信号"和"矮子里拔将军"，
+    // 只有归一在 [0,1]、有真零点才谈得上下限。0.30 时的实测反例：真实 store（43 条同源洞察）上，
+    // 对照组场景「改 pptx 时间戳」以 cov 0.32~0.35 注入了 3 条无关条目——语料同源时共享词多、
+    // IDF 分辨力被拉平，"最不坏的一条"就能过 0.30。0.45 落在实测分布的空隙里（假阳性 ≤0.35、
+    // 下一个真命中 ≥0.49），合成标注集在 0.6 以前 precision/recall 也仍是 1.00。
+    // 用 `--hint-cov` 在真实 store 上重放可复核（见 test/injection-scenarios.test.mjs）。
+    hintMinCoverage: typeof c.hintMinCoverage === 'number' && c.hintMinCoverage >= 0 ? c.hintMinCoverage : 0.45,
     // 提示通道还要求至少这么多个共同词：单个通用词（"插件"）也能拿到 coverage=1.00。
     hintMinMatched: typeof c.hintMinMatched === 'number' && c.hintMinMatched >= 0 ? c.hintMinMatched : 2,
     // 通道级沉默：查询里能在语料中找到对应的词占比低于这个值时，整条提示通道本轮不出声。
@@ -78,14 +115,6 @@ export function cfgEngine(config) {
   }
 }
 
-function textOf(message) {
-  const blocks = (message && message.content) || []
-  return blocks
-    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
-    .map((b) => b.text)
-    .join('\n')
-}
-
 export function lastUserText(messages) {
   if (!Array.isArray(messages)) return ''
   let fallback = ''
@@ -98,8 +127,8 @@ export function lastUserText(messages) {
     // 上一步的注入块会变成这一步的就绪查询（自激：拿自己注入的内容再检索一遍）。
     if (m.source && m.source.kind === 'user') return t.trim()
     // 本插件注入的块同样是 role=user。无 source 的老宿主下若把它当兜底查询，
-    // 就成了"拿自己上一步注入的内容再检索一遍"的自激——正是 kind==='user' 这道闸要防的。
-    if (m.source && m.source.plugin === 'dsh-project-memory') continue
+    // 就成了"拿自己上一步注入的内容再检索一遍"的自激——正是 isOwnInjection 这道闸要防的。
+    if (isOwnInjection(m.source)) continue
     if (!fallback) fallback = t.trim() // 无 source 的消息（老宿主 / 测试）兜底
   }
   return fallback
@@ -146,7 +175,7 @@ export function shouldEchoTaskCard(task, cfg) {
 export function buildEntryContent(task, cfg, { withEdited = true } = {}) {
   if (!task) return ''
   const c = cfg || {}
-  const steps = (task.steps || []).map((s) => (typeof s === 'string' ? s : s.content || s.text || '').slice(0, 80))
+  const steps = (task.steps || []).map((s) => stepContent(s).slice(0, 80))
   const progress = steps.length ? `${steps.length} 步` : ''
   const card = [
     `任务: ${task.title || '(untitled)'}`,
@@ -226,7 +255,11 @@ function collectTriggered(cands, ctx) {
  */
 function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
   const hints = []
-  if (!cands.length) return hints
+  // 影子记录用：本步**全部**被评过分的候选 + 特征 + 判据结果。与 hints/dropped 分开算——
+  // 现有两类记录都只覆盖"过得了相对阈值的那部分"，恰恰缺了"因为没到阈值而从未被考虑"的候选，
+  // 而那正是离线重放阈值时需要的那批。这里只做加法，不动任何现有判据。
+  const candidates = []
+  if (!cands.length) return { hints, candidates }
   if (typeof cfg.relevanceMin === 'number') {
     // 兼容：显式 relevanceMin → 旧的绝对 overlap 判据（老 profile 行为不变）
     for (const it of cands) {
@@ -234,10 +267,10 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
       if (score >= cfg.relevanceMin) hints.push({ it, score, why: `overlap:${score.toFixed(3)}` })
     }
     hints.sort((a, b) => b.score - a.score)
-    return hints
+    return { hints, candidates } // 旧判据路径不产出影子候选（已废弃，无重放价值）
   }
   const q = hintQueryText(hintQuery)
-  if (!q) return hints
+  if (!q) return { hints, candidates }
   const byId = new Map(cands.map((it) => [it.id, it]))
   // 覆盖率语料必须与 BM25 排序同源（insightScoringText）：否则"只在 fix/solution 里有匹配"
   // 的查询词 df=0 → supportRatio=0 → 整条提示通道沉默，而排序明明给了它高分。
@@ -272,7 +305,36 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
     }
     hints.push({ it, score: r.score, why: `relative:${(r.score / (scored[0].score || 1)).toFixed(2)} cov:${ev.coverage.toFixed(2)}/${ev.matched}` })
   }
-  return hints
+
+  // ---- 影子候选（只读、无副作用）：重放一遍**全部**被评分的条目，标出它卡在哪一关 ----
+  // 顺序与真实判据一致（support → coverage → thin → relative），最后 'cand' = 过了全部门槛
+  // （注意 'cand' 不等于"真的注入了"：还要过去重/预算/冷却，那些写在同一行的 injected/silence）。
+  {
+    const top = scored[0]?.score || 0
+    const ratio = typeof cfg.signalMinRatio === 'number' && Number.isFinite(cfg.signalMinRatio) ? cfg.signalMinRatio : 0.5
+    for (const r of scored) {
+      const it = byId.get(r.entry.insightId)
+      if (!it || !Number.isFinite(r.score) || r.score <= 0) continue
+      const ev = coverage.get(it.id) || { coverage: 0, matched: 0, supported: 0, terms: 0 }
+      const needMatched = Math.min(typeof cfg.hintMinMatched === 'number' ? cfg.hintMinMatched : 2, ev.terms)
+      let decision = 'cand'
+      if (channelThin) decision = 'support'
+      else if (typeof cfg.hintMinCoverage === 'number' && ev.coverage < cfg.hintMinCoverage) decision = 'coverage'
+      else if (ev.matched < needMatched) decision = 'thin'
+      else if (r.score < top * Math.max(0, Math.min(1, ratio))) decision = 'relative'
+      candidates.push({
+        id: it.id,
+        channel: 'hint',
+        rel: Number((r.score / (top || 1)).toFixed(3)),
+        coverage: Number(ev.coverage.toFixed(3)),
+        matched: ev.matched,
+        support: ev.supported,
+        terms: ev.terms,
+        decision,
+      })
+    }
+  }
+  return { hints, candidates }
 }
 
 /**
@@ -317,7 +379,7 @@ export function buildInjection(opts) {
   // procedure 不进提示通道：它要过 trigger.scope（见 scoreHints 注释）。
   const consumed = new Set(triggered.map((t) => t.it.id))
   const hintCands = skipItems ? [] : cands.filter((it) => !consumed.has(it.id) && it.kind !== 'procedure')
-  const hints = scoreHints({
+  const { hints, candidates } = scoreHints({
     cands: hintCands,
     query,
     humanText: ctx.humanText,
@@ -368,7 +430,7 @@ export function buildInjection(opts) {
   // 整块只受单轮预算（maxTokens）约束；会话条目额度已在 place() 里单独扣过。
   const clamp = (t) => (t.length > stepBudget ? `${t.slice(0, stepBudget)}\n…(截断)` : t)
   const dedupeText = clamp([entryStable, ...parts].filter(Boolean).join('\n'))
-  return { text: clamp(total.join('\n')), entry, entryStable, labels, reasons, dropped, dedupeText, itemChars: itemUsed }
+  return { text: clamp(total.join('\n')), entry, entryStable, labels, reasons, dropped, candidates, dedupeText, itemChars: itemUsed }
 }
 
 // 每会话状态的会话数上限：六张表共用（旧实现把同一个 200 在五处各写一遍）。
@@ -404,6 +466,8 @@ class InjectionSessions {
     // 反应窗口：本会话最近观察到的 tool/call（参数里有 git commit / npm publish / 改动的路径）。
     // 宿主没有"工具执行前拦截"钩子，所以这是 pre-step 之外唯一能拿到的动作事实。
     this.observed = cache(() => [])
+    // 本会话是否已通告"记忆根是推定的"（会话工作目录，无项目标记）。状态声明只发一次。
+    this.rootNoticed = cache(() => false)
     this._all = Object.values(this)
   }
 
@@ -439,6 +503,7 @@ export function installAutoInject(ctx, config) {
   const cfg = cfgEngine(config)
   // 审计配置同 cfg：安装时解析一次（与 autoContext 其余开关一致）。
   const audit = cfgAudit(config)
+  const shadow = cfgShadow(config)
   const sessions = new InjectionSessions()
 
   installCallObserver(ctx, sessions)
@@ -455,7 +520,7 @@ export function installAutoInject(ctx, config) {
     if (!decision) return fallback()
     if (decision.kind !== 'enter') return decision
     try {
-      return (await injectForStep({ payload, decision, config, cfg, audit, sessions })) || decision
+      return (await injectForStep({ payload, decision, config, cfg, audit, shadow, sessions })) || decision
     } catch (err) {
       console.error(`[dsh-project-memory] auto-inject skipped: ${err?.message || err}`)
       return decision
@@ -463,15 +528,38 @@ export function installAutoInject(ctx, config) {
   })
 }
 
+/** 已就「会话根不安全」提示过的目录：每个进程、每个根只提示一次。 */
+const warnedUnsafeRoots = new Set()
+
+function warnUnsafeSessionRoot(root) {
+  if (warnedUnsafeRoots.has(root)) return
+  warnedUnsafeRoots.add(root)
+  console.error(
+    `[dsh-project-memory] session cwd ${root} is not a project root (home / system / package-manager prefix); ` +
+      'project memory and its audit logs are disabled for this session. Start dsh inside a project directory to enable them.',
+  )
+}
+
 /**
  * 一个 pre-step 的注入决策：解析会话 → 排程 → 必要时构造消息。
  * 返回 null 表示本步无事可做（交回原决策）。
  */
-async function injectForStep({ payload, decision, config, cfg, audit, sessions }) {
+async function injectForStep({ payload, decision, config, cfg, audit, shadow, sessions }) {
   const session = payload && payload.agent && payload.agent.session
-  const root = session && session.header && session.header.cwd
+  const cwd = session && session.header && session.header.cwd
   const sessionId = session && session.id
-  if (!root || !sessionId) return null
+  if (!cwd || !sessionId) return null
+  // 会话 cwd 是家目录/系统目录时整条链路停在这里：不读 store（历史遗留的超大 store
+  // 光是 load() 就能 OOM），也不写审计——`appendShadowAudit` 里的 mkdirSync 正是把
+  // `.dsh-project-memory` 造进家目录、进而触发"目录自标记 → 家目录被锁成项目"的那一步。
+  if (isUnsafeRoot(cwd)) {
+    warnUnsafeSessionRoot(cwd)
+    return null
+  }
+  // 记忆根与懒索引/工具侧同一套解析：项目标记优先，其次是安全的会话工作目录。
+  // 少了这一步，同一个会话的审计日志与懒索引会落在两个不同的 store 里。
+  const root = resolveProjectMemoryRoot(cwd)
+  if (!root) return null
 
   const query = lastUserText(decision.messages)
   const memoryRoot = memoryRootFor(root, config.memoryDir)
@@ -518,8 +606,29 @@ async function injectForStep({ payload, decision, config, cfg, audit, sessions }
   // 留痕仍然记账（去重 + 上限），只是默认不外泄到用户的终端。
   recordDropped({ sessions, sessionId, dropped: built.dropped, budgetLog: cfg.budgetLog })
 
-  const fp = fingerprint(built.dedupeText ?? built.text)
-  if (!built.text || fp === sessions.lastText.peek(sessionId)) return null
+  // 影子记录：**每步**都写一行（含零注入的静默步与对照组），带全部候选的判据特征。
+  // 主审计只在真的注入时写，静默步零痕迹 → 日志无法离线重放"换个阈值会怎样"，
+  // 也攒不出训练样本。只写盘、不进 prompt、不花 token。
+  appendShadowAudit(memoryRoot, shadowRecordFrom({
+    sessionId,
+    root,
+    step: stepNo,
+    query: query || '',
+    ops: readiness.ops,
+    writes: readiness.targets,
+    reasons: built.reasons,
+    candidates: built.candidates,
+    silence: silence.reason,
+  }), shadow)
+
+  // 记忆根通告：根是**推定**的（会话工作目录，且该目录没有任何项目标记）时，
+  // 第一次注入前告诉模型"记忆现在存在哪、怎么改"。它是状态声明（与常驻任务卡同类），
+  // 只发一次、不占条目额度；否则模型只看到一条来自某处的记忆，却不知道那个根是怎么来的。
+  const notice = rootNotice({ root, sessionId, sessions, config })
+
+  const fp = built.text ? fingerprint(built.dedupeText ?? built.text) : fingerprint(notice || '')
+  const injectedText = notice ? (built.text ? `${notice}\n${built.text}` : notice) : built.text
+  if (!injectedText || fp === sessions.lastText.peek(sessionId)) return null
   sessions.lastText.set(sessionId, fp)
 
   // 只记真的进了上下文的那几条：dropped 的没被看到，不能记账（否则以后永远不再注入）。
@@ -534,12 +643,25 @@ async function injectForStep({ payload, decision, config, cfg, audit, sessions }
     quota.lastStep = stepNo
   }
 
+  // 使用记账：注入进上下文 = 这条记忆被用到了。必须在这里显式落盘——注入路径不会走到
+  // 任何其它 save()，只标脏等于进程退出就丢。记账失败绝不影响注入（与审计同约定）。
+  if (built.reasons.length) {
+    try {
+      if (recordHit({ store, globalStore, ids: built.reasons.map((r) => r.id) })) {
+        store.save()
+        globalStore.commit()
+      }
+    } catch {
+      /* ignore：记账是旁路，不能拖累注入 */
+    }
+  }
+
   // S0 观测：只记真的进了上下文的那一次（dropped 单独出现不写，否则每步刷屏）。
   appendInjectionAudit(memoryRoot, auditRecordFrom({
     sessionId,
     root,
     step: stepNo,
-    text: built.text,
+    text: injectedText,
     labels: built.labels,
     reasons: built.reasons,
     dropped: built.dropped,
@@ -547,7 +669,29 @@ async function injectForStep({ payload, decision, config, cfg, audit, sessions }
     silence: silence.reason,
   }), audit)
 
-  return { ...decision, messages: [...decision.messages, injectionMessage(built.text)] }
+  return { ...decision, messages: [...decision.messages, injectionMessage(injectedText)] }
+}
+
+/**
+ * 「记忆根是推定的」一次性通告。
+ *
+ * 触发条件：根是**安全目录但自身没有任何项目标记**（即根来自会话工作目录，而不是
+ * `.git`/`package.json` 这类声明）。此时插件会按 cwd 建 `.dsh-project-memory`——必须
+ * 让模型知道这件事，否则它只会看到记忆来自一个自己没指定过的位置，而纠正的成本随
+ * 会话推进快速上升。通告只发一次，且与常驻任务卡同类：是状态声明，不占条目额度。
+ *
+ * 关掉它：`autoContext.rootNotice: false`。
+ */
+function rootNotice({ root, sessionId, sessions, config }) {
+  if (config?.autoContext?.rootNotice === false) return null
+  if (sessions.rootNoticed.peek(sessionId)) return null
+  if (hasProjectMarker(root)) return null
+  sessions.rootNoticed.set(sessionId, true)
+  return (
+    `memory root: ${root} (inferred from the session working directory; no project marker found). ` +
+    'If project memory should live elsewhere, pass `root: <dir>` to index_repo / watch_repo / remember / query_memory, ' +
+    'or restart dsh inside the project directory.'
+  )
 }
 
 /**
@@ -594,10 +738,9 @@ function injectionMessage(text) {
     content: [{ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${text}` }],
     // 这一块是「同一生产者后续快照会取代的当前状态」，不是一次性通知。
     // 宿主 ContextFormed 是判别联合：snapshot 必须带 sections（notice 才需要 summary）。
-    // 通道不变（仍走 agent/pre-step 追加 user 消息），只修语义。
+    // kind 必须是生产者自有的（v4 没有 'plugin' 兜底 kind），见 SOURCE_KIND 的注释。
     source: {
-      kind: 'plugin',
-      plugin: 'dsh-project-memory',
+      kind: SOURCE_KIND,
       form: 'snapshot',
       sections: [{ name: 'project-memory', text }],
     },

package/src/client/MemoryView.tsx

@@ -120,6 +120,14 @@ export function MemoryView({
   const lastRunRef = useRef(0)
 
   const refresh = useCallback(async (force = false): Promise<void> => {
+    // 没有活跃会话时不发命令、也不报错：面板顶部已经显示「还没有会话」，
+    // 再报一次"同步失败"会让人以为记忆库坏了（0.1.7 上会话快照结构变化时就是这个表象）。
+    if (!sessionId) {
+      setPayload(null)
+      setError(null)
+      setLoading(false)
+      return
+    }
     if (inflightRef.current) return
     const now = Date.now()
     if (!force && now - lastRunRef.current < 800) return
@@ -128,7 +136,7 @@ export function MemoryView({
     setLoading(true)
     setError(null)
     try {
-      const res = await runLine(`/insight list ${scope}`)
+      const res = await runLine(`/tasks insight list ${scope}`)
       if (!res.ok) {
         setError(res.text)
         setPayload(null)
@@ -152,7 +160,7 @@ export function MemoryView({
     setBusy(true)
     setError(null)
     try {
-      const line = `/insight ${action} ${scope} ${id}${action === 'demote' && scope === 'project' && boundTaskId ? ` ${boundTaskId}` : ''}`
+      const line = `/tasks insight ${action} ${scope} ${id}${action === 'demote' && scope === 'project' && boundTaskId ? ` ${boundTaskId}` : ''}`
       const res = await runLine(line)
       if (!res.ok) setError(res.text)
       else void refresh(true)
@@ -230,8 +238,8 @@ export function MemoryView({
         fields.trigger = { keywords: form.trigger.split(/[,，]/).map((s) => s.trim()).filter(Boolean) }
       }
       const line = editingId
-        ? `/insight edit ${scope} ${editingId} ${JSON.stringify(fields)}`
-        : `/insight save ${scope} ${JSON.stringify(fields)}`
+        ? `/tasks insight edit ${scope} ${editingId} ${JSON.stringify(fields)}`
+        : `/tasks insight save ${scope} ${JSON.stringify(fields)}`
       const res = await runLine(line)
       if (!res.ok) {
         setError(res.text)

package/src/client/TaskCommandNode.tsx

@@ -4,7 +4,7 @@
  * 目的：大 JSON 载荷绝不整段渲染进对话（否则切视图会刷屏）。
  */
 import { useEffect, useRef } from 'react'
-import { IconFolderOpenOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { IconFolderOpenOutline16 } from './icons.ts'
 import { parseTaskPayloadText, taskDataStore } from './task-data-store.ts'
 import { parseInsightPayloadText } from './MemoryView.tsx'
 import { taskUIStore } from './task-ui-store.ts'

package/src/client/TaskComponents.tsx

@@ -3,14 +3,15 @@
  * 纯渲染 + 卡片局部行内编辑/拖拽状态，动作经 props 回调交给容器（TaskPanel.tsx）。
  */
 import { useEffect, useLayoutEffect, useRef, useState } from 'react'
+import { Button } from '@deepseek-ai/dsh-client-ui-primitives'
+// 图标走兼容层：0.1.5 用 IconXxx14/16，0.1.7+ 改成 IconXxxRegular + size prop
 import {
-  Button,
   IconChevronDownOutline14,
   IconChevronUpOutline14,
   IconCheckOutline16,
   IconPlayOutline16,
   IconFolderOpenOutline16,
-} from '@deepseek-ai/dsh-client-ui-primitives'
+} from './icons.ts'
 import { createTranslate } from './locales.ts'
 import { useTaskDrag } from './task-hooks.ts'
 import { type Task, type TaskInsight, type TaskStep } from './task-data-store.ts'