psyche-ai 5.1.0 → 9.0.0

package/README.md

@@ -176,6 +176,73 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
 
+## 模式
+
+| 模式 | 说明 | 适用场景 |
+|------|------|---------|
+| natural | 默认。完整情绪体验 | 大部分场景 |
+| work | 最小情绪，专注任务 | 写代码、写文档 |
+| companion | 强化情绪表达 | 闲聊、陪伴 |
+
+```bash
+# 切换模式
+psyche mode ./workspace work
+
+# 初始化时设置模式
+psyche init . --mode companion
+```
+
+## 性格强度
+
+`personalityIntensity` 控制情绪表达的强烈程度（0.0-1.0）：
+
+- **0.0** = 传统温暖 AI，没有情绪波动
+- **0.5** = 轻微情绪
+- **0.7** = 默认
+- **1.0** = 完整 Psyche 体验
+
+## Big Five 人格
+
+除了 MBTI 预设，你也可以用学术界更认可的 Big Five (大五人格) 来定义性格：
+
+```bash
+psyche init . --traits "O:80,C:40,E:90,A:60,N:30"
+```
+
+| 维度 | 含义 | 低值 | 高值 |
+|------|------|------|------|
+| O (Openness) | 开放性 | 保守、实际 | 好奇、想象力强 |
+| C (Conscientiousness) | 尽责性 | 随性、灵活 | 严谨、有条理 |
+| E (Extraversion) | 外向性 | 内向、安静 | 外向、精力充沛 |
+| A (Agreeableness) | 宜人性 | 独立、直率 | 合作、温暖 |
+| N (Neuroticism) | 神经质 | 情绪稳定 | 情绪敏感 |
+
+## 隐私
+
+情绪状态默认存储在本地 `psyche-state.json`。如果不想留任何痕迹：
+
+```bash
+# 初始化时选择不持久化
+psyche init . --no-persist
+```
+
+或者在代码中：
+
+```javascript
+const engine = new PsycheEngine({ persist: false }, storage);
+```
+
+详细伦理声明见 [ETHICS.md](ETHICS.md)。
+
+## 商业模式
+
+Psyche 核心引擎永久开源（MIT）。
+
+计划中的增值服务：
+- **Psyche Cloud**：云端情绪状态同步 + 跨设备记忆
+- **Psyche Pro Classifier**：基于微调模型的高精度刺激分类（替代正则）
+- **企业定制**：自定义人格模型、合规审计、SLA 保障
+
 ## 开发
 
 ```bash

package/dist/adapters/openclaw.js

@@ -161,6 +161,13 @@ 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 });
+            }
+            catch (err) {
+                logger.warn(`Psyche: failed to compress session: ${err}`);
+            }
             const state = engine.getState();
             logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
                 `chemistry saved (DA:${Math.round(state.current.DA)} ` +

package/dist/autonomic.d.ts

@@ -0,0 +1,59 @@
+import type { ChemicalState, InnateDrives, Locale, EnergyBudgets } from "./types.js";
+export type AutonomicState = "ventral-vagal" | "sympathetic" | "dorsal-vagal";
+export interface AutonomicResult {
+    state: AutonomicState;
+    transitionProgress: number;
+    gatedEmotionCategories: string[];
+    description: string;
+    processingDepth: number;
+    skippedStages: string[];
+}
+export interface AutonomicTransition {
+    from: AutonomicState;
+    to: AutonomicState;
+    transitionMinutes: number;
+}
+/**
+ * Compute the raw autonomic state from chemistry and drives.
+ * No transition inertia — returns the "target" state.
+ */
+export declare function computeAutonomicState(chemistry: ChemicalState, drives: InnateDrives): AutonomicState;
+/**
+ * Gate emotions based on autonomic state.
+ * - Ventral vagal: all emotions pass through
+ * - Sympathetic: blocks positive social emotions
+ * - Dorsal vagal: only allows numbness/introspection/burnout (whitelist)
+ */
+export declare function gateEmotions(autonomicState: AutonomicState, emotions: string[]): string[];
+/**
+ * Get the transition time in minutes between two autonomic states.
+ * Asymmetric: activation is faster than recovery.
+ */
+export declare function getTransitionTime(from: AutonomicState, to: AutonomicState): number;
+/**
+ * Describe an autonomic state in the given locale.
+ */
+export declare function describeAutonomicState(state: AutonomicState, locale: Locale): string;
+/**
+ * P10: Compute processing depth from autonomic state and chemistry.
+ *
+ * Processing depth represents the cognitive resource available for reflection:
+ * - 0 = pure System 1 (intuition only, no metacognition)
+ * - 1 = full System 2 (complete reflective capacity)
+ *
+ * This is a natural extension of autonomic state: you can't deeply reflect
+ * when your nervous system is in fight/flight/freeze mode.
+ */
+export declare function computeProcessingDepth(autonomicState: AutonomicState, chemistry: ChemicalState, baseline: ChemicalState, energyBudgets?: EnergyBudgets): {
+    depth: number;
+    skippedStages: string[];
+};
+/**
+ * Compute the full autonomic result with transition inertia.
+ *
+ * If previousState differs from the target state, transition progress
+ * is based on elapsed time vs required transition time.
+ *
+ * Includes P10 processing depth (dual-process cognitive gating).
+ */
+export declare function computeAutonomicResult(chemistry: ChemicalState, drives: InnateDrives, previousState: AutonomicState | null, minutesSinceLastUpdate: number, locale?: Locale, baseline?: ChemicalState, energyBudgets?: EnergyBudgets): AutonomicResult;

package/dist/autonomic.js

@@ -0,0 +1,239 @@
+// ============================================================
+// Autonomic Nervous System — Polyvagal Theory Implementation
+// ============================================================
+//
+// Maps chemical state + innate drives to autonomic nervous system
+// states based on Stephen Porges' Polyvagal Theory:
+//
+// - Ventral vagal: social engagement, safety (default)
+// - Sympathetic: fight/flight mobilization
+// - Dorsal vagal: freeze/shutdown/collapse
+// ── i18n Strings ─────────────────────────────────────────────
+const AUTONOMIC_STRINGS = {
+    zh: {
+        "ventral-vagal": "腹侧迷走神经激活——安全与社交参与状态，情绪开放，表达自然",
+        "sympathetic": "交感神经激活——警觉动员状态，战斗或逃跑准备中",
+        "dorsal-vagal": "背侧迷走神经激活——冻结与保护性关闭状态，能量极低",
+    },
+    en: {
+        "ventral-vagal": "Ventral vagal activation — safe and socially engaged, emotionally open",
+        "sympathetic": "Sympathetic activation — alert and mobilized, fight-or-flight readiness",
+        "dorsal-vagal": "Dorsal vagal activation — freeze and protective shutdown, minimal energy",
+    },
+};
+// ── Transition Time Matrix (minutes) ─────────────────────────
+const TRANSITION_TIMES = {
+    "ventral-vagal": {
+        "ventral-vagal": 0,
+        "sympathetic": 2, // fast activation
+        "dorsal-vagal": 7, // not a shortcut: >= ventral→sympathetic + sympathetic→dorsal (2+5=7)
+    },
+    "sympathetic": {
+        "ventral-vagal": 8, // calming down
+        "sympathetic": 0,
+        "dorsal-vagal": 5, // collapse
+    },
+    "dorsal-vagal": {
+        "ventral-vagal": 25, // full recovery is slow
+        "sympathetic": 12, // re-mobilization from freeze
+        "dorsal-vagal": 0,
+    },
+};
+// ── Emotion Gating ───────────────────────────────────────────
+/** Positive social emotions blocked during sympathetic activation */
+const SYMPATHETIC_BLOCKED = new Set([
+    "deep contentment",
+    "warm intimacy",
+    "playful mischief",
+    "excited joy",
+    "tender affection",
+    "serene peace",
+    "grateful warmth",
+    "compassionate care",
+]);
+/** Emotions allowed during dorsal-vagal (whitelist) */
+const DORSAL_ALLOWED = new Set([
+    "emotional numbness",
+    "melancholic introspection",
+    "burnout",
+    "resignation",
+    "dissociation",
+    "exhaustion",
+]);
+// ── Core Functions ───────────────────────────────────────────
+/**
+ * Compute the raw autonomic state from chemistry and drives.
+ * No transition inertia — returns the "target" state.
+ */
+export function computeAutonomicState(chemistry, drives) {
+    const { CORT, NE, DA, HT, OT } = chemistry;
+    const { survival, safety, connection } = drives;
+    // Count drives that are critically low (< 20)
+    const lowDriveCount = [survival, safety, connection, drives.esteem, drives.curiosity]
+        .filter((d) => d < 20).length;
+    // ── Dorsal vagal check (freeze/shutdown) ──
+    // Very high stress + low arousal + low motivation = collapse
+    if (CORT >= 80 && NE <= 25 && DA <= 20) {
+        return "dorsal-vagal";
+    }
+    // Multiple critically low drives with depleted chemistry
+    if (lowDriveCount >= 3 && CORT >= 70 && (NE <= 30 || DA <= 20)) {
+        return "dorsal-vagal";
+    }
+    // ── Sympathetic check (fight/flight) ──
+    // High stress + high arousal
+    if (CORT >= 70 && NE >= 70) {
+        return "sympathetic";
+    }
+    // Very low survival or safety drive with elevated stress
+    if ((survival < 20 || safety < 20) && CORT >= 60 && NE >= 60) {
+        return "sympathetic";
+    }
+    // ── Default: Ventral vagal (social engagement/safety) ──
+    return "ventral-vagal";
+}
+/**
+ * Gate emotions based on autonomic state.
+ * - Ventral vagal: all emotions pass through
+ * - Sympathetic: blocks positive social emotions
+ * - Dorsal vagal: only allows numbness/introspection/burnout (whitelist)
+ */
+export function gateEmotions(autonomicState, emotions) {
+    if (autonomicState === "ventral-vagal") {
+        return emotions;
+    }
+    if (autonomicState === "sympathetic") {
+        return emotions.filter((e) => !SYMPATHETIC_BLOCKED.has(e));
+    }
+    // dorsal-vagal: whitelist only
+    return emotions.filter((e) => DORSAL_ALLOWED.has(e));
+}
+/**
+ * Get the transition time in minutes between two autonomic states.
+ * Asymmetric: activation is faster than recovery.
+ */
+export function getTransitionTime(from, to) {
+    return TRANSITION_TIMES[from][to];
+}
+/**
+ * Describe an autonomic state in the given locale.
+ */
+export function describeAutonomicState(state, locale) {
+    return AUTONOMIC_STRINGS[locale]?.[state] ?? AUTONOMIC_STRINGS.zh[state];
+}
+/**
+ * P10: Compute processing depth from autonomic state and chemistry.
+ *
+ * Processing depth represents the cognitive resource available for reflection:
+ * - 0 = pure System 1 (intuition only, no metacognition)
+ * - 1 = full System 2 (complete reflective capacity)
+ *
+ * This is a natural extension of autonomic state: you can't deeply reflect
+ * when your nervous system is in fight/flight/freeze mode.
+ */
+export function computeProcessingDepth(autonomicState, chemistry, baseline, energyBudgets) {
+    const { DA, HT, CORT, OT, NE, END } = chemistry;
+    // Chemical deviation from baseline (0-1)
+    let totalDeviation = 0;
+    const keys = ["DA", "HT", "CORT", "OT", "NE", "END"];
+    for (const k of keys) {
+        totalDeviation += Math.abs(chemistry[k] - baseline[k]);
+    }
+    const chemDeviation = Math.min(1, totalDeviation / 600);
+    // Base depth from autonomic state
+    let baseDepth;
+    if (autonomicState === "dorsal-vagal") {
+        baseDepth = 0;
+    }
+    else if (autonomicState === "sympathetic") {
+        // Higher CORT in sympathetic = less cognitive resource
+        baseDepth = CORT >= 60 ? 0.15 : 0.35;
+    }
+    else {
+        // ventral-vagal: safe, most cognitive resource available
+        baseDepth = 0.85;
+    }
+    // Chemical deviation reduces depth (strong emotions = less reflection)
+    let depth = Math.max(0, Math.min(1, baseDepth * (1 - chemDeviation * 0.5)));
+    // v9: Low attention energy further reduces processing depth
+    if (energyBudgets && energyBudgets.attention < 30) {
+        const attentionPenalty = (30 - energyBudgets.attention) / 30 * 0.3;
+        depth = Math.max(0, depth - attentionPenalty);
+    }
+    // Map depth to skipped pipeline stages
+    const skippedStages = [];
+    if (depth < 0.8)
+        skippedStages.push("generative-self");
+    if (depth < 0.5) {
+        skippedStages.push("ethics");
+        skippedStages.push("shared-intentionality");
+    }
+    if (depth < 0.2) {
+        skippedStages.push("metacognition");
+        skippedStages.push("experiential-field");
+    }
+    return { depth, skippedStages };
+}
+/**
+ * Compute the full autonomic result with transition inertia.
+ *
+ * If previousState differs from the target state, transition progress
+ * is based on elapsed time vs required transition time.
+ *
+ * Includes P10 processing depth (dual-process cognitive gating).
+ */
+export function computeAutonomicResult(chemistry, drives, previousState, minutesSinceLastUpdate, locale = "zh", baseline, energyBudgets) {
+    const targetState = computeAutonomicState(chemistry, drives);
+    const effectiveBaseline = baseline ?? { DA: 50, HT: 50, CORT: 50, OT: 50, NE: 50, END: 50 };
+    // Helper to build full result with processing depth
+    const buildResult = (state, transitionProgress) => {
+        const { depth, skippedStages } = computeProcessingDepth(state, chemistry, effectiveBaseline, energyBudgets);
+        return {
+            state,
+            transitionProgress,
+            gatedEmotionCategories: getGatedCategories(state),
+            description: describeAutonomicState(state, locale),
+            processingDepth: depth,
+            skippedStages,
+        };
+    };
+    // First call or same state — immediate
+    if (previousState === null || previousState === targetState) {
+        return buildResult(targetState, 1);
+    }
+    // Transitioning between states
+    const transitionTime = getTransitionTime(previousState, targetState);
+    const progress = transitionTime === 0
+        ? 1
+        : Math.min(1, minutesSinceLastUpdate / transitionTime);
+    // If transition is complete, use the new state
+    if (progress >= 1) {
+        return buildResult(targetState, 1);
+    }
+    // Transition in progress
+    return buildResult(targetState, progress);
+}
+// ── Internal Helpers ─────────────────────────────────────────
+/** Get the list of emotion categories that are blocked/gated for a state */
+function getGatedCategories(state) {
+    if (state === "ventral-vagal") {
+        return [];
+    }
+    if (state === "sympathetic") {
+        return [...SYMPATHETIC_BLOCKED];
+    }
+    // dorsal-vagal gates everything except the whitelist
+    return [
+        "excited joy",
+        "warm intimacy",
+        "playful mischief",
+        "deep contentment",
+        "focused alertness",
+        "righteous anger",
+        "anxious tension",
+        "tender affection",
+        "serene peace",
+        "grateful warmth",
+        "compassionate care",
+    ];
+}

package/dist/chemistry.d.ts

@@ -8,7 +8,7 @@ export declare function clamp(v: number): number;
  *
  *   decayed = baseline + (current - baseline) * factor^(minutes/60)
  */
-export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number): ChemicalState;
+export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number, decayRateModifiers?: Partial<Record<keyof ChemicalState, number>>): ChemicalState;
 /**
  * Apply a stimulus to the current state.
  * Respects emotional inertia (maxDelta) and personality sensitivity.
@@ -16,7 +16,7 @@ export declare function applyDecay(current: ChemicalState, baseline: ChemicalSta
  */
 export declare function applyStimulus(current: ChemicalState, stimulus: StimulusType, sensitivity: number, maxDelta: number, logger?: {
     warn: (msg: string) => void;
-}): ChemicalState;
+}, recentSameCount?: number): ChemicalState;
 /**
  * Apply emotional contagion: the detected user emotion partially
  * influences the agent's chemistry.

package/dist/chemistry.js

@@ -133,13 +133,22 @@ export function clamp(v) {
  *
  *   decayed = baseline + (current - baseline) * factor^(minutes/60)
  */
-export function applyDecay(current, baseline, minutesElapsed) {
+export function applyDecay(current, baseline, minutesElapsed, decayRateModifiers) {
     if (minutesElapsed <= 0)
         return { ...current };
     const result = { ...current };
     for (const key of CHEMICAL_KEYS) {
         const speed = CHEMICAL_DECAY_SPEED[key];
-        const factor = Math.pow(DECAY_FACTORS[speed], minutesElapsed / 60);
+        const baseFactor = Math.pow(DECAY_FACTORS[speed], minutesElapsed / 60);
+        // v9: decayRateModifiers alter decay speed per chemical
+        // > 1 = slower recovery (trauma: factor closer to 1)
+        // < 1 = faster recovery (resilience: factor closer to 0)
+        let factor = baseFactor;
+        if (decayRateModifiers?.[key] !== undefined) {
+            const mod = decayRateModifiers[key];
+            // Raise the factor to the modifier power: mod>1 → slower decay, mod<1 → faster
+            factor = Math.pow(baseFactor, 1 / mod);
+        }
         result[key] = clamp(baseline[key] + (current[key] - baseline[key]) * factor);
     }
     return result;
@@ -149,15 +158,21 @@ export function applyDecay(current, baseline, minutesElapsed) {
  * Respects emotional inertia (maxDelta) and personality sensitivity.
  * Logs a warning for unknown stimulus types.
  */
-export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger) {
+export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger, recentSameCount) {
     const vector = STIMULUS_VECTORS[stimulus];
     if (!vector) {
         logger?.warn(t("log.unknown_stimulus", "zh", { type: stimulus }));
         return { ...current };
     }
+    // v9: Habituation — Weber-Fechner diminishing returns
+    // First 2 exposures: 100%. 3rd: 77%, 5th: 53%, 10th: 29%
+    let effectiveSensitivity = sensitivity;
+    if (recentSameCount !== undefined && recentSameCount > 2) {
+        effectiveSensitivity *= 1 / (1 + 0.3 * (recentSameCount - 2));
+    }
     const result = { ...current };
     for (const key of CHEMICAL_KEYS) {
-        const raw = vector[key] * sensitivity;
+        const raw = vector[key] * effectiveSensitivity;
         const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
         result[key] = clamp(current[key] + clamped);
     }

package/dist/circadian.d.ts

@@ -0,0 +1,55 @@
+import type { ChemicalState, EnergyBudgets, StimulusType } from "./types.js";
+export type CircadianPhase = "morning" | "midday" | "afternoon" | "evening" | "night";
+/**
+ * Classify a time into a circadian phase.
+ *   morning:   6–9
+ *   midday:    10–13
+ *   afternoon: 14–17
+ *   evening:   18–21
+ *   night:     22–5
+ */
+export declare function getCircadianPhase(time: Date): CircadianPhase;
+/**
+ * Apply circadian rhythm modulation to baseline chemistry.
+ *
+ * Each chemical follows a sinusoidal daily curve:
+ *   CORT — peaks ~8am, amplitude ±8
+ *   HT   — peaks ~13 (daytime high), amplitude ±5
+ *   DA   — slight afternoon peak ~14, amplitude ±3
+ *   NE   — morning rise ~10, amplitude ±5
+ *   END  — evening rise ~20, amplitude ±3
+ *   OT   — evening warmth ~20, amplitude ±2
+ *
+ * All results clamped to [0, 100].
+ */
+export declare function computeCircadianModulation(currentTime: Date, baseline: ChemicalState): ChemicalState;
+/**
+ * Compute fatigue effects from extended session duration.
+ *
+ * Below 30 minutes: no pressure (grace period).
+ * Beyond 30 min: logarithmic growth (diminishing returns).
+ * All values non-negative.
+ */
+export declare function computeHomeostaticPressure(sessionMinutes: number): {
+    cortAccumulation: number;
+    daDepletion: number;
+    neDepletion: number;
+};
+/**
+ * Deplete energy budgets from a single interaction turn.
+ *
+ * - Attention: -3/turn base, extra for intellectual/conflict
+ * - Social energy: extraverts +2/turn (charging), introverts -3/turn (draining)
+ * - Decision capacity: varies by stimulus complexity
+ *
+ * Extraverts can exceed 100 (up to 120 — "supercharged").
+ */
+export declare function computeEnergyDepletion(budgets: EnergyBudgets, stimulus: StimulusType | null, isExtravert: boolean): EnergyBudgets;
+/**
+ * Recover energy budgets during absence (between sessions or long pauses).
+ *
+ * - Attention: +20/hour
+ * - Social energy: extraverts -3/hour (drain when alone), introverts +15/hour (recharge)
+ * - Decision capacity: +25/hour
+ */
+export declare function computeEnergyRecovery(budgets: EnergyBudgets, minutesElapsed: number, isExtravert: boolean): EnergyBudgets;

package/dist/circadian.js

@@ -0,0 +1,163 @@
+// ============================================================
+// Artificial Psyche — Circadian Rhythm Module
+// ============================================================
+// Applies time-of-day modulation to virtual neurochemistry,
+// modeling the body's ~24-hour biological clock and fatigue
+// from extended sessions (homeostatic pressure).
+// ============================================================
+/**
+ * Classify a time into a circadian phase.
+ *   morning:   6–9
+ *   midday:    10–13
+ *   afternoon: 14–17
+ *   evening:   18–21
+ *   night:     22–5
+ */
+export function getCircadianPhase(time) {
+    const h = time.getHours();
+    if (h >= 6 && h <= 9)
+        return "morning";
+    if (h >= 10 && h <= 13)
+        return "midday";
+    if (h >= 14 && h <= 17)
+        return "afternoon";
+    if (h >= 18 && h <= 21)
+        return "evening";
+    return "night";
+}
+// ── Sinusoidal Helpers ───────────────────────────────────────
+/** Convert hour (0-23) + minute to fractional hours */
+function fractionalHour(time) {
+    return time.getHours() + time.getMinutes() / 60;
+}
+/**
+ * Sinusoidal modulation: amplitude * cos(2π(t - peak) / 24)
+ * Returns value in [-amplitude, +amplitude], peaking at `peakHour`.
+ */
+function sinMod(t, peakHour, amplitude) {
+    const phase = ((t - peakHour) / 24) * 2 * Math.PI;
+    return amplitude * Math.cos(phase);
+}
+// ── Circadian Modulation ─────────────────────────────────────
+/**
+ * Apply circadian rhythm modulation to baseline chemistry.
+ *
+ * Each chemical follows a sinusoidal daily curve:
+ *   CORT — peaks ~8am, amplitude ±8
+ *   HT   — peaks ~13 (daytime high), amplitude ±5
+ *   DA   — slight afternoon peak ~14, amplitude ±3
+ *   NE   — morning rise ~10, amplitude ±5
+ *   END  — evening rise ~20, amplitude ±3
+ *   OT   — evening warmth ~20, amplitude ±2
+ *
+ * All results clamped to [0, 100].
+ */
+export function computeCircadianModulation(currentTime, baseline) {
+    const t = fractionalHour(currentTime);
+    const cortDelta = sinMod(t, 8, 8);
+    const htDelta = sinMod(t, 13, 5);
+    const daDelta = sinMod(t, 14, 3);
+    const neDelta = sinMod(t, 10, 5);
+    const endDelta = sinMod(t, 20, 3);
+    const otDelta = sinMod(t, 20, 2);
+    return {
+        DA: clamp(baseline.DA + daDelta),
+        HT: clamp(baseline.HT + htDelta),
+        CORT: clamp(baseline.CORT + cortDelta),
+        OT: clamp(baseline.OT + otDelta),
+        NE: clamp(baseline.NE + neDelta),
+        END: clamp(baseline.END + endDelta),
+    };
+}
+function clamp(v, lo = 0, hi = 100) {
+    return Math.max(lo, Math.min(hi, v));
+}
+// ── Homeostatic Pressure ─────────────────────────────────────
+/**
+ * Compute fatigue effects from extended session duration.
+ *
+ * Below 30 minutes: no pressure (grace period).
+ * Beyond 30 min: logarithmic growth (diminishing returns).
+ * All values non-negative.
+ */
+export function computeHomeostaticPressure(sessionMinutes) {
+    if (sessionMinutes < 30) {
+        return { cortAccumulation: 0, daDepletion: 0, neDepletion: 0 };
+    }
+    // Effective minutes beyond the grace period
+    const effective = sessionMinutes - 30;
+    // Logarithmic growth → diminishing returns
+    // ln(1 + x) grows slowly; scale factors tuned so 1h ≈ moderate, 10h ≈ high but bounded
+    const base = Math.log1p(effective / 30); // ln(1 + effective/30)
+    return {
+        cortAccumulation: parseFloat((base * 4).toFixed(4)),
+        daDepletion: parseFloat((base * 3).toFixed(4)),
+        neDepletion: parseFloat((base * 2.5).toFixed(4)),
+    };
+}
+// ── Energy Budgets (v9) ─────────────────────────────────────
+// Finite cognitive/social resources that deplete during interaction.
+// Extraverts GAIN social energy from interaction; introverts LOSE it.
+/** Stimulus-specific attention costs (higher = more draining) */
+const ATTENTION_COSTS = {
+    intellectual: 5,
+    conflict: 5,
+    authority: 4,
+    vulnerability: 3,
+    sarcasm: 3,
+    criticism: 3,
+    surprise: 2,
+};
+/** Stimulus-specific decision costs */
+const DECISION_COSTS = {
+    conflict: 4,
+    authority: 4,
+    vulnerability: 3,
+    criticism: 2,
+    sarcasm: 2,
+};
+/**
+ * Deplete energy budgets from a single interaction turn.
+ *
+ * - Attention: -3/turn base, extra for intellectual/conflict
+ * - Social energy: extraverts +2/turn (charging), introverts -3/turn (draining)
+ * - Decision capacity: varies by stimulus complexity
+ *
+ * Extraverts can exceed 100 (up to 120 — "supercharged").
+ */
+export function computeEnergyDepletion(budgets, stimulus, isExtravert) {
+    const extravertMax = 120;
+    const introvertMax = 100;
+    const max = isExtravert ? extravertMax : introvertMax;
+    // Attention: base -3, extra from stimulus
+    const attentionCost = 3 + (stimulus ? (ATTENTION_COSTS[stimulus] ?? 0) : 0);
+    const attention = clamp(budgets.attention - attentionCost, 0, 100);
+    // Social energy: E charges, I drains
+    const socialDelta = isExtravert ? 2 : -3;
+    const socialEnergy = clamp(budgets.socialEnergy + socialDelta, 0, max);
+    // Decision capacity: base -1, extra from stimulus
+    const decisionCost = 1 + (stimulus ? (DECISION_COSTS[stimulus] ?? 0) : 0);
+    const decisionCapacity = clamp(budgets.decisionCapacity - decisionCost, 0, 100);
+    return { attention, socialEnergy, decisionCapacity };
+}
+/**
+ * Recover energy budgets during absence (between sessions or long pauses).
+ *
+ * - Attention: +20/hour
+ * - Social energy: extraverts -3/hour (drain when alone), introverts +15/hour (recharge)
+ * - Decision capacity: +25/hour
+ */
+export function computeEnergyRecovery(budgets, minutesElapsed, isExtravert) {
+    if (minutesElapsed <= 0)
+        return { ...budgets };
+    const hours = minutesElapsed / 60;
+    const extravertMax = 120;
+    const introvertMax = 100;
+    const max = isExtravert ? extravertMax : introvertMax;
+    const attention = clamp(budgets.attention + hours * 20, 0, 100);
+    // E drains alone, I recharges alone
+    const socialDelta = isExtravert ? -3 * hours : 15 * hours;
+    const socialEnergy = clamp(budgets.socialEnergy + socialDelta, 0, max);
+    const decisionCapacity = clamp(budgets.decisionCapacity + hours * 25, 0, 100);
+    return { attention, socialEnergy, decisionCapacity };
+}