@yolk_vat-y/dsh-project-memory 0.5.11 → 0.5.13

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "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.",
+  "author": "00080000 <3388065969@qq.com>",
   "type": "module",
   "main": "src/index.js",
   "files": [
@@ -18,7 +19,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 && node test/store-gitignore.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 && node test/store-cache.test.mjs && node test/enhancer.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",
@@ -48,13 +49,13 @@
     "pdfjs-dist": "^4.10.38"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-locale": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-client-store": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-llm": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1",
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-store": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.1",
     "@deepseek-ai/schemastery": "^3.18.2",
     "@tsdown/css": "0.22.14",
     "@types/react": "^18.3.31",
@@ -65,8 +66,8 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0 || >=0.1.1-rc.1 <0.2.0-0",
-    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0 || >=0.1.1-rc.1 <0.2.0-0",
+    "@deepseek-ai/dsh-llm": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0 || >=0.1.1-rc.1 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0 || >=0.1.1-rc.1 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0",
     "@deepseek-ai/schemastery": "^3.18.1",
     "typescript": "^5.0.0 || ^6.0.0"
   },

package/scripts/bench-load.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * 在**独立进程**里量一次 store 冷加载的耗时与常驻内存，输出一行 JSON。
+ *
+ * 为什么要单独一个进程：`scripts/bench.mjs` 在同一个进程里已经有一个 store（索引用的那个），
+ * 再 load 第二个副本量出来的堆是两份的。这里从空进程冷加载，数字才是「一个 store 常驻多少」。
+ * 必须带 `--expose-gc` 运行（bench.mjs 会自己加），否则量不到稳定值。
+ *
+ * 用法：node --expose-gc scripts/bench-load.mjs <storeDir>
+ */
+import { performance } from 'node:perf_hooks'
+
+import { ProjectMemoryStore } from '../src/store.js'
+
+const dir = process.argv[2]
+if (!dir) {
+  console.error('usage: node --expose-gc scripts/bench-load.mjs <storeDir>')
+  process.exit(2)
+}
+
+const gc = typeof global.gc === 'function' ? global.gc : () => {}
+const mb = (n) => Math.round((n / 1048576) * 10) / 10
+const snap = () => {
+  const m = process.memoryUsage()
+  return { heapMb: mb(m.heapUsed), rssMb: mb(m.rss) }
+}
+
+gc()
+const t0 = performance.now()
+const store = new ProjectMemoryStore(dir).load()
+const loadMs = performance.now() - t0
+gc()
+const afterLoad = snap()
+
+// allEntries() 会在内存里物化 searchText（派生字段不落盘），这一步才是查询前的水位
+const entries = store.allEntries()
+gc()
+const afterEntries = snap()
+
+console.log(
+  JSON.stringify({
+    loadMs: Number(loadMs.toFixed(2)),
+    entries: entries.length,
+    afterLoad,
+    afterEntries,
+  }),
+)

package/scripts/bench.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 /**
- * 独立基准：给一个真实项目路径，量「冷索引 / 冷加载 / 热查询 / 单文件热重索引 / 存储体积」。
+ * 独立基准：给一个真实项目路径，量「冷索引 / 冷加载 / 热查询 / 单文件热重索引 / 存储体积 / 常驻内存」。
  *
  * 特点：
  * - **不需要运行 dsh**，只 import 插件自己的 src 模块，走的就是线上那条索引与检索路径；
  * - **不碰被测项目**：结果写进临时目录，跑完删除（`--keep` 可保留）；
  * - 索引期零模型调用、零网络请求，所以在任何机器上都能复现。
+ * - 常驻内存（load 后 / allEntries() 后）由一个 `--expose-gc` 的子进程量（`scripts/bench-load.mjs`），
+ *   否则同一个进程里已经有索引用的那个 store，量出来是两份。
  *
  * 用法：
  *   node scripts/bench.mjs [projectPath] [--json] [--samples 100] [--no-pdf] [--keep] [--max-files 20000]
@@ -15,10 +17,12 @@
  *   [{ "query": "jwt token validation", "expect": "src/utils/auth.ts" }, ...]
  * `expect` 按子串匹配结果的 sourcePath / title / id（大小写不敏感）。
  */
+import { execFileSync } from 'node:child_process'
 import { cpSync, existsSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { performance } from 'node:perf_hooks'
+import { fileURLToPath } from 'node:url'
 
 import { ProjectMemoryStore } from '../src/store.js'
 import { buildDocEntries } from '../src/doc-pipeline.js'
@@ -94,6 +98,7 @@ function stats(xs) {
 
 function dirSize(dir) {
   let bytes = 0
+  let allocated = 0
   let files = 0
   const stack = [dir]
   while (stack.length) {
@@ -108,7 +113,11 @@ function dirSize(dir) {
       if (e.isDirectory()) stack.push(p)
       else {
         try {
-          bytes += statSync(p).size
+          const st = statSync(p)
+          bytes += st.size
+          // 一个源文件一个碎分片 → 每个文件至少占一个块（通常 4 KB），`du` 会明显大于
+          // 内容字节和。两个数都给出来，别把「内容大小」当成「占盘大小」。
+          allocated += st.blocks ? st.blocks * 512 : st.size
           files++
         } catch {
           /* ignore */
@@ -116,7 +125,7 @@ function dirSize(dir) {
       }
     }
   }
-  return { bytes, files }
+  return { bytes, allocated, files }
 }
 
 const kb = (n) => `${(n / 1024).toFixed(1)} KB`
@@ -206,6 +215,16 @@ const onDisk = dirSize(tmpStore)
 const coldDir = `${tmpStore}-cold`
 cpSync(tmpStore, coldDir, { recursive: true })
 const coldLoad = timeSync(() => new ProjectMemoryStore(coldDir).load())
+// 常驻内存必须在独立进程里量：本进程已经拿着索引那个 store，再 load 一个副本得到的是两份
+const memory = (() => {
+  try {
+    const loadScript = path.join(path.dirname(fileURLToPath(import.meta.url)), 'bench-load.mjs')
+    const out = execFileSync(process.execPath, ['--expose-gc', loadScript, coldDir], { encoding: 'utf8' })
+    return JSON.parse(out.trim().split('\n').pop())
+  } catch (err) {
+    return { error: err.message }
+  }
+})()
 
 // ---------- 4. 热查询 / 冷查询 ----------
 const queryPool = entries.filter((e) => typeof e.title === 'string' && e.title.trim().length >= 4)
@@ -328,10 +347,12 @@ const result = {
   store: {
     dir: tmpStore,
     bytes: onDisk.bytes,
+    allocatedBytes: onDisk.allocated,
     files: onDisk.files,
     bytesPerEntry: entries.length ? Math.round(onDisk.bytes / entries.length) : 0,
   },
   coldLoadMs: round(coldLoad.ms),
+  memory,
   query: {
     samples: queries.length,
     idfRebuildMs: round(idfCold.ms),
@@ -363,7 +384,17 @@ if (opts.json) {
   console.log(`  read+hash ${result.index.readHashMs} ms · extract ${result.index.extractMs} ms · commit ${result.index.commitMs} ms`)
   console.log(`  per file  p50 ${result.index.perFileMs.p50} ms · p95 ${result.index.perFileMs.p95} ms`)
   console.log(`  note: read+hash depends on the OS page cache — run it twice and say which run you quote`)
-  console.log(`store     ${mb(result.store.bytes)} · ${result.store.bytesPerEntry} bytes/entry · cold load ${result.coldLoadMs} ms`)
+  console.log(
+    `store     ${mb(result.store.bytes)} content · ${mb(result.store.allocatedBytes)} on disk · ${result.store.bytesPerEntry} bytes/entry · cold load ${result.coldLoadMs} ms`,
+  )
+  if (memory && !memory.error) {
+    console.log(
+      `memory    isolated child: after load heap ${memory.afterLoad.heapMb} MB / RSS ${memory.afterLoad.rssMb} MB` +
+        ` · after allEntries() heap ${memory.afterEntries.heapMb} MB / RSS ${memory.afterEntries.rssMb} MB`,
+    )
+  } else if (memory && memory.error) {
+    console.log(`memory    unavailable (${memory.error})`)
+  }
   console.log(`\n-- query (shipped scorer: IDF cache + streaming BM25 + CJK phrase boost) --`)
   console.log(`idf rebuild (first query after write)  ${result.query.idfRebuildMs} ms`)
   console.log(`cold query (rebuild + rank)            ${result.query.coldMs} ms`)

package/src/audit.js

@@ -8,8 +8,9 @@
 //  - 只在确有决策（本条真的进了上下文）时写一行：dropped 单独出现不写，否则每步刷屏；
 //  - 任何异常（目录不可写、磁盘满、记录序列化失败）一律吞掉，绝不影响宿主请求；
 //  - 单文件超限就地轮转一份 `.1`，不引入新的清理线程或后台任务。
-import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs'
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { hasProjectMarker } from './util/fs.js'
 
 export const AUDIT_FILE = 'injection-audit.jsonl'
 const DEFAULT_MAX_BYTES = 256 * 1024
@@ -75,10 +76,34 @@ export function shadowRecordFrom(input) {
  * 追加一行影子记录。返回是否写入成功（仅供测试断言）。与主审计同约定：任何异常一律吞掉，
  * 绝不影响宿主请求。
  */
-export function appendShadowAudit(memoryDir, record, cfg) {
+
+/**
+ * 审计**只为"已经存在"或"结论明确"的根创建 store 目录**。
+ *
+ * 本插件里会在"什么都没索引过"的空目录里造出 `.dsh-project-memory` 的就是下面那句
+ * `mkdirSync`（`load()` 不建目录，`ensureSelfIgnore()` 也要求目录已存在）。于是任何一次
+ * "**在容器目录里**开会话"都会留下一个只装着审计日志的空 store —— 而那个目录随后还会被
+ * `resolveProjectMemoryRoot()` 当成项目根。审计是旁路，没有 store 就没有可对照的候选。
+ *
+ * 两个放行条件：
+ *   - store 目录已存在 → 真被索引/写过，照旧；
+ *   - 该根**自身带项目标记**（`hasProjectMarker`）→ 是"声明过的项目"，即便还没落过盘，
+ *     也该留下第一步的记录（`rootNotice` 用的是同一个判据，两处口径一致）。
+ * "根是推定的（无标记）且还没有内容"→ 跳过。这正是容器目录的那种情况。
+ *
+ * @param {string} memoryDir `<root>/.dsh-project-memory`
+ * @param {string} [root] 项目根；省略时退回 `path.dirname(memoryDir)`
+ */
+function auditDirReady(memoryDir, root) {
+  if (existsSync(memoryDir)) return true
+  return hasProjectMarker(root || path.dirname(memoryDir))
+}
+
+export function appendShadowAudit(memoryDir, record, cfg, root) {
   const c = cfg || {}
   if (c.enabled === false) return false
   if (!memoryDir || !record) return false
+  if (!auditDirReady(memoryDir, root)) return false
   try {
     mkdirSync(memoryDir, { recursive: true })
     const file = shadowFileFor(memoryDir)
@@ -124,10 +149,11 @@ export function auditRecordFrom(input) {
  * @param {object} record {@link auditRecordFrom} 的产物
  * @param {{enabled?: boolean, maxBytes?: number}} [cfg] {@link cfgAudit} 的产物
  */
-export function appendInjectionAudit(memoryDir, record, cfg) {
+export function appendInjectionAudit(memoryDir, record, cfg, root) {
   const c = cfg || {}
   if (c.enabled === false) return false
   if (!memoryDir || !record) return false
+  if (!auditDirReady(memoryDir, root)) return false
   try {
     mkdirSync(memoryDir, { recursive: true })
     const file = auditFileFor(memoryDir)

package/src/auto-inject.js

@@ -619,7 +619,7 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     reasons: built.reasons,
     candidates: built.candidates,
     silence: silence.reason,
-  }), shadow)
+  }), shadow, root)
 
   // 记忆根通告：根是**推定**的（会话工作目录，且该目录没有任何项目标记）时，
   // 第一次注入前告诉模型"记忆现在存在哪、怎么改"。它是状态声明（与常驻任务卡同类），
@@ -648,7 +648,9 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
   if (built.reasons.length) {
     try {
       if (recordHit({ store, globalStore, ids: built.reasons.map((r) => r.id) })) {
-        store.save()
+        // 只有这个根里真有东西才落盘。否则一次**全局** insight 的命中就会为一个从没被
+        // 索引过的容器目录建出整个 store（`save()` 会 mkdir）。审计侧同样不建，见 audit.js。
+        if (store.hasContent) store.save()
         globalStore.commit()
       }
     } catch {
@@ -667,7 +669,7 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     dropped: built.dropped,
     budget: { items: quota.items, chars: quota.chars, lastStep: Number.isFinite(quota.lastStep) ? quota.lastStep : null },
     silence: silence.reason,
-  }), audit)
+  }), audit, root)
 
   return { ...decision, messages: [...decision.messages, injectionMessage(injectedText)] }
 }

package/src/enhancer.js

@@ -109,32 +109,78 @@ export function isTypeScriptFile(filePath) {
          ext === '.mjs' || ext === '.cjs' || ext === '.mts' || ext === '.cts'
 }
 
+/**
+ * 路径归一化。
+ *
+ * 旧实现在 host 里用 `fileName === filePath` 认自己的文件。TypeScript 内部一律走
+ * `normalizePath`（`\`→`/`、消解 `.`/`..`、绝对化），而 `path.join` 给出的是平台原生形态 ——
+ * Windows 上是反斜杠。两边字符串不同 → `getSourceFile` 返回 undefined → `deepParseWithTS`
+ * 静默返回 `[]`：增强整层失效且无日志。2026-09-26 的 Windows CI 就是这样挂的
+ * （`test/enhancer.test.mjs` 的「增强结果落进了 store」），同一份代码在 POSIX 上从不现形。
+ *
+ * 用 TS 自己的 `normalizePath` 而不是自己拼：它才是权威口径。**该函数只在运行时导出、
+ * `typescript.d.ts` 里没有声明**，peer 范围覆盖 TS 5/6/7，所以必须做 `typeof` 兜底。
+ */
+function canonicalTsPath(fileName) {
+  const s = String(fileName)
+  return typeof ts?.normalizePath === 'function' ? ts.normalizePath(s) : s.replace(/\\/g, '/')
+}
+
+/** 跟随 ts.sys 的实际大小写语义；拿不到时按平台回落。 */
+function tsPathCaseSensitive() {
+  if (ts && ts.sys && typeof ts.sys.useCaseSensitiveFileNames === 'boolean') {
+    return ts.sys.useCaseSensitiveFileNames
+  }
+  return process.platform !== 'win32' && process.platform !== 'darwin'
+}
+
 export function deepParseWithTS(filePath, content) {
   if (!ts) return null
 
+  const caseSensitive = tsPathCaseSensitive()
+  const target = caseSensitive ? canonicalTsPath(filePath) : canonicalTsPath(filePath).toLowerCase()
+  const isTarget = (fileName) => {
+    const a = canonicalTsPath(fileName)
+    return (caseSensitive ? a : a.toLowerCase()) === target
+  }
+  // 预建唯一的 SourceFile：它就是"这个文件"的真身，host 只需把它交出去。
+  // 后面按**对象身份**确认 TS 真的收下了它，不依赖 TS 内部怎么命名。
+  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true)
+
   // Create a compiler host that provides the source file from memory
   const host = {
-    getSourceFile: (fileName, languageVersion, onError) => {
-      if (fileName === filePath) {
-        return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true)
-      }
-      return undefined
-    },
+    getSourceFile: (fileName, languageVersion, onError) => (isTarget(fileName) ? sourceFile : undefined),
     getDefaultLibFileName: (options) => ts.getDefaultLibFileName(options),
-    getDefaultLibLocation: () => ts.getDefaultLibFilePath({}),
-    getCanonicalFileName: (fileName) => fileName,
+    getCanonicalFileName: (fileName) => (caseSensitive ? canonicalTsPath(fileName) : canonicalTsPath(fileName).toLowerCase()),
     getCurrentDirectory: () => process.cwd(),
     getNewLine: () => '\n',
-    useCaseSensitiveFileNames: () => true,
-    fileExists: (fileName) => fileName === filePath,
-    readFile: (fileName) => fileName === filePath ? content : undefined,
+    useCaseSensitiveFileNames: () => caseSensitive,
+    fileExists: (fileName) => isTarget(fileName),
+    readFile: (fileName) => (isTarget(fileName) ? content : undefined),
     directoryExists: () => true,
     getDirectories: () => [],
   }
 
-  const program = ts.createProgram([filePath], {}, host)
-  const sourceFile = program.getSourceFile(filePath)
-  if (!sourceFile) return []
+  // 刻意不加载默认 lib（`noLib: true`）：host 手里只有这一个文件的内容，加载 lib 需要把
+  // lib.d.ts 及其引用的 6 个文件（lib.es5 / lib.decorators / lib.decorators.legacy / lib.dom /
+  // lib.webworker.importscripts / lib.scripthost，共 ~2.1MB 文本）一并读盘并重解析。
+  // 实测：每个 program 重解析 p50=102ms/文件；把解析好的 SourceFile 缓存跨 program 复用
+  // （或走 ts.DocumentRegistry）是一次性 ~100ms + 每文件 ~1ms。本版不做，代价是全局类型
+  // （Promise/Array/DOM）在 typeSig 里塌成 any/unknown —— 见 CHANGELOG「已知限制（本版未做）」。
+  // 旧实现在这里留的是 `getDefaultLibLocation: () => ts.getDefaultLibFilePath({})`，返回的是
+  // **文件**路径而不是目录，于是这层加载既没生效、也没人把它写下来。现在把"不载"写成声明。
+  const program = ts.createProgram([filePath], { allowJs: true, noLib: true }, host)
+  // 按**对象身份**确认 TS 收下了这个 SourceFile。`program.getSourceFile(filePath)` 也能问，
+  // 但它内部用 `toPath(name, cwd, getCanonicalFileName)` 拼 key，对相对路径还会拼上 cwd ——
+  // 正是上面那条脆弱路径。`sourceFile.parent` 恒为 undefined，不能用它判断。
+  if (program.getSourceFileByPath(sourceFile.path) !== sourceFile) {
+    // 走到这里 = host 没认出 root path（本该有结果却没有）。**刻意不写终端**：
+    //   · 代价：watch 每 15s 一轮、每个不受支持的 root 都会撞上它，"逐轮一条"去重后仍会变成
+    //     "每个文件一条"，在真实终端里就是刷屏；
+    //   · 收益为 0：返回 [] 只是"这轮没有增强结果"，不会产出错误结果，调用方本来就按空处理。
+    // 这个不变量的看护在 test/enhancer.test.mjs（「路径形态」那组 + 末尾的静默契约），不靠日志。
+    return []
+  }
   const checker = program.getTypeChecker()
 
   const symbols = []
@@ -171,60 +217,79 @@ export function deepParseWithTS(filePath, content) {
     return sourceFile.getLineAndCharacterOfPosition(pos).line + 1
   }
 
+  /**
+   * 参数列表的渲染：用**源码文本**，不是 checker 的类型串。
+   *
+   * 旧实现拼 `${p.name.getText()}: ${type}`，两个副作用都被「L2 会就地重写 L1 文本」放大：
+   *   · 无注解的参数一律写成 `: any`（本仓库 51 个 .js/.mjs 实测：86% 的参数如此），把 L1 正则
+   *     已经提取到的 `chunkChars = 3000` 换成纯噪音；
+   *   · `= 默认值` / `?` / `...rest` / 解构模式全被丢掉（实测 52 个带默认值的条目里丢了 36 个）。
+   * 源码文本两者都保得住，还省掉每个参数一次 checker 调用。单参数限长 80，整行仍由
+   * oneLineDeclaration 收到 200 字符。
+   */
+  function renderParams(node) {
+    return node.parameters.map((p) => oneLineDeclaration(p.getText(), 80)).join(', ')
+  }
+
+  /**
+   * 返回类型只在**有信息量**时落进文本：`any`（无注解 JS 的常态）、`unknown`（未载 lib 时 async
+   * 的推导结果）、`{}`（"任意非空值"）都只会把一行声明撑长，旧实现无条件写 `): any`。
+   * `void` 保留 —— 它至少说明"没有返回值"。
+   */
+  function renderReturn(type) {
+    const s = getTypeStr(type)
+    return s === 'any' || s === 'unknown' || s === '{}' ? '' : `: ${s}`
+  }
+
+  /**
+   * 函数表达式/箭头函数的名字。旧白名单只有 `const x = fn` / `{ m: fn }` / `class { m = fn }`，
+   * 于是 CJS 最常见的 `module.exports.foo = function () {}` 产不出符号（它的父节点是
+   * BinaryExpression）—— 而 isTypeScriptFile() 明确把 `.cjs` 列为可增强对象，等于承诺了拿不到。
+   */
+  function callableName(node) {
+    const parent = node.parent
+    if (!parent) return null
+    if (ts.isVariableDeclaration(parent) || ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent)) {
+      return parent.name?.getText() || '(anonymous)'
+    }
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const left = parent.left
+      if (ts.isPropertyAccessExpression(left)) {
+        // `module.exports = function () {}`（CJS 的默认导出）：只取最后一段会得到名字
+        // "exports"，既看不出它是默认导出，也容易与 `exports.foo` 混淆。保留全名。
+        if (ts.isIdentifier(left.expression) && left.expression.text === 'module' && left.name.text === 'exports') {
+          return 'module.exports'
+        }
+        return left.name.getText()
+      }
+      if (ts.isIdentifier(left)) return left.getText()
+      if (ts.isElementAccessExpression(left) && ts.isStringLiteralLike(left.argumentExpression)) {
+        return left.argumentExpression.text
+      }
+    }
+    return null
+  }
+
+  /** 三个 callable 分支共用：名字与种类由调用方给，类型串的渲染只此一处。 */
+  function pushCallable(node, name, kind) {
+    const typeParams = node.typeParameters?.map((tp) => tp.getText()) || []
+    const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
+    symbols.push({
+      name,
+      kind,
+      typeSig: `${generics}(${renderParams(node)})${renderReturn(getReturnType(getSignature(node)))}`,
+      line: getLine(node)
+    })
+  }
+
   function visit(node) {
     if (ts.isFunctionDeclaration(node) && node.name) {
-      const signature = getSignature(node)
-      const returnType = getReturnType(signature)
-      const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
-      const params = node.parameters.map(p => {
-        const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
-        return `${p.name.getText()}: ${type}`
-      })
-      const returnTypeStr = getTypeStr(returnType)
-      const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
-      symbols.push({
-        name: node.name.getText(),
-        kind: 'function',
-        typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
-        line: getLine(node)
-      })
+      pushCallable(node, node.name.getText(), 'function')
     } else if (ts.isMethodDeclaration(node) && node.name) {
-      const signature = getSignature(node)
-      const returnType = getReturnType(signature)
-      const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
-      const params = node.parameters.map(p => {
-        const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
-        return `${p.name.getText()}: ${type}`
-      })
-      const returnTypeStr = getTypeStr(returnType)
-      const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
-      symbols.push({
-        name: node.name.getText(),
-        kind: 'method',
-        typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
-        line: getLine(node)
-      })
+      pushCallable(node, node.name.getText(), 'method')
     } else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-      const parent = node.parent
-      if (parent && (ts.isVariableDeclaration(parent) || ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent))) {
-        const signature = getSignature(node)
-        const returnType = getReturnType(signature)
-        const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
-        const params = node.parameters.map(p => {
-          const type = p.type ? getTypeStr(checker.getTypeAtLocation(p.type)) : 'any'
-          return `${p.name.getText()}: ${type}`
-        })
-        const returnTypeStr = getTypeStr(returnType)
-        const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
-        const name = parent.name?.getText() || '(anonymous)'
-        const kind = ts.isArrowFunction(node) ? 'arrow' : 'function'
-        symbols.push({
-          name,
-          kind,
-          typeSig: `${generics}(${params.join(', ')}): ${returnTypeStr}`,
-          line: getLine(node)
-        })
-      }
+      const name = callableName(node)
+      if (name) pushCallable(node, name, ts.isArrowFunction(node) ? 'arrow' : 'function')
     } else if (ts.isClassDeclaration(node) && node.name) {
       const typeParams = node.typeParameters?.map(tp => tp.getText()) || []
       const generics = typeParams.length ? `<${typeParams.join(', ')}>` : ''
@@ -266,10 +331,9 @@ export function deepParseWithTS(filePath, content) {
     }
   }
 
-  const sf = program.getSourceFile(filePath)
-  if (sf) {
-    visit(sf)
-  }
+  // 用预建的那个（上面已按对象身份确认它进了 program），不再按名字回查——
+  // 回查依赖 TS 内部的命名，正是 Windows 上出问题的那一步。
+  visit(sourceFile)
   return symbols
 }
 
@@ -280,7 +344,10 @@ export function enqueueEnhance(store, relPath, filePath, priority = PRIORITY.BAT
   try {
     content = readFileSync(filePath, 'utf8')
   } catch {
-    // File disappeared between detection and enqueue - skip silently
+    // 文件在"检测到变化"和"入队"之间消失了（编辑器原子保存 = 写临时文件 + rename，正好落在
+    // 这个窗口）。**刻意不写终端**：这不是故障而是常态，watch 每 15s 一轮还会反复重试同一个
+    // 文件 —— 即使按文件去重也仍会刷屏，而"这轮不增强"不会产出任何错误结果（返回 resolved，
+    // 与成功路径对调用方无差别）。诊断靠断言，不靠日志。
     return Promise.resolve()
   }
   const cacheKey = getCacheKey(content)
@@ -303,7 +370,23 @@ export function enqueueEnhance(store, relPath, filePath, priority = PRIORITY.BAT
     }
   }
 
-  const p = (async () => {
+  // 先登记队列条目，再启动任务。
+  //
+  // 任务体可能在**同步阶段**就跑完：`deepParseWithTS` 是同步的，没有增强结果时根本走不到
+  // 那个 `await`，于是 `finally` 立刻执行。旧实现在任务启动**之后**才登记条目，并在 finally
+  // 里用 `enhanceQueue.findIndex(q => q.promise === p)` 反查自己 ——
+  //   · 队列为空时 `findIndex` 的回调根本不会被调用，`p` 不被求值，看不出问题；
+  //   · 队列非空（真实的 watch 轮询里必然如此）时回调被调用，读到尚未初始化的 `const p`
+  //     → `ReferenceError: Cannot access 'p' before initialization`。
+  // `scheduleProcess` 会 await 这个 promise，但 watch 路径上抛出的那一个没人接，未处理的
+  // rejection 直接把宿主打成 `dsh: fatal load failure`。
+  //
+  // 现在：条目先入队，finally 按**对象身份**摘除自己，完全不引用尚未初始化的绑定。
+  const entry = { relPath, filePath, priority, cacheKey, promise: null }
+  if (existingIdx >= 0) enhanceQueue[existingIdx] = entry
+  else enhanceQueue.push(entry)
+
+  entry.promise = (async () => {
     try {
       const content = readFileSync(filePath, 'utf8')
       const enhanced = deepParseWithTS(filePath, content)
@@ -313,23 +396,15 @@ export function enqueueEnhance(store, relPath, filePath, priority = PRIORITY.BAT
     } catch (err) {
       console.warn(`[dsh-project-memory] enhance failed for ${relPath}: ${err.message}`)
     } finally {
-      // Remove only this task's own queue entry (not a newer one for the same relPath)
-      const idx = enhanceQueue.findIndex(q => q.promise === p)
+      // 只摘自己那一条：同 relPath 的新任务可能已经把它替换掉了（那种情况这里是 -1）。
+      const idx = enhanceQueue.indexOf(entry)
       if (idx >= 0) enhanceQueue.splice(idx, 1)
     }
   })()
-
-  // Update or add to queue
-  const existingIdx2 = enhanceQueue.findIndex(q => q.relPath === relPath)
-  if (existingIdx2 >= 0) {
-    enhanceQueue[existingIdx2] = { relPath, filePath, priority, cacheKey, promise: p }
-  } else {
-    enhanceQueue.push({ relPath, filePath, priority, cacheKey, promise: p })
-  }
   enhanceQueue.sort((a, b) => a.priority - b.priority)
 
   scheduleProcess()
-  return p
+  return entry.promise
 }
 
 function scheduleProcess() {
@@ -368,7 +443,9 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
       ...e,
       // 一行声明（限长）。typeSig 只是构建期的中间量，不落进 entry：它没有读取方，
       // 且 interface 的 typeSig 就是整个类型体，是符号条目变胖的主因。
-      text: oneLineDeclaration(`${enh.name}${enh.typeSig} -- ${relPath}:${enh.line}`),
+      // 分隔符与 L1 的 buildSymbol 保持一致（` — `）：L2 是**就地重写** L1 文本，
+      // 用不同的分隔符会让同一个文件里的条目混排两种格式。
+      text: oneLineDeclaration(`${enh.name}${enh.typeSig} — ${relPath}:${enh.line}`),
       typeSig: undefined,
       enhanced: true
     }
@@ -392,7 +469,7 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
       type: 'symbol',
       title: `${s.name} (${s.kind})`,
       keywords: [s.name, s.kind],
-      text: oneLineDeclaration(`${s.name}${s.typeSig} -- ${relPath}:${s.line}`),
+      text: oneLineDeclaration(`${s.name}${s.typeSig} — ${relPath}:${s.line}`),
       enhanced: true
     })
   }
@@ -408,17 +485,24 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
   }
 }
 
+// 三个入口都不 await 任务，所以必须各自挂一个 catch：任务体内部已经兜底，但
+// **未处理的 rejection 会把整个宿主打成 `dsh: fatal load failure`**（2026-09-26 的事故就是
+// 这个形状：一个 TDZ 从 watch 路径逃出去，dsh web 起不来）。这条路径不该有任何机会向上抛。
+const fireAndForget = (p) => {
+  if (p && typeof p.catch === 'function') p.catch(() => {})
+}
+
 export function onFileObserved(store, relPath, filePath, config, root) {
   if (!isTypeScriptFile(filePath)) return
-  enqueueEnhance(store, relPath, filePath, PRIORITY.ACTIVE, config, root)
+  fireAndForget(enqueueEnhance(store, relPath, filePath, PRIORITY.ACTIVE, config, root))
 }
 
 export function onFileChanged(store, relPath, filePath, config, root) {
   if (!isTypeScriptFile(filePath)) return
-  enqueueEnhance(store, relPath, filePath, PRIORITY.RECENT, config, root)
+  fireAndForget(enqueueEnhance(store, relPath, filePath, PRIORITY.RECENT, config, root))
 }
 
 export function onFileIndexed(store, relPath, filePath, config, root) {
   if (!isTypeScriptFile(filePath)) return
-  enqueueEnhance(store, relPath, filePath, PRIORITY.BATCH, config, root)
+  fireAndForget(enqueueEnhance(store, relPath, filePath, PRIORITY.BATCH, config, root))
 }

package/src/llm.js

@@ -36,7 +36,10 @@ export async function chatText(llm, system, user, { timeoutMs = 120000, route }
   } finally {
     clearTimeout(timer)
   }
-  return textOf(assembler.message())
+  // 0.2.0 起 BlockAssembler.message(source) 的 source 是**必填**（Omit<ModelMessageSource,'kind'>）；
+  // 不传在运行时仍能跑（createAssistantMessage 只做 `{kind:'model', ...source}`），但得到的
+  // assistant 消息会缺 provider/model 归属。我们本来就知道路由，直接如实带上。
+  return textOf(assembler.message({ provider: route.provider, model: route.model }))
 }
 
 export function parseStructuredJson(text) {