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

package/src/util/fs.js

@@ -1,4 +1,4 @@
-import { accessSync, constants, readdirSync, readFileSync, statSync } from 'node:fs'
+import { accessSync, constants, existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { createHash } from 'node:crypto'
 import os from 'node:os'
@@ -94,17 +94,52 @@ export async function readTextFile(filePath, maxBytes = 2 * 1024 * 1024) {
   return buf.toString('utf8')
 }
 
+// 逐目录名排除。除构建产物外，专门收了 macOS/Homebrew 的巨型噪音目录：
+// `Library`/`Applications` 在家目录下是十万级文件，`Cellar`/`Caskroom`/`Frameworks`
+// 在 /opt/homebrew 下同理——它们正是把进程内存打满的那批（issue #5）。
 const DEFAULT_IGNORE = new Set([
   '.git', 'node_modules', 'dist', 'build', '.next', 'venv', '.venv',
   '__pycache__', '.idea', '.vscode', '.dsh-project-memory', '.cache',
   'coverage', '.turbo', 'target', 'vendor', 'third_party', 'thirdparty', 'obj',
+  'Library', 'Applications', 'Cellar', 'Caskroom', 'Frameworks', 'DerivedData',
+  'Pods', 'bower_components', 'jspm_packages', 'logs',
 ])
 
-export function walkDir(root, ignoreNames = DEFAULT_IGNORE) {
+/** 单次扫描的默认上限。0 / 负数 / 非数字 = 不限制。 */
+export const DEFAULT_SCAN_FILES = 20000
+export const DEFAULT_SCAN_DEPTH = 12
+
+/**
+ * 从 config 解析扫描上限。非法值（NaN/0/负数）回落到出厂值——一个配置笔误不该
+ * 把保护整个关掉。显式传 `maxScanFiles: 0` 才会真的关掉（见 README）。
+ */
+export function scanLimits(config) {
+  const files = Number(config?.maxScanFiles)
+  const depth = Number(config?.maxScanDepth)
+  return {
+    maxFiles: Number.isFinite(files) && files > 0 ? files : DEFAULT_SCAN_FILES,
+    maxDepth: Number.isFinite(depth) && depth > 0 ? depth : DEFAULT_SCAN_DEPTH,
+  }
+}
+
+/**
+ * 遍历目录，返回 `{ files, truncated }`。
+ *
+ * 与旧版的两点区别都是 OOM 的直接修复：
+ *   - **有上限**：`maxFiles` / `maxDepth` 封顶，超限只做截断标记，不再一路吃内存；
+ *   - `truncated` 让调用方区分「这棵树扫完了」和「只扫了一部分」——后者绝不能拿
+ *     本轮未见到的文件去删旧条目（见 index-repo/watch 的 unseen 用法）。
+ */
+export function walkDir(root, opts = {}) {
+  const ignoreNames = opts.ignoreNames || DEFAULT_IGNORE
+  const maxFiles = Number.isFinite(opts.maxFiles) && opts.maxFiles > 0 ? opts.maxFiles : Infinity
+  const maxDepth = Number.isFinite(opts.maxDepth) && opts.maxDepth > 0 ? opts.maxDepth : Infinity
   const out = []
-  const stack = [root]
+  const stack = [[root, 0]]
+  let truncated = false
+  let hitFileCap = false
   while (stack.length) {
-    const dir = stack.pop()
+    const [dir, depth] = stack.pop()
     let entries
     try {
       entries = readdirSync(dir, { withFileTypes: true })
@@ -112,16 +147,28 @@ export function walkDir(root, ignoreNames = DEFAULT_IGNORE) {
       continue
     }
     for (const entry of entries) {
-      if (entry.name.startsWith('.') && entry.name !== '.') continue
+      if (entry.name.startsWith('.')) continue
+      const full = path.join(dir, entry.name)
       if (entry.isDirectory()) {
         if (ignoreNames.has(entry.name)) continue
-        stack.push(path.join(dir, entry.name))
+        if (depth + 1 > maxDepth) {
+          truncated = true
+          continue
+        }
+        stack.push([full, depth + 1])
       } else {
-        out.push(path.join(dir, entry.name))
+        if (out.length >= maxFiles) {
+          truncated = true
+          hitFileCap = true
+          break
+        }
+        out.push(full)
       }
     }
+    if (hitFileCap) break
   }
-  return out.sort()
+  out.sort()
+  return { files: out, truncated }
 }
 
 export function isSupportedDoc(ext) {
@@ -160,16 +207,147 @@ export function memoryRootFor(indexRoot, memoryDir) {
 }
 
 /**
- * 不该整体当「项目根」监听的目录：文件系统根，以及共享的 OS 临时目录。
- * 监听后者会把无关程序（以及插件自己的测试夹具）的临时文件全扫进来，而且只要读过
- * `/tmp` 下任意一个文件，findProjectRoot 的兜底就会把根解析成 `/tmp` 并自我固化。
- * 根的**子目录**不受影响——项目放在临时目录的子目录里照常可监听。
+ * 危险根目录：整体扫描/监听它们会直接吃满内存（issue #5 实测把 DSH 撑死的就是
+ * 家目录与 `/opt/homebrew`）。判定是**精确匹配**：只拒绝这些目录**本身**，不拒绝
+ * 它们的子目录（`~/Library` 拒绝，`~/Library/Mobile Documents/…/MyProj` 照常可用）。
+ *
+ * 三类都在名单里：
+ *   - 文件系统根（含 Windows 盘符根）；
+ *   - 家目录及其所有祖先（`/Users`、`/home`、`/`），以及家目录下的系统型子目录；
+ *   - 系统/包管理器前缀（`/usr`、`/opt`、`/opt/homebrew`、`C:\Windows` …）。
  */
-export function isUnwatchableRoot(root) {
+function safeHomedir() {
+  try {
+    return os.homedir()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 危险根集合（判定用，`isUnsafeRoot` 的底座）。
+ *
+ * 参数化是为了**能在任意平台上验证每个平台的分支**：测试用 `path.win32` 模拟 Windows，
+ * 不必真的跑在 Windows 上（第一版正是因为只在 POSIX 分支里塞了 `/usr`、`/opt`，却拿它们
+ * 去断言 Windows，CI 才红）。生产路径只调用无参形式。
+ *
+ * 系统前缀按平台分组是刻意的：`C:\opt`、`C:\usr` 在 Windows 上是**正常用户目录**，
+ * 跨平台套用既会误伤，也会自相矛盾（`/usr/local` 被拒而 `/usr` 放行）。
+ */
+export function collectUnsafeRoots({
+  platform = process.platform,
+  home = safeHomedir(),
+  tmp = os.tmpdir(),
+  env = process.env,
+  pathApi = path,
+} = {}) {
+  const set = new Set()
+  const push = (p) => {
+    if (!p || typeof p !== 'string') return
+    let abs
+    try {
+      abs = pathApi.resolve(p)
+    } catch {
+      return
+    }
+    set.add(storeKey(abs, platform))
+  }
+
+  push(tmp)
+  let homeAbs = null
+  try {
+    homeAbs = home ? pathApi.resolve(home) : null
+  } catch {
+    homeAbs = null
+  }
+  if (homeAbs) {
+    // 家目录 + 它的所有祖先：往上任何一级当根都会把整台机器扫进来。
+    let dir = homeAbs
+    for (;;) {
+      push(dir)
+      const parent = pathApi.dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+    for (const sub of platform === 'win32' ? ['AppData', 'Application Data'] : ['Library', 'Applications', '.Trash']) {
+      push(pathApi.join(homeAbs, sub))
+    }
+  }
+
+  if (platform === 'win32') {
+    for (const name of ['SystemRoot', 'windir', 'ProgramFiles', 'ProgramFiles(x86)', 'ProgramData']) {
+      push(env[name])
+    }
+  } else {
+    // POSIX 系统前缀 + 包管理器/工具链前缀。ARM Mac 的 Homebrew 是 git clone 到
+    // `/opt/homebrew` 的——那里**有 `.git`**，所以单靠"只认项目标记"仍会把整个 Homebrew
+    // 判成项目根（issue #5 的第二个位置）。
+    for (const p of [
+      '/usr', '/usr/local', '/usr/local/Homebrew', '/usr/local/Cellar',
+      '/opt', '/opt/homebrew', '/opt/local',
+      '/etc', '/var', '/bin', '/sbin', '/dev', '/proc', '/sys', '/run',
+      '/System', '/Library', '/Applications', '/private', '/cores',
+      '/home/linuxbrew', '/home/linuxbrew/.linuxbrew', '/nix',
+    ]) {
+      push(p)
+    }
+  }
+  return set
+}
+
+const UNSAFE_DIRS = collectUnsafeRoots()
+
+/** 判定依据文案：用于拒绝时告诉用户「为什么是它」。 */
+function unsafeReason(abs) {
+  const key = storeKey(abs)
+  const parsed = path.parse(abs)
+  if (abs === parsed.root) return 'the filesystem root'
+  let home = null
+  try {
+    home = storeKey(path.resolve(os.homedir()))
+  } catch {
+    home = null
+  }
+  if (home && key === home) return 'your home directory'
+  if (key === storeKey(path.resolve(os.tmpdir()))) return 'the shared temp directory'
+  return 'a system directory that is never a project root'
+}
+
+/** 这个目录能否当项目记忆根？纯判定，无副作用。 */
+export function isUnsafeRoot(root) {
   if (typeof root !== 'string' || !root) return true
-  const abs = path.resolve(root)
-  if (abs === path.parse(abs).root) return true
-  return abs === path.resolve(os.tmpdir())
+  let abs
+  try {
+    abs = path.resolve(root)
+  } catch {
+    return true
+  }
+  const parsed = path.parse(abs)
+  if (!parsed.dir || abs === parsed.root) return true
+  return UNSAFE_DIRS.has(storeKey(abs))
+}
+
+export class UnsafeRootError extends Error {
+  constructor(root, requested) {
+    const target = requested && String(requested).trim() ? String(requested) : String(root)
+    super(
+      `Refusing to use ${target} as a project memory root: it is ${unsafeReason(path.resolve(root))}. ` +
+        'Indexing or watching it would walk the whole directory tree (hundreds of thousands of files) and exhaust memory. ' +
+        'Pass a project directory instead, or set allowUnsafeRoots: true if you really mean it.',
+    )
+    this.name = 'UnsafeRootError'
+    this.root = root
+  }
+}
+
+/**
+ * 校验「这个根可以当项目记忆根」。所有把目录当根写盘的入口都必须先过这一关：
+ * 写盘前拒绝，比事后清理 `.dsh-project-memory` 便宜得多。
+ */
+export function assertSafeRoot(root, { requested = root, allowUnsafe = false } = {}) {
+  if (allowUnsafe) return root
+  if (!isUnsafeRoot(root)) return root
+  throw new UnsafeRootError(root, requested)
 }
 
 export function resolveIndexRoot(exec, explicitRoot) {
@@ -177,4 +355,161 @@ export function resolveIndexRoot(exec, explicitRoot) {
   const sessionCwd = exec?.agent?.session?.header?.cwd
   if (sessionCwd) return path.resolve(sessionCwd)
   return path.resolve(process.cwd())
+}
+
+// ---------------------------------------------------------------------------
+// 项目根推导 —— 全插件唯一的策略实现。
+//
+// 顺序（前两者是"声明"，后两者是"推定"）：
+//   1. 显式传入的 root（工具参数）；
+//   2. 显式登记过的根（watch_repo / watchManager）；
+//   3. 最近的、含 VCS 或构建/清单标记的祖先；
+//   4. 会话工作目录本身 —— 只要它是安全目录。
+// 都没有 → null（该文件不落任何记忆）。
+//
+// 第 4 条是刻意的：`cwd` 是**人明确选择的工作位置**（在那里启动了 dsh），和"模型顺手读到的
+// 某个文件所在目录"完全不是一回事。旧实现把后者也当根（兜底 `path.dirname(file)`），
+// 又让 `.dsh-project-memory` 自己当标记，才把家目录锁成了项目（issue #5）。
+// ---------------------------------------------------------------------------
+
+/** VCS 边界：最强的项目根信号（`.git` 在 worktree 里是文件，existsSync 同样命中）。 */
+export const VCS_MARKERS = ['.git', '.hg', '.svn']
+
+/**
+ * 构建/清单标记。**刻意不含 `.dsh-project-memory`**：那个目录是插件自己创建的，
+ * 一旦算作项目标记就会自我固化——审计日志在会话 cwd 建出它之后，读该目录下任意文件
+ * 都会把根解析回该目录，于是家目录被永久锁成"项目"。
+ */
+export const PROJECT_MARKERS = [
+  'package.json', 'tsconfig.json', 'deno.json', 'deno.jsonc',
+  'go.mod', 'Cargo.toml', 'pyproject.toml', 'requirements.txt', 'setup.py',
+  'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+  'CMakeLists.txt', 'Makefile', 'composer.json', 'Gemfile', 'mix.exs', 'Package.swift',
+]
+
+/** 探针文件名：findProjectRoot 期望文件路径，用目录内的探针路径问"这个目录的根是谁"。 */
+export const PROJECT_PROBE = '__dsh-project-memory__.probe'
+
+/** 该目录**自身**是否带项目标记（不向上找）。用于判断根是"声明的"还是"推定的"。 */
+export function hasProjectMarker(dir) {
+  if (typeof dir !== 'string' || !dir) return false
+  let abs
+  try {
+    abs = path.resolve(dir)
+  } catch {
+    return false
+  }
+  for (const marker of VCS_MARKERS) if (existsSync(path.join(abs, marker))) return true
+  for (const marker of PROJECT_MARKERS) if (existsSync(path.join(abs, marker))) return true
+  return false
+}
+
+function isInside(parent, child) {
+  const rel = path.relative(parent, child)
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))
+}
+
+/** 显式登记的根里，包含该文件的**最深**那一个（最长前缀匹配）。 */
+function longestRootContaining(roots, absPath) {
+  let best = null
+  for (const root of roots) {
+    if (typeof root !== 'string' || !root) continue
+    let resolved
+    try {
+      resolved = path.resolve(root)
+    } catch {
+      continue
+    }
+    if (!isInside(resolved, absPath)) continue
+    if (!best || resolved.length > best.length) best = resolved
+  }
+  return best
+}
+
+function resolveDir(dir) {
+  try {
+    return path.resolve(dir)
+  } catch {
+    return null
+  }
+}
+
+function nearestMarker(absPath, markers) {
+  let dir = path.dirname(absPath)
+  for (;;) {
+    // 撞到家目录/系统目录边界就停：既不把边界当根，也不再向上（上面只会更宽）。
+    if (isUnsafeRoot(dir)) return null
+    for (const marker of markers) {
+      if (existsSync(path.join(dir, marker))) return dir
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+/**
+ * 项目根推导（**只认标记与显式声明，绝不从文件路径兜底**）。
+ *
+ * @param {string} filePath 目标文件（也接受目录内探针文件路径）
+ * @param {{ extraRoots?: Iterable<string>, sessionRoot?: string|null }} [opts]
+ *   `extraRoots`：显式登记过的根（watch_repo / watchManager）。
+ *   `sessionRoot`：会话工作目录，作为**最后**一级推定——仅当文件确实在它里面、
+ *   且它是安全目录时采用。
+ * @returns {string|null}
+ */
+export function findProjectRoot(filePath, opts = {}) {
+  if (typeof filePath !== 'string' || !filePath) return null
+  let abs
+  try {
+    abs = path.resolve(filePath)
+  } catch {
+    return null
+  }
+  const explicit = longestRootContaining(opts.extraRoots || [], abs)
+  if (explicit) return isUnsafeRoot(explicit) ? null : explicit
+
+  const byMarker = nearestMarker(abs, VCS_MARKERS) || nearestMarker(abs, PROJECT_MARKERS)
+  if (byMarker) return byMarker
+
+  const session = resolveDir(opts.sessionRoot)
+  if (session && !isUnsafeRoot(session) && isInside(session, abs)) return session
+  return null
+}
+
+/**
+ * **会话记忆根**：本插件所有"这个会话的记忆放哪"的唯一答案。
+ * 声明优先（标记）→ 会话工作目录（安全时）→ null（家目录/系统目录，且没有标记）。
+ */
+export function resolveProjectMemoryRoot(cwd) {
+  const base = resolveDir(cwd) || resolveDir(process.cwd())
+  if (!base) return null
+  return findProjectRoot(path.join(base, PROJECT_PROBE), { sessionRoot: base })
+}
+
+/**
+ * 工具侧的根解析：显式 root 优先（并校验安全），否则取会话记忆根。
+ * 会话 cwd 是家目录且没有标记时抛 `UnsafeRootError`——旧代码会在那里建
+ * `.dsh-project-memory` 并把它当成项目标记，进而把整个家目录锁成"项目"（issue #5）。
+ */
+export function resolveSafeIndexRoot(exec, explicitRoot, config) {
+  const allowUnsafe = config?.allowUnsafeRoots === true
+  const explicit = explicitRoot && String(explicitRoot).trim() ? String(explicitRoot) : null
+  if (explicit) {
+    return assertSafeRoot(path.resolve(explicit), { requested: explicit, allowUnsafe })
+  }
+  const cwd = resolveIndexRoot(exec)
+  const root = resolveProjectMemoryRoot(cwd)
+  if (root) return root
+  if (allowUnsafe) return cwd
+  throw new UnsafeRootError(cwd, cwd)
+}
+
+/** 尽力而为的会话记忆根：拿不到就返回 null（用于审计镜像这类旁路，不抛错）。 */
+export function sessionMemoryRootOrNull(exec, config) {
+  try {
+    return resolveSafeIndexRoot(exec, null, config)
+  } catch {
+    return null
+  }
 }

package/src/util/task-view.js

@@ -0,0 +1,66 @@
+/**
+ * 任务步骤的读取与展示（纯函数，零依赖，commands/ 与 tools/ 共用）。
+ *
+ * 步骤在数据里出现过三种形状：早期裸字符串、`{ text }` 时代、现在的 `{ content, status }`。
+ * 「取文本 / 归一状态 / 数完成度 / 相对时间 / 取 exec 会话 id」这几件事原本在
+ * commands/tasks.js、commands/task-actions.js、tools/query-memory.js、tools/task-tools.js、
+ * tools/lesson-tools.js、setup/taskbridge.js、auto-inject.js、reflection-pipeline.js 里各抄了一份，
+ * 并且已经漂移成两种取文本语义（`??` 与 `||`）和三种状态归一（无校验 / Set 白名单 / 数组白名单）。
+ * 收敛到这里，只保留一个事实：
+ *   - 文本：content 优先，缺失才回退 text；**content 为空串不再回退**（显式清空的步骤不该顶出旧 text）；
+ *   - 状态：只认宿主 todo/write 的三个合法值，其余（含裸字符串步骤）一律 pending。
+ */
+
+/** 宿主 todo/write 认得的三个状态。 */
+export const STEP_STATUSES = new Set(['pending', 'in_progress', 'completed'])
+
+/**
+ * 步骤文本。字符串步骤原样返回；对象步骤按 `content ?? text ?? ''` 读。
+ * @param {string | { content?: unknown, text?: unknown } | null | undefined} step
+ * @returns {string}
+ */
+export function stepContent(step) {
+  if (typeof step === 'string') return step
+  return step?.content ?? step?.text ?? ''
+}
+
+/**
+ * 步骤状态：非法值、缺失值、以及无状态信息的裸字符串步骤一律归一到 `pending`。
+ * @param {string | { status?: unknown } | null | undefined} step
+ * @returns {'pending' | 'in_progress' | 'completed'}
+ */
+export function stepStatus(step) {
+  if (typeof step === 'string') return 'pending'
+  const status = step?.status
+  return STEP_STATUSES.has(status) ? status : 'pending'
+}
+
+/**
+ * 任务进度：已完成步数 / 总步数。
+ * @param {{ steps?: unknown[] } | null | undefined} task
+ * @returns {{ done: number, total: number }}
+ */
+export function stepProgress(task) {
+  const steps = task?.steps || []
+  let done = 0
+  for (const step of steps) {
+    if (stepStatus(step) === 'completed') done++
+  }
+  return { done, total: steps.length }
+}
+
+/** 相对时间（中文）：面板、list_tasks、/tasks 三处文案共用同一套阈值。 */
+export function timeAgo(iso) {
+  const diff = Date.now() - new Date(iso).getTime()
+  const m = Math.floor(diff / 60000)
+  if (m < 1) return '刚刚'
+  if (m < 60) return `${m}分钟前`
+  const h = Math.floor(m / 60)
+  if (h < 24) return `${h}小时前`
+  return `${Math.floor(h / 24)}天前`
+}
+
+/** 工具执行上下文里的会话 id：agent.session 优先，退化到 ctx.session。 */
+export function sessionIdOf(exec) {
+  return exec?.agent?.session?.id || exec?.ctx?.session?.id
+}

package/src/util/text.js

@@ -1,3 +1,17 @@
+/**
+ * 取消息里的纯文本块（多个 text 块按换行拼接）。
+ * 宿主消息块与流式分片都可能缺字段，这里对空块/空消息一律跳过而不是抛错。
+ * @param {{ content?: Array<{ type?: unknown, text?: unknown } | null> } | null | undefined} message
+ * @returns {string}
+ */
+export 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 truncate(text, maxChars) {
   if (typeof text !== 'string') return String(text)
   if (text.length <= maxChars) return text

package/src/watch.js

@@ -1,6 +1,6 @@
 import { existsSync, statSync } from 'node:fs'
 import path from 'node:path'
-import { isUnwatchableRoot, memoryRootFor, relativePath, storeKey, walkDir } from './util/fs.js'
+import { isUnsafeRoot, memoryRootFor, relativePath, scanLimits, storeKey, walkDir } from './util/fs.js'
 import { OVERSIZE, UNCHANGED, commitFileUpdates, fileKind, planFileIndex, toFileUpdate } from './index-pipeline.js'
 import { ProjectMemoryStore } from './store.js'
 import { onFileChanged, isTypeScriptFile } from './enhancer.js'
@@ -12,10 +12,30 @@ export class WatchManager {
     this.roots = new Map()
     this.timer = null
     this._polling = false
+    this._truncationWarned = new Set()
+  }
+
+  /** 包含该路径的已注册根（最长前缀）：懒索引据此把文件归到显式 watch 过的无标记项目里。 */
+  rootContaining(absPath) {
+    let best = null
+    for (const root of this.roots.keys()) {
+      const rel = path.relative(root, absPath)
+      if (rel.startsWith('..') || path.isAbsolute(rel)) continue
+      if (!best || root.length > best.length) best = root
+    }
+    return best
+  }
+
+  /** 危险根是否被显式放行（唯一开关，显式工具调用与 watch 共用同一判据）。 */
+  unsafeAllowed() {
+    return this.config?.allowUnsafeRoots === true
   }
 
   restorePersisted() {
     const cwd = process.cwd()
+    // cwd 是家目录/系统目录时直接跳过：旧顺序是「先 load 再判断」，而历史遗留的超大 store
+    // 光读盘就能 OOM —— 那恰恰是 issue #5 的报告者重启后会撞上的场景。
+    if (!this.unsafeAllowed() && isUnsafeRoot(cwd)) return
     // 用 load() 的返回值：storeCache 命中时 load() 返回的是缓存实例，忽略返回值会拿到空 store
     const store = new ProjectMemoryStore(memoryRootFor(cwd, this.config.memoryDir)).load()
     if (existsSync(store.dir)) {
@@ -23,8 +43,10 @@ export class WatchManager {
       for (const root of [...store.watchlist]) {
         if (typeof root !== 'string' || !root) continue
         // 自愈剔除两类条目：已不存在的根（每轮白跑，还会把目录重新 mkdir 出来），
-        // 以及不该整体监听的文件系统根 / 共享临时目录（会把别人和测试的临时文件全扫进来）。
-        if (!existsSync(root) || isUnwatchableRoot(root)) {
+        // 以及不该整体监听的根（文件系统根 / 家目录 / 系统与包管理器前缀）——
+        // 后者同时**修复历史遗留**：0.5.8 及以前被误判进去的家目录、/opt/homebrew
+        // 会在下一次启动时被自动摘掉，不需要用户手删 watch.json。
+        if (!existsSync(root) || (!this.unsafeAllowed() && isUnsafeRoot(root))) {
           store.removeWatch(root)
           dropped++
           continue
@@ -39,8 +61,8 @@ export class WatchManager {
     // 根目录不存在就拒绝：否则每轮 poll 都会 commit → save → mkdirSync，
     // 把一条历史遗留、已被删除的 watchlist 条目重新「创建」出来。
     if (!existsSync(root)) return false
-    // 文件系统根 / 共享临时目录不整体监听（子目录允许）。
-    if (isUnwatchableRoot(root)) return false
+    // 文件系统根 / 家目录 / 系统前缀不整体监听（它们的子目录允许），除非显式放行。
+    if (!this.unsafeAllowed() && isUnsafeRoot(root)) return false
     if (!this.roots.has(root)) {
       this.roots.set(root, {
         store: new ProjectMemoryStore(memoryRootFor(root, this.config.memoryDir)).load(),
@@ -96,7 +118,18 @@ export class WatchManager {
     // rel → 本轮采集的 mtime:size。提交成功后才落进快照；CAS 失败的条目留在原地等下一轮。
     const signatures = new Map()
 
-    for (const filePath of walkDir(root)) {
+    const { files, truncated } = walkDir(root, scanLimits(this.config))
+    if (truncated && !this._truncationWarned.has(root)) {
+      // 只提示一次：这是一条**永久**的降级说明，不是每轮都要刷屏的故障。
+      this._truncationWarned.add(root)
+      const { maxFiles, maxDepth } = scanLimits(this.config)
+      console.error(
+        `[dsh-project-memory] watch scan of ${root} hit the limit (maxFiles=${maxFiles}, maxDepth=${maxDepth}); ` +
+          'only part of the tree is refreshed. Raise maxScanFiles/maxScanDepth if this project is legitimately that large.',
+      )
+    }
+
+    for (const filePath of files) {
       const rel = storeKey(relativePath(root, filePath))
       seen.add(rel)
       const kind = fileKind(path.extname(filePath).toLowerCase())
@@ -144,7 +177,13 @@ export class WatchManager {
     }
 
     // 单事务写盘；CAS 失败的条目本轮不落快照，下一轮自然重试。
-    const { stale } = commitFileUpdates(state.store, { updates, unseen: seen, link: updates.length > 0 })
+    // 截断时**不传 unseen**：没扫到的文件不等于被删了，否则一份被上限截掉的树每轮都会
+    // 把自己的记忆删掉一半（先删再下轮重新索引，纯粹的抖动）。
+    const { stale } = commitFileUpdates(state.store, {
+      updates,
+      unseen: truncated ? null : seen,
+      link: updates.length > 0,
+    })
     const failed = new Set(stale)
     for (const update of updates) {
       if (failed.has(update.rel)) continue