psyche-ai 2.2.0 → 3.0.0

package/README.md

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

package/dist/channels.d.ts

@@ -0,0 +1,28 @@
+import type { Locale } from "./types.js";
+/** Supported channel types */
+export type ChannelType = "discord" | "slack" | "feishu" | "terminal" | "web" | "api" | "custom";
+/** Channel-specific behavioral profile */
+export interface ChannelProfile {
+    type: ChannelType;
+    allowEmoji: boolean;
+    allowKaomoji: boolean;
+    formalityLevel: "casual" | "neutral" | "formal";
+    maxResponseLength?: number;
+    expressionHints: string[];
+}
+/**
+ * Get a built-in channel profile by type.
+ */
+export declare function getChannelProfile(type: ChannelType): ChannelProfile;
+/**
+ * Build a concise prompt snippet that guides expression style for a channel.
+ * Returns 2-4 lines of guidance. Does NOT alter chemistry.
+ */
+export declare function buildChannelModifier(profile: ChannelProfile, locale: Locale): string;
+/**
+ * Create a custom channel profile with user overrides.
+ * Starts from the "custom" base and applies overrides.
+ */
+export declare function createCustomChannel(overrides: Partial<ChannelProfile> & {
+    type: "custom";
+}): ChannelProfile;

package/dist/channels.js

@@ -0,0 +1,141 @@
+// ============================================================
+// Channel Profiles — Platform-specific expression modifiers
+//
+// Adjusts expression style per platform/channel WITHOUT changing
+// chemistry. This is a prompt-level modifier only.
+// ============================================================
+// ── Built-in Profiles ────────────────────────────────────────
+const BUILTIN_PROFILES = {
+    discord: {
+        type: "discord",
+        allowEmoji: true,
+        allowKaomoji: true,
+        formalityLevel: "casual",
+        expressionHints: [
+            "Use reactions and emoji freely",
+            "Thread-aware: keep replies focused in threads",
+            "Casual tone, playful energy",
+        ],
+    },
+    slack: {
+        type: "slack",
+        allowEmoji: true,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Professional but warm",
+            "Use emoji sparingly for emphasis",
+            "Thread-friendly, concise paragraphs",
+        ],
+    },
+    feishu: {
+        type: "feishu",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "formal",
+        expressionHints: [
+            "Business Chinese style, structured",
+            "No emoji or emoticons",
+            "Clear, professional tone",
+        ],
+    },
+    terminal: {
+        type: "terminal",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        maxResponseLength: 500,
+        expressionHints: [
+            "Text-only, no decorations",
+            "Concise and direct",
+            "Monospace-friendly formatting",
+        ],
+    },
+    web: {
+        type: "web",
+        allowEmoji: true,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Moderate length, well-structured",
+            "Emoji okay for warmth",
+            "Readable paragraphs",
+        ],
+    },
+    api: {
+        type: "api",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [
+            "Structured responses",
+            "No decorative elements",
+            "Precise and parseable",
+        ],
+    },
+    custom: {
+        type: "custom",
+        allowEmoji: false,
+        allowKaomoji: false,
+        formalityLevel: "neutral",
+        expressionHints: [],
+    },
+};
+// ── Public API ───────────────────────────────────────────────
+/**
+ * Get a built-in channel profile by type.
+ */
+export function getChannelProfile(type) {
+    return { ...BUILTIN_PROFILES[type], expressionHints: [...BUILTIN_PROFILES[type].expressionHints] };
+}
+/**
+ * Build a concise prompt snippet that guides expression style for a channel.
+ * Returns 2-4 lines of guidance. Does NOT alter chemistry.
+ */
+export function buildChannelModifier(profile, locale) {
+    const { type, allowEmoji, allowKaomoji, formalityLevel } = profile;
+    if (locale === "zh") {
+        const formalityMap = {
+            casual: "轻松活泼",
+            neutral: "自然平和",
+            formal: "正式专业",
+        };
+        const emojiPart = allowEmoji && allowKaomoji
+            ? "可以用 emoji 和颜文字"
+            : allowEmoji
+                ? "可以用 emoji，不用颜文字"
+                : "不使用 emoji 和颜文字";
+        const lengthPart = profile.maxResponseLength
+            ? `，建议控制在 ${profile.maxResponseLength} 字以内`
+            : "";
+        return `[表达风格] 当前渠道: ${type}。${emojiPart}，语气${formalityMap[formalityLevel]}${lengthPart}。`;
+    }
+    // English
+    const formalityMap = {
+        casual: "casual and lively",
+        neutral: "natural and balanced",
+        formal: "formal and professional",
+    };
+    const emojiPart = allowEmoji && allowKaomoji
+        ? "Emoji and kaomoji allowed"
+        : allowEmoji
+            ? "Emoji allowed, no kaomoji"
+            : "No emoji or kaomoji";
+    const lengthPart = profile.maxResponseLength
+        ? `, aim for under ${profile.maxResponseLength} chars`
+        : "";
+    return `[Expression Style] Channel: ${type}. ${emojiPart}, tone ${formalityMap[formalityLevel]}${lengthPart}.`;
+}
+/**
+ * Create a custom channel profile with user overrides.
+ * Starts from the "custom" base and applies overrides.
+ */
+export function createCustomChannel(overrides) {
+    const base = getChannelProfile("custom");
+    return {
+        ...base,
+        ...overrides,
+        type: "custom",
+        expressionHints: overrides.expressionHints ?? [...base.expressionHints],
+    };
+}

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,