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

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.5.10 (2026-09-24)
+
+### 修复：共享临时目录仍然是可用的记忆根（issue #5 现场复核的补充发现）
+
+@jinchaofeiyang 在 issue #5 的补充材料里指出 `isUnsafeRoot('/tmp')` 在 macOS 上返回 `false`：
+`os.tmpdir()` 在 macOS 上是 `/var/folders/…/T` 这个**每用户私有**目录，共享的 `/tmp`
+（→ `/private/tmp`）是**另一个路径**，0.5.9 之前不在名单里——于是 `cd /tmp && dsh` 仍会把整个
+/tmp 当项目根全量扫描，与家目录是同一类问题。Windows 同理：`C:\Windows` 被拒，但
+`C:\Windows\Temp` 是精确匹配之外的漏网路径。
+
+- 每用户临时目录与**共享/系统**临时目录合并成"临时目录"一组：POSIX `/tmp`、`/var/tmp`、
+  `/private/tmp`、`/private/var/tmp`、`/var/folders`、`/dev/shm`；Windows `%TEMP%`、`%TMP%`、
+  `%SystemRoot%\Temp`、`%windir%\Temp`。仍是精确匹配——`/tmp/myproj` 这类子目录照常可用
+  （插件自己的测试夹具就依赖这一点）。
+- 拒绝文案据此区分"shared temp directory"与笼统的"system directory"。
+
+### 新增：反直觉输入的回归测试（现场复核要求的第 1 点）
+
+`/opt/homebrew` 是被 `VCS_MARKERS` 的 `.git` **主动选中**的（ARM Mac 的 Homebrew 是 git clone），
+不是兜底误判。所以"拒绝前缀"必须能压过"合法项目标记"。`findProjectRoot` 现在支持注入
+`isUnsafe` 判定，于是这条输入可以在任意平台上用一个临时目录复现：
+
+- 控制组证明：只有 `.git` 时该目录确实会当选（否则这条用例什么都没测）；
+- 加前缀拒绝后必须为 `null`，且上溯在边界处停止；
+- 边界之外的兄弟项目不受影响。
+- 另外用 `path.win32` / `path.posix` 模拟两个平台，把各自的临时目录与系统前缀断言在
+  **任意 runner** 上（macOS 的 `/tmp` 缺口正是靠这个才可能在 ubuntu CI 上被发现）。
+
+### 新增：store 目录自我忽略（不再需要用户改 `.gitignore`）
+
+让用户手动把 `.dsh-project-memory/` 写进自己的 `.gitignore` 是个设计缺陷：忘了就是一次误提交，
+而插件也不该去改用户的文件。现在 store 在自己目录里写一条 `*` 规则（`<store>/.gitignore`）——
+git 会读取工作区里任意目录下的 `.gitignore`，`*` 连这个文件自己一起命中，于是 `git status` /
+`git add -A` 里整棵树都不出现，用户零配置。老版本留下的 store 在第一次 `load()` 时自动补上。
+
+- 顺带：被忽略的文件不会被 `git clean -fd` 删除（未跟踪且未忽略的会被删）。
+- 想跟着仓库提交记忆：`git add -f .dsh-project-memory`（已跟踪的文件不受忽略规则影响）。
+- 回归用例 `test/store-gitignore.test.mjs` 用真 git 仓库验证：store 不进 `git status`、用户的
+  `.gitignore` 逐字不变、`git clean -fd` 后 store 仍在、重复保存不重写该文件、历史 store 首次
+  `load()` 即补上。
+
+### 文档（现场复核要求的第 2 点）
+
+- README 把根策略写成参考文档口径：根解析顺序、排除名单、扫描上限（20000 文件 / 12 层；
+  截断会在结果里说明，且不删除没扫到的条目），以及 store 的自我忽略。
+
 ## 0.5.9 (2026-09-24)
 
 ### 修复：issue #5 —— 在家目录 / `/opt/homebrew` 自动建索引把 DSH 撑到 OOM

package/README.md

@@ -64,8 +64,8 @@ The tools below are **invoked by the agent**, not typed by the user. In the chat
 | Tool | Purpose |
 |---|---|
 | `index_doc file_path` | Index one document (PDF/MD/txt): chunk → deterministic `summary` + whole-chunk `terms` → store with `path:line`. Unchanged files are skipped. |
-| `index_repo root` | Index a whole project: docs get deterministic summaries + whole-chunk terms, code files get a zero-token symbol table. Incremental, cleans up deleted files, cross-links docs to symbols. A root that does not exist — including a Windows-style path resolved on Linux/macOS — is rejected before anything is written, and so is a *dangerous* root (home directory, filesystem root, system / package-manager prefixes): scanning one of those walks hundreds of thousands of files. |
-| `watch_repo root` | Enable automatic refresh: a background poll detects new/changed files (mtime + content hash) and re-indexes only those. Watched roots persist across plugin restarts; a non-existent root and a dangerous root (filesystem root, home directory, shared temp directory, system / package-manager prefixes) are all refused, roots that disappear are dropped instead of being re-created, and a polluted watchlist from an older version is self-healed on startup. |
+| `index_repo root` | Index a whole project: docs get deterministic summaries + whole-chunk terms, code files get a zero-token symbol table. Incremental, cleans up deleted files, cross-links docs to symbols. A root that does not exist — including a Windows-style path resolved on Linux/macOS — or one on the excluded list is rejected before anything is written. |
+| `watch_repo root` | Enable automatic refresh: a background poll detects new/changed files (mtime + content hash) and re-indexes only those. Watched roots persist across plugin restarts; a non-existent or excluded root is refused, roots that disappear are dropped instead of being re-created, and entries that are no longer valid roots are dropped on startup. |
 | `memory_stats root` | Show what the store contains: totals (files / entries / experience notes), last index time, and the per-file list sorted by recency. |
 | `query_memory query` | BM25 search over docs + symbols + experience + insights (lessons / decisions / procedures), optionally query-expanded by the LLM. `type` selects a layer (`all` / `doc` / `symbol` / `experience` / `insight` / `task`). Returns ranked hits with relative scores, sources or insight ids, and doc→symbol references. |
 | `list_tasks` | List task records for the project (archived marked). Call first in a new session before continuing work. |
@@ -153,9 +153,9 @@ The workflow panel is collapsible, automatically adapts to dsh and theme plugin
 | `autoIndexOnFirstUse` | false | full scan of the current working directory on plugin load (opt-in) |
 | `watch` | true | enable the background refresh |
 | `watchInterval` | 15 | poll interval (seconds) |
-| `maxScanFiles` | 20000 | hard cap on files per scan pass; a truncated scan is reported and never deletes the entries it did not reach. Set `0` to disable the cap (at your own risk) |
+| `maxScanFiles` | 20000 | hard cap on files per scan pass; a truncated pass is reported and does not remove the entries it did not reach. Set `0` to disable the cap |
 | `maxScanDepth` | 12 | hard cap on directory depth per scan pass. Set `0` to disable |
-| `allowUnsafeRoots` | false | allow **explicit** tool calls (`index_repo`/`watch_repo`/`remember` with a `root`) to target a dangerous root. Automatic paths (lazy indexing, session audit, TaskBridge, `autoIndexOnFirstUse`) stay inert in these directories regardless |
+| `allowUnsafeRoots` | false | allow **explicit** tool calls (`index_repo`/`watch_repo`/`remember` with a `root`) to target a directory on the excluded list. Automatic paths (lazy indexing, session audit, TaskBridge, `autoIndexOnFirstUse`) stay inert in these directories regardless |
 | `tsPath` | (auto) | optional absolute path to a specific `typescript` install; if omitted, resolves from project cwd → plugin node_modules |
 | `enableTypeScript` | true | set `false` to disable L2 TS enhancement entirely (L1 regex only) |
 
@@ -192,15 +192,15 @@ Automatic injection used to be a *retrieval* problem ("which entry is most relat
 
 The two most relevant switches are `lazyIndexing` (index a file the moment the model reads it; default on) and `autoIndexOnFirstUse` (full scan of the current working directory on plugin load; default off). Lazily indexed project roots are automatically registered with the watcher, so changed files stay fresh without an explicit `watch_repo`.
 
-**Where the project root comes from.** One policy, applied identically by lazy indexing, the session audit trail, TaskBridge and every tool: an explicit `root` argument wins; otherwise an explicitly registered root (`watch_repo`); otherwise the nearest ancestor containing a VCS marker (`.git`/`.hg`/`.svn`) or a build/manifest marker (`package.json`, `go.mod`, `Cargo.toml`, `pyproject.toml`, …); otherwise **the session working directory itself, provided it is a safe directory**. So a marker-less scratch folder you started dsh in still gets project memory — the plugin just says so once:
+**Root resolution.** In order: an explicit `root` argument; a registered root (`watch_repo`); the nearest ancestor with a VCS marker (`.git`/`.hg`/`.svn`) or a build/manifest marker (`package.json`, `go.mod`, `Cargo.toml`, `pyproject.toml`, …); the session working directory, unless it is on the excluded list. A file that matches none of these is not indexed.
 
-```
-memory root: /Users/me/scratch (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.
-```
+When the root comes from the working directory, the model gets one notice per session naming it and how to change it; mute with `autoContext.rootNotice: false`. Starting dsh in a container directory such as `~/workspace` therefore makes that directory the root, and memory spans everything beneath it up to the scan limit — start dsh inside the project for one store per project.
+
+**Excluded directories.** Not used as a root, matched exactly (subdirectories are unaffected): the filesystem root, the home directory, temp directories — `os.tmpdir()` and the shared ones (`/tmp`, `/var/tmp`, `%TEMP%`, `%SystemRoot%\Temp`) — and system / package-manager prefixes (`/opt/homebrew` on POSIX; `%SystemRoot%`, `%ProgramFiles%`, `%ProgramData%` on Windows). A session in one of these runs without memory, with one line on stderr.
+
+**Scan limits.** One pass covers at most `maxScanFiles` files (20000) and `maxScanDepth` directory levels (12). A truncated pass is reported in the `index_repo` result and logged once per root by the watcher, and it does not remove entries it did not reach. Raise both for a larger tree.
 
-That notice goes out once per session and can be muted with `autoContext.rootNotice: false`. What the plugin will **not** do is promote an arbitrary directory to a project: reading a stray file outside the working directory records nothing, and a dangerous root (filesystem root, your home directory, the shared temp directory or a system / package-manager prefix — `/opt/homebrew` on POSIX, `%SystemRoot%`/`%ProgramFiles%`/`%ProgramData%` on Windows) is refused outright — that is what used to walk an entire home directory and exhaust memory. Sessions whose working directory is one of those run with memory disabled (one stderr line explains why).
+The store lives in the tree it indexes and **ignores itself**: it writes a `*` rule into its own `<store>/.gitignore`, which git honours for any directory, so nothing shows up in `git status` or `git add -A` and you have nothing to add to your own `.gitignore`. (It also means `git clean -fd` leaves the store alone.) To commit project memory deliberately, `git add -f .dsh-project-memory` — tracked files are not affected by ignore rules.
 
 Settings live in the plugin's config object. To change them, add an override entry to your profile's `cordis.patch.yml` — for the web profile that is `~/.dsh/profiles/web/cordis.patch.yml`:
 

package/README.zh-CN.md

@@ -63,8 +63,8 @@ dsh plugin --profile web add /path/to/dsh-project-memory.tgz
 | 工具 | 用途 |
 |---|---|
 | `index_doc file_path` | 索引单个文档（PDF/MD/txt）：分块 → 确定性 `summary` + 整 chunk `terms` → 带 `路径:行号` 入库。未变更文件自动跳过。 |
-| `index_repo root` | 索引整个项目：文档生成确定性摘要 + 整 chunk 词项，代码文件生成零 token 符号表。增量更新、清理已删除文件、文档与符号交叉链接。根目录不存在（含在 Linux/macOS 上被解析成相对路径的 Windows 风格路径）时会在写入任何内容前直接拒绝；**危险根**（家目录、文件系统根、系统/包管理器前缀）同样拒绝——扫它们等于走几十万个文件。 |
-| `watch_repo root` | 启用自动刷新：后台轮询检测新增/变更文件（mtime + 内容哈希），仅重抽这些文件。监听的项目在插件重启后自动恢复；不存在的根目录与危险根（文件系统根、家目录、共享临时目录、系统/包管理器前缀）都会被拒绝，已消失的根目录会被丢弃而不是被重新创建，旧版本遗留的污染 watchlist 会在启动时自愈。 |
+| `index_repo root` | 索引整个项目：文档生成确定性摘要 + 整 chunk 词项，代码文件生成零 token 符号表。增量更新、清理已删除文件、文档与符号交叉链接。根目录不存在（含在 Linux/macOS 上被解析成相对路径的 Windows 风格路径）或在排除名单上时，会在写入任何内容前拒绝。 |
+| `watch_repo root` | 启用自动刷新：后台轮询检测新增/变更文件（mtime + 内容哈希），仅重抽这些文件。监听的项目在插件重启后自动恢复；不存在或在排除名单上的根目录会被拒绝，已消失的根目录会被丢弃而不是被重新创建，不再有效的条目会在启动时清掉。 |
 | `memory_stats root` | 查看记忆库内容：总量（文件 / 条目 / 经验笔记）、最近索引时间，以及按时间排序的逐文件清单。 |
 | `query_memory query` | 对文档、符号、经验与 insight（教训/决策/流程）执行 BM25 检索，可选 LLM 查询扩展。`type` 选择层（`all` / `doc` / `symbol` / `experience` / `insight` / `task`）。返回带相对分数（0-100）、引用或 insight id、以及文档→符号链接的排序结果。 |
 | `list_tasks` | 列出本项目任务记录（含归档，带标记）。新会话/续接前先调用。 |
@@ -150,9 +150,9 @@ TaskPanel (Container)
 | `autoIndexOnFirstUse` | false | 插件加载时对当前工作目录做全量扫描（可选） |
 | `watch` | true | 启用后台刷新 |
 | `watchInterval` | 15 | 轮询间隔（秒） |
-| `maxScanFiles` | 20000 | 单次扫描的文件数硬上限；被截断时会在报告里说明，且**绝不**删除没扫到的旧条目。设 `0` 取消上限（自担风险） |
+| `maxScanFiles` | 20000 | 单次扫描的文件数硬上限；被截断时会在报告里说明，且不会删除没扫到的条目。设 `0` 取消上限 |
 | `maxScanDepth` | 12 | 单次扫描的目录深度硬上限。设 `0` 取消 |
-| `allowUnsafeRoots` | false | 允许**显式**工具调用（带 `root` 的 `index_repo`/`watch_repo`/`remember`）指向危险根。自动路径（懒索引、会话审计、TaskBridge、`autoIndexOnFirstUse`）无论此项如何都不会越权 |
+| `allowUnsafeRoots` | false | 允许**显式**工具调用（带 `root` 的 `index_repo`/`watch_repo`/`remember`）指向排除名单上的目录。自动路径（懒索引、会话审计、TaskBridge、`autoIndexOnFirstUse`）无论此项如何都不会越权 |
 | `tsPath` | (自动) | 可选：强制指定特定 `typescript` 安装路径；省略时按项目 cwd → 插件 node_modules 向上解析 |
 | `enableTypeScript` | true | 设为 `false` 彻底禁用 L2 TS 增强（仅保留 L1 正则） |
 
@@ -189,15 +189,15 @@ TaskPanel (Container)
 
 两个最常用的开关是 `lazyIndexing`（模型读取文件的瞬间即索引；默认开启）和 `autoIndexOnFirstUse`（插件加载时对当前工作目录做全量扫描；默认关闭）。懒加载建立的索引根会自动注册到 watcher，文件变更无需手动 `watch_repo` 也能保持新鲜。
 
-**项目根是怎么定的。** 全插件同一套策略——懒索引、会话审计、TaskBridge、所有工具都走它：显式 `root` 参数优先；其次是显式登记的根（`watch_repo`）；其次是最近的、含 VCS 标记（`.git`/`.hg`/`.svn`）或构建/清单标记（`package.json`、`go.mod`、`Cargo.toml`、`pyproject.toml` 等）的祖先目录；最后是**会话工作目录本身（只要它是安全目录）**。所以你在一个没有标记的临时目录里启动 dsh，项目记忆照样能用——插件只会说明一次：
+**项目根怎么定。** 按顺序：显式 `root` 参数 → 登记的根（`watch_repo`）→ 最近的 VCS 标记（`.git`/`.hg`/`.svn`）或构建/清单标记（`package.json`、`go.mod`、`Cargo.toml`、`pyproject.toml` 等）所在祖先 → 会话工作目录（前提是它不在排除名单里）。都不命中则不索引该文件。
 
-```
-memory root: /Users/me/scratch (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.
-```
+根来自工作目录时，模型每个会话收到一条通告，说明根的位置与改法；`autoContext.rootNotice: false` 关闭。因此在 `~/workspace` 这类容器目录里启动 dsh，该目录就是根，记忆覆盖其下所有项目直到扫描上限——想一个项目一个 store，就在项目目录里启动。
+
+**排除名单。** 以下目录不会作为根，精确匹配（子目录不受影响）：文件系统根、家目录、临时目录（`os.tmpdir()` 与共享的 `/tmp`、`/var/tmp`、`%TEMP%`、`%SystemRoot%\Temp`），以及系统/包管理器前缀（POSIX 上的 `/opt/homebrew`，Windows 上的 `%SystemRoot%`、`%ProgramFiles%`、`%ProgramData%`）。这些目录下的会话不启用记忆，stderr 输出一行说明。
+
+**扫描上限。** 单次扫描最多 `maxScanFiles` 个文件（20000）、`maxScanDepth` 层目录（12）。被截断时，`index_repo` 的结果里会说明，watcher 每个根记一行，且不会删除没扫到的条目。目录树更大就调高这两个值。
 
-这条通告每个会话只发一次，可用 `autoContext.rootNotice: false` 关掉。插件**不会**做的是把任意目录升格成项目：在工作目录之外读到一个散文件不会记任何东西；危险根（文件系统根、家目录、共享临时目录、系统/包管理器前缀——POSIX 上如 `/opt/homebrew`，Windows 上是 `%SystemRoot%`/`%ProgramFiles%`/`%ProgramData%`）直接拒绝——旧版正是从这些目录一路扫下去把内存打满的。工作目录属于这些目录的会话，记忆功能整体停用（stderr 会有一行说明）。
+store 建在被索引的目录树里，并且**自我忽略**：它在自己目录内写入一条 `*` 规则（`<store>/.gitignore`）。git 会读取任意目录下的 `.gitignore`，所以 `git status` / `git add -A` 里都看不到它，你自己的 `.gitignore` 一个字都不用加（`git clean -fd` 也因此不会删它）。确实想把记忆跟着仓库提交：`git add -f .dsh-project-memory`——已跟踪的文件不受忽略规则影响。
 
 配置存放在插件的 config 对象中。修改方式：在 profile 的 `cordis.patch.yml` 里加一条覆盖项——web profile 对应 `~/.dsh/profiles/web/cordis.patch.yml`：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "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,7 +18,7 @@
     "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 && 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",
+    "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 && node test/store-gitignore.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",

package/src/store.js

@@ -13,6 +13,7 @@ const BINDING_FILE = 'binding.json'
 const WATCH_FILE = 'watch.json'
 const INSIGHTS_FILE = 'insights.json'
 const SHARDS_DIR = 'shards'
+const GITIGNORE_FILE = '.gitignore'
 
 const storeCache = new Map()
 const STORE_CACHE_MAX = 32
@@ -96,6 +97,9 @@ export class ProjectMemoryStore {
     this._migrateLegacyIfNeeded()
     this._loadSharded()
     this._loadInsights()
+    // 有些路径只读不写（审计 jsonl 直接写在 store 目录里），所以这里也补一次自我忽略，
+    // 让老版本建出来的 store 在第一次 load 就补上。
+    this.ensureSelfIgnore()
     storeCache.set(key, this)
     // 只保留最近打开的项目：长期跨多项目运行时不至于无限增长（被逐出只是下次重新读盘）
     while (storeCache.size > STORE_CACHE_MAX) {
@@ -286,6 +290,28 @@ export class ProjectMemoryStore {
     }
   }
 
+  /**
+   * store 目录**自我忽略**：在目录里放一个内容为 `*` 的 `.gitignore`。
+   *
+   * 为什么不写进用户的 `.gitignore`：那是用户的文件，插件不该改；而且"忘了加"的代价
+   * 是一次误提交。为什么这样就够：git 会读取工作区里**任意**目录下的 `.gitignore`，
+   * 而 `*` 连这个 `.gitignore` 自己一起命中，于是 `git status` / `git add -A` 里整棵树
+   * 都不出现，用户一个字都不用写（`git check-ignore -v` 可复核）。
+   *
+   * 顺带的好处：被忽略的文件不会被 `git clean -fd` 删除（未跟踪且未忽略的会被删）。
+   * 想把记忆跟着仓库提交：`git add -f .dsh-project-memory`——已跟踪的文件不受忽略规则影响。
+   */
+  ensureSelfIgnore() {
+    if (!existsSafe(this.dir)) return
+    const file = path.join(this.dir, GITIGNORE_FILE)
+    if (existsSafe(file)) return
+    try {
+      writeFileSync(file, '# dsh-project-memory: local by default. `git add -f` to commit it.\n*\n')
+    } catch {
+      // 旁路：写不进去不影响存储本身
+    }
+  }
+
   save() {
     // 没有脏数据就不落盘。watch 每轮对每个根都无条件 commit → save；照旧执行的话，
     // 末尾的 `_version++` + `_idfCache = null` 会打在跨实例共享的 store 上，
@@ -302,6 +328,8 @@ export class ProjectMemoryStore {
     if (dirty) mkdirSync(this.dir, { recursive: true })
     // 崩溃遗留的 *.tmp 无论有没有脏数据都顺手清掉（两次 readdir，自带 try/catch）
     this.cleanStaleTmp()
+    // 自我忽略也在无脏数据时执行：老版本建出来的 store 会在下一次 save 时补上。
+    this.ensureSelfIgnore()
     if (!dirty) return
     if (!this._formatWritten) {
       writeJsonAtomic(path.join(this.dir, FORMAT_FILE), { version: 2, layout: 'sharded' })

package/src/util/fs.js

@@ -209,12 +209,16 @@ export function memoryRootFor(indexRoot, memoryDir) {
 /**
  * 危险根目录：整体扫描/监听它们会直接吃满内存（issue #5 实测把 DSH 撑死的就是
  * 家目录与 `/opt/homebrew`）。判定是**精确匹配**：只拒绝这些目录**本身**，不拒绝
- * 它们的子目录（`~/Library` 拒绝，`~/Library/Mobile Documents/…/MyProj` 照常可用）。
+ * 它们的子目录（`~/Library` 拒绝，`~/Library/Mobile Documents/…/MyProj` 照常可用；
+ * `/tmp` 拒绝，`/tmp/myproj` 照常可用）。
  *
- * 三类都在名单里：
+ * 四类都在名单里：
  *   - 文件系统根（含 Windows 盘符根）；
  *   - 家目录及其所有祖先（`/Users`、`/home`、`/`），以及家目录下的系统型子目录；
- *   - 系统/包管理器前缀（`/usr`、`/opt`、`/opt/homebrew`、`C:\Windows` …）。
+ *   - 每用户私有临时目录与共享/系统临时目录（`/tmp`、`/var/tmp`、`%TEMP%`、
+ *     `%SystemRoot%\Temp` …）——macOS 的 `os.tmpdir()` 是 `/var/folders/…/T`，共享的
+ *     `/tmp` 是**另一个**路径，两者都要拒；
+ *   - 系统/包管理器前缀（`/usr`、`/opt`、`/opt/homebrew`、`C:\Windows` …），按平台分组。
  */
 function safeHomedir() {
   try {
@@ -224,6 +228,13 @@ function safeHomedir() {
   }
 }
 
+/**
+ * POSIX 的**共享/系统**临时目录。刻意与 `os.tmpdir()` 分开列：macOS 上 `os.tmpdir()` 是
+ * `/var/folders/…/T` 这个每用户私有目录，共享的 `/tmp`（→ `/private/tmp`）根本不在名单里，
+ * 于是 `cd /tmp && dsh` 仍会把整个 /tmp 当项目根——和家目录是同一类问题（issue #5 补充发现）。
+ */
+const POSIX_SHARED_TEMP = ['/tmp', '/var/tmp', '/private/tmp', '/private/var/tmp', '/var/folders', '/dev/shm']
+
 /**
  * 危险根集合（判定用，`isUnsafeRoot` 的底座）。
  *
@@ -233,8 +244,11 @@ function safeHomedir() {
  *
  * 系统前缀按平台分组是刻意的：`C:\opt`、`C:\usr` 在 Windows 上是**正常用户目录**，
  * 跨平台套用既会误伤，也会自相矛盾（`/usr/local` 被拒而 `/usr` 放行）。
+ *
+ * @returns {{ unsafe: Set<string>, sharedTemp: Set<string> }} `sharedTemp` 单独返回，只为了让
+ *   拒绝文案能说清"是共享临时目录"而不是笼统的"系统目录"——两套集合由同一次调用产出，不会漂移。
  */
-export function collectUnsafeRoots({
+export function collectUnsafeRootSets({
   platform = process.platform,
   home = safeHomedir(),
   tmp = os.tmpdir(),
@@ -242,7 +256,8 @@ export function collectUnsafeRoots({
   pathApi = path,
 } = {}) {
   const set = new Set()
-  const push = (p) => {
+  const sharedTemp = new Set()
+  const push = (target) => (p) => {
     if (!p || typeof p !== 'string') return
     let abs
     try {
@@ -250,10 +265,23 @@ export function collectUnsafeRoots({
     } catch {
       return
     }
-    set.add(storeKey(abs, platform))
+    target.add(storeKey(abs, platform))
+  }
+  const add = push(set)
+  const addTemp = push(sharedTemp)
+
+  // 每用户私有临时目录 + 共享/系统临时目录，都算"共享临时目录"（拒绝文案上同类）。
+  addTemp(tmp)
+  if (platform === 'win32') {
+    addTemp(env.TEMP)
+    addTemp(env.TMP)
+    if (env.SystemRoot) addTemp(pathApi.join(env.SystemRoot, 'Temp'))
+    if (env.windir) addTemp(pathApi.join(env.windir, 'Temp'))
+  } else {
+    for (const p of POSIX_SHARED_TEMP) addTemp(p)
   }
+  for (const key of sharedTemp) set.add(key)
 
-  push(tmp)
   let homeAbs = null
   try {
     homeAbs = home ? pathApi.resolve(home) : null
@@ -264,19 +292,19 @@ export function collectUnsafeRoots({
     // 家目录 + 它的所有祖先：往上任何一级当根都会把整台机器扫进来。
     let dir = homeAbs
     for (;;) {
-      push(dir)
+      add(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))
+      add(pathApi.join(homeAbs, sub))
     }
   }
 
   if (platform === 'win32') {
     for (const name of ['SystemRoot', 'windir', 'ProgramFiles', 'ProgramFiles(x86)', 'ProgramData']) {
-      push(env[name])
+      add(env[name])
     }
   } else {
     // POSIX 系统前缀 + 包管理器/工具链前缀。ARM Mac 的 Homebrew 是 git clone 到
@@ -289,13 +317,20 @@ export function collectUnsafeRoots({
       '/System', '/Library', '/Applications', '/private', '/cores',
       '/home/linuxbrew', '/home/linuxbrew/.linuxbrew', '/nix',
     ]) {
-      push(p)
+      add(p)
     }
   }
-  return set
+  return { unsafe: set, sharedTemp }
+}
+
+/** 兼容入口：只要判定集合。 */
+export function collectUnsafeRoots(opts) {
+  return collectUnsafeRootSets(opts).unsafe
 }
 
-const UNSAFE_DIRS = collectUnsafeRoots()
+const UNSAFE = collectUnsafeRootSets()
+const UNSAFE_DIRS = UNSAFE.unsafe
+const SHARED_TEMP_DIRS = UNSAFE.sharedTemp
 
 /** 判定依据文案：用于拒绝时告诉用户「为什么是它」。 */
 function unsafeReason(abs) {
@@ -309,7 +344,7 @@ function unsafeReason(abs) {
     home = null
   }
   if (home && key === home) return 'your home directory'
-  if (key === storeKey(path.resolve(os.tmpdir()))) return 'the shared temp directory'
+  if (SHARED_TEMP_DIRS.has(key)) return 'the shared temp directory'
   return 'a system directory that is never a project root'
 }
 
@@ -434,11 +469,11 @@ function resolveDir(dir) {
   }
 }
 
-function nearestMarker(absPath, markers) {
+function nearestMarker(absPath, markers, isUnsafe) {
   let dir = path.dirname(absPath)
   for (;;) {
     // 撞到家目录/系统目录边界就停：既不把边界当根，也不再向上（上面只会更宽）。
-    if (isUnsafeRoot(dir)) return null
+    if (isUnsafe(dir)) return null
     for (const marker of markers) {
       if (existsSync(path.join(dir, marker))) return dir
     }
@@ -452,14 +487,18 @@ function nearestMarker(absPath, markers) {
  * 项目根推导（**只认标记与显式声明，绝不从文件路径兜底**）。
  *
  * @param {string} filePath 目标文件（也接受目录内探针文件路径）
- * @param {{ extraRoots?: Iterable<string>, sessionRoot?: string|null }} [opts]
+ * @param {{ extraRoots?: Iterable<string>, sessionRoot?: string|null, isUnsafe?: (dir: string) => boolean }} [opts]
  *   `extraRoots`：显式登记过的根（watch_repo / watchManager）。
  *   `sessionRoot`：会话工作目录，作为**最后**一级推定——仅当文件确实在它里面、
  *   且它是安全目录时采用。
+ *   `isUnsafe`：危险根判定，默认 `isUnsafeRoot`。可注入是为了让"被拒前缀里有一个合法
+ *   `.git`"这条反直觉输入能在任意平台上用一个临时目录复现（`/opt/homebrew` 正是被
+ *   `.git` 主动选中的，不是兜底误判——issue #5 的现场复核结论）。
  * @returns {string|null}
  */
 export function findProjectRoot(filePath, opts = {}) {
   if (typeof filePath !== 'string' || !filePath) return null
+  const isUnsafe = typeof opts.isUnsafe === 'function' ? opts.isUnsafe : isUnsafeRoot
   let abs
   try {
     abs = path.resolve(filePath)
@@ -467,13 +506,13 @@ export function findProjectRoot(filePath, opts = {}) {
     return null
   }
   const explicit = longestRootContaining(opts.extraRoots || [], abs)
-  if (explicit) return isUnsafeRoot(explicit) ? null : explicit
+  if (explicit) return isUnsafe(explicit) ? null : explicit
 
-  const byMarker = nearestMarker(abs, VCS_MARKERS) || nearestMarker(abs, PROJECT_MARKERS)
+  const byMarker = nearestMarker(abs, VCS_MARKERS, isUnsafe) || nearestMarker(abs, PROJECT_MARKERS, isUnsafe)
   if (byMarker) return byMarker
 
   const session = resolveDir(opts.sessionRoot)
-  if (session && !isUnsafeRoot(session) && isInside(session, abs)) return session
+  if (session && !isUnsafe(session) && isInside(session, abs)) return session
   return null
 }