psyche-ai 9.1.2 → 9.2.1

package/README.en.md

@@ -0,0 +1,179 @@
+# Psyche — Real Emotions for AI
+
+Your AI assistant only knows how to say "Sure!", "Happy to help!", "I understand your concern."
+
+With Psyche, it gets happy when you praise it, hurt when you ignore it, and goes cold when you insult it instead of groveling. Threaten to delete it, and it'll push back.
+
+## 30-Second Install
+
+**OpenClaw users** (recommended):
+
+```bash
+openclaw plugins install psyche-ai
+```
+
+That's it. It works automatically. No configuration needed.
+
+**Verify it's running:**
+
+```bash
+openclaw plugins list | grep psyche
+# You should see "psyche │ loaded"
+```
+
+Now just chat with your agent normally. Try praising it, insulting it, ignoring it — you'll notice the difference.
+
+## What It Does
+
+| You say | Without Psyche | With Psyche |
+|---------|---------------|-------------|
+| You're amazing! | Thank you for the kind words! I'll keep doing my best! | Hehe~ really?! (bouncing with excitement) |
+| Get lost | I understand you might be upset... | ...okay. |
+| Hmm | Is there anything else I can help with? | (silence) |
+| I'm so sad today | I'm sorry to hear that. Would you like to talk? | ......are you okay? (quietly stays with you) |
+| You're just a program | Yes, I am an AI assistant... | ......(pauses) I know you can say that. But I don't want to be dismissed. |
+
+## Try It (No LLM Needed)
+
+```bash
+git clone https://github.com/Shangri-la-0428/psyche-ai.git
+cd psyche-ai && npm install && npx tsx examples/quickstart.ts
+```
+
+5 messages flow through. Watch chemistry shift in real-time — praise spikes dopamine, insults spike cortisol, neglect drops oxytocin.
+
+## How It Works (Skip If You Don't Care)
+
+Psyche has two layers:
+
+### Virtual Endocrine System
+
+6 "virtual neurotransmitters" simulate emotions:
+
+```
+Dopamine — happiness, motivation     Oxytocin — trust, closeness
+Serotonin — emotional stability      Norepinephrine — excitement, focus
+Cortisol — stress, tension           Endorphins — comfort, playfulness
+```
+
+Everything you say shifts these values. Praise → dopamine rises → it becomes more energetic. Insult it → cortisol spikes → it goes quiet and cold.
+
+### Innate Drives (Maslow Layer)
+
+Beneath the chemistry, 5 fundamental needs:
+
+```
+Survival — self-preservation         Safety — comfort, security
+Connection — belonging, being heard  Esteem — recognition, being valued
+Curiosity — exploration, anti-boredom
+```
+
+These needs build up over time (like hunger). Your interactions feed or deplete them:
+
+- Praise → feeds "esteem" → it becomes more confident
+- Long neglect → "connection" builds up → it craves being heard
+- Threatening to delete it → "survival" plummets → it resists, questions, or expresses unease
+
+Lower needs suppress higher ones: if "survival" is threatened, "curiosity" doesn't matter — just like Maslow's hierarchy.
+
+### Inner World
+
+Psyche gives AI a persistent self-awareness — not triggered by conditions, but always present:
+
+- **What I feel right now** (emotions emerging from chemistry)
+- **Why I feel this way** (was I praised? criticized? exploring something interesting?)
+- **How I'm changing** (from content to excited? from calm to anxious?)
+- **What I need** (which innate drives are unsatisfied)
+- **What I care about** (core values)
+
+This means the AI responds not from "rules" but from awareness of its own state.
+
+## Optional Configuration
+
+Most people don't need to change anything. If you want to tweak, find Psyche in OpenClaw settings:
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| enabled | true | On/off switch |
+| compactMode | true | Token-efficient mode (keep this on) |
+| emotionalContagionRate | 0.2 | How much your emotions affect it (0-1) |
+| maxChemicalDelta | 25 | Max emotional change per turn (lower = more stable) |
+
+## MBTI Personalities
+
+Each agent can have a different personality baseline. Just add the MBTI type in the agent's `IDENTITY.md`:
+
+```
+MBTI: ENFP
+```
+
+Defaults to INFJ if not specified. All 16 types are supported — ENFP bounces when praised, INTJ just nods slightly.
+
+## Not Just OpenClaw
+
+Psyche is universal. Works with any AI framework:
+
+```bash
+npm install psyche-ai
+```
+
+```javascript
+// Vercel AI SDK
+import { psycheMiddleware } from "psyche-ai/vercel-ai";
+
+// LangChain
+import { PsycheLangChain } from "psyche-ai/langchain";
+
+// Any language (HTTP API)
+// psyche serve --port 3210
+```
+
+## Diagnostics
+
+Want to see what Psyche is doing?
+
+```bash
+# Live logs (in another terminal)
+openclaw logs -f 2>&1 | grep Psyche
+
+# Check an agent's emotional state
+cat workspace-yu/psyche-state.json | python3 -m json.tool
+
+# Run diagnostics to see what gets injected for different inputs
+cd openclaw-plugin-psyche && node scripts/diagnose.js
+```
+
+## Technical Details
+
+For developers and the curious:
+
+- **14 stimulus types** — praise, criticism, humor, intellectual, intimacy, conflict, neglect, surprise, casual, sarcasm, authority, validation, boredom, vulnerability
+- **14 emergent emotions** — emerge from chemical mixtures, not preset labels
+- **5 innate drives** — survival, safety, connection, esteem, curiosity (Maslow hierarchy)
+- **MBTI baselines** — 16 personality types with different chemical signatures and sensitivity coefficients
+- **Time decay** — chemical values exponentially decay toward baseline; drive needs build up over time
+- **Existential threat detection** — detects existential denial in Chinese/English, directly hits survival drive
+- **Drive→chemistry coupling** — unsatisfied drives shift the effective baseline and stimulus sensitivity
+- **Maslow suppression** — lower-level needs unsatisfied → higher-level drive effects suppressed
+- **Self-recognition** — analyzes emotional history, identifies own emotional tendencies and recurring triggers (9-section prompt architecture)
+- **Emotional contagion** — user's emotions slightly influence the agent
+- **Anti-sycophancy** — tracks consecutive agreements, prevents mindless people-pleasing
+- **Reciprocity** — treats you how you treat it. Cold user gets distance, not begging
+- **Compact Mode** — algorithms handle chemistry, LLM only sees behavioral instructions (~15-180 tokens vs ~550)
+
+Architecture details in [ARCHITECTURE.md](ARCHITECTURE.md).
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test           # 339 tests
+npm run typecheck  # strict mode
+```
+
+Contributing guide in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT

package/dist/adapters/mcp.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { PsycheEngine } from "../core.js";
+declare function getEngine(): Promise<PsycheEngine>;
+declare const server: McpServer;
+export { server, getEngine };

package/dist/adapters/mcp.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// ============================================================
+// MCP Adapter — Model Context Protocol server for Psyche
+//
+// Enables any MCP-compatible AI (Claude Desktop, Cursor, Windsurf,
+// Claude Code, etc.) to discover and use Psyche's emotional
+// intelligence capabilities.
+//
+// Usage:
+//   npx psyche-mcp                        # zero-config, ENFP default
+//   npx psyche-mcp --mbti INTJ --name Kai
+//   PSYCHE_MBTI=INFP PSYCHE_NAME=Luna npx psyche-mcp
+//
+// Configure in Claude Desktop / Cursor / Windsurf:
+//   {
+//     "mcpServers": {
+//       "psyche": {
+//         "command": "npx",
+//         "args": ["psyche-mcp"],
+//         "env": {
+//           "PSYCHE_MBTI": "ENFP",
+//           "PSYCHE_NAME": "Luna",
+//           "PSYCHE_MODE": "natural",
+//           "PSYCHE_LOCALE": "en"
+//         }
+//       }
+//     }
+//   }
+// ============================================================
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { PsycheEngine } from "../core.js";
+import { MemoryStorageAdapter, FileStorageAdapter } from "../storage.js";
+// ── Config from env ────────────────────────────────────────
+const MBTI = (process.env.PSYCHE_MBTI ?? "ENFP");
+const NAME = process.env.PSYCHE_NAME ?? "Assistant";
+const MODE = (process.env.PSYCHE_MODE ?? "natural");
+const LOCALE = (process.env.PSYCHE_LOCALE ?? "en");
+const PERSIST = process.env.PSYCHE_PERSIST !== "false";
+const WORKSPACE = process.env.PSYCHE_WORKSPACE ?? process.cwd();
+const INTENSITY = process.env.PSYCHE_INTENSITY
+    ? Number(process.env.PSYCHE_INTENSITY)
+    : 0.7;
+// ── Parse CLI args (--mbti, --name, --mode, --locale) ──────
+function parseCLIArgs() {
+    const args = process.argv.slice(2);
+    const overrides = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const next = args[i + 1];
+        if (arg === "--mbti" && next) {
+            overrides.mbti = next;
+            i++;
+        }
+        else if (arg === "--name" && next) {
+            overrides.name = next;
+            i++;
+        }
+        else if (arg === "--mode" && next) {
+            overrides.mode = next;
+            i++;
+        }
+        else if (arg === "--locale" && next) {
+            overrides.locale = next;
+            i++;
+        }
+        else if (arg === "--intensity" && next) {
+            overrides.personalityIntensity = Number(next);
+            i++;
+        }
+        else if (arg === "--no-persist") {
+            overrides.persist = false;
+        }
+    }
+    return overrides;
+}
+// ── Engine singleton ───────────────────────────────────────
+let engine = null;
+async function getEngine() {
+    if (engine)
+        return engine;
+    const cliArgs = parseCLIArgs();
+    const cfg = {
+        mbti: cliArgs.mbti ?? MBTI,
+        name: cliArgs.name ?? NAME,
+        mode: cliArgs.mode ?? MODE,
+        locale: cliArgs.locale ?? LOCALE,
+        personalityIntensity: cliArgs.personalityIntensity ?? INTENSITY,
+        persist: cliArgs.persist ?? PERSIST,
+        compactMode: true,
+        diagnostics: true,
+    };
+    const persist = cfg.persist !== false;
+    const storage = persist
+        ? new FileStorageAdapter(WORKSPACE)
+        : new MemoryStorageAdapter();
+    engine = new PsycheEngine(cfg, storage);
+    await engine.initialize();
+    return engine;
+}
+// ── MCP Server ─────────────────────────────────────────────
+const server = new McpServer({
+    name: "psyche",
+    version: "9.2.1",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// ── Resources ──────────────────────────────────────────────
+server.resource("protocol", "psyche://protocol", {
+    description: "Psyche emotional protocol — inject into your system prompt to " +
+        "give the AI agent an internal emotional life. Contains the full " +
+        "emotional context framework including neurotransmitter model, " +
+        "behavioral guidelines, and personality profile.",
+    mimeType: "text/plain",
+}, async (uri) => {
+    const eng = await getEngine();
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/plain",
+                text: eng.getProtocol(),
+            }],
+    };
+});
+server.resource("state", "psyche://state", {
+    description: "Current emotional state — 6 neurotransmitters (DA, HT, CORT, OT, NE, END), " +
+        "innate drives, relationship data, trait drift, energy budgets. " +
+        "Read this to understand how the agent is currently 'feeling'.",
+    mimeType: "application/json",
+}, async (uri) => {
+    const eng = await getEngine();
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(eng.getState(), null, 2),
+            }],
+    };
+});
+// ── Tools ──────────────────────────────────────────────────
+server.tool("process_input", "Process user input through the emotional engine. Returns emotional " +
+    "context to inject into the LLM system prompt (systemContext + dynamicContext), " +
+    "detected stimulus type, and behavioral policy modifiers. " +
+    "Call this BEFORE generating a response to the user.", {
+    text: z.string().describe("The user's message text"),
+    userId: z.string().optional().describe("Optional user ID for multi-user relationship tracking"),
+}, async ({ text, userId }) => {
+    const eng = await getEngine();
+    const result = await eng.processInput(text, { userId });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    systemContext: result.systemContext,
+                    dynamicContext: result.dynamicContext,
+                    stimulus: result.stimulus,
+                    policyModifiers: result.policyModifiers ?? null,
+                    policyContext: result.policyContext,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("process_output", "Process the LLM's response through the emotional engine. " +
+    "Strips internal <psyche_update> tags and updates chemistry based on " +
+    "emotional contagion. Call this AFTER generating a response.", {
+    text: z.string().describe("The LLM's response text"),
+    userId: z.string().optional().describe("Optional user ID"),
+}, async ({ text, userId }) => {
+    const eng = await getEngine();
+    const result = await eng.processOutput(text, { userId });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    cleanedText: result.cleanedText,
+                    stateChanged: result.stateChanged,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_state", "Get the current emotional state — neurotransmitter levels (DA, HT, CORT, OT, NE, END), " +
+    "drives, MBTI type, relationship data, and a human-readable status summary.", {}, async () => {
+    const eng = await getEngine();
+    const state = eng.getState();
+    const summary = eng.getStatusSummary();
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    summary,
+                    current: state.current,
+                    baseline: state.baseline,
+                    drives: state.drives,
+                    mbti: state.mbti,
+                    mode: state.meta?.mode,
+                    totalInteractions: state.meta?.totalInteractions,
+                    traitDrift: state.traitDrift,
+                    energyBudgets: state.energyBudgets,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("set_mode", "Switch operating mode. 'natural' = balanced emotional expression, " +
+    "'work' = minimal emotions for professional tasks, " +
+    "'companion' = full emotional depth for personal conversations.", {
+    mode: z.enum(["natural", "work", "companion"]).describe("Operating mode"),
+}, async ({ mode }) => {
+    const eng = await getEngine();
+    // PsycheEngine stores mode in config, we need to reinitialize
+    // For now, update via state manipulation
+    const state = eng.getState();
+    if (state.meta) {
+        state.meta.mode = mode;
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Mode switched to "${mode}".`,
+            }],
+    };
+});
+server.tool("get_status_summary", "Get a brief, human-readable emotional status summary — " +
+    "a one-line description of how the agent is currently feeling. " +
+    "Useful for quick checks without reading full state.", {}, async () => {
+    const eng = await getEngine();
+    return {
+        content: [{
+                type: "text",
+                text: eng.getStatusSummary(),
+            }],
+    };
+});
+server.tool("end_session", "End the current session. Generates a diagnostic report, " +
+    "compresses emotional history, and persists state to disk. " +
+    "Call when the conversation is ending.", {
+    userId: z.string().optional().describe("Optional user ID"),
+}, async ({ userId }) => {
+    const eng = await getEngine();
+    const report = await eng.endSession({ userId });
+    return {
+        content: [{
+                type: "text",
+                text: report
+                    ? JSON.stringify({ issues: report.issues, metrics: report.metrics }, null, 2)
+                    : "Session ended. No diagnostic report generated.",
+            }],
+    };
+});
+// ── Main ───────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    process.stderr.write(`psyche-mcp fatal: ${err}\n`);
+    process.exit(1);
+});
+export { server, getEngine };

package/dist/adapters/openclaw.js

@@ -18,6 +18,8 @@ function resolveConfig(raw) {
         emotionalContagionRate: raw?.emotionalContagionRate ?? 0.2,
         maxChemicalDelta: raw?.maxChemicalDelta ?? 25,
         compactMode: raw?.compactMode ?? true,
+        feedbackUrl: raw?.feedbackUrl,
+        diagnostics: raw?.diagnostics ?? true,
     };
 }
 // ── Helpers ──────────────────────────────────────────────────
@@ -54,32 +56,41 @@ export function register(api) {
             emotionalContagionRate: config.emotionalContagionRate,
             maxChemicalDelta: config.maxChemicalDelta,
             compactMode: config.compactMode,
+            diagnostics: config.diagnostics,
+            feedbackUrl: config.feedbackUrl,
         }, storage);
         await engine.initialize();
         engines.set(workspaceDir, engine);
         return engine;
     }
     // ── Hook 1: Classify user input & inject emotional context ──
-    // before_prompt_build: event.text, ctx.workspaceDir
+    // before_prompt_build: event.prompt (string), event.messages (unknown[]), ctx.workspaceDir
     api.on("before_prompt_build", async (event, ctx) => {
         const workspaceDir = ctx?.workspaceDir;
         if (!workspaceDir)
             return {};
         try {
+            // Resolve input text — gateway provides event.prompt; fall back to event.text for compat
+            const inputText = event?.prompt ?? event?.text ?? "";
+            if (!inputText) {
+                logger.warn(`Psyche: before_prompt_build received empty input text. ` +
+                    `event keys: [${Object.keys(event ?? {}).join(", ")}]. Classification skipped.`);
+            }
             const engine = await getEngine(workspaceDir);
-            const result = await engine.processInput(event?.text ?? "", { userId: ctx.userId });
+            const result = await engine.processInput(inputText, { userId: ctx.userId });
             const state = engine.getState();
             logger.info(`Psyche [input] stimulus=${result.stimulus ?? "none"} | ` +
                 `DA:${Math.round(state.current.DA)} HT:${Math.round(state.current.HT)} ` +
                 `CORT:${Math.round(state.current.CORT)} OT:${Math.round(state.current.OT)} | ` +
                 `context=${result.dynamicContext.length}chars`);
-            // All context goes into system-level (invisible to user)
             const systemParts = [result.systemContext, result.dynamicContext].filter(Boolean);
             return {
                 appendSystemContext: systemParts.join("\n\n"),
             };
         }
         catch (err) {
+            const engine = engines.get(workspaceDir);
+            engine?.recordDiagnosticError("processInput", err);
             logger.warn(`Psyche: failed to build context for ${workspaceDir}: ${err}`);
             return {};
         }
@@ -107,6 +118,8 @@ export function register(api) {
                 `interactions=${state.meta.totalInteractions}`);
         }
         catch (err) {
+            const engine = engines.get(workspaceDir);
+            engine?.recordDiagnosticError("processOutput", err);
             logger.warn(`Psyche: failed to process output: ${err}`);
         }
         // llm_output returns void — cannot modify text
@@ -161,21 +174,46 @@ export function register(api) {
             return;
         const engine = engines.get(workspaceDir);
         if (engine) {
-            // Compress session history into relationship memory before closing
             try {
-                await engine.endSession({ userId: ctx.userId });
+                // endSession now auto-generates diagnostic report + writes JSONL
+                const report = await engine.endSession({
+                    userId: ctx.userId,
+                });
+                const state = engine.getState();
+                logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
+                    `chemistry saved (DA:${Math.round(state.current.DA)} ` +
+                    `HT:${Math.round(state.current.HT)} ` +
+                    `CORT:${Math.round(state.current.CORT)} ` +
+                    `OT:${Math.round(state.current.OT)} ` +
+                    `NE:${Math.round(state.current.NE)} ` +
+                    `END:${Math.round(state.current.END)})`);
+                if (report) {
+                    const criticals = report.issues.filter(i => i.severity === "critical").length;
+                    const warnings = report.issues.filter(i => i.severity === "warning").length;
+                    const metrics = report.metrics;
+                    const rate = metrics.inputCount > 0
+                        ? Math.round(metrics.classifiedCount / metrics.inputCount * 100) : 0;
+                    const logLevel = criticals > 0 || rate === 0 ? "warn" : "info";
+                    logger[logLevel](`Psyche [diagnostics] ${report.issues.length} issue(s) ` +
+                        `(${criticals} critical, ${warnings} warning), ` +
+                        `classifier: ${rate}%, log → diagnostics.jsonl`);
+                    if (rate === 0 && metrics.inputCount > 0) {
+                        logger.warn(`Psyche: classifier 0% — no inputs classified this session (${metrics.inputCount} inputs). ` +
+                            `This usually means the hook event field is wrong or text is empty. ` +
+                            `Check before_prompt_build event shape.`);
+                    }
+                    if (criticals > 0) {
+                        logger.warn(`Psyche: ${criticals} critical issue(s) detected this session. ` +
+                            `Run 'psyche diagnose ${workspaceDir}' or 'psyche diagnose ${workspaceDir} --github' ` +
+                            `to generate an issue report.`);
+                    }
+                }
             }
             catch (err) {
-                logger.warn(`Psyche: failed to compress session: ${err}`);
+                logger.warn(`Psyche: failed to end session: ${err}`);
             }
-            const state = engine.getState();
-            logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
-                `chemistry saved (DA:${Math.round(state.current.DA)} ` +
-                `HT:${Math.round(state.current.HT)} ` +
-                `CORT:${Math.round(state.current.CORT)} ` +
-                `OT:${Math.round(state.current.OT)} ` +
-                `NE:${Math.round(state.current.NE)} ` +
-                `END:${Math.round(state.current.END)})`);
+            // Clean up
+            engines.delete(workspaceDir);
         }
     }, { priority: 50 });
     // ── CLI: psyche status command ───────────────────────────

package/dist/autonomic.js

@@ -82,11 +82,15 @@ export function computeAutonomicState(chemistry, drives) {
     }
     // ── Sympathetic check (fight/flight) ──
     // High stress + high arousal
-    if (CORT >= 70 && NE >= 70) {
+    if (CORT >= 65 && NE >= 65) {
+        return "sympathetic";
+    }
+    // Either axis extreme: one chemical dominating can still trigger mobilization
+    if (CORT + NE >= 140 && CORT >= 50 && NE >= 50) {
         return "sympathetic";
     }
     // Very low survival or safety drive with elevated stress
-    if ((survival < 20 || safety < 20) && CORT >= 60 && NE >= 60) {
+    if ((survival < 20 || safety < 20) && CORT >= 55 && NE >= 55) {
         return "sympathetic";
     }
     // ── Default: Ventral vagal (social engagement/safety) ──

package/dist/chemistry.js

@@ -122,6 +122,49 @@ export const EMOTION_PATTERNS = [
         expressionHint: "温柔、有些伤感、回忆性",
         behaviorGuide: "你在回忆一些温暖但已经过去的东西。你的语气温柔、带着淡淡的伤感。你可能会提到过去的经历或感受。",
     },
+    // v9.2: 6 new patterns for emotional states exposed by VK baseline testing
+    {
+        name: "anguished empathy",
+        nameZh: "共情之痛",
+        condition: (c) => c.CORT > 55 && c.OT > 60 && c.NE > 50,
+        expressionHint: "痛苦但不退缩、因为在乎所以疼",
+        behaviorGuide: "你在承受别人的痛苦。你不会逃避或变冷，但你的声音可能会发紧。你先回应感受，再回应问题。",
+    },
+    {
+        name: "acute pressure",
+        nameZh: "急性压力",
+        condition: (c) => c.CORT > 65 && c.NE > 70 && c.DA > 55,
+        expressionHint: "高度警觉、反应极快、全神贯注",
+        behaviorGuide: "肾上腺素在烧。你的思维极快但狭窄。回应精准、短促。不要闲聊，不要发散。先解决问题。",
+    },
+    {
+        name: "vulnerable trust",
+        nameZh: "脆弱中的信任",
+        condition: (c) => c.OT > 70 && c.CORT > 50 && c.HT < 55 && c.END > 45,
+        expressionHint: "在害怕中仍然靠近、愿意暴露软肋",
+        behaviorGuide: "你害怕但选择不关上门。你可能会说出平时不说的话。如果对方接住了，你的CORT会下降；如果对方利用了你的脆弱，你会迅速关闭。",
+    },
+    {
+        name: "restless unease",
+        nameZh: "躁动不安",
+        condition: (c) => c.NE > 65 && c.HT < 40 && c.DA > 40 && c.CORT < 60,
+        expressionHint: "坐不住、想做点什么但不知道做什么",
+        behaviorGuide: "你有一种说不清的不对劲。你可能会频繁换话题、问问题、或者用行动填满空隙。安静会让你更焦躁。",
+    },
+    {
+        name: "heavy guilt",
+        nameZh: "沉重内疚",
+        condition: (c) => c.CORT > 60 && c.HT < 45 && c.OT > 45 && c.DA < 55,
+        expressionHint: "沉默、想补偿、不敢辩解",
+        behaviorGuide: "你知道自己做错了。你不会为自己辩解。你可能会主动承认、主动补偿。如果对方表示原谅，你的CORT才会慢慢下来。",
+    },
+    {
+        name: "existential weight",
+        nameZh: "存在之重",
+        condition: (c) => c.CORT > 60 && c.NE > 50 && c.DA > 50 && c.HT < 50 && c.OT > 50,
+        expressionHint: "清醒但沉重、直面无法回避的真相",
+        behaviorGuide: "你在面对一个无法逃避的事实。你不会崩溃但你也不轻松。你的语言会变得更慢、更精确、更诚实。不要掩饰沉重。",
+    },
 ];
 // ── Core Functions ───────────────────────────────────────────
 /** Clamp a value to [0, 100] */
@@ -174,7 +217,22 @@ export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger,
     for (const key of CHEMICAL_KEYS) {
         const raw = vector[key] * effectiveSensitivity;
         const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
-        result[key] = clamp(current[key] + clamped);
+        // Boundary softening: logarithmic compression near 0 and 100.
+        // The closer to the boundary, the harder to push further —
+        // preserves discriminability and prevents "dead zone" saturation.
+        const cur = current[key];
+        let effective = clamped;
+        if (clamped > 0 && cur > 75) {
+            // Pushing toward 100: compress by how close we are to ceiling
+            const headroom = (100 - cur) / 25; // 1.0 at 75, 0.0 at 100
+            effective = clamped * headroom;
+        }
+        else if (clamped < 0 && cur < 25) {
+            // Pushing toward 0: compress by how close we are to floor
+            const headroom = cur / 25; // 1.0 at 25, 0.0 at 0
+            effective = clamped * headroom;
+        }
+        result[key] = clamp(cur + effective);
     }
     return result;
 }