dsh-hormone 0.2.0 → 0.4.0

package/README.md

@@ -1,34 +1,57 @@
 # dsh-hormone
 
-给 [DSH](https://github.com/deepseek-ai)（DeepSeek Harness）的助手装一套「激素」：三个连续变化的数值，按事件涨落、随时间衰减，**只在越界时**往系统提示里写一句话。
+给 [DSH](https://github.com/deepseek-ai)（DeepSeek Harness）的助手装一套「激素」：四个连续变化的数值，按事件涨落、随时间衰减、彼此还会互相拉扯，**只在越界时**往系统提示里写一句话。
 
 不是给模型贴情绪标签，是给它一组真的会变的内部状态。
 
-> 状态：`0.2.0`，注入层已跑通，门控层未做。只用 DSH 的公开插件 API，不修改任何其他插件的数据，不联网。
+> 状态：`0.4.0`，注入层已跑通，门控层未做。只用 DSH 的公开插件 API，不修改任何其他插件的数据，不联网。
 
 ## 它是什么
 
 | 状态 | 什么时候涨 | 什么时候降 | 半衰期 |
 |---|---|---|---|
-| `cortisol` 压力 | 工具报错 +0.15；连续 3 次失败再 +0.30；被批评/被纠正 +0.25 | 一轮顺利收尾 −0.20 | 4 小时 |
-| `energy` 精力 | 跨天 +0.80；距上次干活超 1h 缓慢回升（深夜只回到 0.45） | 干活轮按 token 扣减，闲聊不扣 | 不走半衰期 |
+| `cortisol` 压力 | 工具报错 +0.08；连续 3 次失败再 +0.15；被批评/被纠正 +0.12 | 一轮顺利收尾 −0.20 | 3 小时（开心时更短） |
+| `energy` 精力 | 跨天 +0.80；距上次干活超 30 分钟缓慢回升（深夜只回到 0.45） | 干活轮按 token 扣减，闲聊不扣 | 不走半衰期 |
 | `dopamine` 爽度 | 任务顺利收尾 +0.35；被夸/被谢 +0.40 | 自然衰减 | 40 分钟 |
+| `boredom` 无聊 | 25 分钟没人说话就开始涨，之后向 1 靠拢 | 真人说话 −0.30；干活收尾 −0.25 | 上涨半衰期 5 小时 |
 
 更新公式：`新值 = clamp(旧值 × 0.5^(Δt / 半衰期) + Σ增量, 0, 1)`
 
 衰减是必须的。没有衰减，任何状态都会积到 1，然后卡死在那儿。
 
+## 它们会互相影响
+
+四个数不是各算各的：
+
+| 谁影响谁 | 效果 | 参数 |
+|---|---|---|
+| 爽度 → 精力扣减 | 越开心，同样一活儿越不累（最多省一半；按 √ 算，中等开心就省三成） | `COUPLING.joyCost = 0.5` |
+| 压力 → 精力扣减 | 越烦，同样一活儿越累（最多 +40%） | `COUPLING.stressCost = 0.4` |
+| 爽度 → 压力消散 | 开心时压力半衰期最短缩到 65% | `COUPLING.joyDecay = 0.35` |
+| 压力 → 精力恢复 | 烦的时候回血最慢拖到 2.5 倍 | `COUPLING.stressRecover = 1.5` |
+
+也就是说：一直不顺 → 压力高 → 干同样的活掉得更多 → 更难缓过来，是个正反馈；反过来被夸几句 → 掉得少、压力散得快，也是正反馈。两头都有上限，不会失控。
+
+## 熬夜的账第二天还
+
+00:00–07:00 还在干活，每扣掉 1 点精力就记 1.3 倍睡眠债（`DEBT.ratio`），债把精力上限压低：欠满时上限只有 0.6（`DEBT.max = 0.4`），白天怎么摸鱼也回不到满。
+
+债从记债时刻起 24 小时线性衰减——睡一觉就还清，连续熬夜会累加但封顶。这是让「熬一次夜，第二天确实虚」真的成立，而不是只靠深夜基线那 0.45。
+
 ## 它怎么起作用
 
 只有一层，第一版就一层：
 
 **注入** —— 越界了才写，全部正常时一个字都不写：
 
-- `cortisol > 0.7` → 回答收短，不主动揽活
+- `cortisol > 0.75` → 回答收短，不主动揽活
 - `energy < 0.2` → 能一句说完就别铺垫
 - `dopamine > 0.6` → 可以多说两句
+- `boredom > 0.55` → 有点闷，可以主动扯两句
+
+注入文本硬上限 110 字，带 `[hormone]` 前缀，每轮最多一条。
 
-注入文本硬上限 80 字，带 `[hormone]` 前缀，每轮最多一条。
+而且是**边沿触发**：越界的第一轮说一次，之后一直越界就闭嘴，直到恢复正常后再次越界；一直不恢复的话，静默 40 分钟才重提一次（`EMIT.rementionAfterSec`）。否则「精力见底」这种长期状态会每轮刷一遍，把这一句话变成噪音。
 
 **没有做门控**（比如硬压输出长度）。门控是分水岭：注入只是「告诉它现在什么状态」，门控是「替它决定能说多少」。第一版先把状态跑准，跑两天曲线不极端了再谈门控。
 
@@ -36,6 +59,12 @@
 
 ## 装
 
+```bash
+dsh plugin --profile desktop add dsh-hormone
+```
+
+不想走 npm 的话，直接从 GitHub 装也行：
+
 ```bash
 dsh plugin --profile desktop add github:y258dd/dsh-hormone
 ```
@@ -63,7 +92,7 @@ dsh plugin --profile desktop add link:$PWD   # Windows: link:D:/path/to/dsh-horm
 
 状态文件：`%DSH_HOME%\hormone\state.json`（默认 `~/.dsh/hormone/state.json`，Windows 上是 `C:\Users\<你>\.dsh\hormone\state.json`）
 
-纯 JSON，打开就能看。`history` 里是最近 400 次变化，每条带 `why`（`tool-error` / `errors-3` / `turn-done` / `praised` / `blamed`），想验收「跑两天曲线有没有起伏」直接看这个。
+纯 JSON，打开就能看。`history` 里是最近 400 次变化，每条带 `why`（`tool-error` / `errors-3` / `turn-done` / `praised` / `blamed` / `user-chat`），有睡眠债时多一个 `debt` 字段，想验收「跑两天曲线有没有起伏」直接看这个。
 
 删掉这个文件 = 回到初始状态，不会有副作用。
 
@@ -78,11 +107,11 @@ dsh plugin --profile desktop add link:$PWD   # Windows: link:D:/path/to/dsh-horm
 
 三个文件顶部，改完重启：
 
-- `lib/state.js` — `HALF_LIFE`（衰减快慢）、`ENERGY`（日预算、跨天恢复、深夜基线）
+- `lib/state.js` — `HALF_LIFE`（衰减快慢）、`ENERGY`（日预算、跨天恢复、深夜基线、恢复等待）、`BOREDOM`（多久没人说话开始闷、闷得多快）、`COUPLING`（四个情绪互相拉扯的强度）、`DEBT`（熬夜记多少债、上限、多久还清）
 - `lib/events.js` — `DELTA`（各种事件的增量）、`BLAME_RE` / `PRAISE_RE`（关键词）
-- `lib/render.js` — `THRESHOLD`（注入阈值）、`MAX_CHARS`
+- `lib/render.js` — `THRESHOLD`（注入阈值）、`MAX_CHARS`、`EMIT`（一直越界时隔多久重提）
 
-`ENERGY.dailyBudget` 默认 800 万，是按重度使用日的 token 量估的，一次重活掉约 0.07。觉得掉太快就调大。
+`ENERGY.dailyBudget` 默认 1300 万，按 12 天真实用量定的：日均 299 万 token 掉约 0.23，中位日 226 万掉 0.17，峰值日 967 万掉 0.74——一天干活见底，但不会半路清零。觉得掉太快就调大。`COUPLING` 全部设 0 就等于退回「四个数各算各的」。
 
 ## 设计上的几个取舍
 
@@ -105,7 +134,7 @@ dsh plugin --profile desktop add link:$PWD   # Windows: link:D:/path/to/dsh-horm
 ## 测试
 
 ```bash
-npm test              # 33 个用例：衰减、跨天恢复、深夜基线、事件映射、轮次结算、阈值渲染、落盘往返
+npm test              # 52 个用例：衰减、跨天恢复、深夜基线、情绪耦合、睡眠债、无聊涨落、事件映射、轮次结算、阈值渲染、边沿触发、落盘往返
 npm run test:smoke    # 假 ctx 接线冒烟
 ```
 

package/lib/events.js

@@ -8,15 +8,21 @@
 
 import { ENERGY, applyDeltas, nowSec } from './state.js'
 
-/** 每种事件的增量（`applyDeltas` 的第二个参数）。 */
+/**
+ * 每种事件的增量（`applyDeltas` 的第二个参数）。
+ * 0.3.0 整体调低压力、调高缓解：0.2.0 的 +0.15/+0.3 让 cortisol 一两轮就顶到 0.7 以上，
+ * 注入里天天「有点烦」，那不叫敏感，叫吵。
+ */
 export const DELTA = {
-  toolError: { cortisol: 0.15 },
+  toolError: { cortisol: 0.08 },
   /** 连续失败时在 toolError 之上再叠一次。 */
-  repeatedErrors: { cortisol: 0.3 },
-  /** 一轮收尾且没出过错：压力泄掉，爽度上来。 */
-  taskDone: { cortisol: -0.2, dopamine: 0.35 },
-  praised: { dopamine: 0.4 },
-  blamed: { cortisol: 0.25 },
+  repeatedErrors: { cortisol: 0.15 },
+  /** 一轮收尾且没出过错：压力泄掉，爽度上来，也不闷了。 */
+  taskDone: { cortisol: -0.2, dopamine: 0.35, boredom: -0.25 },
+  praised: { dopamine: 0.4, boredom: -0.1 },
+  blamed: { cortisol: 0.12 },
+  /** 真人开口就算陪过了——无聊的主缓解手段。 */
+  userChat: { boredom: -0.3 },
 }
 
 /** 每连续失败几次额外叠一次 repeatedErrors。 */
@@ -88,6 +94,7 @@ export function settleTurn(state, session, now = nowSec()) {
   if (errors === 0) {
     deltas.cortisol = DELTA.taskDone.cortisol
     deltas.dopamine = DELTA.taskDone.dopamine
+    deltas.boredom = DELTA.taskDone.boredom
   }
   const next = applyDeltas(state, deltas, now, errors === 0 ? 'turn-done' : 'turn-end')
   // 先结算再记时间：这轮之前空闲该恢复的已经恢复，从干完这轮起重新计时。
@@ -107,10 +114,20 @@ export function applyEvent(state, event, now = nowSec()) {
       const msg = event.data
       // 只认真人。插件往对话里塞的消息 source.kind 不是 'user'，不能算成用户夸我/骂我。
       if (!msg || msg.source?.kind !== 'user') return null
+      // 真人开口就算有人陪：无聊计时归零，再往下降一截。
+      state.lastUserAt = now
+      const deltas = { boredom: DELTA.userChat.boredom }
+      let why = 'user-chat'
       const tone = detectUserTone(textOfContent(msg.content))
-      if (tone === 'praise') return applyDeltas(state, DELTA.praised, now, 'praised')
-      if (tone === 'blame') return applyDeltas(state, DELTA.blamed, now, 'blamed')
-      return null
+      if (tone === 'praise') {
+        deltas.dopamine = DELTA.praised.dopamine
+        deltas.boredom += DELTA.praised.boredom
+        why = 'praised'
+      } else if (tone === 'blame') {
+        deltas.cortisol = DELTA.blamed.cortisol
+        why = 'blamed'
+      }
+      return applyDeltas(state, deltas, now, why)
     }
 
     case 'tool/result': {

package/lib/index.js

@@ -12,7 +12,7 @@
 import { appendFileSync, mkdirSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { applyEvent, settleTurn } from './events.js'
-import { render } from './render.js'
+import { renderEdge } from './render.js'
 import { loadState, nowSec, project, saveState, stateFile } from './state.js'
 
 export const name = 'dsh-hormone'
@@ -87,7 +87,12 @@ export function apply(ctx) {
       text: () => {
         if (MODE === 'observe') return ''
         try {
-          return render(project(state, nowSec()))
+          // 边沿触发：renderEdge 会写 state.emit 并告诉我们这轮要不要说话、说了什么。
+          // 它改了状态，所以要安排一次落盘，否则下一轮会以为自己没说过。
+          const now = nowSec()
+          const text = renderEdge(state, project(state, now), now)
+          if (text) schedule()
+          return text
         } catch {
           return ''
         }

package/lib/render.js

@@ -1,41 +1,78 @@
 /**
- * dsh-hormone 的渲染层：把三个数翻译成一句人话，塞进系统提示。
+ * dsh-hormone 的渲染层：把四个数翻译成一句人话，塞进系统提示。
  *
  * 规则只有一条：只有越界才写。全都正常就返回空字符串——
  * 不让模型每轮都看见「你现在的激素」，否则它会开始表演情绪。
+ *
+ * 0.4.0 起加了边沿触发（renderEdge）：越界的第一轮说一次，之后一直越界就闭嘴，
+ * 直到状态回到正常再越界、或者静默够久才重提。否则「精力见底」这种长期状态会每轮刷屏。
  */
 
 export const THRESHOLD = {
-  cortisolHigh: 0.7,
+  cortisolHigh: 0.75,
   energyLow: 0.2,
   dopamineHigh: 0.6,
+  boredomHigh: 0.55,
 }
 
-/** 注入文本硬上限（DESIGN 定的 ≤80 字）。 */
-export const MAX_CHARS = 80
+/** 注入文本硬上限（DESIGN 定的 ≤110 字，四条全越界也放得下）。 */
+export const MAX_CHARS = 110
+
+/** 边沿触发：一直越界时，隔多久重新提一次（秒）。 */
+export const EMIT = {
+  rementionAfterSec: 40 * 60,
+}
 
 const fmt = (v) => v.toFixed(2)
 
+const LINES = {
+  cortisol: (v) => `皮质醇 ${fmt(v)}，有点烦，回答收短，别主动揽活。`,
+  energy: (v) => `精力 ${fmt(v)}，见底了，能一句说完就别铺垫。`,
+  dopamine: (v) => `爽度 ${fmt(v)}，心情不错，可以多说两句。`,
+  boredom: (v) => `无聊 ${fmt(v)}，有点闷，可以主动扯两句新鲜事，别干等。`,
+}
+
+/** 现在越界的有哪几项，返回 key 数组（顺序固定，便于比较）。 */
+export function overages(values) {
+  if (!values) return []
+  const keys = []
+  if (values.cortisol > THRESHOLD.cortisolHigh) keys.push('cortisol')
+  if (values.energy < THRESHOLD.energyLow) keys.push('energy')
+  if (values.dopamine > THRESHOLD.dopamineHigh) keys.push('dopamine')
+  if ((values.boredom ?? 0) > THRESHOLD.boredomHigh) keys.push('boredom')
+  return keys
+}
+
 /**
- * @param {{cortisol:number, energy:number, dopamine:number}} values 已投影到当前时刻
+ * @param {{cortisol:number, energy:number, dopamine:number, boredom:number}} values 已投影到当前时刻
+ * @param {string[]} [keys] 只渲染这几项；默认渲染全部越界的
  * @returns {string} 空串表示这轮不注入
  */
-export function render(values) {
+export function render(values, keys = overages(values)) {
   if (!values) return ''
-  const lines = []
-
-  if (values.cortisol > THRESHOLD.cortisolHigh) {
-    lines.push(`皮质醇 ${fmt(values.cortisol)}，有点烦，回答收短，别主动揽活。`)
-  }
-  if (values.energy < THRESHOLD.energyLow) {
-    lines.push(`精力 ${fmt(values.energy)}，见底了，能一句说完就别铺垫。`)
-  }
-  if (values.dopamine > THRESHOLD.dopamineHigh) {
-    lines.push(`爽度 ${fmt(values.dopamine)}，心情不错，可以多说两句。`)
-  }
-
+  const lines = keys.map((k) => LINES[k]?.(values[k])).filter(Boolean)
   if (lines.length === 0) return ''
   const text = `[hormone] ${lines.join(' ')}`
   if (text.length <= MAX_CHARS) return text
   return text.slice(0, MAX_CHARS - 1) + '…'
 }
+
+/**
+ * 边沿触发版：只在「新越界」或「静默够久」时才说话。
+ *
+ * 会写 state.emit（{ active, at }）——这是渲染层唯一的副作用，
+ * 目的是让下一轮知道自己上一轮说过什么。调用方负责落盘。
+ *
+ * @returns {string} 空串表示这轮闭嘴
+ */
+export function renderEdge(state, values, now) {
+  const keys = overages(values)
+  const prev = Array.isArray(state?.emit?.active) ? state.emit.active : []
+  const lastAt = Number.isFinite(state?.emit?.at) ? state.emit.at : 0
+  const fresh = keys.filter((k) => !prev.includes(k))
+  const remention = keys.length > 0 && now - lastAt >= EMIT.rementionAfterSec
+  const speak = fresh.length > 0 || remention
+  const text = speak ? render(values, fresh.length > 0 ? fresh : keys) : ''
+  if (state) state.emit = { active: keys, at: speak ? now : lastAt }
+  return text
+}

package/lib/state.js

@@ -1,9 +1,9 @@
 /**
  * dsh-hormone 的状态层：读/写 state.json、衰减、跨天恢复、原子写。
  *
- * 三个数只是 0–1 的连续变量，没有「情绪标签」。变化只有两个来源：
+ * 四个数只是 0–1 的连续变量，没有「情绪标签」。变化只有两个来源：
  *   1. 事件增量（events.js）；
- *   2. 时间衰减 / 跨天恢复（本文件）。
+ *   2. 时间衰减 / 跨天恢复 / 情绪之间互相拉扯（本文件）。
  * 模型不能改它们（DESIGN 护栏 1）——插件不提供任何写入工具。
  */
 
@@ -11,35 +11,91 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'n
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 
-/** 半衰期（秒）。cortisol 4 小时，dopamine 40 分钟。energy 不走半衰期，见 ENERGY。 */
+/** 半衰期（秒）。cortisol 3 小时，dopamine 40 分钟。energy 不走半衰期，见 ENERGY。 */
 export const HALF_LIFE = {
-  cortisol: 4 * 60 * 60,
+  cortisol: 3 * 60 * 60,
   dopamine: 40 * 60,
 }
 
 export const ENERGY = {
   /**
    * 日预算：一轮的 token 消耗 ÷ 这个数 = energy 扣减量。
-   * 8,000,000 是按 ~/.dsh/.dshw-usage.json 里 2026-10-20~28 的真实日用量估的：
-   * 普通日几十万，重度调试日 427 万 / 966 万。取重度日量级，一次重活掉 ~0.07。
+   * 0.2.0 取 800 万，实测一天就见底；0.3.0 先放到 2500 万，太松（要连干 8 天才见底）；
+   * 0.4.0 按 ~/.dsh/.dshw-usage.json 12 天实测定为 1300 万：
+   * 日均 299 万掉 0.23、中位日 226 万掉 0.17、峰值日 967 万掉 0.74。
    * 觉得掉太快/太慢就改这一个数。
    */
-  dailyBudget: 8_000_000,
+  dailyBudget: 13_000_000,
   /** 跨天恢复：日期变了，energy 至少回升这么多。 */
   dayRecover: 0.8,
   /**
    * 距上次「干活」超过这个时长才缓慢回升（秒）。
    * 只认调过工具的真活：闲聊不刷新这个计时，否则一整天扯淡精力永远涨不回来。
    */
-  idleRecoverAfter: 60 * 60,
-  /** 回升半衰期：向基线靠拢一半所需时间。 */
-  recoverHalfLife: 6 * 60 * 60,
+  idleRecoverAfter: 30 * 60,
+  /** 回升半衰期：向基线靠拢一半所需时间（压力高时会被拉长，见 COUPLING）。 */
+  recoverHalfLife: 4 * 60 * 60,
   /** 白天基线。 */
   dayBaseline: 0.9,
-  /** 深夜基线：23:00–06:00 压低，熬夜不会回满。 */
+  /** 深夜基线：00:00–07:00 压低，熬夜不会回满。 */
   nightBaseline: 0.45,
-  nightFrom: 23,
-  nightTo: 6,
+  nightFrom: 0,
+  nightTo: 7,
+}
+
+/**
+ * 睡眠债：深夜还干活，第二天精力上限打折。
+ * 记债时刻起 24 小时内线性衰减——睡一觉就还清，连续熬夜会累加（有上限）。
+ */
+export const DEBT = {
+  /** 深夜窗口内每扣掉 1 点精力，记多少债。 */
+  ratio: 1.3,
+  /** 债的上限：第二天精力最多打这个折。 */
+  max: 0.4,
+  /** 从记债时刻起，多少小时内衰减到 0。 */
+  decayHours: 24,
+}
+
+/**
+ * 无聊：没人跟它说话就慢慢闷起来，真人一开口就缓解（DELTA.userChat）。
+ * 计时源是 lastUserAt，不是 updatedAt——我自己干活刷新的时间不算「有人陪」。
+ */
+export const BOREDOM = {
+  /** 多久没人说话才开始闷（秒）。 */
+  grace: 25 * 60,
+  /** 之后向 1 靠拢的半衰期。 */
+  riseHalfLife: 5 * 60 * 60,
+  /** 初始值。 */
+  start: 0.05,
+}
+
+/**
+ * 情绪耦合：四个变量不是各算各的。
+ * 越开心越不累、越开心压力散得越快、压力越大恢复越慢。
+ */
+export const COUPLING = {
+  /** 精力扣减放大：cortisol=1 时消耗 ×(1+0.4)。 */
+  stressCost: 0.4,
+  /** 精力扣减缩小：按 √dopamine 算，dopamine=1 时消耗 ×(1-0.5)，d=0.3 时已经省 27%。 */
+  joyCost: 0.5,
+  /** 开心让压力散得快：有效半衰期 ×(1-0.35×dopamine)，最快缩短 35%。 */
+  joyDecay: 0.35,
+  /** 压力让精力回得慢：有效恢复半衰期 ×(1+1.5×cortisol)，最慢拉到 2.5 倍。 */
+  stressRecover: 1.5,
+}
+
+/**
+ * 精力扣减系数：压力往上推，爽度往下压，夹在 0.4–2.5 之间。
+ *
+ * 爽度那一条用 √ 而不是线性：为了「中等开心就已经省得明显」——
+ * 线性省的话 dopamine=0.3 才省 15%，几乎感觉不到；开方后是 27%。
+ * 极端值仍然封在 −50% / +40%，不会因为一时兴奋或烦躁把一项工作算成两个。
+ */
+export function energyCostScale(values) {
+  const cortisol = clamp01(values?.cortisol ?? 0)
+  const dopamine = clamp01(values?.dopamine ?? 0)
+  const scale = 1 + COUPLING.stressCost * cortisol - COUPLING.joyCost * Math.sqrt(dopamine)
+  return Math.min(2.5, Math.max(0.4, scale))
 }
 
 /** history 上限。只用于验收时看曲线，不参与任何计算。 */
@@ -61,9 +117,9 @@ export function decayValue(v, halfLifeSec, dtSec) {
   return clamp01(v * Math.pow(0.5, dtSec / halfLifeSec))
 }
 
-/** 本地小时对应的 energy 基线。 */
+/** 本地小时对应的 energy 基线。注意 0–7 这个窗口不跨午夜，用 && 判。 */
 export function baselineEnergy(hour) {
-  const night = hour >= ENERGY.nightFrom || hour < ENERGY.nightTo
+  const night = hour >= ENERGY.nightFrom && hour < ENERGY.nightTo
   return night ? ENERGY.nightBaseline : ENERGY.dayBaseline
 }
 
@@ -79,7 +135,7 @@ export function nowSec() {
 }
 
 export function freshValues() {
-  return { cortisol: 0.2, energy: ENERGY.dayBaseline, dopamine: 0.1 }
+  return { cortisol: 0.2, energy: ENERGY.dayBaseline, dopamine: 0.1, boredom: BOREDOM.start }
 }
 
 export function freshState(now = nowSec()) {
@@ -89,20 +145,46 @@ export function freshState(now = nowSec()) {
     day: localDay(now),
     /** 上次真正干活的时刻。精力恢复从这时计时，不随闲聊刷新。 */
     lastWorkAt: now,
+    /** 上次真人说话的时刻。无聊从这时计时。 */
+    lastUserAt: now,
+    /** 睡眠债：{ amount, at }。at 是记债时刻，从那时起 24 小时线性衰减到 0。 */
+    debt: { amount: 0, at: now },
+    /** 注入边沿触发用：上一轮越界的是哪几项、上次说话的时刻。 */
+    emit: { active: [], at: 0 },
     values: freshValues(),
     session: { turn: null, tokensInTurn: 0, toolsInTurn: 0, errorsInTurn: 0, consecutiveErrors: 0 },
     history: [],
   }
 }
 
+/** 现在还剩多少睡眠债（0–DEBT.max）。纯函数，靠绝对时间算，反复调用结果一致。 */
+export function effectiveDebt(state, now = nowSec()) {
+  const amount = Number(state?.debt?.amount)
+  const at = state?.debt?.at
+  if (!(amount > 0) || !Number.isFinite(at)) return 0
+  const passed = Math.max(0, now - at)
+  const left = 1 - passed / (DEBT.decayHours * 60 * 60)
+  if (left <= 0) return 0
+  return Math.min(DEBT.max, amount * left)
+}
+
+/** 一次「向目标靠拢」：从 base 出发，过了 sec 秒，靠拢了多少。 */
+function approach(base, target, sec, halfLife) {
+  if (!(sec > 0) || !(halfLife > 0)) return clamp01(base)
+  return clamp01(base + (target - base) * (1 - Math.pow(0.5, sec / halfLife)))
+}
+
 /**
  * 从 updatedAt 投影到现在。纯函数：不改 state、不落盘。
  * 渲染和「加增量」都用它打底，所以衰减不会被重复叠加。
+ * 依赖时长的几项只算「上次写盘之后新增的那一段」，反复调用结果一致。
  */
 export function project(state, now = nowSec()) {
   const dt = Math.max(0, now - state.updatedAt)
   const hour = new Date(now * 1000).getHours()
   const values = state.values ?? freshValues()
+  const cortisol0 = clamp01(values.cortisol)
+  const dopamine0 = clamp01(values.dopamine)
   let energy = clamp01(values.energy)
 
   // 1. 跨天：日期变了就回升一大截（模拟睡了一觉）。
@@ -112,20 +194,42 @@ export function project(state, now = nowSec()) {
 
   // 2. 长时间没干活：向「当前时段」的基线靠拢。
   //    不是加满——深夜的基线本来就低，熬夜补不回来。
-  //    计时只认 lastWorkAt（上一轮真正干活的时刻），闲聊不推迟恢复；
-  //    老状态文件没有这个字段就退回 updatedAt。
+  //    压力大时恢复变慢（COUPLING.stressRecover）。
+  //    计时只认 lastWorkAt（上一轮真正干活的时刻），闲聊不推迟恢复。
+  //    睡眠债会压低上限：熬夜后的第二天，回也回不到满。
+  const debt = effectiveDebt(state, now)
+  const ceiling = 1 - debt
   const lastWork = Number.isFinite(state.lastWorkAt) ? state.lastWorkAt : state.updatedAt
   const idle = Math.max(0, now - lastWork)
-  if (idle > ENERGY.idleRecoverAfter) {
-    const over = idle - ENERGY.idleRecoverAfter
-    const target = baselineEnergy(hour)
-    energy = clamp01(energy + (target - energy) * (1 - Math.pow(0.5, over / ENERGY.recoverHalfLife)))
+  const idleBefore = Math.max(0, state.updatedAt - lastWork)
+  const recoverSec = Math.max(0, idle - Math.max(idleBefore, ENERGY.idleRecoverAfter))
+  if (recoverSec > 0) {
+    const halfLife = ENERGY.recoverHalfLife * (1 + COUPLING.stressRecover * cortisol0)
+    energy = approach(energy, Math.min(baselineEnergy(hour), ceiling), recoverSec, halfLife)
   }
+  energy = Math.min(energy, ceiling)
+
+  // 3. 无聊：从「上次真人说话」起算，过了宽限期慢慢向 1 靠拢。
+  //    同样只算上次写盘之后新增的那一段，避免每次结算重复叠加。
+  const lastUser = Number.isFinite(state.lastUserAt) ? state.lastUserAt : state.updatedAt
+  const quiet = Math.max(0, now - lastUser)
+  const quietBefore = Math.max(0, state.updatedAt - lastUser)
+  const boredSec = Math.max(0, quiet - Math.max(quietBefore, BOREDOM.grace))
+  const boredom = approach(
+    clamp01(values.boredom ?? BOREDOM.start),
+    1,
+    boredSec,
+    BOREDOM.riseHalfLife,
+  )
+
+  // 4. 开心的时候压力散得更快：有效半衰期最短缩到 65%。
+  const cortisolHalfLife = HALF_LIFE.cortisol * (1 - COUPLING.joyDecay * dopamine0)
 
   return {
-    cortisol: decayValue(values.cortisol, HALF_LIFE.cortisol, dt),
+    cortisol: decayValue(cortisol0, cortisolHalfLife, dt),
     energy,
-    dopamine: decayValue(values.dopamine, HALF_LIFE.dopamine, dt),
+    dopamine: decayValue(dopamine0, HALF_LIFE.dopamine, dt),
+    boredom,
   }
 }
 
@@ -139,7 +243,10 @@ function pushHistory(state, now, why) {
     cortisol: round3(state.values.cortisol),
     energy: round3(state.values.energy),
     dopamine: round3(state.values.dopamine),
+    boredom: round3(state.values.boredom),
   }
+  const debt = effectiveDebt(state, now)
+  if (debt > 0) row.debt = round3(debt)
   if (why) row.why = why
   state.history.push(row)
   if (state.history.length > MAX_HISTORY) {
@@ -150,19 +257,36 @@ function pushHistory(state, now, why) {
 /**
  * 先投影到现在，再加增量，写回 state（含 updatedAt / day / history）。
  * 返回 state 本身，方便链式调用。
+ *
+ * 扣精力的增量要乘 energyCostScale：同样一活儿，烦的时候更累，心情好的时候没那么累
+ * ——这就是「情绪互相影响」落到行为上的那一步。
  */
 export function applyDeltas(state, deltas, now = nowSec(), why = '') {
   const projected = project(state, now)
   const before = state.values ?? freshValues()
+  let energyDelta = deltas?.energy ?? 0
+  if (energyDelta < 0) {
+    energyDelta *= energyCostScale(projected)
+    // 深夜（00:00–07:00）还在干活：记一笔睡眠债，第二天精力上限打折。
+    // 注意是 &&：0–7 这个窗口不跨午夜，写成 || 会让全天都算深夜。
+    const hour = new Date(now * 1000).getHours()
+    if (hour >= ENERGY.nightFrom && hour < ENERGY.nightTo) {
+      const owed = effectiveDebt(state, now)
+      state.debt = { amount: Math.min(DEBT.max, owed - energyDelta * DEBT.ratio), at: now }
+    }
+  }
+  const ceiling = 1 - effectiveDebt(state, now)
   const next = {
     cortisol: clamp01(projected.cortisol + (deltas?.cortisol ?? 0)),
-    energy: clamp01(projected.energy + (deltas?.energy ?? 0)),
+    energy: Math.min(clamp01(projected.energy + energyDelta), ceiling),
     dopamine: clamp01(projected.dopamine + (deltas?.dopamine ?? 0)),
+    boredom: clamp01(projected.boredom + (deltas?.boredom ?? 0)),
   }
   const moved =
     Math.abs(next.cortisol - before.cortisol) +
     Math.abs(next.energy - before.energy) +
-    Math.abs(next.dopamine - before.dopamine)
+    Math.abs(next.dopamine - before.dopamine) +
+    Math.abs(next.boredom - (before.boredom ?? 0))
 
   state.values = next
   state.updatedAt = now
@@ -200,10 +324,25 @@ export function loadState() {
     day: typeof raw.day === 'string' && raw.day !== '' ? raw.day : base.day,
     // 老状态没有 lastWorkAt：用最后更新时间兜底，别让恢复计时从 0 开始。
     lastWorkAt: asFiniteOr(raw.lastWorkAt, base.updatedAt),
+    // 老状态没有 lastUserAt：同上，别让无聊从 1970 年算起、一加载就顶满。
+    lastUserAt: asFiniteOr(raw.lastUserAt, base.updatedAt),
+    // 老状态没有睡眠债：从 0 开始，别让一次升级就顶着打折的上限。
+    debt: {
+      amount: clamp01(asFiniteOr(raw.debt?.amount, 0)),
+      at: asFiniteOr(raw.debt?.at, base.updatedAt),
+    },
+    // 老状态没有 emit：当作「还没说过」，下一次越界会正常说一句。
+    emit: {
+      active: Array.isArray(raw.emit?.active)
+        ? raw.emit.active.filter((k) => typeof k === 'string')
+        : [],
+      at: asFiniteOr(raw.emit?.at, 0),
+    },
     values: {
       cortisol: clamp01(asFiniteOr(v.cortisol, base.values.cortisol)),
       energy: clamp01(asFiniteOr(v.energy, base.values.energy)),
       dopamine: clamp01(asFiniteOr(v.dopamine, base.values.dopamine)),
+      boredom: clamp01(asFiniteOr(v.boredom, base.values.boredom)),
     },
     session: {
       turn: Number.isFinite(s.turn) ? s.turn : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-hormone",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Hormone state for DSH agents: a few continuously changing, time-decaying values driven by real session events, written into the system prompt only when they go out of range.",
   "keywords": [
     "dsh",