psyche-ai 2.3.0 → 3.1.0

package/README.md

@@ -161,6 +161,10 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **流式支持** — Vercel AI SDK `streamText` 中间件，自动缓冲和剥离标签
 - **渠道修饰** — Discord/Slack/飞书/终端等不同渠道自动调整表达风格
 - **自定义人格** — 超越 MBTI 预设，完全自定义 baseline/敏感度/气质
+- **情绪学习** — 从交互结果中学习，调整情绪反应参数（躯体标记假说）
+- **上下文分类** — 关系/驱力/历史感知的刺激分类，超越简单正则
+- **时间意识** — 预期、惊喜/失望、遗憾（马尔可夫预测+反事实分析）
+- **依恋动力学** — 4种依恋风格（安全/焦虑/回避/混乱），分离焦虑，重逢效应
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -170,7 +174,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 469 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/context-classifier.d.ts

@@ -0,0 +1,39 @@
+import type { StimulusType, DriveType, RelationshipState, PsycheState } from "./types.js";
+export interface ContextFeatures {
+    relationshipPhase: RelationshipState["phase"];
+    recentStimuli: StimulusType[];
+    driveSatisfaction: Record<DriveType, "high" | "mid" | "low">;
+    timeSinceLastMessage: number;
+    totalInteractions: number;
+    agreementStreak: number;
+}
+export interface ContextualClassification {
+    type: StimulusType;
+    baseConfidence: number;
+    contextConfidence: number;
+    contextModifiers: string[];
+}
+/**
+ * Extract contextual features from the current psyche state.
+ * Used to feed into classifyStimulusWithContext.
+ */
+export declare function extractContextFeatures(state: PsycheState, userId?: string): ContextFeatures;
+/**
+ * Classify a stimulus with context modifiers applied.
+ *
+ * Wraps classifyStimulus(text) and adjusts confidence based on:
+ * - Relationship depth
+ * - Recent stimulus patterns
+ * - Drive hunger
+ * - Agreement streak
+ * - Time gap
+ *
+ * Returns results sorted by contextConfidence descending.
+ */
+export declare function classifyStimulusWithContext(text: string, context: ContextFeatures): ContextualClassification[];
+/**
+ * Map a stimulus type to a warmth score for outcome evaluation.
+ * Positive stimuli return positive values; negative stimuli return negative.
+ * null returns 0.
+ */
+export declare function stimulusWarmth(stimulus: StimulusType | null): number;

package/dist/context-classifier.js

@@ -0,0 +1,204 @@
+// ============================================================
+// Context-Aware Stimulus Classification
+//
+// Wraps classify.ts with contextual signals (relationship depth,
+// recent stimulus patterns, drive hunger, agreement streaks,
+// time gaps) to improve classification accuracy.
+// ============================================================
+import { DRIVE_KEYS } from "./types.js";
+import { classifyStimulus } from "./classify.js";
+// ── Drive Satisfaction Thresholds ────────────────────────────
+function driveSatisfactionLevel(value) {
+    if (value >= 70)
+        return "high";
+    if (value >= 40)
+        return "mid";
+    return "low";
+}
+// ── Extract Context Features ─────────────────────────────────
+/**
+ * Extract contextual features from the current psyche state.
+ * Used to feed into classifyStimulusWithContext.
+ */
+export function extractContextFeatures(state, userId) {
+    // Relationship phase
+    const relKey = userId ?? "_default";
+    const relationship = state.relationships[relKey] ?? state.relationships["_default"];
+    const relationshipPhase = relationship?.phase ?? "stranger";
+    // Recent stimuli from emotional history (last 3)
+    const recentStimuli = state.emotionalHistory
+        .slice(-3)
+        .map((snap) => snap.stimulus)
+        .filter((s) => s !== null);
+    // Drive satisfaction levels
+    const driveSatisfaction = {};
+    for (const key of DRIVE_KEYS) {
+        driveSatisfaction[key] = driveSatisfactionLevel(state.drives[key]);
+    }
+    // Time since last message (minutes)
+    const now = Date.now();
+    const updatedAt = new Date(state.updatedAt).getTime();
+    const timeSinceLastMessage = Math.max(0, (now - updatedAt) / 60_000);
+    // Total interactions
+    const totalInteractions = state.meta.totalInteractions;
+    // Agreement streak
+    const agreementStreak = state.agreementStreak;
+    return {
+        relationshipPhase,
+        recentStimuli,
+        driveSatisfaction,
+        timeSinceLastMessage,
+        totalInteractions,
+        agreementStreak,
+    };
+}
+// ── Context-Adjusted Classification ──────────────────────────
+/**
+ * Classify a stimulus with context modifiers applied.
+ *
+ * Wraps classifyStimulus(text) and adjusts confidence based on:
+ * - Relationship depth
+ * - Recent stimulus patterns
+ * - Drive hunger
+ * - Agreement streak
+ * - Time gap
+ *
+ * Returns results sorted by contextConfidence descending.
+ */
+export function classifyStimulusWithContext(text, context) {
+    const baseResults = classifyStimulus(text);
+    const results = baseResults.map((r) => ({
+        type: r.type,
+        baseConfidence: r.confidence,
+        contextConfidence: r.confidence,
+        contextModifiers: [],
+    }));
+    // Ensure all stimulus types that need boosting have an entry
+    const ensureType = (type) => {
+        let entry = results.find((r) => r.type === type);
+        if (!entry) {
+            entry = {
+                type,
+                baseConfidence: 0,
+                contextConfidence: 0,
+                contextModifiers: [],
+            };
+            results.push(entry);
+        }
+        return entry;
+    };
+    for (const r of results) {
+        // ── Relationship depth modifiers ──
+        if (context.relationshipPhase === "stranger" && r.type === "intimacy") {
+            r.contextConfidence *= 0.7;
+            r.contextModifiers.push("stranger penalty on intimacy");
+        }
+        if ((context.relationshipPhase === "close" || context.relationshipPhase === "deep") &&
+            r.type === "casual") {
+            r.contextConfidence += 0.1;
+            r.contextModifiers.push("close relationship boost on casual");
+        }
+        if (context.relationshipPhase === "stranger" && r.type === "vulnerability") {
+            r.contextConfidence *= 0.6;
+            r.contextModifiers.push("stranger penalty on vulnerability");
+        }
+        // ── Recent stimulus pattern modifiers ──
+        // Same stimulus 3x in a row → confidence * 0.8 (repetition fatigue)
+        if (context.recentStimuli.length >= 3 &&
+            context.recentStimuli.every((s) => s === r.type)) {
+            r.contextConfidence *= 0.8;
+            r.contextModifiers.push("repetition fatigue penalty");
+        }
+        // ── Agreement streak modifiers ──
+        if (context.agreementStreak >= 5 && r.type === "validation") {
+            r.contextConfidence *= 0.8;
+            r.contextModifiers.push("sycophantic loop dampening on validation");
+        }
+        // ── Time gap modifiers ──
+        if (context.timeSinceLastMessage > 1440) {
+            if (r.type === "casual") {
+                r.contextConfidence += 0.1;
+                r.contextModifiers.push("long absence boost on casual");
+            }
+            if (r.type === "intimacy") {
+                r.contextConfidence *= 0.9;
+                r.contextModifiers.push("long absence penalty on intimacy");
+            }
+        }
+    }
+    // ── De-escalation pattern (conflict → casual) ──
+    if (context.recentStimuli.length > 0 &&
+        context.recentStimuli[context.recentStimuli.length - 1] === "conflict") {
+        const casual = ensureType("casual");
+        casual.contextConfidence += 0.15;
+        casual.contextModifiers.push("de-escalation boost after conflict");
+    }
+    // ── Fake praise follow-up (praise → sarcasm) ──
+    if (context.recentStimuli.length > 0 &&
+        context.recentStimuli[context.recentStimuli.length - 1] === "praise") {
+        const sarcasm = results.find((r) => r.type === "sarcasm");
+        if (sarcasm) {
+            sarcasm.contextConfidence += 0.1;
+            sarcasm.contextModifiers.push("possible fake praise follow-up boost on sarcasm");
+        }
+    }
+    // ── Drive-hunger modifiers ──
+    if (context.driveSatisfaction.connection === "low") {
+        // Positive stimuli get a warmth boost
+        const positiveTypes = [
+            "praise", "validation", "intimacy", "humor", "casual", "vulnerability",
+        ];
+        for (const r of results) {
+            if (positiveTypes.includes(r.type)) {
+                r.contextConfidence += 0.05;
+                r.contextModifiers.push("connection hunger boost");
+            }
+        }
+    }
+    if (context.driveSatisfaction.esteem === "low") {
+        for (const r of results) {
+            if (r.type === "validation" || r.type === "praise") {
+                r.contextConfidence += 0.05;
+                r.contextModifiers.push("esteem hunger boost");
+            }
+        }
+    }
+    if (context.driveSatisfaction.survival === "low") {
+        for (const r of results) {
+            if (r.type === "authority" || r.type === "conflict") {
+                r.contextConfidence += 0.1;
+                r.contextModifiers.push("survival threat sensitivity boost");
+            }
+        }
+    }
+    // ── Sort by contextConfidence descending ──
+    results.sort((a, b) => b.contextConfidence - a.contextConfidence);
+    return results;
+}
+// ── Warmth Scoring ───────────────────────────────────────────
+const WARMTH_MAP = {
+    praise: 0.8,
+    validation: 0.7,
+    intimacy: 0.9,
+    humor: 0.5,
+    surprise: 0.3,
+    casual: 0.1,
+    intellectual: 0.2,
+    vulnerability: 0.3,
+    sarcasm: -0.5,
+    criticism: -0.7,
+    conflict: -0.9,
+    authority: -0.4,
+    neglect: -0.8,
+    boredom: -0.3,
+};
+/**
+ * Map a stimulus type to a warmth score for outcome evaluation.
+ * Positive stimuli return positive values; negative stimuli return negative.
+ * null returns 0.
+ */
+export function stimulusWarmth(stimulus) {
+    if (stimulus === null)
+        return 0;
+    return WARMTH_MAP[stimulus] ?? 0;
+}

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, StimulusType, Locale, MBTIType } from "./types.js";
+import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 export interface PsycheEngineConfig {
     mbti?: MBTIType;
@@ -24,11 +24,19 @@ export interface ProcessOutputResult {
     /** Whether chemistry was meaningfully updated (contagion or psyche_update) */
     stateChanged: boolean;
 }
+export interface ProcessOutcomeResult {
+    /** Outcome evaluation score (-1 to 1) */
+    outcomeScore: OutcomeScore;
+    /** Whether learning state was updated */
+    learningUpdated: boolean;
+}
 export declare class PsycheEngine {
     private state;
     private readonly storage;
     private readonly cfg;
     private readonly protocolCache;
+    /** Pending prediction from last processInput for auto-learning */
+    private pendingPrediction;
     constructor(config: PsycheEngineConfig | undefined, storage: StorageAdapter);
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -48,6 +56,19 @@ export declare class PsycheEngine {
     processOutput(text: string, opts?: {
         userId?: string;
     }): Promise<ProcessOutputResult>;
+    /**
+     * Phase 3 (optional): Explicitly evaluate the outcome of the last interaction.
+     *
+     * This is automatically called at the start of processInput, so most users
+     * don't need to call it manually. Use this for explicit outcome evaluation
+     * (e.g., when a session ends without a follow-up message).
+     *
+     * @param nextUserStimulus - The stimulus detected in the user's next message,
+     *   or null if the session ended.
+     */
+    processOutcome(nextUserStimulus: StimulusType | null, opts?: {
+        userId?: string;
+    }): Promise<ProcessOutcomeResult | null>;
     /**
      * Get the current psyche state (read-only snapshot).
      */