@yolk_vat-y/dsh-project-memory 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Changelog
 
-## 0.5.1 (unreleased)
+## 0.5.2 (2026-09-09)
+
+### Changed (file hotspot + resume info)
+
+- **Task files now stay in "hot" order (writes first)**: `task.files` is kept sorted by recency-weighted activity — written/edited files always precede read-only ones, ordered by last-write then last-read time; a read never outranks a written file. Every surface reads `task.files` in order, so `select_task` resume, `query_memory` task rows, `/tasks` and the task panel all surface the hottest files first. Per-file metadata (`fileMeta`: `lastWriteAt` / `lastReadAt` / touch count `n`) is additive and old tasks stay compatible.
+- **Resident task card shows ≤3 "editing now" files**: the silent-injection task block appends `编辑中: a.ts, b.ts` for recently written files (`autoContext.editedMax`, default 3).
+- **No echo of the task card when the model maintains its own task list**: when the most recent progress is the model's own `todo_write` with no newer human message (`lastTodoAt > lastHumanAt`), the resident task card is suppressed (saves tokens) while relevant project/global insight injection is kept. `autoContext.skipEchoSelfTodo` toggles it (default on).
+
+### Changed (cold-index I/O)
+
+- **Single-read indexing — cold index ~4× faster**: every indexing path read each file twice (`await sha256OfFile()` for the hash, then `readFileSync()` for the body) and paid a per-file `async readFile` thread-pool round-trip. New `readFileForIndex()` does one synchronous read and hands the same buffer to both `createHash('sha256')` and `toString('utf8')`; `index_repo`, `watch`, and lazy read-on-observe all use it. Unchanged files are still hashed without decoding. Synthetic 5,000-file corpus (WSL2, Node 24): cold index 1,093 ms → 272 ms (4.0×); the `read+hash` phase drops from 70% to 11% of the pipeline. Tests green.
+
+### Fixed (host-contract + watch robustness)
+
+- **`agent/pre-step` could still crash every step** — the listener called `next()` outside any guard, so a missing/renamed continuation rejected it (`next is not a function`, the exact 0.5.1 failure mode); and when a downstream listener returned `undefined`, the plugin forwarded that `undefined`, making the host read `decision.kind` off `undefined` and abort the step. Both now degrade to a valid `enter` decision built from `payload.messages`; genuine downstream errors still propagate. Regression test `test/host-contract.test.mjs`.
+- **Watch poll storms** — `start(NaN)` / `start(undefined)` produced `setInterval(fn, NaN)`, which Node silently rewrites to a 1 ms interval, saturating the event loop so the agent stopped responding; invalid intervals now fall back to 15 s. `poll()` had no re-entrancy guard, so a slow poll (large repo, or doc LLM summaries) overlapped the next tick and stacked concurrent indexing; a re-entrancy flag now skips overlapping ticks.
+- **`WatchManager.restorePersisted()` dropped persisted watch roots** — it ignored `load()`'s return value, so on a `storeCache` hit it iterated the empty new instance instead of the loaded one; it now uses the returned store.
+
+### Changed (injection + cache hygiene)
+
+- **Removed the unused `wrapLlmStream` helper** — silent injection is wired solely through the host's `agent/pre-step` seam; the `llm.stream` wrapper could never intercept the host's internal reference, so it was dead code (and its tests went with it).
+- **Per-session injection fingerprint** — the "already injected" fingerprint was one shared value, so concurrent sessions could suppress each other's injection; it is now keyed per session (bounded).
+- **Injection no longer re-fires on hotspot churn** — the dedupe fingerprint now covers only stable content (task title/steps/insights plus matched insights); the volatile `编辑中` file list still appears in the injected block but no longer triggers a re-injection on every file write.
+- **Bounded store cache, synchronous effect** — `ProjectMemoryStore`'s cross-project cache is capped so long-running multi-project use cannot grow without bound; the optional `autoIndexOnFirstUse` effect is now a proper synchronous disposer instead of an async callback.
+
+### Files
+- src/setup/taskbridge.js, src/auto-inject.js, src/util/fs.js, src/store.js, src/index.js, src/tools/index-repo.js, src/watch.js, src/lazy.js, test/auto-inject.test.mjs, test/host-contract.test.mjs, package.json, README.md, README.zh-CN.md
+
+## 0.5.1 (2026-09-08)
 
 ### Fixed
 
@@ -17,7 +45,7 @@
 ### Files
 - src/auto-inject.js, src/client/TaskComponents.tsx, src/client/TaskPanel.module.css, client/client.js (+ map), package.json
 
-## 0.5.0 (unreleased)
+## 0.5.0 (2026-09-07)
 
 ### Added — v0.5 tiered insight memory (lessons / decisions / procedures)
 

package/README.md

@@ -16,7 +16,7 @@ The workflow panel is collapsible, automatically adapts to dsh and theme plugin
 ![alt text](docs/images/image-4.png)
 ## Features
 
-- **TaskBridge: cross-session development tasks** — the plugin watches each session's live todo list (`todo_write` events) and file reads (`tool/call`): progress snapshots (`steps`) and touched files sync into durable per-project task entities. An unbound session that writes a todo auto-creates a task. New sessions continue by `list_tasks` → `select_task` (bind / rename / unarchive); `query_memory` gains `type: 'task'` and appends a task-count hint to `type: 'all'` results. The user-side `/tasks` command shows the task stack, step progress, involved files, and the current session binding. Titles are chosen by the model via `select_task(title=…)` (fallback: the part of your message after the last colon). Capacity is project-size adaptive (`fileCount/20`, clamped 5–100). Storage: `.dsh-project-memory/tasks.json` + `binding.json`. Auto-sync requires a dsh build with session events + `todo_write` (verified on 0.1.2-alpha.x); on older hosts the task tools still work as a plain record list.
+- **TaskBridge: cross-session development tasks** — the plugin watches each session's live todo list (`todo_write` events) and file reads (`tool/call`): progress snapshots (`steps`) and touched files sync into durable per-project task entities. An unbound session that writes a todo auto-creates a task. Associated files are kept in **recency-weighted order (written/edited first; a read never outranks a written file)** so a resumed session sees at a glance where to look. New sessions continue by `list_tasks` → `select_task` (bind / rename / unarchive); `query_memory` gains `type: 'task'` and appends a task-count hint to `type: 'all'` results. The user-side `/tasks` command shows the task stack, step progress, involved files, and the current session binding. Titles are chosen by the model via `select_task(title=…)` (fallback: the part of your message after the last colon). Capacity is project-size adaptive (`fileCount/20`, clamped 5–100). Storage: `.dsh-project-memory/tasks.json` + `binding.json`. Auto-sync requires a dsh build with session events + `todo_write` (verified on 0.1.2-alpha.x); on older hosts the task tools still work as a plain record list.
 - **Task Panel (v0.4.2+): Floating task panel in dsh web** — built on the real dsh web 0.1.2-rc.1 client plugin contract (cordis inject + apply, registered into host `shell.overlay` slot). Draggable cards show steps/files (click to copy path); collapse to a draggable mini-bar; hide completely (summon with `/task` / `/tasks`). Render errors have error boundaries — panel crash no longer takes down the host.
 - **Task Panel Behavior** —
   - **Default hidden**: panel does not show on dsh web startup
@@ -38,7 +38,7 @@ The workflow panel is collapsible, automatically adapts to dsh and theme plugin
 - **blindSpots-aware recall** — document summaries carry a `blindSpots` field (what the summary explicitly does NOT cover). When a query hits a blind spot, `query_memory` appends a warning pointing the model to read the source file, preventing hallucination from partial summaries.
 - **Experience notes** — problems → solutions; similar problems supersede instead of duplicating, and notes are returned only when a search matches. The note store is bounded: capacity scales with project size (clamped to 100–2000), and the oldest notes are pruned when the limit is exceeded. **Supersede tightened to bidirectional 0.7 overlap** (was 0.6); **experience `problem` field now participates in CJK phrase boost** for long-tail query recall.
 - **v0.5 tiered insight memory (lessons / decisions / procedures)** — one `insight` entity across three scopes: `task` (private drafts in `tasks.json`), `project` (`.dsh-project-memory/insights.json`), `global` (`~/.config/dsh-project-memory/global.json`). `save_lesson` writes any scope; dedupe is bidirectional token overlap ≥ 0.7 (merge) with a 0.65–0.7 reinforce band; **promotion is a scope change, not a copy** — 2 tasks hitting the same insight promote it to project, 3+ to global. Archive is soft (`archived`), decay/capacity prune archived entries only; writes are filtered for secret/token-shaped content. LLM **reflection is off by default** and only ever writes task-level drafts (`source: reflect`) on task switch-away/archive. Panel gains a Task / Project / Global memory view with approve, promote/demote, archive/restore, delete, edit and a create form (procedures can carry an “as Skill” trigger). Old `experience.json` notes are imported into `insights.json` once, non-destructively. Defaults & rationale: `PLAN-v0.5.0.md`.
-- **Streaming TF + IDF caching** — query path caches IDF (term inverse frequency) per store version; on cache hit, single-pass streaming scores 20k entries in ~8 ms (5k files) / ~1 ms (1k files) with zero intermediate objects; write path is O(1) version bump.
+- **Streaming TF + IDF caching** — query path caches IDF (term inverse frequency) per store version; on cache hit, single-pass streaming scores 20k entries in ~3 ms (5k files) / ~0.6 ms (1k files) with zero intermediate objects; write path is O(1) version bump.
 - **Lock-free sync transactions** — all writes (index / watch / remember / forget / watch_repo) go through synchronous transactions `store.commit(fn)`; fn succeeds then atomic write; JS single-threaded event loop guarantees no interleaving; `remember`/`forget` never blocked by watch re-indexing.
 - **Minimal dependencies** — pure JavaScript; the only runtime dependency is `pdfjs-dist` (PDF text extraction), no native builds required.
 - **Negligible overhead** — pure in-process operation; cold start <100 ms (5k files), typical project query median 2–3 ms (p99 < 7 ms); bottleneck is LLM summarization and PDF parsing, not the plugin.
@@ -49,16 +49,16 @@ The workflow panel is collapsible, automatically adapts to dsh and theme plugin
 
 | Scenario | Scale | Measured |
 |----------|-------|----------|
-| Full cold index | 5,000 files / 20k entries | 353 ms |
-| Cold load | 5,000 files | 82 ms |
+| Full cold index | 5,000 files / 20k entries | 272 ms |
+| Cold load | 5,000 files | 43 ms |
 | Hot lazy re-index (single file) | 5k files | median 2.3 ms / max 4.0 ms |
-| query_memory (cached) | 5k files / 20k entries | median 9.3 ms / p95 12.6 ms |
-| query_memory (cached) | 1k files / 4k entries | median 1.0 ms / p95 2.0 ms |
+| query_memory (cached) | 5k files / 20k entries | median 3.0 ms / p95 5.9 ms |
+| query_memory (cached) | 1k files / 4k entries | median 0.6 ms / p95 1.7 ms |
 | Full cold index | 10,000 files / 40k entries | 637 ms |
-| Cold load | 10,000 files | 144 ms |
+| Cold load | 10,000 files | 108 ms |
 | Hot lazy re-index (single file) | 10k files | median 4.5 ms / max 10.2 ms |
 
-> Synthetic benchmark: generated code (~8 symbols/file), Node 24, Linux native FS, SSD. Measures pure indexing overhead without LLM calls. query_memory benchmark uses IDF cache + precomputed searchText; first query after write rebuilds IDF (~150 ms), subsequent queries hit cache.
+> Synthetic benchmark: generated code (~4–5 symbols/file), Node 24, Linux, SSD. Measures pure indexing overhead without LLM calls. query_memory benchmark uses IDF cache + precomputed searchText; first query after write rebuilds IDF (~150 ms), subsequent queries hit cache.
 
 ### Real Project Storage
 
@@ -265,7 +265,7 @@ These are deliberate scope choices.
 | `enableTypeScript` | true | set `false` to disable L2 TS enhancement entirely (L1 regex only) |
 | `insight.*` | dedupOverlap `0.7` · reinforceBand `0.65` · maxProject `100` · maxGlobalProcedures `200` · promoteConfidence `0.7` · globalPromoteTasks `3` · decayDays `90` · `globalFile` (auto) | v0.5 insight dedupe / reinforce / promotion / capacity / archive settings |
 | `reflection.enabled` | false | v0.5 LLM reflection, **draft-only at task level** (fires on task switch-away / archive). `cooldownMs` `1800000`, `maxLessonsPerReflect` `3`, `maxDecisionsPerReflect` `2` |
-| `autoContext.enabled` | true | v0.5 silent injection wrapper (entry block + relevance). Inert (full passthrough) until the host exposes a resolvable session cwd; `maxTokens` `400` |
+| `autoContext.enabled` | true | v0.5 silent injection wrapper (entry block + relevance). Inert (full passthrough) until the host exposes a resolvable session cwd; `maxTokens` `400`, `editedMax` `3` (how many recently-written "editing now" files the resident task card shows), `skipEchoSelfTodo` `true` (don't echo the task card back when the model itself maintains the task list with no newer human message; relevant insights still inject) |
 
 ### Toggling features
 
@@ -301,7 +301,7 @@ These commands are for **maintaining the plugin code** — regular users do not
 
 ```bash
 npm install
-npm test          # 211 tests (166 core + 11 TaskBridge + 11 insight-store + 5 reflection + 9 auto-inject + 9 insight-actions)
+npm test          # 215 tests (166 core + 11 TaskBridge + 11 insight-store + 5 reflection + 7 auto-inject + 9 insight-actions + 6 host-contract)
 ```
 
 ## License

package/README.zh-CN.md

@@ -17,7 +17,7 @@
 ![alt text](docs/images/image-4.png)
 ## 特性
 
-- **TaskBridge：跨会话开发任务** — 监听会话内宿主 `todo_write` 维护的任务清单与 `tool/call` 读文件：进度快照（steps）与触碰文件自动同步进跨会话的任务实体。未绑定会话写 todo 时自动建档。新会话通过 `list_tasks` → `select_task`（绑定/改名/解归档）续接；`query_memory` 新增 `type:'task'`，`type:'all'` 结果尾部附任务计数提示。用户侧 `/tasks` 命令展示任务栈、步骤进度、涉及文件与当前会话绑定。标题由模型经 `select_task(title=…)` 命名（回退：取消息最后一个「：」后的任务段）。容量随项目体积自适应（fileCount/20，clamp 5–100）。存储：`.dsh-project-memory/tasks.json` + `binding.json`。自动同步需含会话事件与 `todo_write` 的 dsh（0.1.2-alpha.x 实测）；旧宿主下降级为纯记录。
+- **TaskBridge：跨会话开发任务** — 监听会话内宿主 `todo_write` 维护的任务清单与 `tool/call` 读文件：进度快照（steps）与触碰文件自动同步进跨会话的任务实体。未绑定会话写 todo 时自动建档。关联文件按**最近活跃排序（写过/编辑的排最前，任何读取不越过写过文件）**，续接时一眼看到该看哪些文件。新会话通过 `list_tasks` → `select_task`（绑定/改名/解归档）续接；`query_memory` 新增 `type:'task'`，`type:'all'` 结果尾部附任务计数提示。用户侧 `/tasks` 命令展示任务栈、步骤进度、涉及文件与当前会话绑定。标题由模型经 `select_task(title=…)` 命名（回退：取消息最后一个「：」后的任务段）。容量随项目体积自适应（fileCount/20，clamp 5–100）。存储：`.dsh-project-memory/tasks.json` + `binding.json`。自动同步需含会话事件与 `todo_write` 的 dsh（0.1.2-alpha.x 实测）；旧宿主下降级为纯记录。
 - **Task Panel（v0.4.2+）：dsh web 浮动任务面板** — 按 dsh web 0.1.2-rc.1 真实 client 插件契约落地（cordis inject + apply，注册进宿主 `shell.overlay` 槽）。卡片可拖拽、展开查看步骤/文件（点击复制路径）；折叠为可拖拽顶部迷你条；可彻底隐藏（输入 `/task` / `/tasks` 唤起）。渲染错误有边界兜底，面板崩溃不再拖垮宿主。
 - **任务面板行为** —
   - **默认隐藏**：dsh web 启动时面板不显示
@@ -39,7 +39,7 @@
 - **blindSpots 感知召回** — 文档摘要携带 `blindSpots` 字段（明确说明摘要未覆盖的内容）。查询命中盲区时，`query_memory` 追加提示引导模型去读原文，防止半截摘要误导。
 - **经验笔记** — 记录问题 → 方案；相似问题覆盖而非重复；笔记仅在检索命中时返回。笔记数量有界：容量随项目规模伸缩（钳制在 100–2000），超限时淘汰最旧的笔记。**覆盖阈值收紧为双向 0.7 重叠**（原 0.6）；**经验 `problem` 字段现参与 CJK 短语加分**，提升长尾问句召回。
 - **v0.5 分层 insight 记忆（教训 / 决策 / 流程）** — 一个 `insight` 实体贯穿三级：`task`（任务私有草稿，存 `tasks.json`）、`project`（`.dsh-project-memory/insights.json`）、`global`（`~/.config/dsh-project-memory/global.json`）。`save_lesson` 三级可写；去重采用双向 token overlap ≥ 0.7（合并）外加 0.65–0.7 近重复强化带；**提升 = scope 字段变更而非复制**——同一 insight 被 2 个任务命中升 project、3+ 升 global。归档为软删（`archived`），容量/衰减只清归档区；写盘前过滤密钥/token 形态内容。LLM **反思默认关闭**，且只产任务级草稿（`source: reflect`，触发于任务切走/归档时）。面板新增 Task / Project / Global 记忆视图：审核、提升/降级、归档/恢复、删除、编辑与新建表单（procedure 可带"作为 Skill"触发关键词）。旧 `experience.json` 笔记**非破坏**导入 `insights.json` 一次。默认值与设计说明见 `PLAN-v0.5.0.md`。
-- **流式 TF + IDF 缓存** — 查询路径按存储版本缓存 IDF（词逆频率）；命中时单次流式遍历 20k 条目仅需 ~8 ms（5k 文件） / ~1 ms（1k 文件），零中间对象；写入路径仅 O(1) 版本号递增。
+- **流式 TF + IDF 缓存** — 查询路径按存储版本缓存 IDF（词逆频率）；命中时单次流式遍历 20k 条目仅需 ~3 ms（5k 文件） / ~0.6 ms（1k 文件），零中间对象；写入路径仅 O(1) 版本号递增。
 - **无锁同步事务** — 不采用锁：所有写入（index / watch / remember / forget / watch_repo）统一走同步事务 `store.commit(fn)`，fn 成功后才一次落盘；JS 单线程事件循环保证事务间不交错，`remember`/`forget` 不会被 watch 重索引阻塞排队。多实例并发写入同一项目存储时，得益于 CAS 幂等更新与原子提交，自然具备幂等性，无数据损坏风险。
 - **依赖极简** — 纯 JavaScript；唯一运行时依赖是 `pdfjs-dist`（PDF 文本提取），无需原生构建。
 - **开销可忽略** — 纯进程内操作；冷启动 <100 ms（5k 文件），典型项目查询中位数 2–3 ms（p99 < 7 ms）；瓶颈在 LLM 摘要与 PDF 解析，插件本身不阻塞。
@@ -50,16 +50,16 @@
 
 | 场景 | 规模 | 实测 |
 |------|------|------|
-| 批量冷记忆构建 | 5,000 文件 / 20k 条目 | 353 ms |
-| 冷加载 | 5,000 文件 | 82 ms |
+| 批量冷记忆构建 | 5,000 文件 / 20k 条目 | 272 ms |
+| 冷加载 | 5,000 文件 | 43 ms |
 | 热路径懒记忆 | 单文件重记忆+落盘 | 中位数 2.3 ms / 最大 4.0 ms (5k) |
-| query_memory (缓存命中) | 5k 文件 / 20k 条目 | 中位数 9.3 ms / p95 12.6 ms |
-| query_memory (缓存命中) | 1k 文件 / 4k 条目 | 中位数 1.0 ms / p95 2.0 ms |
+| query_memory (缓存命中) | 5k 文件 / 20k 条目 | 中位数 3.0 ms / p95 5.9 ms |
+| query_memory (缓存命中) | 1k 文件 / 4k 条目 | 中位数 0.6 ms / p95 1.7 ms |
 | 批量冷记忆构建 | 10,000 文件 / 40k 条目 | 637 ms |
-| 冷加载 | 10,000 文件 | 144 ms |
+| 冷加载 | 10,000 文件 | 108 ms |
 | 热路径懒记忆 | 单文件重记忆+落盘 | 中位数 4.5 ms / 最大 10.2 ms (10k) |
 
-> 合成基准：生成代码（~8 符号/文件），Node 24，Linux 文件系统，SSD。测量纯索引开销，不含 LLM 调用。query_memory 基准使用 IDF 缓存 + 预计算 searchText；写入后首次查询重建 IDF（~150 ms），后续查询命中缓存。
+> 合成基准：生成代码（~4–5 符号/文件），Node 24，Linux 文件系统，SSD。测量纯索引开销，不含 LLM 调用。query_memory 基准使用 IDF 缓存 + 预计算 searchText；写入后首次查询重建 IDF（~150 ms），后续查询命中缓存。
 
 ### 真实项目存储体积
 
@@ -264,7 +264,7 @@ TaskPanel (Container)
 | `enableTypeScript` | true | 设为 `false` 彻底禁用 L2 TS 增强（仅保留 L1 正则） |
 | `insight.*` | dedupOverlap `0.7` · reinforceBand `0.65` · maxProject `100` · maxGlobalProcedures `200` · promoteConfidence `0.7` · globalPromoteTasks `3` · decayDays `90` · `globalFile`（自动） | v0.5 insight 去重/强化/提升/容量/归档设置 |
 | `reflection.enabled` | false | v0.5 LLM 反思，**只写任务级草稿**（触发于任务切走/归档）。`cooldownMs` `1800000`、`maxLessonsPerReflect` `3`、`maxDecisionsPerReflect` `2` |
-| `autoContext.enabled` | true | v0.5 静默注入包装（entry 常驻块 + relevance）。宿主无法解析会话 cwd 时完全透传（零副作用）；`maxTokens` `400` |
+| `autoContext.enabled` | true | v0.5 静默注入包装（entry 常驻块 + relevance）。宿主无法解析会话 cwd 时完全透传（零副作用）；`maxTokens` `400`、`editedMax` `3`（resident 任务卡显示最近"编辑中"文件数）、`skipEchoSelfTodo` `true`（模型自己写/维护任务清单后、无新人类消息时不回声任务卡，省 token；相关 insights 仍注入） |
 
 ### 功能开关
 
@@ -300,7 +300,7 @@ dsh web --patch ./config.yml
 
 ```bash
 npm install
-npm test          # 211 项测试（核心 166 + TaskBridge 11 + insight-store 11 + reflection 5 + auto-inject 9 + insight-actions 9）
+npm test          # 215 项测试（核心 166 + TaskBridge 11 + insight-store 11 + reflection 5 + auto-inject 7 + insight-actions 9 + host-contract 6）
 ```
 
 ## 许可证

package/client/client.js

@@ -560,7 +560,7 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region \0dsh-css:/home/sxt/project/dsh-project-memory/src/client/TaskPanel.module.css.mjs
+		//#region \0dsh-css:src/client/TaskPanel.module.css.mjs
 		const css$1 = ".vZSZnG_panel{pointer-events:auto;background:var(--dsw-alias-bg-layer-2,var(--dsw-alias-bg-base,#fff));border:1px solid var(--dsw-alias-border-l2,#7f7f7f4d);border-radius:14px;flex-direction:column;width:380px;max-width:calc(100vw - 24px);max-height:min(70vh,640px);font-family:inherit;animation:.18s ease-out vZSZnG_panelIn;display:flex;position:fixed;overflow:hidden;box-shadow:0 12px 32px #00000029,0 2px 8px #00000014}@keyframes vZSZnG_panelIn{0%{opacity:0;transform:translateY(-4px)}to{opacity:1;transform:none}}.vZSZnG_dragHandle{cursor:grab;z-index:1;justify-content:center;align-items:center;height:12px;display:flex;position:absolute;top:0;left:0;right:0}.vZSZnG_dragHandle:active{cursor:grabbing}.vZSZnG_handleGrip{background:var(--dsw-alias-separator-primary,#7f7f7f59);opacity:.8;border-radius:2px;width:32px;height:3px}.vZSZnG_header{border-bottom:1px solid var(--dsw-alias-border-l1,#7f7f7f2e);-webkit-user-select:none;user-select:none;justify-content:space-between;align-items:center;gap:8px;padding:10px 10px 8px 14px;display:flex}.vZSZnG_headerLeft{align-items:center;gap:6px;min-width:0;display:flex}.vZSZnG_headerIcon{color:var(--dsw-alias-label-secondary);flex:none}.vZSZnG_headerTitle{color:var(--dsw-alias-label-primary);white-space:nowrap;margin:0;font-size:13px;font-weight:600;line-height:20px}.vZSZnG_headerRight{align-items:center;gap:2px;margin-left:auto;display:flex}.vZSZnG_counts{color:var(--dsw-alias-label-tertiary);white-space:nowrap;margin-right:4px;font-size:11px;line-height:16px}.vZSZnG_boundBadge{color:var(--dsw-alias-label-primary-foreground,#fff);background:var(--dsw-alias-button-primary-fill,#3a6ef5);white-space:nowrap;border-radius:7px;flex:none;padding:0 6px;font-size:10px;line-height:14px}.vZSZnG_notice{color:var(--dsw-alias-state-warn-label,#b7791f);background:var(--dsw-alias-interactive-bg-hover,#7f7f7f1a);word-break:break-all;border-radius:8px;margin:8px 12px 0;padding:6px 10px;font-size:12px;line-height:18px}.vZSZnG_taskList{scrollbar-width:thin;scrollbar-color:var(--dsw-alias-scrollbar-bg-l2,transparent) transparent;flex-direction:column;gap:6px;padding:8px;display:flex;overflow-y:auto}.vZSZnG_emptyState{text-align:center;color:var(--dsw-alias-label-secondary);padding:36px 24px 30px}.vZSZnG_emptyTitle{color:var(--dsw-alias-label-primary);margin:0 0 6px;font-size:13px;font-weight:600}.vZSZnG_emptyDesc{color:var(--dsw-alias-label-tertiary);margin:0;font-size:12px;line-height:20px}.vZSZnG_syncHint{color:var(--dsw-alias-label-dimmed);justify-content:center;align-items:center;gap:6px;margin:10px 0 0;font-size:11px;display:flex}.vZSZnG_card{border:1px solid var(--dsw-alias-border-l1,#7f7f7f29);background:var(--dsw-alias-bg-base,transparent);border-radius:10px;transition:border-color .15s;overflow:hidden}.vZSZnG_cardBound{border-color:var(--dsw-alias-border-l3,#7f7f7f59);box-shadow:inset 0 0 0 .5px var(--dsw-alias-border-l3,transparent)}.vZSZnG_cardHead{cursor:pointer;text-align:left;background:0 0;border:none;justify-content:space-between;align-items:center;gap:8px;width:100%;padding:8px 10px 7px;display:flex}.vZSZnG_cardHead:hover{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f14)}.vZSZnG_cardTitleRow{align-items:center;gap:6px;min-width:0;display:flex}.vZSZnG_cardTitle{color:var(--dsw-alias-label-primary);white-space:nowrap;text-overflow:ellipsis;font-size:13px;font-weight:500;line-height:20px;overflow:hidden}.vZSZnG_cardMeta{color:var(--dsw-alias-label-tertiary);flex:none;align-items:center;gap:8px;display:flex}.vZSZnG_progressText{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:16px}.vZSZnG_updated{color:var(--dsw-alias-label-dimmed);font-size:10px;line-height:14px}.vZSZnG_chevron{color:var(--dsw-alias-label-tertiary);display:inline-flex}.vZSZnG_track{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f1f);border-radius:1px;height:2px;margin:0 10px 6px;overflow:hidden}.vZSZnG_trackFill{background:var(--dsw-alias-label-primary-bluish,var(--dsw-alias-button-primary-fill,#3a6ef5));border-radius:1px;height:100%;transition:width .2s}.vZSZnG_cardBody{border-top:1px solid var(--dsw-alias-border-l1,#7f7f7f24);overscroll-behavior:contain;max-height:300px;padding:8px 10px 10px;overflow-y:auto}.vZSZnG_section{margin-bottom:8px}.vZSZnG_section:last-child{margin-bottom:0}.vZSZnG_sectionLabel{color:var(--dsw-alias-label-secondary);align-items:center;gap:6px;margin-bottom:4px;font-size:11px;line-height:16px;display:flex}.vZSZnG_sectionCount{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f1a);color:var(--dsw-alias-label-tertiary);border-radius:6px;padding:0 5px;font-size:10px;line-height:14px}.vZSZnG_stepsList{flex-direction:column;gap:1px;margin:0;padding:0;list-style:none;display:flex}.vZSZnG_stepRow{align-items:flex-start;gap:7px;padding:3px 2px;display:flex}.vZSZnG_stepRow>svg{flex:none;margin-top:2px}.vZSZnG_stepDone{color:var(--dsw-alias-label-dimmed)}.vZSZnG_stepRun{color:var(--dsw-alias-label-primary-bluish,#3a6ef5)}.vZSZnG_stepPending{background:var(--dsw-alias-border-l3,#7f7f7f80);border-radius:50%;flex:none;width:8px;height:8px;margin:5px 3px}.vZSZnG_stepContent{color:var(--dsw-alias-label-secondary);word-break:break-word;white-space:pre-wrap;font-size:12px;line-height:20px}.vZSZnG_stepContentDone{color:var(--dsw-alias-label-dimmed);text-decoration:line-through}.vZSZnG_stepContentRun{color:var(--dsw-alias-label-primary)}.vZSZnG_muted{color:var(--dsw-alias-label-dimmed);font-size:11px;line-height:18px}.vZSZnG_filesList{flex-direction:column;margin:0;padding:0;list-style:none;display:flex}.vZSZnG_fileRow{cursor:pointer;text-align:left;background:0 0;border:none;border-radius:6px;align-items:center;gap:6px;width:100%;padding:3px 4px;display:flex}.vZSZnG_fileRow:hover{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f14)}.vZSZnG_fileDot{background:var(--dsw-alias-border-l3,#7f7f7f80);border-radius:50%;flex:none;width:5px;height:5px}.vZSZnG_filePath{color:var(--dsw-alias-label-secondary);white-space:nowrap;text-overflow:ellipsis;text-align:left;direction:rtl;font-family:ui-monospace,SF Mono,Menlo,Consolas,monospace;font-size:11px;line-height:18px;overflow:hidden}.vZSZnG_fileLine{color:var(--dsw-alias-label-dimmed);flex:none;font-size:10px;line-height:18px}.vZSZnG_cardFooter{gap:6px;margin-top:8px;display:flex}@media (prefers-reduced-motion:reduce){.vZSZnG_panel{animation:none}.vZSZnG_trackFill,.vZSZnG_card{transition:none}}.vZSZnG_miniBar{border:1px solid var(--dsw-alias-border-l3,#7f7f7f4d);background:var(--dsw-alias-bg-layer-2,var(--dsw-alias-bg-base,#fff));max-width:min(46vw,340px);height:34px;color:var(--dsw-alias-label-primary);cursor:grab;-webkit-user-select:none;user-select:none;pointer-events:auto;border-radius:999px;align-items:center;gap:7px;padding:0 12px;font-size:12px;line-height:18px;transition:background .15s,border-color .15s;display:inline-flex;position:fixed;box-shadow:0 6px 20px #00000024,0 1px 4px #00000014}.vZSZnG_miniBar:active{cursor:grabbing}.vZSZnG_miniBar:hover{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f14)}.vZSZnG_miniIcon{color:var(--dsw-alias-label-secondary);flex:none}.vZSZnG_miniText{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}.vZSZnG_miniChevron{color:var(--dsw-alias-label-tertiary);flex:none}.vZSZnG_taskList{flex:auto;min-height:0}.vZSZnG_card{flex-direction:column;display:flex}.vZSZnG_boundaryFallback{border:1px solid var(--dsw-alias-border-l3,#7f7f7f4d);background:var(--dsw-alias-bg-layer-2,#fff);color:var(--dsw-alias-label-secondary);cursor:pointer;pointer-events:auto;border-radius:999px;padding:4px 10px;font-size:12px;line-height:18px;position:fixed;top:64px;right:16px}.vZSZnG_stepToggle{cursor:pointer;background:0 0;border:none;border-radius:4px;flex:none;align-items:center;margin-top:2px;padding:0;display:inline-flex}.vZSZnG_stepToggle:hover{background:var(--dsw-alias-interactive-bg-hover,#7f7f7f1f)}.vZSZnG_stepToggle:disabled{cursor:default;opacity:.5}.vZSZnG_stepEditable{cursor:text;border-radius:3px}.vZSZnG_stepEditable:hover{outline:1px dashed var(--dsw-alias-border-l3,#7f7f7f66);outline-offset:1px}.vZSZnG_stepInput{box-sizing:border-box;width:auto;min-width:0;font:inherit;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-base,transparent);border:1px solid var(--dsw-alias-border-l3,#7f7f7f73);border-radius:5px;flex:auto;padding:0 5px;font-size:12px;line-height:20px}.vZSZnG_editorArea{box-sizing:border-box;min-width:0;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-base,transparent);border:1px solid var(--dsw-alias-border-l3,#7f7f7f73);resize:none;vertical-align:middle;cursor:text;white-space:pre-wrap;word-break:break-word;border-radius:5px;flex:1;margin:0;padding:2px 5px;font-family:inherit;font-size:12px;line-height:20px;overflow:hidden}.vZSZnG_editorArea:focus{border-color:var(--dsw-alias-border-l3,#7f7f7f99);outline:none}.vZSZnG_stepDragging{opacity:.3;background:var(--dsw-alias-interactive-bg-hover,#7f7f7f14)}.vZSZnG_cardTitleEditable{cursor:text;border-radius:3px}.vZSZnG_cardTitleEditable:hover{outline:1px dashed var(--dsw-alias-border-l3,#7f7f7f66);outline-offset:1px}.vZSZnG_panel[data-theme=glass],.vZSZnG_miniBar[data-theme=glass]{background:color-mix(in srgb, var(--dsw-alias-bg-layer-2,#fff) 90%, transparent);-webkit-backdrop-filter:blur(18px)saturate(1.2);border:1px solid color-mix(in srgb, var(--dsw-alias-border-l2,#7f7f7f4d) 80%, transparent)}.vZSZnG_panel[data-theme=glass] .vZSZnG_card{background:color-mix(in srgb, var(--dsw-alias-bg-base,transparent) 84%, transparent);border-color:color-mix(in srgb, var(--dsw-alias-border-l1,#7f7f7f29) 60%, transparent)}.vZSZnG_panel[data-theme=glass] .vZSZnG_cardBody{border-top-color:color-mix(in srgb, var(--dsw-alias-border-l1,#7f7f7f24) 60%, transparent)}@media (prefers-reduced-transparency:reduce){.vZSZnG_panel[data-theme=glass],.vZSZnG_miniBar[data-theme=glass]{background:var(--dsw-alias-bg-layer-2,#fff);-webkit-backdrop-filter:none;backdrop-filter:none}.vZSZnG_panel[data-theme=glass] .vZSZnG_card{background:var(--dsw-alias-bg-base,transparent)}}@supports not ((-webkit-backdrop-filter:blur(1px)) or (backdrop-filter:blur(1px))){.vZSZnG_panel[data-theme=glass],.vZSZnG_miniBar[data-theme=glass]{background:var(--dsw-alias-bg-layer-2,#fff)}}.vZSZnG_panel[data-theme=brutal]{box-shadow:none;border-width:1px;border-radius:6px}.vZSZnG_panel[data-theme=brutal] .vZSZnG_card{border:1px solid var(--dsw-alias-border-l3,#7f7f7f6b);background:var(--dsw-alias-bg-base,transparent);box-shadow:none;border-radius:3px}.vZSZnG_panel[data-theme=brutal] .vZSZnG_cardHead{padding:7px 10px 6px}.vZSZnG_panel[data-theme=brutal] .vZSZnG_cardTitle{letter-spacing:.01em;font-weight:650}.vZSZnG_panel[data-theme=brutal] .vZSZnG_headerTitle{letter-spacing:.03em}.vZSZnG_panel[data-theme=brutal] .vZSZnG_boundBadge{border-radius:2px}.vZSZnG_panel[data-theme=brutal] .vZSZnG_track{border-radius:0;height:3px}.vZSZnG_panel[data-theme=brutal] .vZSZnG_trackFill{border-radius:0}.vZSZnG_panel[data-theme=brutal] .vZSZnG_cardBody{border-top:1px solid var(--dsw-alias-border-l2,#7f7f7f3d)}.vZSZnG_panel[data-theme=mono] .vZSZnG_headerTitle,.vZSZnG_panel[data-theme=mono] .vZSZnG_counts,.vZSZnG_panel[data-theme=mono] .vZSZnG_cardTitle,.vZSZnG_panel[data-theme=mono] .vZSZnG_progressText,.vZSZnG_panel[data-theme=mono] .vZSZnG_stepContent,.vZSZnG_panel[data-theme=mono] .vZSZnG_filePath{font-family:ui-monospace,SF Mono,Menlo,Consolas,Liberation Mono,monospace}.vZSZnG_panel[data-theme=mono] .vZSZnG_cardTitle{font-size:12px}.vZSZnG_panel[data-theme=mono] .vZSZnG_stepContent{font-size:11.5px}.vZSZnG_panel[data-theme=mono] .vZSZnG_card{border-radius:5px}.vZSZnG_panel[data-theme=mono] .vZSZnG_trackFill{border-radius:0}.vZSZnG_panel[data-theme=mono] .vZSZnG_stepPending{border-radius:1px}.vZSZnG_panel[data-theme=mono] .vZSZnG_updated{letter-spacing:.02em}.vZSZnG_headerIconBtn{color:inherit;cursor:pointer;background:0 0;border:none;border-radius:0;flex:none;justify-content:center;align-items:center;margin:0;padding:0;display:inline-flex}.vZSZnG_headerIcon{color:var(--dsw-alias-label-secondary);flex:none;display:block}.vZSZnG_headerLeft{min-width:0}.vZSZnG_headerTitle{text-overflow:ellipsis;flex:0 auto;min-width:0;overflow:hidden}.vZSZnG_headerRight{min-width:0}.vZSZnG_counts{text-overflow:ellipsis;flex:none;max-width:45%;margin-left:auto;overflow:hidden}.vZSZnG_dragGhost{pointer-events:none;z-index:9999;transition:left 50ms,top 50ms;position:fixed;transform:translate(-50%,-50%)}.vZSZnG_dragGhostCard{background:var(--dsw-alias-bg-layer-2,var(--dsw-alias-bg-base,#fff));border:1px solid var(--dsw-alias-border-l3,#7f7f7f59);color:var(--dsw-alias-label-primary);white-space:nowrap;border-radius:8px;align-items:center;gap:8px;max-width:280px;padding:8px 12px;font-size:12px;line-height:20px;display:inline-flex;transform:scale(.9);box-shadow:0 8px 24px #0000002e,0 2px 8px #0000001a}.vZSZnG_dragGhostContent{text-overflow:ellipsis;word-break:break-word;flex:1;min-width:0;overflow:hidden}.vZSZnG_dragGhostClose{width:20px;height:20px;color:var(--dsw-alias-label-tertiary);cursor:pointer;opacity:.6;background:0 0;border:none;border-radius:4px;flex:none;justify-content:center;align-items:center;margin-left:8px;font-size:16px;line-height:1;transition:opacity .15s,background .15s,color .15s;display:inline-flex}.vZSZnG_dragGhostClose:hover{opacity:1;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-interactive-bg-hover,#7f7f7f1f)}.vZSZnG_dropTargetBefore{position:relative}.vZSZnG_dropTargetBefore:before{content:\"\";background:var(--dsw-alias-button-primary-fill,#3a6ef5);height:2px;box-shadow:0 0 4px var(--dsw-alias-button-primary-fill,#3a6ef5);border-radius:1px;animation:.8s ease-in-out infinite vZSZnG_dropPulse;position:absolute;top:-1px;left:0;right:0}.vZSZnG_dropTargetAfter{position:relative}.vZSZnG_dropTargetAfter:after{content:\"\";background:var(--dsw-alias-button-primary-fill,#3a6ef5);height:2px;box-shadow:0 0 4px var(--dsw-alias-button-primary-fill,#3a6ef5);border-radius:1px;animation:.8s ease-in-out infinite vZSZnG_dropPulse;position:absolute;bottom:-1px;left:0;right:0}@keyframes vZSZnG_dropPulse{0%,to{opacity:.6}50%{opacity:1}}.vZSZnG_memoryPane{flex-direction:column;gap:6px;max-height:480px;padding:8px 10px 10px;display:flex;overflow:auto}.vZSZnG_memToolbar{justify-content:space-between;align-items:center;gap:8px;display:flex}.vZSZnG_memCount{opacity:.75;font-size:12px;font-weight:600}.vZSZnG_memList{flex-direction:column;gap:6px;display:flex}.vZSZnG_memRow{border:1px solid var(--dsw-border-weak,#80808040);background:color-mix(in srgb, var(--dsw-bg-secondary,#f5f5f5) 45%, transparent);border-radius:6px;flex-direction:column;gap:4px;padding:6px 8px;display:flex}.vZSZnG_memRowArchived{opacity:.55}.vZSZnG_memRowMain{flex-direction:column;gap:2px;display:flex}.vZSZnG_memTitle{word-break:break-word;align-items:flex-start;gap:6px;font-size:13px;line-height:1.35;display:flex}.vZSZnG_kindBadge{background:var(--dsw-accent-soft,#5078ff26);color:var(--dsw-accent,#4d6bfe);border-radius:4px;flex:none;padding:0 5px;font-size:11px;line-height:1.5}.vZSZnG_memMeta{flex-wrap:wrap;align-items:center;gap:4px;display:flex}.vZSZnG_badge{background:color-mix(in srgb, var(--dsw-fg,#222) 8%, transparent);border-radius:4px;padding:0 5px;font-size:11px;line-height:1.5}.vZSZnG_badgeDraft{color:#b26a00;background:#ffb40029}.vZSZnG_badgeArchived{opacity:.8}.vZSZnG_memBody{opacity:.8;word-break:break-word;font-size:12px}.vZSZnG_memActs{flex-wrap:wrap;gap:4px;display:flex}.vZSZnG_memToolbarActs{align-items:center;gap:6px;display:flex}.vZSZnG_memNew{border:1px solid var(--dsw-border-weak,#80808040);border-radius:6px;flex-direction:column;gap:6px;padding:8px;display:flex}.vZSZnG_memNewRow{align-items:center;gap:8px;display:flex}.vZSZnG_memLabel{opacity:.8;align-items:center;gap:6px;font-size:12px;display:inline-flex}.vZSZnG_memNew select,.vZSZnG_memNew textarea{box-sizing:border-box;width:100%}";
 		const tagId$1 = "@yolk_vat-y/dsh-project-memory/TaskPanel.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$1) + "]") === null) {
@@ -2005,7 +2005,7 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
-		//#region \0dsh-css:/home/sxt/project/dsh-project-memory/src/client/TaskCommandNode.module.css.mjs
+		//#region \0dsh-css:src/client/TaskCommandNode.module.css.mjs
 		const css = ".TPe-xa_row{max-width:100%;color:var(--dsw-alias-label-tertiary);white-space:nowrap;text-overflow:ellipsis;align-items:center;gap:6px;padding:2px 0;font-size:12px;line-height:20px;display:inline-flex;overflow:hidden}.TPe-xa_row[data-variant=ok]{color:var(--dsw-alias-label-secondary)}.TPe-xa_row[data-variant=error]{color:var(--dsw-alias-state-warn-label,#b7791f)}.TPe-xa_row[data-variant=running]{color:var(--dsw-alias-label-dimmed)}.TPe-xa_icon{color:var(--dsw-alias-label-tertiary);flex:none}";
 		const tagId = "@yolk_vat-y/dsh-project-memory/TaskCommandNode.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "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",
@@ -17,7 +17,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",
+    "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",
     "build:client": "tsdown"
   },
   "keywords": [

package/src/auto-inject.js

@@ -1,10 +1,10 @@
 // PR 2 静默注入引擎（entry 常驻块 + relevance 门控）
 // 安全约定：
 //  - 纯函数 buildInjection 可单测；
-//  - wrapLlmStream 仅在 resolver 给出项目 root 时才会真正动 messages，
-//    任何异常/禁用/无 root → 原样透传（零副作用），绝不让宿主请求受影响。
-//  - “静默注入”文本带 [Memory Inject] 前缀，落在最后一条 user message 内容块里；
-//    指纹去重保证内容未变不重复追加（变更由宿主消息历史自然保留到压缩前）。
+//  - 唯一接线点是宿主 agent/pre-step 瀑布事件；任何异常/无会话 cwd → 交回合法决策，
+//    绝不让宿主请求受影响（宿主直接读 decision.kind，返回 undefined 会崩掉整步）。
+//  - “静默注入”文本带 [Memory Inject] 前缀，作为一条 plugin source 的 user 消息追加；
+//    按会话指纹去重，内容未变不重复追加。
 import { createHash } from 'node:crypto'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { ProjectMemoryStore } from './store.js'
@@ -25,6 +25,10 @@ export function cfgEngine(config) {
     maxTokens: typeof c.maxTokens === 'number' ? c.maxTokens : 400,
     entryMaxInsights: typeof c.entryMaxInsights === 'number' ? c.entryMaxInsights : 6,
     relevanceMin: typeof c.relevanceMin === 'number' ? c.relevanceMin : 0.25,
+    // resident 任务卡最多显示几个"编辑中"文件（纯写权重，最近写优先）
+    editedMax: typeof c.editedMax === 'number' ? c.editedMax : 3,
+    // 模型自己写/维护任务清单后、尚无新人类消息时，不把任务卡再回声给模型（省 token）
+    skipEchoSelfTodo: c.skipEchoSelfTodo !== false,
   }
 }
 
@@ -62,14 +66,40 @@ function linesOf(list) {
   return out
 }
 
-/** 任务卡 + 非草稿任务级 insights 摘要（常驻块主体）。 */
-export function buildEntryContent(task, cfg) {
+/** 任务卡上"编辑中"文件（写过、最近写优先，最多 max 个）。 */
+export function editedFiles(task, max) {
+  if (!task || !task.fileMeta) return []
+  const meta = task.fileMeta
+  // task.files 已由 taskbridge 保持热序（写过在前、按 lastWriteAt 倒序）
+  return (task.files || []).filter((f) => meta[f] && meta[f].lastWriteAt).slice(0, max)
+}
+
+/**
+ * 是否回声 resident 任务卡：最近一次推进是模型自己 todo 写步骤、且之后没有新人类消息时，
+ * 不回声（模型刚写的东西再喂回去 = 噪音/浪费 token）。保留相关 insights 注入不变。
+ */
+export function shouldEchoTaskCard(task, cfg) {
+  if (!task) return false
+  const c = cfg || {}
+  if (c.skipEchoSelfTodo === false) return true
+  const lt = task.lastTodoAt
+  const lh = task.lastHumanAt
+  if (lt && lh) return !(lt > lh)
+  return true
+}
+
+/** 任务卡 + 非草稿任务级 insights 摘要（常驻块主体）。
+ * withEdited=false 用于去重指纹：排除随写文件高频变化的“编辑中”行。 */
+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 card = [`任务: ${task.title || '(untitled)'}`, `进度: ${steps.filter((s) => true).length ? `${steps.length} 步` : ''}`, ...steps.slice(0, 12).map((s, i) => `  ${i + 1}. ${s}`)]
   const insights = linesOf(task.insights)
+  const edited = editedFiles(task, c.editedMax || 3)
   const parts = [...card]
-  if (insights.length) parts.push(`任务记忆:`, ...insights.slice(0, cfg.entryMaxInsights || 6))
+  if (withEdited && edited.length) parts.push(`  编辑中: ${edited.join(', ')}`)
+  if (insights.length) parts.push(`任务记忆:`, ...insights.slice(0, c.entryMaxInsights || 6))
   return parts.join('\n')
 }
 
@@ -122,59 +152,16 @@ export function buildInjection(opts) {
     labels.push(label)
     if (parts.join('\n').length > budgetChars) break
   }
-  // 常驻块文本（内容哈希由 wrapper 判“是否已注入过”）
-  const entry = task ? buildEntryContent(task, cfg) : ''
+  // 常驻块文本。去重指纹只看稳定内容（任务标题/步骤/insights + 相关 insights）：
+  // “编辑中”随每次写文件变化，若参与指纹会导致每写一个文件就重发整块（噪音 + token 浪费）。
+  const echo = shouldEchoTaskCard(task, cfg)
+  const entry = echo ? buildEntryContent(task, cfg) : ''
+  const entryStable = echo ? buildEntryContent(task, cfg, { withEdited: false }) : ''
   const total = [entry, ...parts].filter(Boolean)
   if (!total.length) return { text: '', labels: [] }
-  let text = total.join('\n')
-  if (text.length > budgetChars) text = text.slice(0, budgetChars) + '\n…(截断)'
-  return { text, labels }
-}
-
-/**
- * 包装 llm.stream。resolver(ctx, config) 返回项目 root；返回 null → 完全透传。
- * opts.state 持有“当前注入指纹”（跨请求去重）。
- */
-export function wrapLlmStream(streamFn, config, { resolveRoot, state, llmName = 'llm' } = {}) {
-  const auto = (config && config.autoContext) || {}
-  if (auto.enabled === false) return streamFn
-  const orig = typeof streamFn === 'function' ? streamFn : () => {}
-  const cfg = cfgEngine(config)
-  const mem = state || {}
-  return async function* wrapped(params) {
-    try {
-      const resolved = resolveRoot ? resolveRoot(config) : null
-      const root = typeof resolved === 'string' ? resolved : (resolved && resolved.root) || null
-      const sessionId = resolved && typeof resolved === 'object' ? resolved.sessionId || null : null
-      if (root) {
-        const query = lastUserText(params && params.messages)
-        const store = new ProjectMemoryStore(memoryRootFor(root, config.memoryDir)).load()
-        const globalStore = new GlobalStore(cfgInsight(config).globalFile || defaultGlobalFile()).load()
-        const sid = sessionId || null
-        const boundTaskId = sid && store.getBoundTaskId(sid) ? store.getBoundTaskId(sid) : null
-        const task = boundTaskId ? store.getTask(boundTaskId) : null
-        const built = buildInjection({ query, task, store, globalStore, projectTagsList: projectTags(root), cfg })
-        const fp = fingerprint(built.text)
-        if (built.text && fp !== mem.lastFp) {
-          const last = params.messages && params.messages[params.messages.length - 1]
-          if (last && last.role === 'user') {
-            const content = Array.isArray(last.content) ? last.content : []
-            content.push({ type: 'text', text: `\n\n${INJECT_MARK} ${llmName}\n${built.text}` })
-            last.content = content
-            mem.lastFp = fp
-            if (!mem.loggedFire) {
-              mem.loggedFire = true
-              console.log(`[dsh-project-memory] auto-context: FIRST injection fired (${built.text.length} chars, root=${root}${sessionId ? `, session=${sessionId}` : ''})`)
-            }
-          }
-        }
-      }
-    } catch (err) {
-      console.error(`[dsh-project-memory] auto-inject skipped: ${err?.message || err}`)
-    }
-    // 无论注入与否都原样走宿主 stream（异常同样原样传播）
-    yield* orig(params)
-  }
+  const clamp = (t) => (t.length > budgetChars ? t.slice(0, budgetChars) + '\n…(截断)' : t)
+  const dedupeText = clamp([entryStable, ...parts].filter(Boolean).join('\n'))
+  return { text: clamp(total.join('\n')), labels, dedupeText }
 }
 
 /** 注册 agent/pre-step 监听，向每步请求的 enter 决策追加记忆消息（默认开）。
@@ -185,10 +172,18 @@ export function installAutoInject(ctx, config) {
   const auto = (config && config.autoContext) || {}
   if (auto.enabled === false) return
   const cfg = cfgEngine(config)
-  const mem = {}
+  // 每个会话一份“上次注入指纹”。用单个变量会让并发会话互相抑制注入。
+  const lastFpBySession = new Map()
+  const LAST_FP_MAX = 200
   ctx.on('agent/pre-step', async (payload, next) => {
-    const decision = await next()
-    if (!decision || decision.kind !== 'enter') return decision
+    // 宿主契约是 waterfall(payload, next)，next 一定存在；但一旦宿主版本漂移、或事件被当
+    // 普通事件调用，next 缺失会让本监听器 reject（历史事故正是 `next is not a function`）。
+    // 更致命的是返回 undefined：宿主 agent.ts 直接读 `decision.kind`，会崩掉整步 → 无法回复。
+    // 因此两种情况都退化为一个合法的 enter 决策，绝不让宿主请求受影响。
+    const fallback = () => ({ kind: 'enter', messages: (payload && payload.messages) || [] })
+    const decision = typeof next === 'function' ? await next() : fallback()
+    if (!decision) return fallback()
+    if (decision.kind !== 'enter') return decision
     try {
       const agent = payload && payload.agent
       const session = agent && agent.session
@@ -201,11 +196,12 @@ export function installAutoInject(ctx, config) {
       const boundTaskId = store.getBoundTaskId(sessionId) ? store.getBoundTaskId(sessionId) : null
       const task = boundTaskId ? store.getTask(boundTaskId) : null
       const built = buildInjection({ query: query || '', task, store, globalStore, projectTagsList: projectTags(root), cfg })
-      const fp = fingerprint(built.text)
-      if (built.text && fp !== mem.lastFp) {
+      const fp = fingerprint(built.dedupeText ?? built.text)
+      if (built.text && fp !== lastFpBySession.get(sessionId)) {
         // 以宿主 createUserMessage 构造的完整 user 消息追加（带 id/source，plan-mode narration 同款）。
         // 裸 {role,content} 消息缺 source 会让宿主逐条读 message.source.kind 时崩溃。
-        mem.lastFp = fp
+        lastFpBySession.set(sessionId, fp)
+        if (lastFpBySession.size > LAST_FP_MAX) lastFpBySession.delete(lastFpBySession.keys().next().value)
         const injectMessage = createUserMessage({
           content: [{ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${built.text}` }],
           source: { kind: 'plugin', plugin: 'dsh-project-memory', form: 'notice', summary: `记忆注入 ${built.text.length} 字符` },

package/src/index.js

@@ -118,14 +118,22 @@ export function apply(ctx, config) {
   installAutoInject(ctx, config)
 
   if (config.autoIndexOnFirstUse) {
-    ctx.effect(async () => {
-      const root = process.cwd()
-      try {
-        watchManager.addRoot(root)
-        const report = await indexRepository(ctx, config, root)
-        console.log(`[dsh-project-memory] ${report}`)
-      } catch (err) {
-        console.error(`[dsh-project-memory] auto-index failed for ${root}: ${err.message}`)
+    // effect 回调必须同步并返回 disposer；异步体独立执行，用 cancelled 标志避免卸载后再写日志
+    ctx.effect(() => {
+      let cancelled = false
+      const run = async () => {
+        const root = process.cwd()
+        try {
+          watchManager.addRoot(root)
+          const report = await indexRepository(ctx, config, root)
+          if (!cancelled) console.log(`[dsh-project-memory] ${report}`)
+        } catch (err) {
+          if (!cancelled) console.error(`[dsh-project-memory] auto-index failed for ${root}: ${err.message}`)
+        }
+      }
+      run()
+      return () => {
+        cancelled = true
       }
     })
   }

package/src/lazy.js

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { tmpdir } from 'node:os'
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import { isSupportedCode, isSupportedDoc, memoryRootFor, relativePath, sha256OfFile, storeKey } from './util/fs.js'
+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 { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
@@ -88,12 +88,13 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   const existing = store.fileRecord(rel)
   let hash
   let size
+  let buffer
   let entries
   try {
     if (isSupportedCode(ext) && config.maxFileSizeMb && statSync(filePath).size > config.maxFileSizeMb * 1024 * 1024) {
       return false
     }
-    ;({ hash, size } = await sha256OfFile(filePath))
+    ;({ hash, size, buffer } = readFileForIndex(filePath))
   } catch {
     return false
   }
@@ -105,7 +106,7 @@ export async function indexFile(ctx, config, filePath, watchManager = null) {
   }
 
   if (isSupportedCode(ext)) {
-    entries = scanSymbols(rel, filePath, readFileSync(filePath, 'utf8'))
+    entries = scanSymbols(rel, filePath, buffer.toString('utf8'))
     onFileObserved(store, rel, filePath, config, root)
     return store.commit((s) => {
       s.markFile(rel, { sha256: hash, size, type: 'code', indexedAt: new Date().toISOString() })

package/src/setup/taskbridge.js

@@ -8,6 +8,8 @@ import { findProjectRoot } from '../lazy.js'
 import { ProjectMemoryStore } from '../store.js'
 
 const FS_FILE_TOOLS = new Set(['read', 'write', 'edit', 'read_image'])
+const WRITE_TOOLS = new Set(['write', 'edit']) // 编辑/写入 = 高热点
+const READ_TOOLS = new Set(['read', 'read_image'])
 const MAX_FILES_PER_TASK = 100
 const TITLE_MAX = 24
 
@@ -100,7 +102,42 @@ function pickTitle(meta, todos) {
 }
 
 /**
- * 单条会话事件处理（导出便于测试）：user/message 记首条真人文本；
+ * 热点排序：写过(编辑)的文件永远排前；同是写过按 lastWriteAt 倒序；
+ * 纯读文件按 lastReadAt 倒序排在写区之后（任何读取都不会越过写过文件）。
+ */
+export function hotSortFiles(files, meta) {
+  const m = meta || {}
+  return (files || []).slice().sort((a, b) => {
+    const A = m[a]
+    const B = m[b]
+    const aw = A && A.lastWriteAt ? 1 : 0
+    const bw = B && B.lastWriteAt ? 1 : 0
+    if (aw !== bw) return bw - aw
+    if (aw) return String(B.lastWriteAt).localeCompare(String(A.lastWriteAt))
+    return String(B.lastReadAt || '').localeCompare(String(A.lastReadAt || ''))
+  })
+}
+
+/** 触碰文件后更新元数据并重排 task.files（写 vs 读分别记时间/次数）。 */
+export function touchTaskFile(task, rel, kind, now) {
+  task.fileMeta = task.fileMeta || {}
+  if (!task.files.includes(rel)) {
+    task.files.push(rel)
+    if (task.files.length > MAX_FILES_PER_TASK) {
+      const dropped = task.files.shift()
+      delete task.fileMeta[dropped]
+    }
+  }
+  const m = task.fileMeta[rel] || {}
+  m.n = (m.n || 0) + 1
+  if (kind === 'write') m.lastWriteAt = now
+  m.lastReadAt = now
+  task.fileMeta[rel] = m
+  task.files = hotSortFiles(task.files, task.fileMeta)
+}
+
+/**
+ * 单条会话事件处理（导出便于测试）：user/message 记首条真人文本并刷新 lastHumanAt；
  * todo/write → 已绑定则覆盖 steps，未绑定则自动新建任务并绑定；
  * tool/call（fs 工具）→ 绑定任务 files 并集。
  */
@@ -108,17 +145,35 @@ export function onSessionEvent(config, session, event, meta) {
   const sessionId = session?.id
   const type = event?.type
   if (!sessionId || !type) return
+  const now = new Date().toISOString()
 
+  // 人类消息：记首条真人文本 + 若已绑定任务则刷新 lastHumanAt（供“模型自维护不回声任务卡”判断）
   if (type === 'user/message') {
-    if (!meta.has(sessionId) && event.data?.source?.kind === 'user') {
+    if (event.data?.source?.kind === 'user') {
       const text = firstTextOf(event.data?.content)
-      if (text) meta.set(sessionId, { firstHuman: text })
+      const m = meta.get(sessionId) || {}
+      if (!m.firstHuman && text) m.firstHuman = text
+      m.lastHumanAt = now
+      meta.set(sessionId, m)
+      try {
+        const { store } = taskStoreFor(session?.header?.cwd, config)
+        store.commit((s) => {
+          const tid = s.getBoundTaskId(sessionId)
+          const task = tid ? s.getTask(tid) : null
+          if (task && !task.archived) {
+            task.lastHumanAt = now
+            task.updatedAt = now
+            s._dirtyTasks = true
+          }
+        })
+      } catch {
+        /* 人类消息戳记失败不影响主流程 */
+      }
     }
     return
   }
 
   const { root, store } = taskStoreFor(session?.header?.cwd, config)
-  const now = new Date().toISOString()
 
   if (type === 'todo/write') {
     const todos = event.data?.todos
@@ -136,6 +191,7 @@ export function onSessionEvent(config, session, event, meta) {
           title,
           steps: null,
           files: [],
+          fileMeta: {},
           archived: false,
           lastSessionId: sessionId,
           createdAt: now,
@@ -146,6 +202,7 @@ export function onSessionEvent(config, session, event, meta) {
         s.setBinding(sessionId, task.id)
       }
       task.steps = todos
+      task.lastTodoAt = now // 模型/todo 最近一次自维护时刻
       task.updatedAt = now
       task.lastActiveAt = now
       task.lastSessionId = sessionId
@@ -169,13 +226,12 @@ export function onSessionEvent(config, session, event, meta) {
     if (!raw) return
     const rel = normalizeRelFile(root, raw)
     if (!rel) return
+    const kind = WRITE_TOOLS.has(data.name) ? 'write' : READ_TOOLS.has(data.name) ? 'read' : null
+    if (!kind) return
     store.commit((s) => {
       const task = s.getTask(taskId)
       if (!task || task.archived) return
-      if (!task.files.includes(rel)) {
-        task.files.push(rel)
-        if (task.files.length > MAX_FILES_PER_TASK) task.files.shift()
-      }
+      touchTaskFile(task, rel, kind, now)
       task.lastActiveAt = now
       s._dirtyTasks = true
     })

package/src/store.js

@@ -14,6 +14,7 @@ const INSIGHTS_FILE = 'insights.json'
 const SHARDS_DIR = 'shards'
 
 const storeCache = new Map()
+const STORE_CACHE_MAX = 32
 
 function loadJson(filePath, fallback) {
   let raw
@@ -85,6 +86,12 @@ export class ProjectMemoryStore {
     this._loadSharded()
     this._loadInsights()
     storeCache.set(key, this)
+    // 只保留最近打开的项目：长期跨多项目运行时不至于无限增长（被逐出只是下次重新读盘）
+    while (storeCache.size > STORE_CACHE_MAX) {
+      const oldest = storeCache.keys().next().value
+      if (oldest === key) break
+      storeCache.delete(oldest)
+    }
     return this
   }
 

package/src/tools/index-repo.js

@@ -1,7 +1,7 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import path from 'node:path'
-import { readFileSync, statSync } from 'node:fs'
-import { isSupportedCode, isSupportedDoc, looksLikeDump, memoryRootFor, relativePath, sha256OfFile, storeKey, walkDir } from '../util/fs.js'
+import { statSync } from 'node:fs'
+import { isSupportedCode, isSupportedDoc, looksLikeDump, memoryRootFor, readFileForIndex, relativePath, storeKey, walkDir } from '../util/fs.js'
 import { buildDocEntries } from '../doc-pipeline.js'
 import { scanSymbols } from '../symbols.js'
 import { linkEntries } from '../link.js'
@@ -38,8 +38,8 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
         continue
       }
 
-      // existing declared above before hash
-      const { hash } = await sha256OfFile(filePath)
+      // 单次读盘：同一 buffer 供哈希与正文使用（不再 sha256OfFile + readFileSync 读两遍）
+      const { hash, buffer } = readFileForIndex(filePath)
       if (!reindex && existing && existing.sha256 === hash) {
         skipped++
         continue
@@ -47,12 +47,11 @@ export async function indexRepository(ctx, config, root, { reindex = false } = {
 
       let entries
       if (isSupportedCode(ext)) {
-        const content = readFileSync(filePath, 'utf8')
-        entries = scanSymbols(rel, filePath, content)
+        entries = scanSymbols(rel, filePath, buffer.toString('utf8'))
         fileUpdates.push({ rel, expectedHash: existing?.sha256, hash, size, entries, type: 'code' })
         updated++
       } else {
-        const content = readFileSync(filePath, 'utf8')
+        const content = buffer.toString('utf8')
         if (looksLikeDump(content)) {
           fileUpdates.push({ rel, deleted: true })
           skipped++

package/src/util/fs.js

@@ -1,4 +1,4 @@
-import { accessSync, constants, readdirSync, statSync } from 'node:fs'
+import { accessSync, constants, readdirSync, readFileSync, statSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
@@ -32,6 +32,18 @@ export async function sha256OfFile(filePath) {
   return { hash: sha256OfBuffer(buf), size: buf.length }
 }
 
+/**
+ * 单次同步读：同一 buffer 同时供内容哈希与正文解码使用。
+ *
+ * 替代 “await sha256OfFile() + readFileSync()” 的二次读盘。对大量小文件的批量
+ * 索引，逐文件 `async readFile` 的线程池往返是主要开销（实测 2000 文件 260ms →
+ * 单次同步读 ~6ms）；调用方拿到 buffer 后按需 toString('utf8')，未变更文件无需解码。
+ */
+export function readFileForIndex(filePath) {
+  const buffer = readFileSync(filePath)
+  return { hash: sha256OfBuffer(buffer), size: buffer.length, buffer }
+}
+
 export async function readTextFile(filePath, maxBytes = 2 * 1024 * 1024) {
   const buf = await readFile(filePath)
   if (buf.length > maxBytes) {

package/src/watch.js

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, statSync } from 'node:fs'
 import path from 'node:path'
-import { isSupportedCode, isSupportedDoc, memoryRootFor, relativePath, sha256OfFile, storeKey, walkDir } from './util/fs.js'
+import { isSupportedCode, isSupportedDoc, memoryRootFor, readFileForIndex, relativePath, storeKey, walkDir } from './util/fs.js'
 import { buildDocEntries } from './doc-pipeline.js'
 import { scanSymbols } from './symbols.js'
 import { linkEntries } from './link.js'
@@ -13,13 +13,14 @@ export class WatchManager {
     this.config = config
     this.roots = new Map()
     this.timer = null
+    this._polling = false
   }
 
   restorePersisted() {
     const cwd = process.cwd()
-    const store = new ProjectMemoryStore(memoryRootFor(cwd, this.config.memoryDir))
+    // 用 load() 的返回值：storeCache 命中时 load() 返回的是缓存实例，忽略返回值会拿到空 store
+    const store = new ProjectMemoryStore(memoryRootFor(cwd, this.config.memoryDir)).load()
     if (existsSync(store.dir)) {
-      store.load()
       for (const root of store.watchlist) {
         if (typeof root === 'string' && root) this.addRoot(root)
       }
@@ -43,7 +44,11 @@ export class WatchManager {
 
   start(intervalMs = 15000) {
     if (this.timer) return
-    this.timer = setInterval(() => this.poll(), Math.max(intervalMs, 1000))
+    // NaN/undefined 会让 setInterval 退化成 1ms 轮询（Node 只发一条 TimeoutNaNWarning），
+    // 足以打满事件循环让 agent 无法响应；非法值回退到 15s。
+    const raw = Number(intervalMs)
+    const ms = Number.isFinite(raw) ? Math.max(raw, 1000) : 15000
+    this.timer = setInterval(() => this.poll(), ms)
     if (this.timer.unref) this.timer.unref()
   }
 
@@ -53,12 +58,20 @@ export class WatchManager {
   }
 
   async poll() {
-    for (const [root, state] of this.roots) {
-      try {
-        await this.pollRoot(root, state)
-      } catch (err) {
-        console.error(`[dsh-project-memory] watch poll failed for ${root}: ${err.message}`)
+    // setInterval 不等待上一轮：大仓库/文档 LLM 摘要让一轮 >interval 时，
+    // 轮询会叠加成并发索引，最终打满事件循环。用重入锁让慢轮询自然跳过。
+    if (this._polling) return
+    this._polling = true
+    try {
+      for (const [root, state] of this.roots) {
+        try {
+          await this.pollRoot(root, state)
+        } catch (err) {
+          console.error(`[dsh-project-memory] watch poll failed for ${root}: ${err.message}`)
+        }
       }
+    } finally {
+      this._polling = false
     }
   }
 
@@ -89,14 +102,15 @@ export class WatchManager {
         continue
       }
 
-      const { hash } = await sha256OfFile(filePath)
+      // 单次读盘：同一 buffer 供哈希与正文使用
+      const { hash, buffer } = readFileForIndex(filePath)
       const existing = state.store.fileRecord(rel)
       if (existing && existing.sha256 === hash) continue
 
       try {
         let entries
         if (isSupportedCode(ext)) {
-          entries = scanSymbols(rel, filePath, readFileSync(filePath, 'utf8'))
+          entries = scanSymbols(rel, filePath, buffer.toString('utf8'))
         } else {
           entries = await buildDocEntries(this.ctx.llm, rel, filePath, {
             chunkChars: this.config.chunkChars,