dsh-hormone 0.0.0-stage → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 y258dd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# dsh-hormone
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+给 [DSH](https://github.com/deepseek-ai)（DeepSeek Harness）的助手装一套「激素」：四个连续变化的数值，按事件涨落、随时间衰减、彼此还会互相拉扯，**只在越界时**往系统提示里写一句话。
+
+不是给模型贴情绪标签，是给它一组真的会变的内部状态。
+
+> 状态：`0.4.0`，注入层已跑通，门控层未做。只用 DSH 的公开插件 API，不修改任何其他插件的数据，不联网。
+
+## 它是什么
+
+| 状态 | 什么时候涨 | 什么时候降 | 半衰期 |
+|---|---|---|---|
+| `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.75` → 回答收短，不主动揽活
+- `energy < 0.2` → 能一句说完就别铺垫
+- `dopamine > 0.6` → 可以多说两句
+- `boredom > 0.55` → 有点闷，可以主动扯两句
+
+注入文本硬上限 110 字，带 `[hormone]` 前缀，每轮最多一条。
+
+而且是**边沿触发**：越界的第一轮说一次，之后一直越界就闭嘴，直到恢复正常后再次越界；一直不恢复的话，静默 40 分钟才重提一次（`EMIT.rementionAfterSec`）。否则「精力见底」这种长期状态会每轮刷一遍，把这一句话变成噪音。
+
+**没有做门控**（比如硬压输出长度）。门控是分水岭：注入只是「告诉它现在什么状态」，门控是「替它决定能说多少」。第一版先把状态跑准，跑两天曲线不极端了再谈门控。
+
+也没有做记忆权重（`emotion` 字段）。那要改 memory-lite 的写入格式，是另一件事。
+
+## 装
+
+```bash
+dsh plugin --profile desktop add dsh-hormone
+```
+
+不想走 npm 的话，直接从 GitHub 装也行：
+
+```bash
+dsh plugin --profile desktop add github:y258dd/dsh-hormone
+```
+
+改代码想热重载时，克隆下来用 link 装：
+
+```bash
+git clone https://github.com/y258dd/dsh-hormone.git
+cd dsh-hormone
+dsh plugin --profile desktop add link:$PWD   # Windows: link:D:/path/to/dsh-hormone
+```
+
+或者手改 `~/.dsh/profiles/desktop/package.json`：
+
+```json
+{
+  "dependencies": { "dsh-hormone": "link:/path/to/dsh-hormone" },
+  "dsh": { "profile": { "bundles": ["dsh-hormone"] } }
+}
+```
+
+装完重启 DSH 生效。
+
+## 看它在干什么
+
+状态文件：`%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` / `user-chat`），有睡眠债时多一个 `debt` 字段，想验收「跑两天曲线有没有起伏」直接看这个。
+
+删掉这个文件 = 回到初始状态，不会有副作用。
+
+## 环境变量
+
+| 变量 | 作用 |
+|---|---|
+| `DSH_HORMONE_MODE=observe` | 只记状态，不注入。想先观察几天、不想它影响回答时用。 |
+| `DSH_HORMONE_DEBUG=1` | 把每个会话事件的摘要追加到 `%DSH_HOME%\hormone\events.jsonl`，用来核对事件结构。 |
+
+## 调参
+
+三个文件顶部，改完重启：
+
+- `lib/state.js` — `HALF_LIFE`（衰减快慢）、`ENERGY`（日预算、跨天恢复、深夜基线、恢复等待）、`BOREDOM`（多久没人说话开始闷、闷得多快）、`COUPLING`（四个情绪互相拉扯的强度）、`DEBT`（熬夜记多少债、上限、多久还清）
+- `lib/events.js` — `DELTA`（各种事件的增量）、`BLAME_RE` / `PRAISE_RE`（关键词）
+- `lib/render.js` — `THRESHOLD`（注入阈值）、`MAX_CHARS`、`EMIT`（一直越界时隔多久重提）
+
+`ENERGY.dailyBudget` 默认 1300 万，按 12 天真实用量定的：日均 299 万 token 掉约 0.23，中位日 226 万掉 0.17，峰值日 967 万掉 0.74——一天干活见底，但不会半路清零。觉得掉太快就调大。`COUPLING` 全部设 0 就等于退回「四个数各算各的」。
+
+## 设计上的几个取舍
+
+**状态只能被事件改，模型改不了。** 插件不提供任何写入工具。一旦模型能自己调「我心情不好」，这套东西就退化成摇骰子——它想演什么就调什么。
+
+**关键词匹配，不是理解。** 判断「被夸/被批评」用的是正则，会漏判也会误判。所以批评优先于夸奖：误判成被夸会让爽度虚假上涨，比漏掉一次更坏。实测不灵就改 `events.js` 里的正则。
+
+**turn 边界靠 `assistant/message` 的 `turn` 号变化检测。** DSH 没有 `turn/start` / `turn/end` 事件。最后一轮在插件卸载时兜底结算。
+
+**只认真人说的话。** `user/message` 里 `source.kind === 'user'` 才算数，插件自己注入的消息一律忽略——不然 memory-lite 塞进去的上下文会莫名其妙把爽度顶满。
+
+**不联网、不写凭据。** 唯一的外部 IO 是 `%DSH_HOME%\hormone\` 下两个 JSON/JSONL 文件。
+
+设计取舍与事件字段的来龙去脉见 [docs/DESIGN.md](docs/DESIGN.md)。
+
+## 关掉它
+
+`dsh plugin --profile desktop remove dsh-hormone`，或者从 bundles 里删掉那一行。关掉之后一切照旧——它不修改任何其他插件的数据，只是每轮往系统提示里多写一句话（或者不写）。
+
+## 测试
+
+```bash
+npm test              # 52 个用例：衰减、跨天恢复、深夜基线、情绪耦合、睡眠债、无聊涨落、事件映射、轮次结算、阈值渲染、边沿触发、落盘往返
+npm run test:smoke    # 假 ctx 接线冒烟
+```
+
+不需要第三方依赖，Node 20+ 直接跑。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# dsh-hormone — DSH bundle patch
+#
+# 装法（装完重启 DSH）：
+#   dsh plugin --profile desktop add link:D:/DSH/dsh-hormone
+#
+# 数据落在 %DSH_HOME%\hormone\state.json，纯文本，随时能打开看、能删。
+# 想只记不注入：设环境变量 DSH_HORMONE_MODE=observe 再启动。
+# 想抓一轮真实事件结构：设 DSH_HORMONE_DEBUG=1，事件会追加到 %DSH_HOME%\hormone\events.jsonl。
+- insert:
+    - id: dsh-hormone
+      name: dsh-hormone

package/lib/events.js

@@ -0,0 +1,165 @@
+/**
+ * dsh-hormone 的事件层：把 DSH 会话事件翻译成激素增量。
+ *
+ * 全部是关键词匹配，不是「理解」——宁可漏判，不要误判：
+ * 误判成「被夸」会让爽度虚假上涨，比漏判更坏。
+ * 实测不灵就改这里的 DELTA 和正则，别改 index.js。
+ */
+
+import { ENERGY, applyDeltas, nowSec } from './state.js'
+
+/**
+ * 每种事件的增量（`applyDeltas` 的第二个参数）。
+ * 0.3.0 整体调低压力、调高缓解：0.2.0 的 +0.15/+0.3 让 cortisol 一两轮就顶到 0.7 以上，
+ * 注入里天天「有点烦」，那不叫敏感，叫吵。
+ */
+export const DELTA = {
+  toolError: { cortisol: 0.08 },
+  /** 连续失败时在 toolError 之上再叠一次。 */
+  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。 */
+export const REPEATED_ERROR_EVERY = 3
+
+/** 先判批评再判夸奖：宁可漏掉一次爽度，也不要把骂当成夸。 */
+const BLAME_RE =
+  /(又错|错了|不对|搞错|弄错|理解错|搞砸|不是这个|怎么又|说了多少遍|你能不能认真|别瞎猜|没用啊|不行啊)/
+
+const PRAISE_RE =
+  /(好棒|太棒|好厉害|厉害了|不错|牛逼|牛啊|超赞|靠谱|辛苦了|谢谢|感谢|喜欢你|爱你|漂亮|乖)/
+
+/** 返回 'blame' | 'praise' | null。 */
+export function detectUserTone(text) {
+  const t = typeof text === 'string' ? text : ''
+  if (t === '') return null
+  if (BLAME_RE.test(t)) return 'blame'
+  if (PRAISE_RE.test(t)) return 'praise'
+  return null
+}
+
+/** message.content 可能是字符串，也可能是 [{type:'text', text}] 块数组。 */
+export function textOfContent(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  const out = []
+  for (const part of content) {
+    if (typeof part === 'string') out.push(part)
+    else if (part && part.type === 'text' && typeof part.text === 'string') out.push(part.text)
+  }
+  return out.join('\n')
+}
+
+function num(v) {
+  const n = typeof v === 'string' ? Number(v) : v
+  return Number.isFinite(n) && n > 0 ? n : 0
+}
+
+/** usage 的字段可能是字符串（dsh-context 里也是先 Number 化）。 */
+export function tokensOf(usage) {
+  if (!usage || typeof usage !== 'object') return 0
+  return (
+    num(usage.inputTokens) +
+    num(usage.cacheReadTokens) +
+    num(usage.cacheWriteTokens) +
+    num(usage.outputTokens)
+  )
+}
+
+/**
+ * 结算「当前这一轮」：扣精力，没出过错就奖励。
+ * 调用方负责把 session 的当前轮标记清掉。
+ */
+export function settleTurn(state, session, now = nowSec()) {
+  if (session.turn === null || session.turn === undefined) return null
+  const tokens = num(session.tokensInTurn)
+  const tools = num(session.toolsInTurn)
+  const errors = num(session.errorsInTurn)
+  session.turn = null
+  session.tokensInTurn = 0
+  session.toolsInTurn = 0
+  session.errorsInTurn = 0
+
+  // 「干活」的判据是本轮有没有工具调用。纯聊天一轮也能吃几万 token，
+  // 按 token 扣精力等于把闲聊当重活；没调工具就既不扣精力，也不给收尾奖励。
+  if (tools === 0) return null
+
+  const deltas = { energy: -tokens / ENERGY.dailyBudget }
+  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')
+  // 先结算再记时间：这轮之前空闲该恢复的已经恢复，从干完这轮起重新计时。
+  state.lastWorkAt = now
+  return next
+}
+
+/**
+ * 纯函数：吃一个事件，可能改 state。
+ * 返回 state 表示「有变化、该落盘」，返回 null 表示无视。
+ */
+export function applyEvent(state, event, now = nowSec()) {
+  const session = state.session
+
+  switch (event?.type) {
+    case 'user/message': {
+      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') {
+        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': {
+      // 有工具返回就说明这轮在真干活，成功失败都算——区分闲聊的唯一依据。
+      session.toolsInTurn = num(session.toolsInTurn) + 1
+      const isError = event.data?.message?.isError === true
+      if (!isError) {
+        session.consecutiveErrors = 0
+        return null
+      }
+      session.consecutiveErrors = num(session.consecutiveErrors) + 1
+      session.errorsInTurn = num(session.errorsInTurn) + 1
+      const repeated = session.consecutiveErrors % REPEATED_ERROR_EVERY === 0
+      const deltas = { cortisol: DELTA.toolError.cortisol }
+      if (repeated) deltas.cortisol += DELTA.repeatedErrors.cortisol
+      return applyDeltas(state, deltas, now, repeated ? 'errors-3' : 'tool-error')
+    }
+
+    case 'assistant/message': {
+      const data = event.data
+      const turn = typeof data?.turn === 'number' ? data.turn : null
+      let changed = null
+      // turn 号一变，说明上一轮已经结束：先把上一轮结算掉。
+      if (turn !== null && session.turn !== null && turn !== session.turn) {
+        changed = settleTurn(state, session, now)
+      }
+      if (turn !== null) session.turn = turn
+      session.tokensInTurn = num(session.tokensInTurn) + tokensOf(data?.usage)
+      return changed
+    }
+
+    default:
+      return null
+  }
+}

package/lib/index.js

@@ -0,0 +1,120 @@
+/**
+ * dsh-hormone — DSH 插件入口。
+ *
+ * 职责只有三件：订阅会话事件、把状态写盘、把越界的激素注入系统提示。
+ * 所有「激素怎么变」的逻辑在 state.js / events.js / render.js，本文件不做判断。
+ *
+ * 环境变量：
+ *   DSH_HORMONE_MODE=observe  只记状态，不注入（想先看着跑几天时用）
+ *   DSH_HORMONE_DEBUG=1       把事件摘要追加到 %DSH_HOME%/hormone/events.jsonl
+ */
+
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { applyEvent, settleTurn } from './events.js'
+import { renderEdge } from './render.js'
+import { loadState, nowSec, project, saveState, stateFile } from './state.js'
+
+export const name = 'dsh-hormone'
+
+/** 需要 systemPrompt 服务才能注入；没有就退化成只记状态。 */
+export const inject = ['systemPrompt']
+
+const MODE = process.env.DSH_HORMONE_MODE === 'observe' ? 'observe' : 'inject'
+const DEBUG = process.env.DSH_HORMONE_DEBUG === '1'
+
+/** 写盘节流：事件可能一秒来好几个，攒一下再写。 */
+const FLUSH_MS = 800
+
+function debugLog(session, event) {
+  if (!DEBUG) return
+  try {
+    const dir = dirname(stateFile())
+    mkdirSync(dir, { recursive: true })
+    const data = event?.data ?? {}
+    const row = {
+      t: new Date().toISOString(),
+      session: session?.id ?? session?.sessionId ?? null,
+      type: event?.type ?? null,
+      turn: data.turn ?? null,
+      step: data.step ?? null,
+      usage: data.usage ?? null,
+      isError: data.message?.isError ?? null,
+      sourceKind: data.source?.kind ?? data.message?.source?.kind ?? null,
+    }
+    appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(row) + '\n', 'utf8')
+  } catch {
+    /* 调试日志写不进去不影响主逻辑 */
+  }
+}
+
+export function apply(ctx) {
+  let state = loadState()
+  let timer = null
+
+  const flush = () => {
+    timer = null
+    try {
+      saveState(state)
+    } catch (error) {
+      console.error('[hormone] 状态写入失败:', error?.message ?? error)
+    }
+  }
+
+  const schedule = () => {
+    if (timer !== null) return
+    timer = setTimeout(flush, FLUSH_MS)
+    if (typeof timer.unref === 'function') timer.unref()
+  }
+
+  try {
+    ctx.on('session/event', (session, event) => {
+      try {
+        debugLog(session, event)
+        if (applyEvent(state, event, nowSec()) !== null) schedule()
+      } catch (error) {
+        console.error('[hormone] 事件处理失败:', error?.message ?? error)
+      }
+    })
+  } catch (error) {
+    console.error('[hormone] 无法订阅 session/event，激素将不更新:', error?.message ?? error)
+  }
+
+  try {
+    ctx.systemPrompt.context({
+      name: 'dsh-hormone',
+      order: 21,
+      text: () => {
+        if (MODE === 'observe') return ''
+        try {
+          // 边沿触发：renderEdge 会写 state.emit 并告诉我们这轮要不要说话、说了什么。
+          // 它改了状态，所以要安排一次落盘，否则下一轮会以为自己没说过。
+          const now = nowSec()
+          const text = renderEdge(state, project(state, now), now)
+          if (text) schedule()
+          return text
+        } catch {
+          return ''
+        }
+      },
+    })
+  } catch (error) {
+    console.error('[hormone] 无法注册注入，退化为只记状态:', error?.message ?? error)
+  }
+
+  // 插件卸载 / DSH 退出：把最后一轮结算掉，再把状态落盘。
+  ctx.effect(() => () => {
+    try {
+      settleTurn(state, state.session, nowSec())
+    } catch {
+      /* 结算失败也要继续落盘 */
+    }
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+    flush()
+  })
+
+  if (DEBUG) console.log('[hormone] 已启动，模式:', MODE, '状态文件:', stateFile())
+}

package/lib/render.js

@@ -0,0 +1,78 @@
+/**
+ * dsh-hormone 的渲染层：把四个数翻译成一句人话，塞进系统提示。
+ *
+ * 规则只有一条：只有越界才写。全都正常就返回空字符串——
+ * 不让模型每轮都看见「你现在的激素」，否则它会开始表演情绪。
+ *
+ * 0.4.0 起加了边沿触发（renderEdge）：越界的第一轮说一次，之后一直越界就闭嘴，
+ * 直到状态回到正常再越界、或者静默够久才重提。否则「精力见底」这种长期状态会每轮刷屏。
+ */
+
+export const THRESHOLD = {
+  cortisolHigh: 0.75,
+  energyLow: 0.2,
+  dopamineHigh: 0.6,
+  boredomHigh: 0.55,
+}
+
+/** 注入文本硬上限（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, boredom:number}} values 已投影到当前时刻
+ * @param {string[]} [keys] 只渲染这几项；默认渲染全部越界的
+ * @returns {string} 空串表示这轮不注入
+ */
+export function render(values, keys = overages(values)) {
+  if (!values) return ''
+  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

@@ -0,0 +1,373 @@
+/**
+ * dsh-hormone 的状态层：读/写 state.json、衰减、跨天恢复、原子写。
+ *
+ * 四个数只是 0–1 的连续变量，没有「情绪标签」。变化只有两个来源：
+ *   1. 事件增量（events.js）；
+ *   2. 时间衰减 / 跨天恢复 / 情绪之间互相拉扯（本文件）。
+ * 模型不能改它们（DESIGN 护栏 1）——插件不提供任何写入工具。
+ */
+
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+/** 半衰期（秒）。cortisol 3 小时，dopamine 40 分钟。energy 不走半衰期，见 ENERGY。 */
+export const HALF_LIFE = {
+  cortisol: 3 * 60 * 60,
+  dopamine: 40 * 60,
+}
+
+export const ENERGY = {
+  /**
+   * 日预算：一轮的 token 消耗 ÷ 这个数 = energy 扣减量。
+   * 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: 13_000_000,
+  /** 跨天恢复：日期变了，energy 至少回升这么多。 */
+  dayRecover: 0.8,
+  /**
+   * 距上次「干活」超过这个时长才缓慢回升（秒）。
+   * 只认调过工具的真活：闲聊不刷新这个计时，否则一整天扯淡精力永远涨不回来。
+   */
+  idleRecoverAfter: 30 * 60,
+  /** 回升半衰期：向基线靠拢一半所需时间（压力高时会被拉长，见 COUPLING）。 */
+  recoverHalfLife: 4 * 60 * 60,
+  /** 白天基线。 */
+  dayBaseline: 0.9,
+  /** 深夜基线：00:00–07:00 压低，熬夜不会回满。 */
+  nightBaseline: 0.45,
+  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 上限。只用于验收时看曲线，不参与任何计算。 */
+export const MAX_HISTORY = 400
+
+/** history 只在累计变化超过这个量时才记一条，避免刷盘噪音。 */
+const HISTORY_MIN_MOVE = 0.02
+
+export function clamp01(v) {
+  if (!Number.isFinite(v)) return 0
+  if (v < 0) return 0
+  if (v > 1) return 1
+  return v
+}
+
+/** 半衰期衰减：过了 dt 秒，剩 v × 0.5^(dt / 半衰期)。 */
+export function decayValue(v, halfLifeSec, dtSec) {
+  if (!(dtSec > 0) || !(halfLifeSec > 0)) return clamp01(v)
+  return clamp01(v * Math.pow(0.5, dtSec / halfLifeSec))
+}
+
+/** 本地小时对应的 energy 基线。注意 0–7 这个窗口不跨午夜，用 && 判。 */
+export function baselineEnergy(hour) {
+  const night = hour >= ENERGY.nightFrom && hour < ENERGY.nightTo
+  return night ? ENERGY.nightBaseline : ENERGY.dayBaseline
+}
+
+export function localDay(nowSec) {
+  const d = new Date(nowSec * 1000)
+  const m = String(d.getMonth() + 1).padStart(2, '0')
+  const day = String(d.getDate()).padStart(2, '0')
+  return `${d.getFullYear()}-${m}-${day}`
+}
+
+export function nowSec() {
+  return Math.floor(Date.now() / 1000)
+}
+
+export function freshValues() {
+  return { cortisol: 0.2, energy: ENERGY.dayBaseline, dopamine: 0.1, boredom: BOREDOM.start }
+}
+
+export function freshState(now = nowSec()) {
+  return {
+    version: 1,
+    updatedAt: now,
+    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. 跨天：日期变了就回升一大截（模拟睡了一觉）。
+  if (state.day && state.day !== localDay(now)) {
+    energy = clamp01(energy + ENERGY.dayRecover)
+  }
+
+  // 2. 长时间没干活：向「当前时段」的基线靠拢。
+  //    不是加满——深夜的基线本来就低，熬夜补不回来。
+  //    压力大时恢复变慢（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)
+  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(cortisol0, cortisolHalfLife, dt),
+    energy,
+    dopamine: decayValue(dopamine0, HALF_LIFE.dopamine, dt),
+    boredom,
+  }
+}
+
+function round3(v) {
+  return Math.round(clamp01(v) * 1000) / 1000
+}
+
+function pushHistory(state, now, why) {
+  const row = {
+    t: now,
+    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) {
+    state.history.splice(0, state.history.length - MAX_HISTORY)
+  }
+}
+
+/**
+ * 先投影到现在，再加增量，写回 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: 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.boredom - (before.boredom ?? 0))
+
+  state.values = next
+  state.updatedAt = now
+  state.day = localDay(now)
+  if (moved >= HISTORY_MIN_MOVE) pushHistory(state, now, why)
+  return state
+}
+
+// ── 存储 ──────────────────────────────────────────────────────────────
+export function stateFile() {
+  const home = process.env.DSH_HOME || join(homedir(), '.dsh')
+  return join(home, 'hormone', 'state.json')
+}
+
+function asFiniteOr(v, fallback) {
+  return Number.isFinite(v) ? v : fallback
+}
+
+/** 读盘。坏文件、旧版本、缺字段一律回退到默认值，不让插件因为脏数据起不来。 */
+export function loadState() {
+  let raw
+  try {
+    raw = JSON.parse(readFileSync(stateFile(), 'utf8'))
+  } catch {
+    return freshState()
+  }
+  if (!raw || typeof raw !== 'object' || raw.version !== 1) return freshState()
+
+  const base = freshState(asFiniteOr(raw.updatedAt, nowSec()))
+  const v = raw.values ?? {}
+  const s = raw.session ?? {}
+  const state = {
+    version: 1,
+    updatedAt: base.updatedAt,
+    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,
+      tokensInTurn: asFiniteOr(s.tokensInTurn, 0),
+      toolsInTurn: asFiniteOr(s.toolsInTurn, 0),
+      errorsInTurn: asFiniteOr(s.errorsInTurn, 0),
+      consecutiveErrors: asFiniteOr(s.consecutiveErrors, 0),
+    },
+    history: Array.isArray(raw.history)
+      ? raw.history.filter((row) => row && Number.isFinite(row.t)).slice(-MAX_HISTORY)
+      : [],
+  }
+  return state
+}
+
+/** 临时文件 + rename 原子写；权限尽量压到 600（Windows 上 chmod 是 no-op，忽略）。 */
+export function saveState(state) {
+  const file = stateFile()
+  mkdirSync(dirname(file), { recursive: true })
+  const tmp = file + '.tmp'
+  writeFileSync(tmp, JSON.stringify(state), 'utf8')
+  renameSync(tmp, file)
+  try {
+    chmodSync(file, 0o600)
+  } catch {
+    /* Windows 上不支持，无所谓 */
+  }
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "dsh-hormone",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "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",
+    "dsh-plugin",
+    "deepseek-harness",
+    "hormone",
+    "mood",
+    "system-prompt"
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node tests/test.mjs",
+    "test:smoke": "node tests/smoke.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/y258dd/dsh-hormone.git"
+  },
+  "bugs": {
+    "url": "https://github.com/y258dd/dsh-hormone/issues"
+  },
+  "homepage": "https://github.com/y258dd/dsh-hormone#readme",
+  "author": "y258dd",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "license": "MIT"
 }