dsh-cerebrum 0.1.3 → 0.1.4

package/README.md

@@ -56,7 +56,8 @@ dsh plugin --profile desktop add D:\workspace\dsh-cerebrum
 装好插件后，输入框上方会出现 🧠 芯片：显示当前情绪、记忆量、好感度级别；点击展开**大脑仪表盘**（效价/唤醒/支配条、DA/5-HT/NE/ACh、五因素、记忆/技能/意图/好感）。
 
 - **不喜欢可以关掉**：面板里的 🙈 隐藏芯片（点小 🧠 恢复）；彻底关闭用配置 `ui.enabled: false`（重启宿主生效，芯片完全不出现）；
-- 面板可**拖动**（按住标题栏）、可 **📌 固定**到输入栏上方成横条；
+- 面板可**拖动**（按住标题栏，位置会记住）、可 **📌 固定**到输入栏上方成横条；
+- **安全**：回环 API 只接受本机 Host/Origin，不做通配 CORS；可选 `api.token`（同时设置浏览器 `localStorage['cerebrum.token']` 即可让面板带上它）；`/recall` 只读、不训练记忆；`/interact` 限流 30 次/分；
 - **宠物联动（免配置）**：检测到同源的 `dsh-pet`（`/dsh-pet-7340`）时，情绪变化会自动推给桌宠——加锁 → 让宠物说一句大脑台词 → 释放锁；不需要用户配置。不想要联动可设 `ui.drivePet: false`；
 - 数据来自宿主内置的 127.0.0.1 只读 API（`http://127.0.0.1:18734`，端口可配 `config.api.port`）；
 - UI 只读：修改记忆/情绪仍通过 `cerebrum_*` 工具；
@@ -98,7 +99,7 @@ dsh plugin --profile desktop add D:\workspace\dsh-cerebrum
 ## 开发
 
 ```powershell
-npm test          # 65 个单元 + 集成测试（node:test）
+npm test          # 79 个单元 + 集成测试（node:test）
 npm run check     # 用安装版 DSH 内的真实 Cordis 容器加载插件并跑一轮对话
 npm run demo      # 离线仿真，打印情绪/调质时间线并写 examples/.demo/timeline.json
 npm run dashboard # 生成 examples/.demo/dashboard.html（自包含可视化）
@@ -111,6 +112,14 @@ npm run retention # 计算幂律遗忘曲线与间隔效应，写 examples/.demo
 
 ![认知状态面板](docs/assets/cerebrum-dashboard.png)
 
+## 已知限制
+
+- **性能**：检索为纯 JS（SDR + BM25），几万条情景时单次召回仍在毫秒级，但超大库（10 万+）会变慢；
+- **GUI 端口**：面板按 18734–18743 探测宿主 API；若把 `api.port` 改到该段之外，面板会显示"未连接"；
+- **token 模式**：开启 `api.token` 后，脚本请求必须带 `x-cerebrum-token`；面板需在浏览器 `localStorage['cerebrum.token']` 设置同一个值；
+- **多实例并发**：同一工作区被两个 DSH 实例（如 web + desktop）同时写入时没有跨进程锁，内存各持一份、后写者覆盖；建议同一工作区只跑一个实例；
+- **无 embedding**：语义检索靠 SDR + 词面，极少数近义改写会走"知道感"（probe）而不是直接召回。
+
 ## 文档
 
 - [设计文档（中文）](docs/DESIGN.zh.md) — 脑结构映射、公式、参数、集成方式、评估方案

package/docs/publish.md

@@ -1,8 +1,13 @@
 # 发布 dsh-cerebrum 到 DSH 插件市场
 
+> **发布纪律**
+> - **发版必须经用户明确同意**：改代码只提交 main，不自动发版；确认后才运行 `node scripts/release.mjs --yes`
+> - 小改动攒成一批再发，不为了一个修复单独发一个版本
+> - 发版后等 npm registry 传播（可能几分钟），必要时网页批准 staged 版本
+
 > **发布状态（2026-10-28）**
 > - GitHub 公开仓库：https://github.com/liu-wen-wu/dsh-cerebrum（main + tag v0.1.1，SSH 推送）
-> - npm：`dsh-cerebrum@0.1.2` 已上线（latest；0.1.1 上一版，含内置宠物桥接）
+> - npm：`dsh-cerebrum@0.1.3` 已上线（latest；含 #121 复审要求的安全加固）
 > - 市场收录申请：https://github.com/polang233/dsh-plugin-index/issues/121
 > - 本地安装：`dsh-cerebrum@link:D:/workspace/dsh-cerebrum`（desktop profile，已热加载验证）
 

package/lib/api.js

@@ -51,12 +51,28 @@ const send = (res, status, payload, origin) => {
 export const startBrainApi = (service, { port = 18734, ui = { enabled: true }, token = '', logger = console } = {}) => {
   // Interaction rate limit: /interact is the only mutation; cap it to stop flooding.
   let interactWindow = { at: 0, count: 0 }
+  // Global request budget: a runaway page/poll can never hammer the brain.
+  let requestWindow = { at: 0, count: 0 }
+  const withinBudget = (limit = 240) => {
+    const now = Date.now()
+    if (now - requestWindow.at > 60_000) requestWindow = { at: now, count: 0 }
+    requestWindow.count += 1
+    return requestWindow.count <= limit
+  }
   const server = http.createServer((req, res) => {
     const origin = req.headers.origin
     const allowedOrigin = origin && LOOPBACK_ORIGIN.test(String(origin)) ? String(origin) : null
     const access = checkAccess(req, token)
     if (!access.ok) return send(res, access.status, { error: access.reason }, allowedOrigin)
-    if (req.method === 'OPTIONS') return send(res, 204, {}, allowedOrigin)
+    if (!withinBudget()) return send(res, 429, { error: 'rate-limited' }, allowedOrigin)
+    if (req.method === 'OPTIONS') {
+      if (allowedOrigin) res.setHeader('Access-Control-Allow-Origin', allowedOrigin)
+      res.setHeader('Access-Control-Allow-Methods', CORS_METHODS)
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, x-cerebrum-token')
+      res.setHeader('Vary', 'Origin')
+      res.statusCode = 204
+      return res.end()
+    }
     if (req.method !== 'GET') return send(res, 405, { error: 'method not allowed' }, allowedOrigin)
     const url = new URL(req.url, `http://127.0.0.1:${port}`)
     const reply = (status, payload) => send(res, status, payload, allowedOrigin)
@@ -74,7 +90,8 @@ export const startBrainApi = (service, { port = 18734, ui = { enabled: true }, t
         case '/recall': {
           const query = url.searchParams.get('q') ?? ''
           const sessionId = url.searchParams.get('session') || undefined
-          const hits = service.recall(query, { k: 3, sessionId })
+          // A read endpoint must not rehearse memory (no stability/RIF side effects).
+          const hits = service.recall(query, { k: 3, sessionId, reinforce: false })
           return reply(200, {
             query,
             memories: hits.map((hit) => ({

package/lib/client.js

@@ -18,14 +18,20 @@ window.__ModuleLoader__.load({
     var useRef = react.useRef
     var createElement = react.createElement
 
-    var PORTS = [18734, 18735, 18736, 18737]
+    var PORTS = Array.from({ length: 10 }, function (_, i) { return 18734 + i })
     var activePort = 0
     var POLL_MS = 5000
 
     // Probe the standard port first; if another app owns it, walk the range.
+    // Optional shared secret: set `config.api.token` and `localStorage['cerebrum.token']`.
     var get = function (path) {
+      var token = null
+      try {
+        token = localStorage.getItem('cerebrum.token')
+      } catch (err) {}
+      var init = token ? { headers: { 'x-cerebrum-token': token } } : undefined
       var attempt = function (index) {
-        return fetch('http://127.0.0.1:' + PORTS[index] + path)
+        return fetch('http://127.0.0.1:' + PORTS[index] + path, init)
           .then(function (r) {
             if (!r.ok) return null
             activePort = index
@@ -67,7 +73,14 @@ window.__ModuleLoader__.load({
       var [state, setState] = useState(null)
       var [open, setOpen] = useState(false)
       var [pinned, setPinned] = useState(false)
-      var [pos, setPos] = useState(null)
+      var [pos, setPos] = useState(function () {
+        try {
+          var raw = localStorage.getItem('cerebrum.pos')
+          return raw ? JSON.parse(raw) : null
+        } catch (err) {
+          return null
+        }
+      })
       var [uiEnabled, setUiEnabled] = useState(true)
       var [hidden, setHidden] = useState(function () {
         try {
@@ -283,12 +296,19 @@ window.__ModuleLoader__.load({
         if (event.target && event.target.getAttribute && event.target.getAttribute('data-no-drag') === '1') return
         var rect = panelRef.current ? panelRef.current.getBoundingClientRect() : { left: 0, top: 0 }
         dragRef.current = { dx: event.clientX - rect.left, dy: event.clientY - rect.top }
+        var latest = null
         var move = function (ev) {
-          setPos({ x: Math.max(8, ev.clientX - dragRef.current.dx), y: Math.max(8, ev.clientY - dragRef.current.dy) })
+          latest = { x: Math.max(8, ev.clientX - dragRef.current.dx), y: Math.max(8, ev.clientY - dragRef.current.dy) }
+          setPos(latest)
         }
         var up = function () {
           window.removeEventListener('mousemove', move)
           window.removeEventListener('mouseup', up)
+          if (latest) {
+            try {
+              localStorage.setItem('cerebrum.pos', JSON.stringify(latest))
+            } catch (err) {}
+          }
         }
         window.addEventListener('mousemove', move)
         window.addEventListener('mouseup', up)

package/lib/core/affect.js

@@ -139,8 +139,10 @@ export class AffectSystem {
     this.decay(now)
     const a = {}
     for (const dim of APPRAISAL_DIMS) {
-      if (dim === 'congruence' || dim === 'norm') a[dim] = clamp(Number(dims[dim] ?? 0), -1, 1)
-      else a[dim] = clamp(Number(dims[dim] ?? 0))
+      const raw = Number(dims[dim])
+      const value = Number.isFinite(raw) ? raw : 0
+      if (dim === 'congruence' || dim === 'norm') a[dim] = clamp(value, -1, 1)
+      else a[dim] = clamp(value)
     }
     // Trait gain: neuroticism amplifies threat appraisal, extraversion amplifies relevance of social events.
     const P = this.personality?.params() ?? {}

package/lib/core/judge.js

@@ -14,6 +14,7 @@
  */
 
 import { clamp, prospectValue, sigmoid, softmax } from './math.js'
+import { tokenize } from './sdr.js'
 
 const HIGH_STAKES = /(删除|删掉|覆盖|格式化|上线|发布|生产|数据库|密码|密钥|转账|支付|合同|法律|医疗|诊断| irreversible|delete|drop table|force push|rm -rf|production|deploy|password|secret|payment)/i
 const IRREVERSIBLE = /(删除|覆盖|格式化|清空|永久|drop|delete|truncate|rm -rf|force|覆写)/i
@@ -47,7 +48,8 @@ export class Judge {
     if (q.length === 0) throw new Error('judge requires a question')
 
     const highStakes = HIGH_STAKES.test(q)
-    const stakesLevel = highStakes ? 'high' : stakes
+    const stakesInput = stakes === 'low' || stakes === 'high' ? stakes : 'medium'
+    const stakesLevel = highStakes ? 'high' : stakesInput
     const magnitude = STAKES_VALUE[stakesLevel] ?? 0.55
     const baseLoss = P.lossAversion * (1 + 0.25 * magnitude)
     const lossAversion = A ? A.lossAversion(baseLoss) : baseLoss
@@ -232,8 +234,8 @@ export class Judge {
       if (!best || Math.abs(score) > Math.abs(best.value)) best = { option: candidate.option, value: score }
     }
     if (!best) return null
-    // Only report a gut preference when it actually has a sign.
-    return Math.sign(best.value) === Math.sign(gut) && Math.abs(best.value) > 0.01 ? best : best
+    // Report the option with the strongest signed gut pull (magnitude decides).
+    return Math.abs(best.value) > 0.01 ? best : null
   }
 
   _stance({ gut, evidence, P, magnitude, q }) {
@@ -278,10 +280,11 @@ export class Judge {
   }
 }
 
-/** Cheap lexical overlap similarity in [0, 1] (no encoder dependency). */
+/** Lexical overlap in [0, 1] using the same CJK-aware tokenizer as memory.
+ *  Splitting on whitespace would score every Chinese sentence pair as 0. */
 const simTokens = (a, b) => {
-  const tokensA = new Set(String(a).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length > 0))
-  const tokensB = new Set(String(b).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length > 0))
+  const tokensA = new Set(tokenize(String(a)))
+  const tokensB = new Set(tokenize(String(b)))
   if (tokensA.size === 0 || tokensB.size === 0) return 0
   let inter = 0
   for (const t of tokensA) if (tokensB.has(t)) inter++

package/lib/core/math.js

@@ -3,7 +3,11 @@
  * retrieval, appraisal and judgment can be replayed and unit-tested.
  */
 
-export const clamp = (x, lo = 0, hi = 1) => (x < lo ? lo : x > hi ? hi : x)
+export const clamp = (x, lo = 0, hi = 1) => {
+  const n = Number(x)
+  if (Number.isNaN(n)) return lo
+  return n < lo ? lo : n > hi ? hi : n
+}
 
 export const lerp = (a, b, t) => a + (b - a) * t
 

package/lib/core/memory.js

@@ -593,13 +593,14 @@ export class MemoryStore {
   recall(query, options = {}) {
     const now = Number(options.now) || Date.now()
     const k = Math.max(1, Number(options.k) || 5)
+    const queryText = String(query ?? '').slice(0, 2000)
     const moodValence = Number(options.moodValence ?? 0)
     const moodBias = clamp(Number(options.moodBias ?? 0.18))
     const kinds = Array.isArray(options.kinds) && options.kinds.length > 0 ? new Set(options.kinds) : null
     if (this.episodes.length === 0) return []
 
-    const cue = this.encoder.encode(query)
-    const cueConcepts = selectConcepts(this.encoder, query, 8)
+    const cue = this.encoder.encode(queryText)
+    const cueConcepts = selectConcepts(this.encoder, queryText, 8)
     const seeds = new Map()
     for (const concept of cueConcepts) {
       const node = this.concepts.get(concept)
@@ -620,7 +621,7 @@ export class MemoryStore {
     for (const ep of [...this.episodes].sort((a, b) => b.importance - a.importance).slice(0, 60)) candidates.add(ep.id)
     // Lexical layer: exact terms (error codes, names, versions) surface even when
     // the semantic code misses them.
-    const lexScores = this.bm25.search(query, { limit: 80 })
+    const lexScores = this.bm25.search(queryText, { limit: 80 })
     let lexMax = 0
     for (const score of lexScores.values()) lexMax = Math.max(lexMax, score)
     for (const id of lexScores.keys()) candidates.add(id)
@@ -641,7 +642,7 @@ export class MemoryStore {
     if (completion.winners.length > 0) this.stats.completions++
     const currentContext = options.contextCode?.size > 0 ? options.contextCode : this.prevContext
 
-    const rng = makeRng((now ^ (query.length * 2654435761)) >>> 0)
+    const rng = makeRng((now ^ (queryText.length * 2654435761)) >>> 0)
     const noise = () => gaussian(rng) * 0.04
     const scored = []
     for (const ep of pool) {
@@ -694,7 +695,8 @@ export class MemoryStore {
     const picked = scored.slice(0, k)
     if (options.reinforce !== false && picked.length > 0) {
       // Retrieval strengthens the winner; a close competitor is suppressed instead
-      // (retrieval-induced forgetting), not rehearsed as if it had been recalled.
+      // (retrieval-induced forgetting). Far competitors are left untouched — a
+      // retrieval is not a rehearsal of everything that was merely considered.
       this._rehearse(picked[0].episode, now)
       for (let i = 1; i < picked.length; i++) {
         const hit = picked[i]
@@ -702,8 +704,6 @@ export class MemoryStore {
           // Suppression acts on the trace's stability, not a cosmetic score.
           hit.episode.stability = Math.max(0.25, hit.episode.stability * 0.96)
           hit.episode.strength = clamp(0.3 + 0.7 * Math.min(1, Math.log1p(hit.episode.stability) / Math.log1p(365)))
-        } else {
-          hit.episode.stability = Math.min(3650, hit.episode.stability * 1.01)
         }
       }
       // Context reinstatement closes the loop: the next retrieval starts here.
@@ -784,7 +784,7 @@ export class MemoryStore {
       ep.interferences += 1
       this._recordReview(ep, 'interference', at)
       this.stats.interferences++
-      this.dirty = true
+      // No episode rewrite: the review record carries S/D and is replayed on load.
     }
   }
 
@@ -805,7 +805,7 @@ export class MemoryStore {
    */
   probe(query, { now = Date.now(), limit = 600 } = {}) {
     if (this.episodes.length === 0) return { similarity: 0, episode: null }
-    const cue = this.encoder.encode(query)
+    const cue = this.encoder.encode(String(query ?? '').slice(0, 2000))
     let best = { similarity: 0, episode: null }
     for (const ep of this.episodes.slice(-limit)) {
       const similarity = this.encoder.similarity(cue, ep.code)
@@ -834,13 +834,19 @@ export class MemoryStore {
   update(id, patch = {}) {
     const ep = this.byId.get(id)
     if (!ep) return null
+    const textChanged = typeof patch.text === 'string' && patch.text.trim().length > 0
     if (typeof patch.summary === 'string' && patch.summary.trim().length > 0) ep.summary = truncate(patch.summary.trim(), 240)
-    if (typeof patch.text === 'string' && patch.text.trim().length > 0) ep.text = truncate(patch.text.trim(), 4000)
+    if (textChanged) ep.text = truncate(patch.text.trim(), 4000)
     if (Number.isFinite(patch.importance)) ep.importance = clamp(patch.importance)
     if (Array.isArray(patch.tags)) ep.tags = patch.tags.slice(0, 12).map(String)
     if (typeof patch.resident === 'boolean') ep.resident = patch.resident
     ep.consolidated = false
     this.dirty = true
+    // Lexical index must follow the text, otherwise BM25 keeps serving stale terms.
+    if (textChanged) {
+      this.bm25.remove(id)
+      this.bm25.add(id, ep.text)
+    }
     return ep
   }
 
@@ -870,6 +876,8 @@ export class MemoryStore {
     if (outcome && typeof outcome === 'object') ep.outcome = { success: outcome.success === true, errors: Number(outcome.errors ?? 0) }
     if (typeof note === 'string' && note.trim().length > 0) {
       ep.text = truncate(`${ep.text}\n[重构] ${note.trim()}`, 4000)
+      this.bm25.remove(ep.id)
+      this.bm25.add(ep.id, ep.text)
     }
     ep.reconsolidations += 1
     ep.consolidated = false
@@ -970,10 +978,12 @@ export class MemoryStore {
             this._recordReview(ep, 'schema', now)
           }
           // SOAR chunking: a consistent schema becomes a reusable procedure.
-          // `when` = the concepts shared by most episodes, so partial cues still match.
-          const common = [...new Set(episodes.flatMap((ep) => ep.concepts))]
-            .filter((candidate) => candidate.length >= 2 && candidate.length <= 4 && !/^[才过次第再又把被着]/.test(candidate))
-            .filter((candidate) => episodes.filter((ep) => ep.concepts.includes(candidate)).length >= Math.ceil(episodes.length / 2))
+          // `when` = tokens from the cluster's summaries, so the trigger reads
+          // like the situation instead of a random high-frequency trigram.
+          const summaryTokens = this.encoder.topTokens(episodes.map((ep) => ep.summary).join(' '), 12)
+          const common = summaryTokens
+            .filter((token) => token.length >= 2 && token.length <= 4 && !/^[才过次第再又把被着的地得]/.test(token))
+            .filter((token) => episodes.filter((ep) => ep.concepts.includes(token) || ep.summary.includes(token)).length >= Math.ceil(episodes.length / 2))
             .slice(0, 3)
           this.upsertSkill({ when: common.length > 0 ? common : [concept], do: node.gist, source: 'auto', strength: 0.3 + 0.1 * Math.min(episodes.length, 5), now })
         }
@@ -1037,7 +1047,12 @@ export class MemoryStore {
     for (const ep of this.episodes) if (!ep.consolidated) ep.replayCount++
 
     this.stats.consolidated++
+    // Schema/consolidated flags are structural: unlike stability they cannot be
+    // replayed from the review log, so the episode log must be rewritten.
+    if (applied.length > 0 || created.length > 0) this.dirty = true
     this.prune(now)
+    this._pruneConcepts(now)
+    this._pruneEdges(now)
     this.flush()
     // Decision receipt: the same inputs reproduce the same hash (auditable consolidation).
     const receipt = {
@@ -1048,7 +1063,9 @@ export class MemoryStore {
       episodes: this.episodes.length,
       concepts: this.concepts.size,
     }
-    receipt.hash = crypto.createHash('sha256').update(JSON.stringify({ at: receipt.at, stage, applied: applied.length, created: created.length, episodes: receipt.episodes })).digest('hex').slice(0, 16)
+    // Hash covers the decision inputs only (not the wall clock), so the same
+    // consolidation is reproducible and verifiable.
+    receipt.hash = crypto.createHash('sha256').update(JSON.stringify({ stage, applied: applied.length, created: created.length, episodes: receipt.episodes, concepts: receipt.concepts })).digest('hex').slice(0, 16)
     this.receiptLog.append(receipt)
     this.stats.receipts = this.receiptLog.items.length
     return {
@@ -1068,12 +1085,15 @@ export class MemoryStore {
   /** Forgetting curve + capacity eviction. */
   prune(now = Date.now()) {
     if (this.episodes.length <= this.maxEpisodes * 0.9) return []
-    const scored = this.episodes.map((ep) => {
+    // Resident preferences and schema-backed traces are never evicted.
+    const pinned = this.episodes.filter((ep) => ep.resident || ep.schema)
+    const candidates = this.episodes.filter((ep) => !ep.resident && !ep.schema)
+    const scored = candidates.map((ep) => {
       const keep = this.retention(ep, now) * (0.35 + 0.65 * ep.importance) + 0.02 * Math.log1p(ep.retrievals)
       return { ep, keep }
     })
     scored.sort((a, b) => b.keep - a.keep)
-    const keepCount = Math.floor(this.maxEpisodes * 0.9)
+    const keepCount = Math.max(0, Math.floor(this.maxEpisodes * 0.9) - pinned.length)
     const kept = scored.slice(0, keepCount).map(({ ep }) => ep)
     const dropped = scored.slice(keepCount)
     for (const { ep } of dropped) {
@@ -1083,8 +1103,8 @@ export class MemoryStore {
         node.gist = node.gist || truncate(`${ep.summary}（已压缩）`, 200)
       }
     }
-    this.episodes = kept
-    this.byId = new Map(kept.map((ep) => [ep.id, ep]))
+    this.episodes = [...kept, ...pinned]
+    this.byId = new Map(this.episodes.map((ep) => [ep.id, ep]))
     for (const id of dropped.map(({ ep }) => ep.id)) this.bm25.remove(id)
     this._rebuildConceptIndex()
     this.dirty = true
@@ -1092,6 +1112,45 @@ export class MemoryStore {
     return dropped.map(({ ep }) => ep.id)
   }
 
+  /** Cortical-style fan-out limit: keep the strongest outgoing edges and drop
+   *  pure noise (weak AND seen only once). Bounds graph size without losing
+   *  strong associations. */
+  _pruneEdges(now = Date.now(), { fanout = 40, weak = 0.03, totalCap = 120000 } = {}) {
+    let removed = 0
+    const bySource = new Map()
+    for (const [key, edge] of this.edges) {
+      const source = key.split('\u0001')[0]
+      let list = bySource.get(source)
+      if (!list) bySource.set(source, (list = []))
+      list.push([key, edge])
+    }
+    for (const [, list] of bySource) {
+      if (list.length <= fanout) continue
+      list.sort((a, b) => b[1].w - a[1].w)
+      // A hard fan-out limit (cortical connectivity is sparse): keep the strongest
+      // outgoing links and drop the rest regardless of absolute weight.
+      for (const [key] of list.slice(fanout)) {
+        this.edges.delete(key)
+        removed++
+      }
+    }
+    for (const [key, edge] of [...this.edges]) {
+      if (edge.w < weak && edge.count <= 1) {
+        this.edges.delete(key)
+        removed++
+      }
+    }
+    if (this.edges.size > totalCap) {
+      const weakest = [...this.edges.entries()].sort((a, b) => a[1].w - b[1].w)
+      for (const [key] of weakest.slice(0, this.edges.size - totalCap)) {
+        this.edges.delete(key)
+        removed++
+      }
+    }
+    if (removed > 0) this._rebuildAdjacency()
+    return removed
+  }
+
   topConcepts(limit = 10) {
     return [...this.concepts.entries()]
       .sort((a, b) => b[1].strength - a[1].strength || b[1].count - a[1].count)
@@ -1099,6 +1158,37 @@ export class MemoryStore {
       .map(([name, node]) => ({ name, strength: round3(node.strength), count: node.count, gist: node.gist, schema: node.schema }))
   }
 
+  /** Conceptual garbage collection: drop orphaned weak concepts and cap the map. */
+  _pruneConcepts(now = Date.now(), cap = 6000) {
+    const referenced = new Set(this.conceptIndex.keys())
+    const cutoff = now - 90 * 24 * 60 * 60 * 1000
+    let removed = 0
+    for (const [name, node] of [...this.concepts]) {
+      if (referenced.has(name) || node.schema) continue
+      if (node.lastAt > cutoff) continue
+      if (node.strength >= 0.5 && (node.hot ?? 0) > 0.05) continue
+      this.concepts.delete(name)
+      removed++
+    }
+    if (this.concepts.size > cap) {
+      const weakest = [...this.concepts.entries()]
+        .sort((a, b) => a[1].strength + (a[1].hot ?? 0) - (b[1].strength + (b[1].hot ?? 0)))
+      for (const [name] of weakest.slice(0, this.concepts.size - cap)) {
+        if (referenced.has(name)) continue
+        this.concepts.delete(name)
+        removed++
+      }
+    }
+    if (removed > 0) {
+      for (const key of [...this.edges.keys()]) {
+        const [a, b] = key.split('\u0001')
+        if (!this.concepts.has(a) && !this.concepts.has(b)) this.edges.delete(key)
+      }
+      this._rebuildAdjacency()
+    }
+    return removed
+  }
+
   /** Resident layer: preferences, working agreements and schema memories. */
   resident(limit = 6) {
     return this.episodes

package/lib/service.js

@@ -227,12 +227,54 @@ export class CerebrumService {
   _session(id) {
     let state = this.sessions.get(id)
     if (!state) {
-      state = { id, turn: 0, user: [], assistant: [], tools: [], errors: 0, success: 0, startedAt: Date.now(), lastUserText: '', events: 0, cwd: null, dir: null, context: null, wm: [], segment: null, lastTurnAt: 0, lastBoundaryAt: 0, turnMemory: { read: [], wrote: [] }, prevConcepts: [], lastUserSeq: null, persona: null }
+      state = { id, turn: 0, user: [], assistant: [], tools: [], errors: 0, success: 0, startedAt: Date.now(), lastUserText: '', events: 0, cwd: null, dir: null, context: null, wm: [], segment: null, pendingChecked: false, lastTurnAt: 0, lastBoundaryAt: 0, turnMemory: { read: [], wrote: [] }, prevConcepts: [], lastUserSeq: null, persona: null }
       this.sessions.set(id, state)
     }
     return state
   }
 
+  // ---- crash-safe pending segment ------------------------------------------
+
+  _pendingFile(state) {
+    const store = this._storeForState(state)
+    return path.join(store.dir, 'pending', `${String(state.id).replace(/[^\w.-]/g, '_')}.json`)
+  }
+
+  _savePending(state, segment) {
+    if (!state || !segment) return
+    try {
+      const file = this._pendingFile(state)
+      ensureDir(path.dirname(file))
+      writeJson(file, { savedAt: Date.now(), segment })
+    } catch (error) {
+      this.logger?.warn?.('[cerebrum] pending segment write failed:', error?.message ?? error)
+    }
+  }
+
+  _loadPending(state) {
+    try {
+      const file = this._pendingFile(state)
+      if (!fs.existsSync(file)) return null
+      const data = readJson(file, null)
+      const segment = data?.segment
+      if (!segment || !Array.isArray(segment.turns) || segment.turns.length === 0) return null
+      // Guard against an ancient pending file resurfacing after a long break.
+      const age = Date.now() - Number(segment.lastAt ?? 0)
+      if (age > 24 * 60 * 60 * 1000) return null
+      return segment
+    } catch {
+      return null
+    }
+  }
+
+  _clearPending(state) {
+    try {
+      fs.rmSync(this._pendingFile(state), { force: true })
+    } catch {
+      /* best effort */
+    }
+  }
+
   /**
    * Observe one session event. Never throws into the loop: a broken memory
    * write must not fail a turn.
@@ -247,6 +289,12 @@ export class CerebrumService {
         state.cwd = cwd
         state.dir = this._storeForCwd(cwd).dir
       }
+      // Crash recovery: once the workspace is known, restore an open event that a
+      // previous process persisted (writes happen per turn, see _savePending).
+      if (!state.pendingChecked) {
+        state.pendingChecked = true
+        if (!state.segment) state.segment = this._loadPending(state)
+      }
       if (state.events++ > MAX_PENDING_EVENTS) return
 
       switch (event.type) {
@@ -328,6 +376,7 @@ export class CerebrumService {
     if (!this.config.autoCapture.enabled) return undefined
     if (reason?.kind === 'aborted') {
       state.segment = null
+      this._clearPending(state)
       return undefined
     }
 
@@ -440,6 +489,9 @@ export class CerebrumService {
     segment.toolCount += tools.length
     segment.lastAt = now
     segment.code = eventCode
+    // Crash-safe: the open event is persisted after every turn, so a host crash
+    // costs at most the current turn instead of the whole open event.
+    this._savePending(state, segment)
 
     // A high-stakes or failed turn is its own episode; do not dissolve it into a
     // longer event where its lesson would be averaged away.
@@ -514,6 +566,7 @@ export class CerebrumService {
       rawSeqs: segment.seqs,
     })
     this._noteTurnMemory(state, 'wrote', { id: episode.id, summary: episode.summary })
+    this._clearPending(state)
     this._updateSelf({ episode, emotion: emotion ?? this.affect.emotion, errors: segment.errors, toolCount: segment.toolCount, store })
     this.turnCount++
     this._schedulePersist()
@@ -564,12 +617,13 @@ export class CerebrumService {
 
   // ---- operations exposed to tools -----------------------------------------
 
-  recall(query, { k = 5, kinds, sessionId } = {}) {
+  recall(query, { k = 5, kinds, sessionId, reinforce = true } = {}) {
     const store = this._storeForSession(sessionId)
     const state = sessionId ? this.sessions.get(sessionId) : null
     const hits = store.recall(String(query ?? ''), {
       k,
       kinds,
+      reinforce,
       moodValence: this.affect.valence,
       moodBias: this.config.affect.moodBias,
       contextCode: state?.context,
@@ -694,13 +748,14 @@ export class CerebrumService {
     }
   }
 
-  remember({ text, summary, importance, tags, kind = 'explicit', resident = false, sessionId } = {}) {
+  remember({ text, summary, importance, tags, kind = 'explicit', resident = false, force = false, sessionId } = {}) {
     const store = this._storeForSession(sessionId)
     const state = sessionId ? this.sessions.get(sessionId) : null
     const now = Date.now()
     // Idempotent write: a near-duplicate strengthens the existing trace instead
     // of piling up a second copy (mnemon's dedup, memento's conditional write).
-    const duplicate = store.findDuplicate(text)
+    // `force` bypasses this when the user explicitly wants a separate memory.
+    const duplicate = force ? null : store.findDuplicate(text)
     if (duplicate) {
       const updated = store.reconsolidate(duplicate.ep.id, {
         summary: summary ? String(summary) : duplicate.ep.summary,
@@ -938,11 +993,14 @@ export class CerebrumService {
     return entry.persona
   }
 
-  /** Read a file for tool inputs (character-card PNGs). */
+  /** Read a file for tool inputs (character-card PNGs). Capped to avoid OOM. */
   readFile(filePath) {
     if (typeof filePath !== 'string' || filePath.length === 0) return null
     try {
-      return fs.readFileSync(path.resolve(filePath))
+      const resolved = path.resolve(filePath)
+      const stat = fs.statSync(resolved)
+      if (!stat.isFile() || stat.size > 10 * 1024 * 1024) return null
+      return fs.readFileSync(resolved)
     } catch {
       return null
     }
@@ -1025,7 +1083,12 @@ export class CerebrumService {
 
     let text = lines.join('\n')
     const max = this.config.prompt.maxChars
-    if (text.length > max) text = `${text.slice(0, max - 1)}…`
+    if (text.length > max) {
+      // Never split a surrogate pair (emoji) at the cut point.
+      let cut = text.slice(0, max - 1)
+      if (/[\uD800-\uDBFF]$/.test(cut)) cut = cut.slice(0, -1)
+      text = `${cut}…`
+    }
     return text
   }
 

package/lib/tools.js

@@ -155,6 +155,7 @@ export const buildTools = (service) => [
         summary: { type: 'string', description: '一句话摘要，用于未来检索展示' },
         importance: { type: 'number', description: '重要度 0..1，默认 0.6' },
         resident: { type: 'boolean', description: '标记为常驻记忆（偏好/约定），每轮注入；默认 false' },
+        force: { type: 'boolean', description: '跳过近重复合并，强制写入一条新记忆；默认 false' },
         tags: { type: 'array', description: '标签', items: { type: 'string' } },
         kind: { type: 'string', enum: ['explicit', 'semantic', 'episodic'], description: '记忆类型，默认 explicit' },
       },
@@ -170,6 +171,7 @@ export const buildTools = (service) => [
         summary: args.summary,
         importance: args.importance,
         resident: args.resident === true,
+        force: args.force === true,
         tags: args.tags,
         kind: args.kind ?? 'explicit',
         sessionId: sessionIdOf(exec),
@@ -430,6 +432,15 @@ export const buildTools = (service) => [
               episodeIds: { type: 'array', items: { type: 'string' } },
               gist: { type: 'string' },
               lesson: { type: 'string' },
+              skill: {
+                type: 'object',
+                description: '可选：沉淀一条程序性规则（when→do），来源标为 model',
+                properties: {
+                  when: { type: 'array', items: { type: 'string' }, description: '触发情境关键词' },
+                  do: { type: 'string', description: '做法/动作' },
+                },
+                required: ['do'],
+              },
             },
             required: ['episodeIds', 'gist'],
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cerebrum",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Brain-inspired cognitive architecture for DeepSeek Harness: hippocampal episodic memory, cortical semantic memory, spreading-activation recall, appraisal-based emotion, neuromodulator state, Big Five personality and dual-process judgment.",
   "type": "module",
   "main": "lib/index.js",
@@ -92,6 +92,7 @@
     "pet-hook": "node examples/pet-hook.mjs",
     "privacy": "node scripts/privacy-check.mjs",
     "release": "node scripts/release.mjs",
-    "market": "node scripts/check-market.mjs"
+    "market": "node scripts/check-market.mjs",
+    "bench": "node scripts/bench.mjs"
   }
 }