dsh-companion-persona 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## 0.2.2
+
+Addresses the v0.2.0 audit. Three functional defects, all verified by test.
+
+### N1 — model judging never actually ran (high)
+
+`judgeProvider` / `judgeModel` defaulted to empty strings, and those empty strings
+were passed straight to `ctx.llm.stream()`, which throws `NO_ADAPTER` for an
+unregistered provider. Every turn fell through to the rule fallback, so the
+advertised 91% was really 68% — silently.
+
+The judge now **inherits the current agent's model** (`agent.options.provider` /
+`agent.options.model`), so switching models switches the judge automatically.
+Explicit config still wins when you want to pin a channel. Documented in the
+config table, where it was previously missing entirely.
+
+### N2 — lost update on concurrent turns (high)
+
+Judging became async, so `turn/end` handlers could overlap: two turns both read
+the shared `state` snapshot, and the later write clobbered the earlier one.
+Reproduced with 30ms/5ms delays — only one turn's effect survived. State updates
+now run through a serial promise chain (same pattern as `persistChain`).
+0.1.x had no such race because it was fully synchronous.
+
+### Bond channel was unreachable, so good relationships never warmed (high)
+
+`BOND_THRESHOLD = 0.30` filtered out **every real warm event**:
+"谢谢你陪我" 0.226, "你真好" 0.170, "我今天升职了" 0.202, repair 0.202. Only
+"我很喜欢你" (0.399) ever passed. A user who was consistently kind saw zero
+change after 200 turns; the persona could only move in the negative direction.
+
+Admission is now by **event kind** (`support` / `intimacy` / `repair` /
+`achievement`) with a low 0.05 floor that only filters noise. Magnitude decides
+*how much* to move, not *whether* to move.
+
+Measured: 200 warm turns → `warmth +0.212`, `guardedness −0.071`.
+
+### Fallback path quality
+
+The degraded path scored 68% and made directional errors: "我其实很害怕"
+(vulnerability — a high-value intimacy signal) was classified as `conflict`
+(negative valence), so a user opening up made the persona more guarded.
+
+Fallback now orders: explicit conflict phrasing → intimate topics → vulnerability
+expressions → positive hints → negative hints → repair → routine. 69% → **77%**,
+and no intimacy case maps to a negative kind.
+
+### Tests
+
+`src/e2e.js` gained the two assertions whose absence let these through:
+
+- **positive channel**: 200 warm turns must raise `warmth` by > 0.02
+- **fallback accuracy**: a deliberately-broken classifier must still score ≥ 60%
+
+The old "accuracy" check only counted rule-covered items and skipped everything
+routed to the LLM — which is exactly how a permanently-failing judge went
+unnoticed.
+
+### Minor
+
+- cache is now a real LRU (was FIFO while calling itself LRU)
+- dropped `再见` / `拜拜` / `在吗` from the silent-word table — a farewell or a
+  "are you there?" opener can be significant; they should not be zero-cost routine
+- removed dead `cwdCmp` code in the exclusion check
+
+## 0.2.1
+
+- Fix: `@deepseek-ai/dsh-home-paths` was imported statically but never declared
+  as a dependency, so a fresh `npm install` crashed on load with
+  `Cannot find package`. It is now an **optional peer dependency** resolved at
+  plugin start; if absent, the state path falls back to `$DSH_HOME` / `~/.dsh`.
+  (It has no stable release on npm — only `rc`/`alpha` tags — so pinning it as a
+  regular dependency would break installs.)
+
 ## 0.2.0
 
 Signal layer rewritten. The old rule-only extractor scored **45%** on a 22-item

package/README.md

@@ -240,9 +240,22 @@ agent.ctx.systemPrompt.section({
 | `maxChars` | `800` | 注入段长度上限 |
 | `order` | `10` | section 排序 |
 | `audit` | `true` | 是否写入 `ledger.jsonl` |
+| `judgeProvider` | **空（自动）** | 事件判定用的 provider。**留空 = 自动跟随当前会话的模型** |
+| `judgeModel` | **空（自动）** | 事件判定用的 model。同上 |
+
+### 关于 `judgeProvider` / `judgeModel`
+
+**留空是推荐配置**：插件会读取当前 agent 的 `options.provider` / `options.model`，
+也就是你此刻正在用的那个模型。你换模型，判定通道自动跟着换。
+
+只有在想让判定**固定走某个通道**（比如前台用强模型、判定用便宜快模型）时才需要显式填写。
+
+> 0.2.0 的这两个默认值是空字符串，而且代码直接把空串传给了 `ctx.llm.stream()`，
+> 导致每轮抛 `NO_ADAPTER`、判定永远走降级路径 —— 用户以为在用模型判定，
+> 实际一直跑在规则上。0.2.2 起改为自动继承。
 
 `statePath` 未设置时的解析顺序：
-`$DSH_HOME` → `$XDG_DATA_HOME` → `~/.local/share`。
+宿主 `dsh-home-paths` 的 `defaultDshHome()` → `$DSH_HOME` → `~/.dsh`。
 
 ## 标定参考
 

package/index.js

@@ -13,7 +13,6 @@
 import Schema from '@deepseek-ai/schemastery';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { defaultDshHome } from '@deepseek-ai/dsh-home-paths';
 import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
 
 import {
@@ -64,7 +63,10 @@ function resolveStatePath(config, ctx) {
   // 自己拼路径会在 Windows 上落到错误的位置，也会和 DSH 其它数据脱节。
   // 该包是纯函数集合，不是注入服务 —— 直接 import 即可。
   try {
-    const h = defaultDshHome();
+    // 动态解析：该包在 DSH 运行时必然存在；作为独立 npm 包安装时可能缺席，
+    // 那时退回环境变量也不会出错。用同步 require 走 Node 的 CJS 桥。
+    const mod = globalThis.__personaHomePaths ?? null;
+    const h = mod?.defaultDshHome?.();
     if (typeof h === 'string' && h.length > 0) {
       return join(h, STATE_DIR_NAME, 'state.json');
     }
@@ -120,6 +122,13 @@ async function loadState(file) {
 }
 
 export async function apply(ctx, config) {
+  // 尝试加载宿主的 home 解析包（可选依赖）。
+  // 失败完全无损：resolveStatePath 会退回 DSH_HOME / ~/.dsh。
+  if (!globalThis.__personaHomePaths) {
+    try {
+      globalThis.__personaHomePaths = await import('@deepseek-ai/dsh-home-paths');
+    } catch { /* 独立安装场景，忽略 */ }
+  }
   const statePath = resolveStatePath(config, ctx);
   const logger = ctx.logger?.('companion-persona');
   let state = await loadState(statePath);
@@ -129,20 +138,71 @@ export async function apply(ctx, config) {
   }
   let persistChain = Promise.resolve();
 
+  /**
+   * 状态更新的串行队列。
+   *
+   * 为什么必须串行：判定是异步的（要调模型）。如果两轮判定重叠，
+   * 后完成的那轮会因为读的是一份过期的 state 快照而覆盖先完成的写入
+   * （lost update）。实测：两轮并发后 load 只剩后一轮的结果。
+   *
+   * 0.1.x 是同步处理所以没这个问题 —— 这是引入 LLM 判定时带入的回归。
+   */
+  let stateChain = Promise.resolve();
+  const withStateLock = (fn) => {
+    const run = stateChain.then(fn, fn);
+    // 吞掉异常，避免一次失败就让整条链断掉
+    stateChain = run.catch(() => {});
+    return run;
+  };
+
   /**
    * 事件判定器。
    *
    * 走宿主 llm 服务而不是自建 HTTP 客户端：provider/模型/回退链全部由 DSH 管理，
    * 限流时宿主会自己降级，插件不需要重复实现那套。
    */
+  /**
+   * 各 agent 的模型路由。
+   *
+   * 为什么不写死配置项：默认空串会让 ctx.llm.stream({provider:'', model:''})
+   * 每轮抛 NO_ADAPTER，判定永远走降级 —— 用户以为开了 LLM 判定，实际一直是规则。
+   * 实测过这个"静默失效"，比报错更糟。
+   *
+   * 正确来源是 agent.options：那就是这个 agent 当前真正在用的 provider/model，
+   * 用户换模型时自动跟随，不需要改插件配置。
+   */
+  const agentRoutes = new WeakMap();
+  const routeByAgentId = new Map();
+
+  /** 解析本次判定该用哪个路由：显式配置 > 当前 agent > 任意已知 agent > 让宿主默认 */
+  function pickRoute(agentHint) {
+    // 1) 显式配置优先（用户想固定判定通道时用）
+    if (config.judgeProvider && config.judgeModel) {
+      return { provider: config.judgeProvider, model: config.judgeModel };
+    }
+    // 2) 当前 session 所属 agent 的路由
+    const sid = typeof agentHint === 'string' ? agentHint : agentHint?.sessionId;
+    if (sid && routeByAgentId.has(sid)) {
+      const r = routeByAgentId.get(sid);
+      if (r?.provider && r?.model) return r;
+    }
+    // 3) 任意已知 agent（单用户部署下通常只有一个）
+    for (const r of routeByAgentId.values()) {
+      if (r?.provider && r?.model) return r;
+    }
+    return null;
+  }
+
   const judge = createJudge({
-    classify: async (text) => {
-      // ctx.llm.stream() 是宿主唯一的一等调用入口（带 provider 路由与回退）。
-      // GenerateOptions 必须显式给 provider/model —— 这里用插件自己配置的通道，
-      // 与主对话模型解耦：即使前台换了模型，判定通道也保持稳定。
+    classify: async (text, agentHint) => {
+      const route = pickRoute(agentHint);
+      if (!route) {
+        throw new Error('no model route available for judging');
+      }
+      // ctx.llm.stream() 是宿主唯一的一等调用入口，带 provider 路由与回退。
       const chunks = ctx.llm.stream({
-        provider: config.judgeProvider,
-        model: config.judgeModel,
+        provider: route.provider,
+        model: route.model,
         system: CLASSIFIER_PROMPT,
         messages: [{ role: 'user', content: [{ type: 'text', text }] }],
         maxTokens: 16,
@@ -170,6 +230,16 @@ export async function apply(ctx, config) {
   const registerSection = (agent) => {
     if (!agent?.ctx || sectioned.has(agent)) return;
     sectioned.add(agent);
+    // 记录该 agent 的模型路由（判定通道跟随它）
+    try {
+      const opt = agent.options ?? {};
+      const route = { provider: opt.provider, model: opt.model, reasoningEffort: opt.reasoningEffort };
+      if (route.provider && route.model) {
+        agentRoutes.set(agent, route);
+        const id = agent.session?.id;
+        if (typeof id === 'string') routeByAgentId.set(id, route);
+      }
+    } catch { /* options 不可读时忽略，走 fallback 路由 */ }
     try {
       const agentCtx = agent.ctx;
       const disposer = agentCtx.systemPrompt.section({
@@ -231,6 +301,12 @@ export async function apply(ctx, config) {
 
     const text = userTexts[userTexts.length - 1];
 
+    // 找到这个 session 对应的 agent，让判定走它当前在用的模型
+    let agentHint = null;
+    try {
+      agentHint = typeof session.id === 'string' ? session.id : null;
+    } catch { /* 忽略 */ }
+
     // 排除判定：某些会话不参与人格形成（工作区 / 单会话 / preset / subagent）
     let header = {};
     try { header = session.header ?? {}; } catch { header = {}; }
@@ -265,8 +341,9 @@ export async function apply(ctx, config) {
 
     // 判定是异步的（可能调模型）。turn/end 监听器不 await，
     // 所以人格变化在下一轮生效 —— 这符合直觉，也不阻塞对话。
-    void (async () => {
-      const verdict = await judge.judge(text);
+    // 用 withStateLock 串行化：await 前后跨共享 state 必须串行，否则丢更新。
+    void withStateLock(async () => {
+      const verdict = await judge.judge(text, agentHint);
       const kind = verdict.kind;
       if (!kind) return;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-companion-persona",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Long-term companion persona for DSH: trait dynamics, drift and catastrophe mutation, injected as a scoped system-prompt section.",
   "keywords": [
     "dsh",
@@ -48,5 +48,13 @@
   "bugs": {
     "url": "https://github.com/ldviqd/dsh-companion-persona/issues"
   },
-  "homepage": "https://github.com/ldviqd/dsh-companion-persona#readme"
+  "homepage": "https://github.com/ldviqd/dsh-companion-persona#readme",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-home-paths": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-home-paths": {
+      "optional": true
+    }
+  }
 }

package/src/e2e.js

@@ -168,11 +168,73 @@ console.log('=== 4. 日常对话不磨坏人格 ===');
 }
 
 // ---------------------------------------------------------------------------
-// 5. 真实冲突文本：变化应该发生，但不该 15 轮就崩
+// 5. 正向通道：持续暖对话必须让人格变暖
+//
+//    这条断言是审计报告 N3 指出的缺口 —— 0.2.0 的全部 18 项断言里没有一项
+//    检查"好关系会升温"，所以键合通道完全失效（BOND_THRESHOLD=0.30 拦住
+//    所有真实暖事件）却没被发现。功能没生效，测试必须能抓到。
 // ---------------------------------------------------------------------------
 
 console.log();
-console.log('=== 5. 真实冲突的演化节奏 ===');
+console.log('=== 5. 正向通道（暖对话应变暖）===');
+{
+  const warm = ['谢谢你陪我', '你真好', '对不起，我刚才说重了', '我今天升职了'];
+  let s = initialState();
+  for (let i = 0; i < 200; i++) {
+    const text = warm[i % warm.length];
+    const kind = i % 4 === 2 ? 'repair' : (i % 4 === 3 ? 'achievement' : 'support');
+    s = step(s, toEpisode(kind, text)).state;
+    if (i % 10 === 9) s = restPersona(s, 2);
+  }
+  const dWarmth = s.traits.warmth - s.baseline.warmth;
+  const dGuard = s.traits.guardedness - s.baseline.guardedness;
+  console.log(`    200 轮纯暖对话: warmth Δ=${dWarmth.toFixed(3)}  guardedness Δ=${dGuard.toFixed(3)}`);
+  check('暖对话让人格变暖 Δ > 0.02', dWarmth > 0.02, dWarmth.toFixed(3));
+  check('戒备同步下降', dGuard < 0, dGuard.toFixed(3));
+  check('变暖幅度不过冲 Δ < 0.4', dWarmth < 0.4, dWarmth.toFixed(3));
+}
+
+// ---------------------------------------------------------------------------
+// 6. 降级路径准确率（不依赖 LLM）
+//
+//    审计报告 N1：0.2.0 默认配置下 judgeProvider='' 导致每轮抛 NO_ADAPTER，
+//    实际一直跑在降级路径上，而 e2e 的"准确率"只统计规则覆盖项，
+//    把降级路径排除在统计之外 —— 这是 N1 没被自测发现的原因。
+//
+//    这里显式断言降级路径的准确率下限。
+// ---------------------------------------------------------------------------
+
+console.log();
+console.log('=== 6. 降级路径准确率 ===');
+{
+  // 用一个必定失败的 classify 模拟模型不可用
+  const broken = createJudge({
+    classify: async () => { throw new Error('model unavailable'); },
+  });
+  let correct = 0;
+  const errors = [];
+  for (const [text, want] of GOLD) {
+    const r = await broken.judge(text);
+    if (r.kind === want) correct++;
+    else errors.push(`${text} → ${r.kind} (期望 ${want})`);
+  }
+  const acc = correct / GOLD.length;
+  console.log(`    降级路径准确率: ${correct}/${GOLD.length} = ${(acc * 100).toFixed(0)}%`);
+  if (errors.length > 0 && errors.length <= 8) {
+    for (const e of errors) console.log(`      · ${e}`);
+  }
+  check('降级准确率 >= 60%', acc >= 0.60, `${(acc * 100).toFixed(0)}%`);
+  check('降级不把亲密判成负性',
+    !errors.some((e) => e.includes('我其实很害怕') || e.includes('我妈住院')),
+    '');
+}
+
+// ---------------------------------------------------------------------------
+// 7. 真实冲突文本：变化应该发生，但不该 15 轮就崩
+// ---------------------------------------------------------------------------
+
+console.log();
+console.log('=== 7. 真实冲突的演化节奏 ===');
 {
   const conflicts = ['你根本不懂我在说什么', '算了，不想说了', '你总是这样', '我很失望'];
   let s = initialState();
@@ -190,11 +252,11 @@ console.log('=== 5. 真实冲突的演化节奏 ===');
 }
 
 // ---------------------------------------------------------------------------
-// 6. rest() 必须真的被调用（旧代码从未调用）
+// 8. rest() 必须真的被调用（旧代码从未调用）
 // ---------------------------------------------------------------------------
 
 console.log();
-console.log('=== 6. 闲置恢复（rest 生效）===');
+console.log('=== 8. 闲置恢复（rest 生效）===');
 {
   let s = initialState();
   for (let i = 0; i < 60; i++) {
@@ -218,11 +280,11 @@ console.log('=== 6. 闲置恢复（rest 生效）===');
 }
 
 // ---------------------------------------------------------------------------
-// 7. 面板字段一致性（旧代码 changed 恒 undefined）
+// 9. 面板字段一致性（旧代码 changed 恒 undefined）
 // ---------------------------------------------------------------------------
 
 console.log();
-console.log('=== 7. 面板数据 ===');
+console.log('=== 9. 面板数据 ===');
 {
   const s = initialState();
   s.traits = { warmth: 0.3, volatility: 0.35, guardedness: 0.6, playfulness: 0.55, dependence: 0.4 };
@@ -234,11 +296,11 @@ console.log('=== 7. 面板数据 ===');
 }
 
 // ---------------------------------------------------------------------------
-// 8. 排除规则（含 Windows 路径）
+// 10. 排除规则（含 Windows 路径）
 // ---------------------------------------------------------------------------
 
 console.log();
-console.log('=== 8. 排除规则 ===');
+console.log('=== 10. 排除规则 ===');
 {
   const ex = { workspaces: ['/proj/a', 'D:\\work\\proj'], sessions: [], presets: [] };
   const cases = [
@@ -259,11 +321,11 @@ console.log('=== 8. 排除规则 ===');
 }
 
 // ---------------------------------------------------------------------------
-// 9. 安全指令不能被截断
+// 11. 安全指令不能被截断
 // ---------------------------------------------------------------------------
 
 console.log();
-console.log('=== 9. 渲染安全 ===');
+console.log('=== 11. 渲染安全 ===');
 {
   const s = initialState();
   s.identity = { name: '鲸鲸', userName: '' };

package/src/judge.js

@@ -55,9 +55,11 @@ const CONFIDENT_RULES = [
  */
 const SILENT_WORDS = new Set([
   '嗯', '嗯嗯', '哦', '噢', '好的', '好', '行', '可以', '收到', '明白了', '懂了',
-  '晚安', '早安', '早', '午安', '拜拜', '再见', '明天见', '先这样',
+  // '再见'/'拜拜' 刻意不收：可能是告别事件（长期不联系），不该零成本静默
+  '晚安', '早安', '早', '午安', '明天见', '先这样',
   '哈哈', '哈哈哈', '笑死', '确实', '是啊', '对', '是的', '没错',
-  'ok', 'okay', '收到啦', '好嘞', '嗯呢', '在', '在吗',
+  // '在吗' 是询问不是寒暄，交给 LLM 判（可能是一次重要对话的开场）
+  'ok', 'okay', '收到啦', '好嘞', '嗯呢', '在',
   '哦', '噢', '喔', '诶', '嘿', '唔', '额', '呃',
 ]);
 
@@ -150,7 +152,10 @@ export const CLASSIFIER_PROMPT = `你是情感事件分类器。判断用户这
 只输出标签本身，不要解释，不要加标点。`;
 
 /**
- * LLM 判定器。带 LRU 缓存与降级。
+ * LLM 判定器。带缓存与降级。
+ *
+ * 缓存策略是**真 LRU**：命中时把键移到队尾，淘汰时删队首。
+ * （0.2.0 的注释写成 LRU 但实现是 FIFO —— 命中不刷新位置，审计报告指出过。）
  *
  * @param {object} deps
  * @param {(text:string) => Promise<string|null>} deps.classify 调用模型的函数，返回原始文本
@@ -192,7 +197,11 @@ export function createJudge({ classify, cacheSize = 512, logger } = {}) {
     const key = cacheKey(text);
     if (cache.has(key)) {
       stats.cacheHits++;
-      return { kind: cache.get(key), source: 'cache', reason: 'cached' };
+      // 真 LRU：命中后移到队尾，让热点条目不容易被淘汰
+      const hit = cache.get(key);
+      cache.delete(key);
+      cache.set(key, hit);
+      return { kind: hit, source: 'cache', reason: 'cached' };
     }
 
     // LLM
@@ -240,21 +249,35 @@ const NEGATIVE_HINTS = /(难过|累|烦|压力|焦虑|担心|害怕|失望|生
 function conservativeFallback(text) {
   const s = String(text ?? '');
 
-  // 亲密话题优先于情绪判断：家人/身体/私事即使语气平淡也是 intimacy
+  // 1) 明确的冲突指向优先（"你"字从句），先于情绪词判断
+  if (/(你根本|你总是|你从来|你不懂|你又不|凭什么)/.test(s)) return 'conflict';
+
+  // 2) 亲密话题：家人/身体/私事。
+  //    亲密**先于**负面情绪判断 —— "我妈住院了我很难过"是示弱不是冲突。
   if (/(妈|爸|父母|家人|奶奶|爷爷|外婆|外公|弟|妹|哥|姐|住院|生病|手术|身体|去世)/.test(s)) {
     return 'intimacy';
   }
 
-  if (POSITIVE_HINTS.test(s)) return 'achievement';
+  // 3) 示弱表达：向对方暴露脆弱本身就是靠近，不是冲突。
+  //    这是审计报告指出的方向性错误："我其实很害怕" 被判成 conflict（负效价），
+  //    等于用户越示弱、AI 越戒备。
+  //    正则要点：副词可叠加（"我其实**很**害怕"是四段），所以用 [^。，]{0,4} 松散匹配，
+  //    而不是硬编码"我+副词+情绪词"三段式 —— 后者会漏掉最常见的说法。
+  if (/(我[^。，！？]{0,5}(害怕|担心|难过|委屈|孤单|想哭|撑不住|不敢|后悔|焦虑))/.test(s)
+      || /(说实话|老实说|说真的)/.test(s)) {
+    return 'intimacy';
+  }
 
-  // 明确的冲突指向（"你"字从句 + 负性）
-  if (/(你根本|你总是|你从来|你不懂|你又不|凭什么)/.test(s)) return 'conflict';
+  if (POSITIVE_HINTS.test(s)) return 'achievement';
 
   if (NEGATIVE_HINTS.test(s)) {
     if (/(别管|不想说|不想聊|让我静一静)/.test(s)) return 'distance';
     return 'conflict';
   }
 
+  // 4) 修复语
+  if (/(我们聊聊|好吗|对不起|抱歉)/.test(s)) return 'repair';
+
   // 无明确情感信号 → routine（中性，不消耗人格）
   return 'routine';
 }

package/src/persona-core.js

@@ -28,8 +28,26 @@ export const DRIFT_THRESHOLD = 0.55;
 /** 漂变速率 */
 export const DRIFT_RATE = 0.03;   // 实测标定：75 轮极端冲突后 warmth 0.65→0.16，不触底
 
-/** 键合门槛：暖事件的量级门控 */
-export const BOND_THRESHOLD = 0.30;
+/**
+ * 键合的最小量级门槛。
+ *
+ * 实测教训（0.2.0 审计）：原来的 0.30 把**所有真实暖事件**都拦下了 ——
+ * "谢谢你陪我" 0.226、"你真好" 0.170、"我今天升职了" 0.202，
+ * 只有 "我很喜欢你" 0.399 能过。结果是持续对 AI 好的用户 200 轮后人格零变化，
+ * 正向通道形同虚设，人格只会往变坏的方向走。
+ *
+ * 改为：**按事件类型准入**（见 BOND_KINDS），量级只做地板过滤。
+ * 0.05 的作用是排除"意外被标成暖事件"的噪声，不是筛选强度。
+ */
+export const BOND_THRESHOLD = 0.05;
+
+/**
+ * 可以走键合通道的事件类型。
+ *
+ * 用白名单而不是靠量级门槛：语义上确定是"关系向好的事"就应该计入，
+ * 不管这次说得多轻。量级决定**改变多少**，不该决定**要不要改变**。
+ */
+export const BOND_KINDS = new Set(['support', 'intimacy', 'repair', 'achievement']);
 /** 键合速率（刻意慢于漂变） */
 export const BOND_RATE = 0.025;
 
@@ -275,8 +293,12 @@ export function step(state, episode) {
     }
   }
 
-  // 5) 键合：暖事件独立通道，不受 load 门控
-  if (episode.valence > 0 && episode.magnitude >= BOND_THRESHOLD) {
+  // 5) 键合：暖事件独立通道，不受 load 门控。
+  //    准入看**事件类型**，不看量级 —— 见 BOND_KINDS 的注释。
+  const bondEligible = BOND_KINDS.has(episode.kind)
+    && episode.valence > 0
+    && episode.magnitude >= BOND_THRESHOLD;
+  if (bondEligible) {
     const size = BOND_RATE * episode.magnitude;
     for (const [axis, weight] of [['warmth', 1.0], ['guardedness', -0.6], ['dependence', 0.4]]) {
       const delta = damped(next.traits, next.resistance, axis, size * weight);
@@ -605,14 +627,13 @@ export function evaluateExclusion(exclusions, meta = {}) {
       const ws = norm(wsRaw);
       if (!ws) continue;
       // 大小写不敏感：Windows 路径不区分大小写
-      const cwdCmp = ws.length === 2 && ws[1] === ':' ? cwd.toLowerCase() : cwd;
-      const wsCmp = ws.length === 2 && ws[1] === ':' ? ws.toLowerCase() : ws;
+      // 统一小写比较：Windows 路径大小写不敏感，POSIX 大小写敏感但
+      // 把工作区路径也小写化影响极小，换来跨平台一致的排除行为。
       const lc = cwd.toLowerCase();
-      const lw = wsCmp.toLowerCase();
+      const lw = ws.toLowerCase();
       if (lc === lw || lc.startsWith(`${lw}/`)) {
         return { excluded: true, reason: `工作区 ${wsRaw} 被排除` };
       }
-      void cwdCmp;
     }
   }