dsh-hormone 0.0.0-stage → 0.2.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,116 @@
-# 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.2.0`，注入层已跑通，门控层未做。只用 DSH 的公开插件 API，不修改任何其他插件的数据，不联网。
+
+## 它是什么
+
+| 状态 | 什么时候涨 | 什么时候降 | 半衰期 |
+|---|---|---|---|
+| `cortisol` 压力 | 工具报错 +0.15；连续 3 次失败再 +0.30；被批评/被纠正 +0.25 | 一轮顺利收尾 −0.20 | 4 小时 |
+| `energy` 精力 | 跨天 +0.80；距上次干活超 1h 缓慢回升（深夜只回到 0.45） | 干活轮按 token 扣减，闲聊不扣 | 不走半衰期 |
+| `dopamine` 爽度 | 任务顺利收尾 +0.35；被夸/被谢 +0.40 | 自然衰减 | 40 分钟 |
+
+更新公式：`新值 = clamp(旧值 × 0.5^(Δt / 半衰期) + Σ增量, 0, 1)`
+
+衰减是必须的。没有衰减，任何状态都会积到 1，然后卡死在那儿。
+
+## 它怎么起作用
+
+只有一层，第一版就一层：
+
+**注入** —— 越界了才写，全部正常时一个字都不写：
+
+- `cortisol > 0.7` → 回答收短，不主动揽活
+- `energy < 0.2` → 能一句说完就别铺垫
+- `dopamine > 0.6` → 可以多说两句
+
+注入文本硬上限 80 字，带 `[hormone]` 前缀，每轮最多一条。
+
+**没有做门控**（比如硬压输出长度）。门控是分水岭：注入只是「告诉它现在什么状态」，门控是「替它决定能说多少」。第一版先把状态跑准，跑两天曲线不极端了再谈门控。
+
+也没有做记忆权重（`emotion` 字段）。那要改 memory-lite 的写入格式，是另一件事。
+
+## 装
+
+```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`），想验收「跑两天曲线有没有起伏」直接看这个。
+
+删掉这个文件 = 回到初始状态，不会有副作用。
+
+## 环境变量
+
+| 变量 | 作用 |
+|---|---|
+| `DSH_HORMONE_MODE=observe` | 只记状态，不注入。想先观察几天、不想它影响回答时用。 |
+| `DSH_HORMONE_DEBUG=1` | 把每个会话事件的摘要追加到 `%DSH_HOME%\hormone\events.jsonl`，用来核对事件结构。 |
+
+## 调参
+
+三个文件顶部，改完重启：
+
+- `lib/state.js` — `HALF_LIFE`（衰减快慢）、`ENERGY`（日预算、跨天恢复、深夜基线）
+- `lib/events.js` — `DELTA`（各种事件的增量）、`BLAME_RE` / `PRAISE_RE`（关键词）
+- `lib/render.js` — `THRESHOLD`（注入阈值）、`MAX_CHARS`
+
+`ENERGY.dailyBudget` 默认 800 万，是按重度使用日的 token 量估的，一次重活掉约 0.07。觉得掉太快就调大。
+
+## 设计上的几个取舍
+
+**状态只能被事件改，模型改不了。** 插件不提供任何写入工具。一旦模型能自己调「我心情不好」，这套东西就退化成摇骰子——它想演什么就调什么。
+
+**关键词匹配，不是理解。** 判断「被夸/被批评」用的是正则，会漏判也会误判。所以批评优先于夸奖：误判成被夸会让爽度虚假上涨，比漏掉一次更坏。实测不灵就改 `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              # 33 个用例：衰减、跨天恢复、深夜基线、事件映射、轮次结算、阈值渲染、落盘往返
+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,148 @@
+/**
+ * dsh-hormone 的事件层：把 DSH 会话事件翻译成激素增量。
+ *
+ * 全部是关键词匹配，不是「理解」——宁可漏判，不要误判：
+ * 误判成「被夸」会让爽度虚假上涨，比漏判更坏。
+ * 实测不灵就改这里的 DELTA 和正则，别改 index.js。
+ */
+
+import { ENERGY, applyDeltas, nowSec } from './state.js'
+
+/** 每种事件的增量（`applyDeltas` 的第二个参数）。 */
+export const DELTA = {
+  toolError: { cortisol: 0.15 },
+  /** 连续失败时在 toolError 之上再叠一次。 */
+  repeatedErrors: { cortisol: 0.3 },
+  /** 一轮收尾且没出过错：压力泄掉，爽度上来。 */
+  taskDone: { cortisol: -0.2, dopamine: 0.35 },
+  praised: { dopamine: 0.4 },
+  blamed: { cortisol: 0.25 },
+}
+
+/** 每连续失败几次额外叠一次 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
+  }
+  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
+      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
+    }
+
+    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,115 @@
+/**
+ * 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 { render } 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 {
+          return render(project(state, nowSec()))
+        } 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,41 @@
+/**
+ * dsh-hormone 的渲染层：把三个数翻译成一句人话，塞进系统提示。
+ *
+ * 规则只有一条：只有越界才写。全都正常就返回空字符串——
+ * 不让模型每轮都看见「你现在的激素」，否则它会开始表演情绪。
+ */
+
+export const THRESHOLD = {
+  cortisolHigh: 0.7,
+  energyLow: 0.2,
+  dopamineHigh: 0.6,
+}
+
+/** 注入文本硬上限（DESIGN 定的 ≤80 字）。 */
+export const MAX_CHARS = 80
+
+const fmt = (v) => v.toFixed(2)
+
+/**
+ * @param {{cortisol:number, energy:number, dopamine:number}} values 已投影到当前时刻
+ * @returns {string} 空串表示这轮不注入
+ */
+export function render(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)}，心情不错，可以多说两句。`)
+  }
+
+  if (lines.length === 0) return ''
+  const text = `[hormone] ${lines.join(' ')}`
+  if (text.length <= MAX_CHARS) return text
+  return text.slice(0, MAX_CHARS - 1) + '…'
+}

package/lib/state.js

@@ -0,0 +1,234 @@
+/**
+ * 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 4 小时，dopamine 40 分钟。energy 不走半衰期，见 ENERGY。 */
+export const HALF_LIFE = {
+  cortisol: 4 * 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。
+   * 觉得掉太快/太慢就改这一个数。
+   */
+  dailyBudget: 8_000_000,
+  /** 跨天恢复：日期变了，energy 至少回升这么多。 */
+  dayRecover: 0.8,
+  /**
+   * 距上次「干活」超过这个时长才缓慢回升（秒）。
+   * 只认调过工具的真活：闲聊不刷新这个计时，否则一整天扯淡精力永远涨不回来。
+   */
+  idleRecoverAfter: 60 * 60,
+  /** 回升半衰期：向基线靠拢一半所需时间。 */
+  recoverHalfLife: 6 * 60 * 60,
+  /** 白天基线。 */
+  dayBaseline: 0.9,
+  /** 深夜基线：23:00–06:00 压低，熬夜不会回满。 */
+  nightBaseline: 0.45,
+  nightFrom: 23,
+  nightTo: 6,
+}
+
+/** 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 基线。 */
+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 }
+}
+
+export function freshState(now = nowSec()) {
+  return {
+    version: 1,
+    updatedAt: now,
+    day: localDay(now),
+    /** 上次真正干活的时刻。精力恢复从这时计时，不随闲聊刷新。 */
+    lastWorkAt: now,
+    values: freshValues(),
+    session: { turn: null, tokensInTurn: 0, toolsInTurn: 0, errorsInTurn: 0, consecutiveErrors: 0 },
+    history: [],
+  }
+}
+
+/**
+ * 从 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()
+  let energy = clamp01(values.energy)
+
+  // 1. 跨天：日期变了就回升一大截（模拟睡了一觉）。
+  if (state.day && state.day !== localDay(now)) {
+    energy = clamp01(energy + ENERGY.dayRecover)
+  }
+
+  // 2. 长时间没干活：向「当前时段」的基线靠拢。
+  //    不是加满——深夜的基线本来就低，熬夜补不回来。
+  //    计时只认 lastWorkAt（上一轮真正干活的时刻），闲聊不推迟恢复；
+  //    老状态文件没有这个字段就退回 updatedAt。
+  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)))
+  }
+
+  return {
+    cortisol: decayValue(values.cortisol, HALF_LIFE.cortisol, dt),
+    energy,
+    dopamine: decayValue(values.dopamine, HALF_LIFE.dopamine, dt),
+  }
+}
+
+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),
+  }
+  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 本身，方便链式调用。
+ */
+export function applyDeltas(state, deltas, now = nowSec(), why = '') {
+  const projected = project(state, now)
+  const before = state.values ?? freshValues()
+  const next = {
+    cortisol: clamp01(projected.cortisol + (deltas?.cortisol ?? 0)),
+    energy: clamp01(projected.energy + (deltas?.energy ?? 0)),
+    dopamine: clamp01(projected.dopamine + (deltas?.dopamine ?? 0)),
+  }
+  const moved =
+    Math.abs(next.cortisol - before.cortisol) +
+    Math.abs(next.energy - before.energy) +
+    Math.abs(next.dopamine - before.dopamine)
+
+  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),
+    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)),
+    },
+    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.2.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"
 }