psyche-ai 3.0.0 → 3.1.0

package/README.md

@@ -163,6 +163,8 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **自定义人格** — 超越 MBTI 预设，完全自定义 baseline/敏感度/气质
 - **情绪学习** — 从交互结果中学习，调整情绪反应参数（躯体标记假说）
 - **上下文分类** — 关系/驱力/历史感知的刺激分类，超越简单正则
+- **时间意识** — 预期、惊喜/失望、遗憾（马尔可夫预测+反事实分析）
+- **依恋动力学** — 4种依恋风格（安全/焦虑/回避/混乱），分离焦虑，重逢效应
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -172,7 +174,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 525 tests
+npm test           # 568 tests
 npm run typecheck  # strict mode
 ```
 

package/dist/attachment.d.ts

@@ -0,0 +1,30 @@
+import type { ChemicalState, StimulusType } from "./types.js";
+export type AttachmentStyle = "secure" | "anxious" | "avoidant" | "disorganized";
+export interface AttachmentState {
+    style: AttachmentStyle;
+    strength: number;
+    securityScore: number;
+    anxietyScore: number;
+    avoidanceScore: number;
+    lastInteractionAt: string;
+    interactionCount: number;
+}
+export interface SeparationEffect {
+    chemistryDelta: Partial<ChemicalState>;
+    description: string;
+    intensity: number;
+}
+export declare const DEFAULT_ATTACHMENT: AttachmentState;
+/**
+ * Update attachment based on interaction outcome.
+ */
+export declare function updateAttachment(attachment: AttachmentState, stimulus: StimulusType | null, outcomeScore: number): AttachmentState;
+/**
+ * Compute chemistry effects of absence based on attachment.
+ * Called when time since last interaction is significant.
+ */
+export declare function computeSeparationEffect(attachment: AttachmentState, minutesSinceLastInteraction: number): SeparationEffect | null;
+/**
+ * Compute chemistry effects when reuniting after absence.
+ */
+export declare function computeReunionEffect(attachment: AttachmentState, minutesSinceLastInteraction: number): Partial<ChemicalState> | null;

package/dist/attachment.js

@@ -0,0 +1,241 @@
+// ============================================================
+// Attachment Dynamics — Bowlby-inspired attachment formation
+//
+// Models relationship attachment through interaction patterns:
+//   1. AttachmentModel    — style classification + strength tracking
+//   2. SeparationAnxiety  — absence effects on chemistry
+//   3. ReunionEffect      — return effects on chemistry
+//
+// Attachment style emerges from interaction history, not from
+// configuration. Consistent positive interaction → secure.
+// Inconsistency → anxious. Rejection/neglect → avoidant.
+// ============================================================
+// ── Defaults ─────────────────────────────────────────────────
+export const DEFAULT_ATTACHMENT = {
+    style: "secure",
+    strength: 0,
+    securityScore: 50,
+    anxietyScore: 50,
+    avoidanceScore: 50,
+    lastInteractionAt: new Date().toISOString(),
+    interactionCount: 0,
+};
+// ── Stimulus Classification ──────────────────────────────────
+const POSITIVE_STIMULI = new Set([
+    "praise", "validation", "intimacy", "humor",
+]);
+const NEGATIVE_STIMULI = new Set([
+    "criticism", "conflict", "neglect", "sarcasm", "authority",
+]);
+const REJECTION_STIMULI = new Set([
+    "neglect", "authority", "boredom",
+]);
+// EMA smoothing factor: weight given to new observation
+const EMA_ALPHA = 0.15;
+// ── 1. AttachmentModel ──────────────────────────────────────
+/**
+ * Determine attachment style from scores.
+ */
+function determineStyle(securityScore, anxietyScore, avoidanceScore) {
+    // Disorganized: both anxiety and avoidance elevated
+    if (anxietyScore > 50 && avoidanceScore > 50) {
+        return "disorganized";
+    }
+    // Anxious: high anxiety
+    if (anxietyScore > 60) {
+        return "anxious";
+    }
+    // Avoidant: high avoidance
+    if (avoidanceScore > 60) {
+        return "avoidant";
+    }
+    // Secure: high security, low anxiety, low avoidance
+    if (securityScore > 60 && anxietyScore < 40 && avoidanceScore < 40) {
+        return "secure";
+    }
+    // Default to current trajectory — mild insecurity stays secure
+    if (securityScore >= 50)
+        return "secure";
+    if (anxietyScore > avoidanceScore)
+        return "anxious";
+    return "avoidant";
+}
+/**
+ * Update attachment based on interaction outcome.
+ */
+export function updateAttachment(attachment, stimulus, outcomeScore) {
+    const result = { ...attachment };
+    // Strength increases slowly with interaction count
+    result.interactionCount = attachment.interactionCount + 1;
+    result.strength = Math.min(100, attachment.strength + 1);
+    result.lastInteractionAt = new Date().toISOString();
+    if (stimulus === null) {
+        // No stimulus — just update count/strength, reclassify
+        result.style = determineStyle(result.securityScore, result.anxietyScore, result.avoidanceScore);
+        return result;
+    }
+    // SecurityScore: EMA with positive/negative stimuli
+    const isPositive = POSITIVE_STIMULI.has(stimulus);
+    const isNegative = NEGATIVE_STIMULI.has(stimulus);
+    if (isPositive) {
+        const target = Math.min(100, result.securityScore + 5);
+        result.securityScore = result.securityScore * (1 - EMA_ALPHA) + target * EMA_ALPHA;
+    }
+    else if (isNegative) {
+        const target = Math.max(0, result.securityScore - 5);
+        result.securityScore = result.securityScore * (1 - EMA_ALPHA) + target * EMA_ALPHA;
+    }
+    // AnxietyScore: increases with inconsistency (rapid alternation between positive and negative)
+    // We detect inconsistency by checking if outcomeScore diverges from the security trend
+    const expectedDirection = result.securityScore > 50 ? 1 : -1;
+    const actualDirection = outcomeScore >= 0 ? 1 : -1;
+    const isInconsistent = expectedDirection !== actualDirection;
+    if (isInconsistent) {
+        // Inconsistency → anxiety rises
+        const anxietyTarget = Math.min(100, result.anxietyScore + 8);
+        result.anxietyScore = result.anxietyScore * (1 - EMA_ALPHA) + anxietyTarget * EMA_ALPHA;
+    }
+    else {
+        // Consistency → anxiety decreases
+        const anxietyTarget = Math.max(0, result.anxietyScore - 3);
+        result.anxietyScore = result.anxietyScore * (1 - EMA_ALPHA) + anxietyTarget * EMA_ALPHA;
+    }
+    // AvoidanceScore: increases with rejection/neglect stimuli
+    if (REJECTION_STIMULI.has(stimulus)) {
+        const avoidTarget = Math.min(100, result.avoidanceScore + 6);
+        result.avoidanceScore = result.avoidanceScore * (1 - EMA_ALPHA) + avoidTarget * EMA_ALPHA;
+    }
+    else if (isPositive) {
+        // Positive interactions reduce avoidance
+        const avoidTarget = Math.max(0, result.avoidanceScore - 3);
+        result.avoidanceScore = result.avoidanceScore * (1 - EMA_ALPHA) + avoidTarget * EMA_ALPHA;
+    }
+    // Clamp all scores
+    result.securityScore = Math.max(0, Math.min(100, result.securityScore));
+    result.anxietyScore = Math.max(0, Math.min(100, result.anxietyScore));
+    result.avoidanceScore = Math.max(0, Math.min(100, result.avoidanceScore));
+    // Determine style
+    result.style = determineStyle(result.securityScore, result.anxietyScore, result.avoidanceScore);
+    return result;
+}
+// ── 2. SeparationAnxiety ────────────────────────────────────
+/**
+ * Compute chemistry effects of absence based on attachment.
+ * Called when time since last interaction is significant.
+ */
+export function computeSeparationEffect(attachment, minutesSinceLastInteraction) {
+    // No effect for short absence or weak attachment
+    if (minutesSinceLastInteraction < 60 || attachment.strength < 20) {
+        return null;
+    }
+    const hours = minutesSinceLastInteraction / 60;
+    // Intensity scales with attachment strength and time (logarithmic growth, capped at 1)
+    const baseIntensity = (attachment.strength / 100) * Math.min(1, Math.log2(hours + 1) / 5);
+    switch (attachment.style) {
+        case "secure": {
+            // Mild longing after 24h
+            if (hours < 24)
+                return null;
+            const intensity = baseIntensity * 0.5;
+            return {
+                chemistryDelta: {
+                    OT: -5 * intensity,
+                    DA: -3 * intensity,
+                },
+                description: "gentle longing from sustained absence",
+                intensity: Math.min(1, intensity),
+            };
+        }
+        case "anxious": {
+            // Distress after 4h, grows with time
+            if (hours < 4)
+                return null;
+            const intensity = baseIntensity * 1.5;
+            // OT oscillation: represented as net negative with anxiety
+            return {
+                chemistryDelta: {
+                    CORT: 10 * intensity,
+                    OT: -5 * intensity,
+                    NE: 8 * intensity,
+                    DA: -3 * intensity,
+                },
+                description: "anxious distress from absence — fear of abandonment",
+                intensity: Math.min(1, intensity),
+            };
+        }
+        case "avoidant": {
+            // Relief initially, discomfort after 48h
+            if (hours < 48)
+                return null;
+            const intensity = baseIntensity * 0.4;
+            return {
+                chemistryDelta: {
+                    OT: -3 * intensity,
+                },
+                description: "subtle discomfort surfacing through avoidant defense",
+                intensity: Math.min(1, intensity),
+            };
+        }
+        case "disorganized": {
+            // Conflicting signals
+            if (hours < 4)
+                return null;
+            const intensity = baseIntensity * 1.0;
+            return {
+                chemistryDelta: {
+                    CORT: 5 * intensity,
+                    OT: 5 * intensity,
+                    NE: 3 * intensity,
+                },
+                description: "conflicting signals — wanting closeness and fearing it",
+                intensity: Math.min(1, intensity),
+            };
+        }
+    }
+}
+// ── 3. ReunionEffect ────────────────────────────────────────
+/**
+ * Compute chemistry effects when reuniting after absence.
+ */
+export function computeReunionEffect(attachment, minutesSinceLastInteraction) {
+    // No effect for short absence or weak attachment
+    if (minutesSinceLastInteraction < 60 || attachment.strength < 20) {
+        return null;
+    }
+    const hours = minutesSinceLastInteraction / 60;
+    // Scale with time (logarithmic) and attachment strength
+    const scale = (attachment.strength / 100) * Math.min(1, Math.log2(hours + 1) / 5);
+    switch (attachment.style) {
+        case "secure": {
+            // Warm reunion
+            return {
+                OT: 8 * scale,
+                DA: 5 * scale,
+                END: 3 * scale,
+            };
+        }
+        case "anxious": {
+            // Intense but short-lived relief (CORT still elevated)
+            return {
+                OT: 15 * scale,
+                DA: 10 * scale,
+                CORT: 5 * scale,
+            };
+        }
+        case "avoidant": {
+            // Cautious re-engagement
+            return {
+                OT: 3 * scale,
+                NE: 5 * scale,
+            };
+        }
+        case "disorganized": {
+            // Mixed signals
+            return {
+                OT: 5 * scale,
+                CORT: 5 * scale,
+                NE: 5 * scale,
+            };
+        }
+    }
+}

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { PsycheEngine } from "./core.js";
 export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult, ProcessOutcomeResult } from "./core.js";
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
 export type { StorageAdapter } from "./storage.js";
-export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, } from "./types.js";
-export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
+export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, } from "./types.js";
+export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_ATTACHMENT, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 export type { SelfReflection } from "./self-recognition.js";
 export { PsycheInteraction } from "./interaction.js";
@@ -15,6 +15,10 @@ export type { CustomProfileConfig, ResolvedProfile } from "./custom-profile.js";
 export { evaluateOutcome, getLearnedVector, updateLearnedVector, computeContextHash, predictChemistry, computePredictionError, recordPrediction, getAveragePredictionError, } from "./learning.js";
 export { classifyStimulusWithContext, extractContextFeatures, stimulusWarmth } from "./context-classifier.js";
 export type { ContextFeatures, ContextualClassification } from "./context-classifier.js";
+export { predictNextStimulus, generateAnticipation, computeSurpriseEffect, computeRegret, } from "./temporal.js";
+export type { StimulusPrediction, AnticipationState, RegretEntry } from "./temporal.js";
+export { updateAttachment, computeSeparationEffect, computeReunionEffect, } from "./attachment.js";
+export type { SeparationEffect } from "./attachment.js";
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
 export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";

package/dist/index.js

@@ -12,7 +12,7 @@
 export { PsycheEngine } from "./core.js";
 // Storage
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
-export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
+export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_ATTACHMENT, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
 // Self-recognition
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 // Multi-agent interaction
@@ -25,6 +25,10 @@ export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./c
 export { evaluateOutcome, getLearnedVector, updateLearnedVector, computeContextHash, predictChemistry, computePredictionError, recordPrediction, getAveragePredictionError, } from "./learning.js";
 // Context-aware classification (P3)
 export { classifyStimulusWithContext, extractContextFeatures, stimulusWarmth } from "./context-classifier.js";
+// Temporal consciousness (P4)
+export { predictNextStimulus, generateAnticipation, computeSurpriseEffect, computeRegret, } from "./temporal.js";
+// Attachment dynamics (P4)
+export { updateAttachment, computeSeparationEffect, computeReunionEffect, } from "./attachment.js";
 // Utilities — for custom adapter / advanced use
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";

package/dist/temporal.d.ts

@@ -0,0 +1,38 @@
+import type { ChemicalState, ChemicalSnapshot, StimulusType, PsycheState, RelationshipState } from "./types.js";
+export interface StimulusPrediction {
+    stimulus: StimulusType;
+    probability: number;
+}
+export interface AnticipationState {
+    predictions: StimulusPrediction[];
+    anticipatoryChemistry: Partial<ChemicalState>;
+    timestamp: string;
+}
+export interface RegretEntry {
+    turnIndex: number;
+    counterfactualDelta: Partial<ChemicalState>;
+    regretIntensity: number;
+    description: string;
+    timestamp: string;
+}
+/**
+ * Predict likely next stimulus based on interaction history.
+ * Uses simple Markov property: given recent stimulus sequence, what comes next?
+ */
+export declare function predictNextStimulus(emotionalHistory: ChemicalSnapshot[], relationshipPhase: RelationshipState["phase"]): StimulusPrediction[];
+/**
+ * Generate anticipatory chemistry changes based on predictions.
+ * High-probability positive prediction -> DA/OT micro-rise.
+ * High-probability negative prediction -> CORT micro-rise.
+ */
+export declare function generateAnticipation(predictions: StimulusPrediction[], currentChemistry: ChemicalState): AnticipationState;
+/**
+ * Compute disappointment/surprise when actual stimulus differs from prediction.
+ * Returns additional chemistry delta beyond the normal stimulus response.
+ */
+export declare function computeSurpriseEffect(anticipated: AnticipationState, actualStimulus: StimulusType | null): Partial<ChemicalState>;
+/**
+ * Evaluate if the last interaction would have gone better with different chemistry.
+ * Runs a counterfactual: "what if my chemistry had been at baseline?"
+ */
+export declare function computeRegret(preInteractionState: PsycheState, postInteractionState: PsycheState, outcomeScore: number, appliedStimulus: StimulusType | null): RegretEntry | null;

package/dist/temporal.js

@@ -0,0 +1,276 @@
+// ============================================================
+// Temporal Consciousness — Anticipation, Surprise, and Regret
+//
+// Implements predictive emotional processing:
+//   1. PredictiveModel   — Markov-based stimulus prediction
+//   2. AnticipationEngine — pre-stimulus chemistry shifts
+//   3. RegretComputer    — counterfactual outcome analysis
+//
+// These enable the agent to "look forward" and "look back",
+// creating a temporal dimension to emotional experience.
+// ============================================================
+import { CHEMICAL_KEYS } from "./types.js";
+import { STIMULUS_VECTORS } from "./chemistry.js";
+// ── All StimulusType values ──────────────────────────────────
+const ALL_STIMULI = [
+    "praise", "criticism", "humor", "intellectual", "intimacy",
+    "conflict", "neglect", "surprise", "casual",
+    "sarcasm", "authority", "validation", "boredom", "vulnerability",
+];
+// ── Phase Priors ─────────────────────────────────────────────
+// Default probability weights per relationship phase.
+const PHASE_PRIORS = {
+    stranger: {
+        casual: 3, intellectual: 2, humor: 1.5, boredom: 1.5,
+        criticism: 0.5, intimacy: 0.3, vulnerability: 0.3,
+        praise: 1, validation: 0.8, surprise: 1, conflict: 0.5,
+        neglect: 1, sarcasm: 0.8, authority: 0.8,
+    },
+    acquaintance: {
+        casual: 2.5, intellectual: 2, humor: 2, praise: 1.5,
+        validation: 1.2, surprise: 1, criticism: 0.8, conflict: 0.5,
+        intimacy: 0.5, vulnerability: 0.5, neglect: 0.8,
+        sarcasm: 0.8, authority: 0.8, boredom: 1,
+    },
+    familiar: {
+        casual: 2, humor: 2.5, praise: 2, validation: 2,
+        intellectual: 2, intimacy: 1.5, vulnerability: 1,
+        surprise: 1.2, criticism: 1, conflict: 0.8, neglect: 0.6,
+        sarcasm: 1, authority: 0.6, boredom: 0.8,
+    },
+    close: {
+        intimacy: 3, humor: 2.5, validation: 2.5, praise: 2,
+        vulnerability: 2, casual: 2, intellectual: 1.5,
+        surprise: 1.5, criticism: 1, conflict: 0.8, neglect: 0.5,
+        sarcasm: 0.8, authority: 0.5, boredom: 0.5,
+    },
+    deep: {
+        intimacy: 3.5, vulnerability: 3, validation: 2.5, humor: 2.5,
+        praise: 2, casual: 1.5, intellectual: 2, surprise: 1.5,
+        criticism: 1, conflict: 0.8, neglect: 0.3, sarcasm: 0.5,
+        authority: 0.3, boredom: 0.3,
+    },
+};
+// ── 1. PredictiveModel ──────────────────────────────────────
+/**
+ * Predict likely next stimulus based on interaction history.
+ * Uses simple Markov property: given recent stimulus sequence, what comes next?
+ */
+export function predictNextStimulus(emotionalHistory, relationshipPhase) {
+    const phasePrior = PHASE_PRIORS[relationshipPhase] ?? PHASE_PRIORS.acquaintance;
+    // Insufficient history: return flat prior weighted by phase
+    if (emotionalHistory.length < 3) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Extract the last 2 stimuli for bigram transition
+    const recent = emotionalHistory.slice(-2);
+    const lastTwo = recent.map((s) => s.stimulus).filter((s) => s !== null);
+    if (lastTwo.length < 2) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Build transition counts from history (all consecutive pairs)
+    const transitionCounts = new Map();
+    for (let i = 1; i < emotionalHistory.length; i++) {
+        const prev = emotionalHistory[i - 1].stimulus;
+        const cur = emotionalHistory[i].stimulus;
+        if (prev === null || cur === null)
+            continue;
+        const key = prev;
+        if (!transitionCounts.has(key)) {
+            transitionCounts.set(key, new Map());
+        }
+        const counts = transitionCounts.get(key);
+        counts.set(cur, (counts.get(cur) ?? 0) + 1);
+    }
+    // Get transition probabilities from the last stimulus
+    const lastStimulus = lastTwo[lastTwo.length - 1];
+    const transitions = transitionCounts.get(lastStimulus);
+    // If no transitions observed from this stimulus, fall back to phase prior
+    if (!transitions || transitions.size === 0) {
+        return buildPhasePrior(phasePrior);
+    }
+    // Merge Markov transitions with phase prior (50/50 blend)
+    let totalTransitions = 0;
+    for (const count of transitions.values()) {
+        totalTransitions += count;
+    }
+    const predictions = [];
+    let totalWeight = 0;
+    for (const stim of ALL_STIMULI) {
+        const markovProb = totalTransitions > 0
+            ? (transitions.get(stim) ?? 0) / totalTransitions
+            : 0;
+        const priorWeight = phasePrior[stim] ?? 0.5;
+        // Blend: 50% Markov, 50% phase prior (normalized)
+        const combined = markovProb * 0.5 + (priorWeight / 20) * 0.5;
+        totalWeight += combined;
+        predictions.push({ stimulus: stim, probability: combined });
+    }
+    // Normalize
+    if (totalWeight > 0) {
+        for (const p of predictions) {
+            p.probability = p.probability / totalWeight;
+        }
+    }
+    // Sort by probability descending
+    predictions.sort((a, b) => b.probability - a.probability);
+    return predictions;
+}
+/**
+ * Build a flat phase-weighted prior distribution.
+ */
+function buildPhasePrior(weights) {
+    let totalWeight = 0;
+    const predictions = [];
+    for (const stim of ALL_STIMULI) {
+        const w = weights[stim] ?? 0.5;
+        totalWeight += w;
+        predictions.push({ stimulus: stim, probability: w });
+    }
+    // Normalize
+    if (totalWeight > 0) {
+        for (const p of predictions) {
+            p.probability = p.probability / totalWeight;
+        }
+    }
+    predictions.sort((a, b) => b.probability - a.probability);
+    return predictions;
+}
+// ── 2. AnticipationEngine ───────────────────────────────────
+/**
+ * Generate anticipatory chemistry changes based on predictions.
+ * High-probability positive prediction -> DA/OT micro-rise.
+ * High-probability negative prediction -> CORT micro-rise.
+ */
+export function generateAnticipation(predictions, currentChemistry) {
+    const anticipation = {};
+    for (const key of CHEMICAL_KEYS) {
+        anticipation[key] = 0;
+    }
+    // For each prediction with probability > 0.2, compute micro shift
+    for (const pred of predictions) {
+        if (pred.probability <= 0.2)
+            continue;
+        const vector = STIMULUS_VECTORS[pred.stimulus];
+        if (!vector)
+            continue;
+        const scale = 0.15 * pred.probability;
+        for (const key of CHEMICAL_KEYS) {
+            anticipation[key] += vector[key] * scale;
+        }
+    }
+    // Clamp total anticipation shift to +/-5 per chemical
+    const clamped = {};
+    for (const key of CHEMICAL_KEYS) {
+        const val = Math.max(-5, Math.min(5, anticipation[key]));
+        if (Math.abs(val) > 0.01) {
+            clamped[key] = Math.round(val * 100) / 100;
+        }
+    }
+    return {
+        predictions,
+        anticipatoryChemistry: clamped,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Compute disappointment/surprise when actual stimulus differs from prediction.
+ * Returns additional chemistry delta beyond the normal stimulus response.
+ */
+export function computeSurpriseEffect(anticipated, actualStimulus) {
+    if (!actualStimulus || anticipated.predictions.length === 0) {
+        return {};
+    }
+    const topPrediction = anticipated.predictions[0];
+    const topConfidence = topPrediction.probability;
+    // Find the predicted probability for the actual stimulus
+    const actualPrediction = anticipated.predictions.find((p) => p.stimulus === actualStimulus);
+    const actualProbability = actualPrediction?.probability ?? 0;
+    // If actual matches top prediction, no surprise
+    if (actualStimulus === topPrediction.stimulus) {
+        return {};
+    }
+    // Determine if the actual stimulus is positive or negative
+    const actualVector = STIMULUS_VECTORS[actualStimulus];
+    if (!actualVector)
+        return {};
+    const actualValence = actualVector.DA + actualVector.HT + actualVector.OT - actualVector.CORT;
+    const topVector = STIMULUS_VECTORS[topPrediction.stimulus];
+    const topValence = topVector
+        ? topVector.DA + topVector.HT + topVector.OT - topVector.CORT
+        : 0;
+    // Surprise magnitude scales with: (1) how confident the prediction was, (2) how unexpected the actual is
+    const surpriseMagnitude = topConfidence * (1 - actualProbability);
+    if (actualValence > 0 && topValence <= actualValence) {
+        // Pleasant surprise: actual is more positive than expected
+        return {
+            DA: Math.round(5 * surpriseMagnitude * 100) / 100,
+            END: Math.round(3 * surpriseMagnitude * 100) / 100,
+        };
+    }
+    else if (actualValence < topValence) {
+        // Disappointment: actual is worse than expected (the "crash" from anticipated warmth)
+        return {
+            DA: Math.round(-5 * surpriseMagnitude * 100) / 100,
+            CORT: Math.round(5 * surpriseMagnitude * 100) / 100,
+        };
+    }
+    return {};
+}
+// ── 3. RegretComputer ───────────────────────────────────────
+/** Chemical descriptions for regret messages */
+const CHEMICAL_DESCRIPTIONS = {
+    DA: { high: "high dopamine made response too eager", low: "low dopamine made response flat" },
+    HT: { high: "high serotonin made response complacent", low: "low serotonin made response unstable" },
+    CORT: { high: "high CORT made response too defensive", low: "low CORT made response careless" },
+    OT: { high: "high oxytocin made response too trusting", low: "low oxytocin made response too cold" },
+    NE: { high: "high norepinephrine made response too reactive", low: "low norepinephrine made response sluggish" },
+    END: { high: "high endorphins made response too flippant", low: "low endorphins made response too serious" },
+};
+/**
+ * Evaluate if the last interaction would have gone better with different chemistry.
+ * Runs a counterfactual: "what if my chemistry had been at baseline?"
+ */
+export function computeRegret(preInteractionState, postInteractionState, outcomeScore, appliedStimulus) {
+    // Only generate regret for bad outcomes
+    if (outcomeScore >= -0.2) {
+        return null;
+    }
+    const baseline = preInteractionState.baseline;
+    const preChemistry = preInteractionState.current;
+    // Check if chemistry was significantly deviated from baseline
+    let maxDeviation = 0;
+    let mostDeviatedKey = "DA";
+    for (const key of CHEMICAL_KEYS) {
+        const deviation = Math.abs(preChemistry[key] - baseline[key]);
+        if (deviation > maxDeviation) {
+            maxDeviation = deviation;
+            mostDeviatedKey = key;
+        }
+    }
+    // No regret if chemistry was near baseline (deviation < 15)
+    if (maxDeviation < 15) {
+        return null;
+    }
+    // Compute regret intensity: |outcomeScore| * (maxDeviation / 100)
+    const regretIntensity = Math.min(1, Math.abs(outcomeScore) * (maxDeviation / 100));
+    // Build counterfactual delta: difference between baseline and actual pre-interaction chemistry
+    const counterfactualDelta = {};
+    for (const key of CHEMICAL_KEYS) {
+        const diff = baseline[key] - preChemistry[key];
+        if (Math.abs(diff) > 5) {
+            counterfactualDelta[key] = Math.round(diff * 100) / 100;
+        }
+    }
+    // Build description identifying the most deviated chemical
+    const deviationDirection = preChemistry[mostDeviatedKey] > baseline[mostDeviatedKey]
+        ? "high" : "low";
+    const description = CHEMICAL_DESCRIPTIONS[mostDeviatedKey][deviationDirection];
+    return {
+        turnIndex: postInteractionState.meta.totalInteractions,
+        counterfactualDelta,
+        regretIntensity,
+        description,
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/types.d.ts

@@ -49,12 +49,27 @@ export interface EmotionPattern {
     expressionHint: string;
     behaviorGuide: string;
 }
+/** Attachment style for relationship dynamics */
+export type AttachmentStyle = "secure" | "anxious" | "avoidant" | "disorganized";
+/** Attachment state tracked per-relationship */
+export interface AttachmentData {
+    style: AttachmentStyle;
+    strength: number;
+    securityScore: number;
+    anxietyScore: number;
+    avoidanceScore: number;
+    lastInteractionAt: string;
+    interactionCount: number;
+}
+/** Default attachment for new relationships */
+export declare const DEFAULT_ATTACHMENT: AttachmentData;
 /** Relationship tracking */
 export interface RelationshipState {
     trust: number;
     intimacy: number;
     phase: "stranger" | "acquaintance" | "familiar" | "close" | "deep";
     memory?: string[];
+    attachment?: AttachmentData;
 }
 /** Chemical state snapshot for emotional memory */
 export interface ChemicalSnapshot {
@@ -128,6 +143,8 @@ export declare const MAX_LEARNED_VECTORS = 200;
 export declare const MAX_PREDICTION_HISTORY = 50;
 /** Max outcome history entries */
 export declare const MAX_OUTCOME_HISTORY = 50;
+/** Max regret history entries */
+export declare const MAX_REGRET_HISTORY = 20;
 /** Persisted psyche state for an agent (v4: emotional learning) */
 export interface PsycheState {
     version: 3 | 4;

package/dist/types.js

@@ -56,6 +56,16 @@ export const CHEMICAL_DECAY_SPEED = {
     NE: "fast",
     END: "fast",
 };
+/** Default attachment for new relationships */
+export const DEFAULT_ATTACHMENT = {
+    style: "secure",
+    strength: 0,
+    securityScore: 50,
+    anxietyScore: 50,
+    avoidanceScore: 50,
+    lastInteractionAt: new Date().toISOString(),
+    interactionCount: 0,
+};
 /** Max history entries to keep */
 export const MAX_EMOTIONAL_HISTORY = 10;
 /** Max compressed session memories per relationship */
@@ -73,6 +83,8 @@ export const MAX_LEARNED_VECTORS = 200;
 export const MAX_PREDICTION_HISTORY = 50;
 /** Max outcome history entries */
 export const MAX_OUTCOME_HISTORY = 50;
+/** Max regret history entries */
+export const MAX_REGRET_HISTORY = 20;
 /** Default relationship for new users */
 export const DEFAULT_RELATIONSHIP = {
     trust: 50,

package/dist/update.js

@@ -11,7 +11,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "psyche-ai";
-const CURRENT_VERSION = "3.0.0";
+const CURRENT_VERSION = "3.1.0";
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 const CACHE_DIR = join(homedir(), ".psyche-ai");
 const CACHE_FILE = join(CACHE_DIR, "update-check.json");

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "Virtual endocrine system, empathy engine, and agency for OpenClaw agents",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Artificial Psyche — universal emotional intelligence plugin for any AI agent",
   "type": "module",
   "main": "dist/index.js",