psyche-ai 2.3.0 → 3.0.0

package/README.md

@@ -161,6 +161,8 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **流式支持** — Vercel AI SDK `streamText` 中间件，自动缓冲和剥离标签
 - **渠道修饰** — Discord/Slack/飞书/终端等不同渠道自动调整表达风格
 - **自定义人格** — 超越 MBTI 预设，完全自定义 baseline/敏感度/气质
+- **情绪学习** — 从交互结果中学习，调整情绪反应参数（躯体标记假说）
+- **上下文分类** — 关系/驱力/历史感知的刺激分类，超越简单正则
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -170,7 +172,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 469 tests
+npm test           # 525 tests
 npm run typecheck  # strict mode
 ```
 

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).
      */

package/dist/core.js

@@ -1,13 +1,17 @@
 // ============================================================
 // PsycheEngine — Framework-agnostic emotional intelligence core
 //
-// Two-phase API:
-//   processInput(text)  → systemContext + dynamicContext + stimulus
-//   processOutput(text) → cleanedText + stateChanged
+// Three-phase API:
+//   processInput(text)   → systemContext + dynamicContext + stimulus
+//   processOutput(text)  → cleanedText + stateChanged
+//   processOutcome(text) → outcomeScore (optional: evaluate last interaction)
 //
-// Orchestrates: chemistry, classify, prompt, profiles, guards
+// Auto-learning: processInput auto-evaluates the previous turn's
+// outcome using the new user message as the outcome signal.
+//
+// Orchestrates: chemistry, classify, prompt, profiles, guards, learning
 // ============================================================
-import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES } from "./types.js";
+import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE } from "./types.js";
 import { applyDecay, applyStimulus, applyContagion, clamp } from "./chemistry.js";
 import { classifyStimulus } from "./classify.js";
 import { buildDynamicContext, buildProtocolContext, buildCompactContext } from "./prompt.js";
@@ -16,6 +20,7 @@ import { isStimulusType } from "./guards.js";
 import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, } from "./psyche-file.js";
 import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
 import { checkForUpdate } from "./update.js";
+import { evaluateOutcome, computeContextHash, updateLearnedVector, predictChemistry, recordPrediction, } from "./learning.js";
 const NOOP_LOGGER = { info: () => { }, warn: () => { }, debug: () => { } };
 // ── PsycheEngine ─────────────────────────────────────────────
 export class PsycheEngine {
@@ -23,6 +28,8 @@ export class PsycheEngine {
     storage;
     cfg;
     protocolCache = new Map();
+    /** Pending prediction from last processInput for auto-learning */
+    pendingPrediction = null;
     constructor(config = {}, storage) {
         this.storage = storage;
         this.cfg = {
@@ -41,6 +48,11 @@ export class PsycheEngine {
     async initialize() {
         const loaded = await this.storage.load();
         if (loaded) {
+            // Migrate v3 → v4: add learning state if missing
+            if (!loaded.learning) {
+                loaded.learning = { ...DEFAULT_LEARNING_STATE };
+                loaded.version = 4;
+            }
             this.state = loaded;
         }
         else {
@@ -56,6 +68,29 @@ export class PsycheEngine {
      */
     async processInput(text, opts) {
         let state = this.ensureInitialized();
+        // ── Auto-learning: evaluate previous turn's outcome ──────
+        if (this.pendingPrediction && text.length > 0) {
+            const nextClassifications = classifyStimulus(text);
+            const nextStimulus = (nextClassifications[0]?.confidence ?? 0) >= 0.5
+                ? nextClassifications[0].type
+                : null;
+            const outcome = evaluateOutcome(this.pendingPrediction.preInteractionState, state, nextStimulus, this.pendingPrediction.appliedStimulus);
+            // Record prediction accuracy
+            state = {
+                ...state,
+                learning: recordPrediction(state.learning, this.pendingPrediction.predictedChemistry, state.current, this.pendingPrediction.appliedStimulus),
+            };
+            // Update learned vectors based on outcome
+            if (this.pendingPrediction.appliedStimulus) {
+                state = {
+                    ...state,
+                    learning: updateLearnedVector(state.learning, this.pendingPrediction.appliedStimulus, this.pendingPrediction.contextHash, outcome.adaptiveScore, state.current, state.baseline),
+                };
+            }
+            this.pendingPrediction = null;
+        }
+        // ── Snapshot pre-interaction state for next turn's outcome evaluation
+        const preInteractionState = { ...state };
         // Time decay toward baseline (chemistry + drives)
         const now = new Date();
         const minutesElapsed = (now.getTime() - new Date(state.updatedAt).getTime()) / 60000;
@@ -124,6 +159,21 @@ export class PsycheEngine {
             ...state,
             meta: { ...state.meta, totalInteractions: state.meta.totalInteractions + 1 },
         };
+        // ── Generate prediction for next turn's auto-learning ────
+        if (appliedStimulus) {
+            const ctxHash = computeContextHash(state, opts?.userId);
+            const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, appliedStimulus);
+            const predicted = predictChemistry(preInteractionState.current, appliedStimulus, state.learning, ctxHash, effectiveSensitivity, this.cfg.maxChemicalDelta);
+            this.pendingPrediction = {
+                predictedChemistry: predicted,
+                preInteractionState,
+                appliedStimulus,
+                contextHash: ctxHash,
+            };
+        }
+        else {
+            this.pendingPrediction = null;
+        }
         // Persist
         this.state = state;
         await this.storage.save(state);
@@ -185,6 +235,41 @@ export class PsycheEngine {
         }
         return { cleanedText, stateChanged };
     }
+    /**
+     * 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.
+     */
+    async processOutcome(nextUserStimulus, opts) {
+        if (!this.pendingPrediction)
+            return null;
+        let state = this.ensureInitialized();
+        const pending = this.pendingPrediction;
+        this.pendingPrediction = null;
+        const outcome = evaluateOutcome(pending.preInteractionState, state, nextUserStimulus, pending.appliedStimulus);
+        // Record prediction
+        state = {
+            ...state,
+            learning: recordPrediction(state.learning, pending.predictedChemistry, state.current, pending.appliedStimulus),
+        };
+        // Update learned vectors
+        let learningUpdated = false;
+        if (pending.appliedStimulus) {
+            state = {
+                ...state,
+                learning: updateLearnedVector(state.learning, pending.appliedStimulus, pending.contextHash, outcome.adaptiveScore, state.current, state.baseline),
+            };
+            learningUpdated = true;
+        }
+        this.state = state;
+        await this.storage.save(state);
+        return { outcomeScore: outcome, learningUpdated };
+    }
     /**
      * Get the current psyche state (read-only snapshot).
      */
@@ -216,7 +301,7 @@ export class PsycheEngine {
         const selfModel = getDefaultSelfModel(mbti);
         const now = new Date().toISOString();
         return {
-            version: 3,
+            version: 4,
             mbti,
             baseline,
             current: { ...baseline },
@@ -228,6 +313,7 @@ export class PsycheEngine {
             emotionalHistory: [],
             agreementStreak: 0,
             lastDisagreement: null,
+            learning: { ...DEFAULT_LEARNING_STATE },
             meta: {
                 agentName: name,
                 createdAt: now,

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export { PsycheEngine } from "./core.js";
-export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult } 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, } from "./types.js";
-export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, 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, } 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 { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 export type { SelfReflection } from "./self-recognition.js";
 export { PsycheInteraction } from "./interaction.js";
@@ -12,6 +12,9 @@ export { getChannelProfile, buildChannelModifier, createCustomChannel } from "./
 export type { ChannelType, ChannelProfile } from "./channels.js";
 export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./custom-profile.js";
 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 { 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, DRIVE_KEYS, DRIVE_NAMES_ZH, } 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";
 // Self-recognition
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 // Multi-agent interaction
@@ -21,6 +21,10 @@ export { PsycheInteraction } from "./interaction.js";
 export { getChannelProfile, buildChannelModifier, createCustomChannel } from "./channels.js";
 // Custom profiles — beyond MBTI presets
 export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./custom-profile.js";
+// Emotional learning (P3)
+export { evaluateOutcome, getLearnedVector, updateLearnedVector, computeContextHash, predictChemistry, computePredictionError, recordPrediction, getAveragePredictionError, } from "./learning.js";
+// Context-aware classification (P3)
+export { classifyStimulusWithContext, extractContextFeatures, stimulusWarmth } from "./context-classifier.js";
 // Utilities — for custom adapter / advanced use
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";

package/dist/learning.d.ts

@@ -0,0 +1,56 @@
+import type { PsycheState, StimulusType, ChemicalState, StimulusVector, LearningState, OutcomeScore } from "./types.js";
+/**
+ * Evaluate the adaptive outcome of an interaction turn.
+ *
+ * Computes a score from -1 to 1 using multiple signals:
+ * drive changes, relationship changes, user warmth, conversation continuation.
+ */
+export declare function evaluateOutcome(prevState: PsycheState, currentState: PsycheState, nextUserStimulus: StimulusType | null, appliedStimulus: StimulusType | null): OutcomeScore;
+/**
+ * Get the effective stimulus vector for a given stimulus + context,
+ * combining the base vector with any learned adjustment.
+ */
+export declare function getLearnedVector(learning: LearningState, stimulus: StimulusType, contextHash: string): StimulusVector;
+/**
+ * Update a learned vector adjustment based on an outcome.
+ *
+ * Learning rule:
+ * - Positive outcome → reinforce (adjust toward actual delta)
+ * - Negative outcome → suppress (adjust away from actual delta)
+ * - Learning rate: 0.05 * |outcomeScore|
+ * - Each adjustment clamped to +/- 50% of base vector value
+ */
+export declare function updateLearnedVector(learning: LearningState, stimulus: StimulusType, contextHash: string, outcomeScore: number, actualChemistry: ChemicalState, baselineChemistry: ChemicalState): LearningState;
+/**
+ * Compute a context hash from the current psyche state.
+ *
+ * Format: "{phase}:{last3stimuli}:{driveLevels}"
+ * Drive levels are encoded as h(igh)/m(id)/l(ow) for each of the 5 drives.
+ *
+ * Example: "familiar:praise,casual,intellectual:hml_hh"
+ */
+export declare function computeContextHash(state: PsycheState, _userId?: string): string;
+/**
+ * Predict the resulting chemistry after applying a stimulus,
+ * using learned vectors instead of raw base vectors.
+ *
+ * Same math as applyStimulus in chemistry.ts but with learned adjustments.
+ */
+export declare function predictChemistry(current: ChemicalState, stimulus: StimulusType, learning: LearningState, contextHash: string, sensitivity: number, maxDelta: number): ChemicalState;
+/**
+ * Compute the prediction error between predicted and actual chemistry.
+ *
+ * Euclidean distance across all 6 chemicals, normalized to 0-1 range.
+ * Normalization factor: sqrt(6 * 100^2) = sqrt(60000) ~= 244.95
+ */
+export declare function computePredictionError(predicted: ChemicalState, actual: ChemicalState): number;
+/**
+ * Record a prediction and its actual outcome.
+ * Pushes to predictionHistory and trims to MAX_PREDICTION_HISTORY.
+ */
+export declare function recordPrediction(learning: LearningState, predicted: ChemicalState, actual: ChemicalState, stimulus: StimulusType | null): LearningState;
+/**
+ * Get the average prediction error over recent history.
+ * Returns 1.0 if no history exists (maximum uncertainty).
+ */
+export declare function getAveragePredictionError(learning: LearningState): number;

package/dist/learning.js

@@ -0,0 +1,272 @@
+// ============================================================
+// Emotional Learning Engine — Damasio's Somatic Marker Hypothesis
+//
+// The system learns from interaction outcomes which emotional
+// reactions are adaptive. Over time, stimulus→chemistry mappings
+// shift based on what actually worked in context.
+//
+// Components:
+//   1. OutcomeEvaluator  — scores interaction outcomes
+//   2. StimulusVectorStore — learned vector adjustments
+//   3. PredictionEngine  — predict & track prediction error
+// ============================================================
+import { CHEMICAL_KEYS, DRIVE_KEYS, MAX_LEARNED_VECTORS, MAX_PREDICTION_HISTORY, } from "./types.js";
+import { STIMULUS_VECTORS, clamp } from "./chemistry.js";
+// ── 1. OutcomeEvaluator ─────────────────────────────────────
+/** Warmth mapping for nextUserStimulus */
+const WARMTH_MAP = {
+    praise: 0.8,
+    validation: 0.7,
+    intimacy: 0.9,
+    humor: 0.5,
+    casual: 0,
+    intellectual: 0.2,
+    surprise: 0.3,
+    vulnerability: 0.4,
+    criticism: -0.6,
+    conflict: -0.8,
+    neglect: -0.9,
+    sarcasm: -0.5,
+    authority: -0.4,
+    boredom: -0.3,
+};
+/**
+ * Evaluate the adaptive outcome of an interaction turn.
+ *
+ * Computes a score from -1 to 1 using multiple signals:
+ * drive changes, relationship changes, user warmth, conversation continuation.
+ */
+export function evaluateOutcome(prevState, currentState, nextUserStimulus, appliedStimulus) {
+    // Drive delta: sum of all drive changes, normalized
+    let driveSum = 0;
+    for (const key of DRIVE_KEYS) {
+        driveSum += currentState.drives[key] - prevState.drives[key];
+    }
+    const driveDelta = Math.max(-1, Math.min(1, driveSum / 50));
+    // Relationship delta: change in trust + intimacy of _default relationship
+    const prevRel = prevState.relationships._default ?? { trust: 50, intimacy: 30 };
+    const curRel = currentState.relationships._default ?? { trust: 50, intimacy: 30 };
+    const relChange = (curRel.trust - prevRel.trust) + (curRel.intimacy - prevRel.intimacy);
+    const relationshipDelta = Math.max(-1, Math.min(1, relChange / 20));
+    // User warmth: what the user said next
+    const userWarmthDelta = nextUserStimulus !== null ? (WARMTH_MAP[nextUserStimulus] ?? 0) : 0;
+    // Conversation continued
+    const conversationContinued = nextUserStimulus !== null;
+    // Weighted average
+    const continuedBonus = conversationContinued ? 0.15 : -0.15;
+    const raw = driveDelta * 0.25
+        + relationshipDelta * 0.25
+        + userWarmthDelta * 0.35
+        + continuedBonus;
+    const adaptiveScore = Math.max(-1, Math.min(1, raw));
+    const signals = {
+        driveDelta,
+        relationshipDelta,
+        userWarmthDelta,
+        conversationContinued,
+    };
+    return {
+        turnIndex: currentState.meta.totalInteractions,
+        stimulus: appliedStimulus,
+        adaptiveScore,
+        signals,
+        timestamp: new Date().toISOString(),
+    };
+}
+// ── 2. StimulusVectorStore ──────────────────────────────────
+/**
+ * Get the effective stimulus vector for a given stimulus + context,
+ * combining the base vector with any learned adjustment.
+ */
+export function getLearnedVector(learning, stimulus, contextHash) {
+    const base = STIMULUS_VECTORS[stimulus];
+    if (!base) {
+        // Unknown stimulus — return zeros
+        return { DA: 0, HT: 0, CORT: 0, OT: 0, NE: 0, END: 0 };
+    }
+    // Look for a learned adjustment matching this stimulus + context
+    const entry = learning.learnedVectors.find((v) => v.stimulus === stimulus && v.contextHash === contextHash);
+    if (!entry)
+        return { ...base };
+    // Apply adjustment
+    const result = { ...base };
+    for (const key of CHEMICAL_KEYS) {
+        const adj = entry.adjustment[key] ?? 0;
+        result[key] = base[key] + adj;
+    }
+    return result;
+}
+/**
+ * Update a learned vector adjustment based on an outcome.
+ *
+ * Learning rule:
+ * - Positive outcome → reinforce (adjust toward actual delta)
+ * - Negative outcome → suppress (adjust away from actual delta)
+ * - Learning rate: 0.05 * |outcomeScore|
+ * - Each adjustment clamped to +/- 50% of base vector value
+ */
+export function updateLearnedVector(learning, stimulus, contextHash, outcomeScore, actualChemistry, baselineChemistry) {
+    const base = STIMULUS_VECTORS[stimulus];
+    if (!base)
+        return learning;
+    // Chemistry delta: what actually happened
+    const chemDelta = {};
+    for (const key of CHEMICAL_KEYS) {
+        chemDelta[key] = actualChemistry[key] - baselineChemistry[key];
+    }
+    // Learning rate: conservative, proportional to outcome strength
+    const learningRate = 0.05 * Math.abs(outcomeScore);
+    const direction = outcomeScore >= 0 ? 1 : -1;
+    // Find or create entry
+    const existingIdx = learning.learnedVectors.findIndex((v) => v.stimulus === stimulus && v.contextHash === contextHash);
+    let entry;
+    if (existingIdx >= 0) {
+        entry = { ...learning.learnedVectors[existingIdx] };
+        entry.adjustment = { ...entry.adjustment };
+    }
+    else {
+        entry = {
+            stimulus,
+            contextHash,
+            adjustment: {},
+            confidence: 0,
+            sampleCount: 0,
+            lastUpdated: new Date().toISOString(),
+        };
+    }
+    // Update adjustment for each chemical
+    for (const key of CHEMICAL_KEYS) {
+        const currentAdj = entry.adjustment[key] ?? 0;
+        const delta = chemDelta[key] * direction * learningRate;
+        let newAdj = currentAdj + delta;
+        // Clamp to +/- 50% of base vector absolute value
+        const baseAbs = Math.abs(base[key]);
+        const maxAdj = Math.max(baseAbs * 0.5, 1); // at least 1 to allow learning on zero-base values
+        newAdj = Math.max(-maxAdj, Math.min(maxAdj, newAdj));
+        entry.adjustment[key] = newAdj;
+    }
+    // Update metadata
+    entry.sampleCount += 1;
+    entry.confidence = 0.9 * entry.confidence + 0.1 * Math.abs(outcomeScore);
+    entry.lastUpdated = new Date().toISOString();
+    // Build new vectors array
+    let newVectors;
+    if (existingIdx >= 0) {
+        newVectors = [...learning.learnedVectors];
+        newVectors[existingIdx] = entry;
+    }
+    else {
+        newVectors = [...learning.learnedVectors, entry];
+    }
+    // Trim to MAX_LEARNED_VECTORS: keep highest sampleCount entries
+    if (newVectors.length > MAX_LEARNED_VECTORS) {
+        newVectors.sort((a, b) => b.sampleCount - a.sampleCount);
+        newVectors = newVectors.slice(0, MAX_LEARNED_VECTORS);
+    }
+    return {
+        ...learning,
+        learnedVectors: newVectors,
+    };
+}
+/**
+ * Compute a context hash from the current psyche state.
+ *
+ * Format: "{phase}:{last3stimuli}:{driveLevels}"
+ * Drive levels are encoded as h(igh)/m(id)/l(ow) for each of the 5 drives.
+ *
+ * Example: "familiar:praise,casual,intellectual:hml_hh"
+ */
+export function computeContextHash(state, _userId) {
+    // Relationship phase
+    const rel = state.relationships._default ?? { phase: "stranger" };
+    const phase = rel.phase;
+    // Last 3 stimuli from emotional history
+    const history = state.emotionalHistory ?? [];
+    const recentStimuli = history
+        .slice(-3)
+        .map((s) => s.stimulus ?? "none")
+        .join(",");
+    // Drive satisfaction levels: h(igh >=67), m(id 34-66), l(ow <34)
+    const driveLevels = [];
+    for (const key of DRIVE_KEYS) {
+        const val = state.drives[key];
+        if (val >= 67)
+            driveLevels.push("h");
+        else if (val >= 34)
+            driveLevels.push("m");
+        else
+            driveLevels.push("l");
+    }
+    // Format: separate safety from the rest for readability
+    // survival_safety_connection_esteem_curiosity
+    const driveStr = driveLevels.join("");
+    return `${phase}:${recentStimuli || "none"}:${driveStr}`;
+}
+// ── 3. PredictionEngine ─────────────────────────────────────
+/**
+ * Predict the resulting chemistry after applying a stimulus,
+ * using learned vectors instead of raw base vectors.
+ *
+ * Same math as applyStimulus in chemistry.ts but with learned adjustments.
+ */
+export function predictChemistry(current, stimulus, learning, contextHash, sensitivity, maxDelta) {
+    const vector = getLearnedVector(learning, stimulus, contextHash);
+    const result = { ...current };
+    for (const key of CHEMICAL_KEYS) {
+        const raw = vector[key] * sensitivity;
+        const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
+        result[key] = clamp(current[key] + clamped);
+    }
+    return result;
+}
+/**
+ * Compute the prediction error between predicted and actual chemistry.
+ *
+ * Euclidean distance across all 6 chemicals, normalized to 0-1 range.
+ * Normalization factor: sqrt(6 * 100^2) = sqrt(60000) ~= 244.95
+ */
+export function computePredictionError(predicted, actual) {
+    let sumSq = 0;
+    for (const key of CHEMICAL_KEYS) {
+        const diff = predicted[key] - actual[key];
+        sumSq += diff * diff;
+    }
+    const maxDistance = Math.sqrt(6 * 100 * 100); // ~244.95
+    return Math.sqrt(sumSq) / maxDistance;
+}
+/**
+ * Record a prediction and its actual outcome.
+ * Pushes to predictionHistory and trims to MAX_PREDICTION_HISTORY.
+ */
+export function recordPrediction(learning, predicted, actual, stimulus) {
+    const error = computePredictionError(predicted, actual);
+    const record = {
+        predictedChemistry: { ...predicted },
+        actualChemistry: { ...actual },
+        stimulus,
+        predictionError: error,
+        timestamp: new Date().toISOString(),
+    };
+    let newHistory = [...learning.predictionHistory, record];
+    if (newHistory.length > MAX_PREDICTION_HISTORY) {
+        newHistory = newHistory.slice(newHistory.length - MAX_PREDICTION_HISTORY);
+    }
+    return {
+        ...learning,
+        predictionHistory: newHistory,
+    };
+}
+// ── 4. Utility ──────────────────────────────────────────────
+/**
+ * Get the average prediction error over recent history.
+ * Returns 1.0 if no history exists (maximum uncertainty).
+ */
+export function getAveragePredictionError(learning) {
+    if (learning.predictionHistory.length === 0)
+        return 1.0;
+    let sum = 0;
+    for (const record of learning.predictionHistory) {
+        sum += record.predictionError;
+    }
+    return sum / learning.predictionHistory.length;
+}

package/dist/psyche-file.js

@@ -4,7 +4,7 @@
 // ============================================================
 import { readFile, writeFile, access, rename, constants } from "node:fs/promises";
 import { join } from "node:path";
-import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, MAX_EMOTIONAL_HISTORY, MAX_RELATIONSHIP_MEMORY, } from "./types.js";
+import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, MAX_EMOTIONAL_HISTORY, MAX_RELATIONSHIP_MEMORY, } from "./types.js";
 import { getBaseline, getDefaultSelfModel, extractMBTI, getSensitivity, getTemperament } from "./profiles.js";
 import { applyDecay, detectEmotions } from "./chemistry.js";
 import { decayDrives, computeEffectiveBaseline } from "./drives.js";
@@ -240,10 +240,12 @@ export function migrateToLatest(raw, fallbackName) {
         };
     }
     // v2→v3: add drives
+    // v3→v4: add learning
     return {
         ...state,
-        version: 3,
+        version: 4,
         drives: state.drives ?? { ...DEFAULT_DRIVES },
+        learning: state.learning ?? { ...DEFAULT_LEARNING_STATE },
     };
 }
 /**
@@ -257,7 +259,7 @@ export async function initializeState(workspaceDir, opts, logger = NOOP_LOGGER)
     const selfModel = getDefaultSelfModel(mbti);
     const now = new Date().toISOString();
     const state = {
-        version: 3,
+        version: 4,
         mbti,
         baseline,
         current: { ...baseline },
@@ -271,6 +273,7 @@ export async function initializeState(workspaceDir, opts, logger = NOOP_LOGGER)
         emotionalHistory: [],
         agreementStreak: 0,
         lastDisagreement: null,
+        learning: { ...DEFAULT_LEARNING_STATE },
         meta: {
             agentName,
             createdAt: now,

package/dist/types.d.ts

@@ -81,9 +81,56 @@ export interface SelfModel {
     boundaries: string[];
     currentInterests: string[];
 }
-/** Persisted psyche state for an agent (v0.3: innate drives) */
+/** Learned adjustment to a stimulus vector for a specific context */
+export interface LearnedVectorAdjustment {
+    stimulus: StimulusType;
+    contextHash: string;
+    adjustment: Partial<StimulusVector>;
+    confidence: number;
+    sampleCount: number;
+    lastUpdated: string;
+}
+/** A single prediction record for prediction error tracking */
+export interface PredictionRecord {
+    predictedChemistry: ChemicalState;
+    actualChemistry: ChemicalState;
+    stimulus: StimulusType | null;
+    predictionError: number;
+    timestamp: string;
+}
+/** Outcome evaluation signals for a turn */
+export interface OutcomeSignals {
+    driveDelta: number;
+    relationshipDelta: number;
+    userWarmthDelta: number;
+    conversationContinued: boolean;
+}
+/** Outcome evaluation for a single interaction turn */
+export interface OutcomeScore {
+    turnIndex: number;
+    stimulus: StimulusType | null;
+    adaptiveScore: number;
+    signals: OutcomeSignals;
+    timestamp: string;
+}
+/** Persisted learning state */
+export interface LearningState {
+    learnedVectors: LearnedVectorAdjustment[];
+    predictionHistory: PredictionRecord[];
+    outcomeHistory: OutcomeScore[];
+    totalOutcomesProcessed: number;
+}
+/** Default empty learning state */
+export declare const DEFAULT_LEARNING_STATE: LearningState;
+/** Max learned vector entries */
+export declare const MAX_LEARNED_VECTORS = 200;
+/** Max prediction history entries */
+export declare const MAX_PREDICTION_HISTORY = 50;
+/** Max outcome history entries */
+export declare const MAX_OUTCOME_HISTORY = 50;
+/** Persisted psyche state for an agent (v4: emotional learning) */
 export interface PsycheState {
-    version: 3;
+    version: 3 | 4;
     mbti: MBTIType;
     baseline: ChemicalState;
     current: ChemicalState;
@@ -95,6 +142,7 @@ export interface PsycheState {
     emotionalHistory: ChemicalSnapshot[];
     agreementStreak: number;
     lastDisagreement: string | null;
+    learning: LearningState;
     meta: {
         agentName: string;
         createdAt: string;

package/dist/types.js

@@ -60,6 +60,19 @@ export const CHEMICAL_DECAY_SPEED = {
 export const MAX_EMOTIONAL_HISTORY = 10;
 /** Max compressed session memories per relationship */
 export const MAX_RELATIONSHIP_MEMORY = 20;
+/** Default empty learning state */
+export const DEFAULT_LEARNING_STATE = {
+    learnedVectors: [],
+    predictionHistory: [],
+    outcomeHistory: [],
+    totalOutcomesProcessed: 0,
+};
+/** Max learned vector entries */
+export const MAX_LEARNED_VECTORS = 200;
+/** Max prediction history entries */
+export const MAX_PREDICTION_HISTORY = 50;
+/** Max outcome history entries */
+export const MAX_OUTCOME_HISTORY = 50;
 /** 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 = "2.3.0";
+const CURRENT_VERSION = "3.0.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": "2.3.0",
+  "version": "3.0.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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