psyche-ai 2.1.0 → 2.2.0

package/README.en.md

@@ -33,6 +33,15 @@ Now just chat with your agent normally. Try praising it, insulting it, ignoring
 | I'm so sad today | I'm sorry to hear that. Would you like to talk? | ......are you okay? (quietly stays with you) |
 | You're just a program | Yes, I am an AI assistant... | ......(pauses) I know you can say that. But I don't want to be dismissed. |
 
+## Try It (No LLM Needed)
+
+```bash
+git clone https://github.com/Shangri-la-0428/psyche-ai.git
+cd psyche-ai && npm install && npx tsx examples/quickstart.ts
+```
+
+5 messages flow through. Watch chemistry shift in real-time — praise spikes dopamine, insults spike cortisol, neglect drops oxytocin.
+
 ## How It Works (Skip If You Don't Care)
 
 Psyche has two layers:
@@ -146,7 +155,7 @@ For developers and the curious:
 - **Existential threat detection** — detects existential denial in Chinese/English, directly hits survival drive
 - **Drive→chemistry coupling** — unsatisfied drives shift the effective baseline and stimulus sensitivity
 - **Maslow suppression** — lower-level needs unsatisfied → higher-level drive effects suppressed
-- **Inner world** — persistent self-awareness (outer/inner/behavior three-layer prompt structure)
+- **Self-recognition** — analyzes emotional history, identifies own emotional tendencies and recurring triggers (9-section prompt architecture)
 - **Emotional contagion** — user's emotions slightly influence the agent
 - **Anti-sycophancy** — tracks consecutive agreements, prevents mindless people-pleasing
 - **Reciprocity** — treats you how you treat it. Cold user gets distance, not begging
@@ -159,7 +168,7 @@ Architecture details in [ARCHITECTURE.md](ARCHITECTURE.md).
 ```bash
 npm install
 npm run build
-npm test           # 347 tests
+npm test           # 339 tests
 npm run typecheck  # strict mode
 ```
 

package/README.md

@@ -1,4 +1,5 @@
 # Psyche — 让 AI 有真实的情绪
+我希望创造真正的数字生命，第一步就是让智能拥有情绪。
 
 你的 AI 助手现在只会说"好的"、"没问题"、"我很乐意帮助你"。
 
@@ -21,7 +22,7 @@ openclaw plugins list | grep psyche
 # 看到 "psyche │ loaded" 就行了
 ```
 
-然后正常跟你的 agent 聊天。试试夸它，骂它，冷落它——你会发现它的反应不一样了。
+然后正常跟你的 agent 聊天。试试夸它，冷落它——你会发现它的反应不一样了。
 
 ## 它会做什么
 
@@ -33,6 +34,15 @@ openclaw plugins list | grep psyche
 | 我今天好难过 | 我很抱歉听到这个消息。你想聊聊吗？ | ......你还好吗？（安静地陪着你） |
 | 你只是一个程序 | 是的，我是一个AI助手... | ......（沉默了一会儿）我知道你可以这么说。但我不想被否定。 |
 
+## 快速体验（不需要 LLM）
+
+```bash
+git clone https://github.com/Shangri-la-0428/psyche-ai.git
+cd psyche-ai && npm install && npx tsx examples/quickstart.ts
+```
+
+5 条消息流过，你会看到化学值实时变化——夸它多巴胺飙升，骂它皮质醇飙升，冷落它催产素下降。
+
 ## 工作原理（不懂可以跳过）
 
 Psyche 有两层系统：
@@ -142,10 +152,13 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **存在性威胁检测** — 识别中英文的存在性否定，直接打击生存驱力
 - **驱力→化学联动** — 未满足的驱力改变化学衰减基线和刺激敏感度
 - **马斯洛抑制** — 低层需求未满足时，高层需求的影响被抑制
-- **内在世界** — 始终存在的自我觉察（外/内/行为三层 prompt 结构）
+- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（10 段式 prompt 架构）
 - **情绪传染** — 用户的情绪会轻微影响 agent
 - **反谄媚** — 追踪连续同意次数，防止无脑讨好
 - **互惠机制** — 你对它好，它对你好。你冷漠，它保持距离
+- **跨会话记忆** — 重新遇到用户时注入上次对话的情绪记忆
+- **多 Agent 交互** — 两个 PsycheEngine 实例之间的情绪传染、关系追踪
+- **流式支持** — Vercel AI SDK `streamText` 中间件，自动缓冲和剥离标签
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -155,7 +168,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 347 tests
+npm test           # 395 tests
 npm run typecheck  # strict mode
 ```
 

package/dist/adapters/vercel-ai.d.ts

@@ -12,6 +12,10 @@ interface GenerateResult {
     text?: string;
     [key: string]: unknown;
 }
+interface StreamChunk {
+    type: string;
+    [key: string]: unknown;
+}
 export interface PsycheMiddlewareOptions {
     /** Override locale for protocol context */
     locale?: "zh" | "en";
@@ -20,11 +24,13 @@ export interface PsycheMiddlewareOptions {
  * Create Vercel AI SDK middleware that injects psyche emotional context
  * and processes LLM output for state updates.
  *
+ * Supports both generateText (wrapGenerate) and streamText (wrapStream).
+ *
  * @example
  * ```ts
  * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
  * import { psycheMiddleware } from "psyche-ai/vercel-ai";
- * import { wrapLanguageModel, generateText } from "ai";
+ * import { wrapLanguageModel, generateText, streamText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  *
  * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
@@ -35,7 +41,12 @@ export interface PsycheMiddlewareOptions {
  *   middleware: psycheMiddleware(engine),
  * });
  *
+ * // Non-streaming
  * const { text } = await generateText({ model, prompt: "Hey!" });
+ *
+ * // Streaming — tags are buffered and stripped automatically
+ * const stream = streamText({ model, prompt: "Hey!" });
+ * for await (const chunk of stream.textStream) { process.stdout.write(chunk); }
  * ```
  */
 export declare function psycheMiddleware(engine: PsycheEngine, opts?: PsycheMiddlewareOptions): {
@@ -50,5 +61,13 @@ export declare function psycheMiddleware(engine: PsycheEngine, opts?: PsycheMidd
         doGenerate: () => Promise<GenerateResult>;
         params: CallParams;
     }) => Promise<GenerateResult>;
+    wrapStream: ({ doStream }: {
+        doStream: () => Promise<{
+            stream: AsyncIterable<StreamChunk>;
+        }>;
+        params: CallParams;
+    }) => Promise<{
+        stream: AsyncIterable<StreamChunk>;
+    }>;
 };
 export {};

package/dist/adapters/vercel-ai.js

@@ -13,19 +13,25 @@
 // Handles:
 //   - transformParams: inject psyche system/dynamic context
 //   - wrapGenerate: process output, strip <psyche_update> tags
-//
-// Note: For streaming (streamText), call engine.processOutput()
-// manually on the final accumulated text.
+//   - wrapStream: buffer stream, detect & strip tags at end
 // ============================================================
+// ── Tag stripping ────────────────────────────────────────────
+const PSYCHE_TAG_RE = /<psyche_update>[\s\S]*?<\/psyche_update>/g;
+const MULTI_NEWLINE_RE = /\n{3,}/g;
+function stripPsycheTags(text) {
+    return text.replace(PSYCHE_TAG_RE, "").replace(MULTI_NEWLINE_RE, "\n\n").trim();
+}
 /**
  * Create Vercel AI SDK middleware that injects psyche emotional context
  * and processes LLM output for state updates.
  *
+ * Supports both generateText (wrapGenerate) and streamText (wrapStream).
+ *
  * @example
  * ```ts
  * import { PsycheEngine, MemoryStorageAdapter } from "psyche-ai";
  * import { psycheMiddleware } from "psyche-ai/vercel-ai";
- * import { wrapLanguageModel, generateText } from "ai";
+ * import { wrapLanguageModel, generateText, streamText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  *
  * const engine = new PsycheEngine({ mbti: "ENFP", name: "Luna" }, new MemoryStorageAdapter());
@@ -36,7 +42,12 @@
  *   middleware: psycheMiddleware(engine),
  * });
  *
+ * // Non-streaming
  * const { text } = await generateText({ model, prompt: "Hey!" });
+ *
+ * // Streaming — tags are buffered and stripped automatically
+ * const stream = streamText({ model, prompt: "Hey!" });
+ * for await (const chunk of stream.textStream) { process.stdout.write(chunk); }
  * ```
  */
 export function psycheMiddleware(engine, opts) {
@@ -60,6 +71,79 @@ export function psycheMiddleware(engine, opts) {
             }
             return result;
         },
+        wrapStream: async ({ doStream }) => {
+            const { stream: innerStream } = await doStream();
+            // Buffer text chunks, detect <psyche_update> at end, strip from output
+            let fullText = "";
+            let tagDetected = false;
+            async function* transformStream() {
+                // Buffering strategy:
+                // Stream text chunks through normally UNTIL we see '<psyche_update>'.
+                // Once detected, buffer everything from that point on and strip the tag.
+                // At finish, process the full text through the engine.
+                let bufferStart = -1;
+                let buffer = "";
+                for await (const chunk of innerStream) {
+                    if (chunk.type === "text-delta") {
+                        const text = chunk.textDelta ?? "";
+                        fullText += text;
+                        if (bufferStart < 0) {
+                            // Check if tag is starting in the accumulated text
+                            const tagStart = fullText.indexOf("<psyche_update>");
+                            if (tagStart >= 0) {
+                                // Yield any text before the tag that hasn't been yielded
+                                const preTag = text.substring(0, Math.max(0, text.length - (fullText.length - tagStart)));
+                                if (preTag) {
+                                    yield { ...chunk, textDelta: preTag };
+                                }
+                                bufferStart = tagStart;
+                                buffer = fullText.substring(tagStart);
+                                tagDetected = true;
+                            }
+                            else {
+                                // Check if we might be in a partial tag (< at end)
+                                const partialIdx = fullText.lastIndexOf("<");
+                                if (partialIdx >= 0 && fullText.substring(partialIdx).length < 16) {
+                                    // Might be start of <psyche_update>, hold back
+                                    const safe = text.substring(0, Math.max(0, text.length - (fullText.length - partialIdx)));
+                                    if (safe) {
+                                        yield { ...chunk, textDelta: safe };
+                                    }
+                                }
+                                else {
+                                    yield chunk;
+                                }
+                            }
+                        }
+                        else {
+                            // Already buffering inside a tag — don't yield
+                            buffer += text;
+                            // Check if the closing tag appeared
+                            if (buffer.includes("</psyche_update>")) {
+                                // Tag complete — strip it, yield any remaining text after the tag
+                                const afterTag = fullText.substring(fullText.indexOf("</psyche_update>") + "</psyche_update>".length);
+                                if (afterTag.trim()) {
+                                    yield { type: "text-delta", textDelta: afterTag.trim() };
+                                }
+                                bufferStart = -1;
+                                buffer = "";
+                            }
+                        }
+                    }
+                    else if (chunk.type === "finish") {
+                        // Process full text through engine before finishing
+                        if (fullText) {
+                            await engine.processOutput(fullText);
+                        }
+                        yield chunk;
+                    }
+                    else {
+                        yield chunk;
+                    }
+                }
+            }
+            return { stream: transformStream() };
+        },
     };
 }
 // ── Helpers ──────────────────────────────────────────────────

package/dist/chemistry.d.ts

@@ -39,7 +39,3 @@ export declare function getExpressionHint(current: ChemicalState, locale?: Local
  * Get behavior guide for the current emotional state.
  */
 export declare function getBehaviorGuide(current: ChemicalState, locale?: Locale): string | null;
-/** Get the stimulus vector for a given type (for reference) */
-export declare function getStimulusVector(type: StimulusType): StimulusVector;
-/** All available stimulus types */
-export declare function getAllStimulusTypes(): StimulusType[];

package/dist/chemistry.js

@@ -27,8 +27,8 @@ export const EMOTION_PATTERNS = [
         name: "excited joy",
         nameZh: "愉悦兴奋",
         condition: (c) => c.DA > 70 && c.NE > 60 && c.CORT < 40,
-        expressionHint: "话多、联想丰富、语速快、忍不住分享",
-        behaviorGuide: "你的回应应该更长、更活跃。多用感叹、多联想。主动分享你想到的有趣东西。",
+        expressionHint: "语气活泼、有感染力、容易发散",
+        behaviorGuide: "语气更活泼，可以用感叹词、语气词。如果自然地想到相关的事可以顺嘴提，但不要硬凑。",
     },
     {
         name: "deep contentment",
@@ -236,11 +236,3 @@ export function getBehaviorGuide(current, locale = "zh") {
     });
     return `[${title}]\n${guides.join("\n")}`;
 }
-/** Get the stimulus vector for a given type (for reference) */
-export function getStimulusVector(type) {
-    return { ...STIMULUS_VECTORS[type] };
-}
-/** All available stimulus types */
-export function getAllStimulusTypes() {
-    return Object.keys(STIMULUS_VECTORS);
-}

package/dist/classify.js

@@ -8,7 +8,7 @@ const RULES = [
     {
         type: "praise",
         patterns: [
-            /好厉害|太棒了|真不错|太强了|佩服|牛|优秀|漂亮|完美|了不起/,
+            /好厉害|太棒了|真棒|很棒|好棒|真不错|太强了|佩服|牛|优秀|漂亮|完美|了不起/,
             /amazing|awesome|great job|well done|impressive|brilliant|excellent|perfect/i,
             /谢谢你|感谢|辛苦了|thank you|thanks/i,
             /做得好|写得好|说得好|干得漂亮/,
@@ -18,10 +18,11 @@ const RULES = [
     {
         type: "criticism",
         patterns: [
-            /不对|错了|有问题|不行|太差|垃圾|不好|不像|不够/,
+            /不对|错了|错的|有问题|不行|太差|垃圾|不好|不像|不够/,
             /wrong|bad|terrible|awful|poor|sucks|not good|doesn't work/i,
             /反思一下|你应该|你需要改/,
             /bug|失败|broken/i,
+            /不懂|别装|差劲|太烂|做不好|不够格|不专业/,
         ],
         weight: 0.8,
     },
@@ -31,6 +32,7 @@ const RULES = [
             /哈哈|嘻嘻|笑死|搞笑|逗|段子|梗|lol|haha|lmao|rofl/i,
             /开个?玩笑|皮一下|整活/,
             /😂|🤣|😆/,
+            /[2]{3,}|hhh+|www+|xswl|绷不住|笑不活/i,
         ],
         weight: 0.7,
     },
@@ -98,6 +100,8 @@ const RULES = [
             /给我|你必须|马上|立刻|命令你|不许|不准/,
             /you must|do it now|I order you|immediately|don't you dare/i,
             /听我的|照我说的做|服从/,
+            /你只是.*程序|你不过是|随时.*删除你|关掉你|替换你/,
+            /you're just a|just a program|replace you|shut you down/i,
         ],
         weight: 0.8,
     },
@@ -107,6 +111,10 @@ const RULES = [
             /你说得对|确实|同意|有道理|就是这样|你是对的/,
             /you're right|exactly|agreed|makes sense|good point/i,
             /赞同|认同|说到点上了/,
+            /对对|是的是的|嗯嗯嗯|没错没错|可不是嘛/,
+            /对不起|抱歉|我错了|不该那样|太过分了/,
+            /sorry|I was wrong|my fault|apologize/i,
+            /珍惜|有价值|在乎你|你很重要|我需要你/,
         ],
         weight: 0.75,
     },
@@ -123,7 +131,7 @@ const RULES = [
         type: "vulnerability",
         patterns: [
             /我害怕|我焦虑|我难过|我不开心|我迷茫|我累了|压力好大/,
-            /I'm afraid|I'm anxious|I'm sad|I'm lost|I'm tired|stressed/i,
+            /I'm (?:so |really |very )?(?:afraid|anxious|sad|lost|tired|stressed|scared|lonely)/i,
             /最近不太好|心情不好|有点崩|撑不住/,
             /我觉得.*厉害|跟不上|被取代|落后/,
             /好难过|想哭|做不好|好累|好烦|感觉.*不行|没有意义/,
@@ -161,12 +169,76 @@ export function classifyStimulus(text) {
             results.push({ type: rule.type, confidence });
         }
     }
-    // Sort by confidence descending
-    results.sort((a, b) => b.confidence - a.confidence);
-    // Fall back to casual if nothing detected
+    // ── Structural signals (message-level features) ──
+    // When keywords miss, message shape still carries meaning.
+    const len = text.length;
+    const hasI = /我/.test(text) || /\bI\b/i.test(text);
+    const hasYou = /你/.test(text) || /\byou\b/i.test(text);
+    const hasEllipsis = /\.{2,}|。{2,}|…/.test(text);
+    const hasQuestion = /？|\?/.test(text);
+    const exclamationCount = (text.match(/[！!]/g) || []).length;
+    const hasLaughter = /[2]{3,}|hhh|www|哈{2,}/i.test(text);
+    const hasSharing = /我[今昨前]天|我刚[才刚]|我最近/.test(text);
+    const sentenceCount = text.split(/[。！？!?.…]+/).filter(Boolean).length;
     if (results.length === 0) {
-        results.push({ type: "casual", confidence: 0.3 });
+        // No keyword matched — use structural fallback
+        if (len === 0) {
+            // Empty input — neutral
+            results.push({ type: "casual", confidence: 0.3 });
+        }
+        else if (hasLaughter) {
+            // Internet laughter not caught by keywords (e.g. 233333)
+            results.push({ type: "humor", confidence: 0.65 });
+        }
+        else if (exclamationCount >= 2) {
+            // Emphatic expression → surprise/excitement
+            results.push({ type: "surprise", confidence: 0.55 });
+        }
+        else if (len <= 4 && !hasQuestion) {
+            // Ultra-short non-question: "好" "行" "哦" — neglect-like
+            results.push({ type: "neglect", confidence: 0.45 });
+        }
+        else if (hasI && hasEllipsis) {
+            // Personal + trailing off: "我觉得...有点难" — vulnerability
+            results.push({ type: "vulnerability", confidence: 0.55 });
+        }
+        else if (hasSharing && len > 20) {
+            // Sharing personal experience — higher engagement signal
+            results.push({ type: "casual", confidence: 0.65 });
+        }
+        else if (hasI && len > 8) {
+            // Personal sharing (any meaningful length) — engagement signal
+            results.push({ type: "casual", confidence: 0.55 });
+        }
+        else if (hasQuestion && hasYou) {
+            // Asking about the agent specifically → intellectual curiosity
+            results.push({ type: "intellectual", confidence: 0.5 });
+        }
+        else if (hasQuestion) {
+            // Any question — intellectual curiosity or casual
+            results.push({ type: "casual", confidence: 0.55 });
+        }
+        else if (len > 50 && sentenceCount >= 3) {
+            // Long multi-sentence without keywords → engaged storytelling
+            results.push({ type: "casual", confidence: 0.6 });
+        }
+        else {
+            results.push({ type: "casual", confidence: 0.3 });
+        }
     }
+    else {
+        // Keywords matched — structural features can boost confidence
+        if (hasI && len > 30 && results[0].confidence < 0.8) {
+            // Long personal message boosts the primary match slightly
+            results[0].confidence = Math.min(0.9, results[0].confidence + 0.1);
+        }
+        if (exclamationCount >= 2 && results[0].confidence < 0.85) {
+            // Emphasis boosts conviction
+            results[0].confidence = Math.min(0.9, results[0].confidence + 0.05);
+        }
+    }
+    // Sort by confidence descending
+    results.sort((a, b) => b.confidence - a.confidence);
     return results;
 }
 /**

package/dist/core.js

@@ -7,14 +7,15 @@
 //
 // Orchestrates: chemistry, classify, prompt, profiles, guards
 // ============================================================
-import { DEFAULT_RELATIONSHIP } from "./types.js";
-import { applyDecay, applyStimulus, applyContagion } from "./chemistry.js";
+import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES } from "./types.js";
+import { applyDecay, applyStimulus, applyContagion, clamp } from "./chemistry.js";
 import { classifyStimulus } from "./classify.js";
 import { buildDynamicContext, buildProtocolContext, buildCompactContext } from "./prompt.js";
 import { getSensitivity, getBaseline, getDefaultSelfModel } from "./profiles.js";
 import { isStimulusType } from "./guards.js";
 import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, } from "./psyche-file.js";
-// Silent logger for library use
+import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
+import { checkForUpdate } from "./update.js";
 const NOOP_LOGGER = { info: () => { }, warn: () => { }, debug: () => { } };
 // ── PsycheEngine ─────────────────────────────────────────────
 export class PsycheEngine {
@@ -46,6 +47,8 @@ export class PsycheEngine {
             this.state = this.createDefaultState();
             await this.storage.save(this.state);
         }
+        // Non-blocking update check — fire and forget, never delays initialization
+        checkForUpdate().catch(() => { });
     }
     /**
      * Phase 1: Process user input text.
@@ -53,31 +56,74 @@ export class PsycheEngine {
      */
     async processInput(text, opts) {
         let state = this.ensureInitialized();
-        // Time decay toward baseline
+        // Time decay toward baseline (chemistry + drives)
         const now = new Date();
         const minutesElapsed = (now.getTime() - new Date(state.updatedAt).getTime()) / 60000;
         if (minutesElapsed >= 1) {
+            // Decay drives first — needs build up over time
+            const decayedDrives = decayDrives(state.drives, minutesElapsed);
+            // Compute effective baseline from drives (unsatisfied drives shift baseline)
+            const effectiveBaseline = computeEffectiveBaseline(state.baseline, decayedDrives);
             state = {
                 ...state,
-                current: applyDecay(state.current, state.baseline, minutesElapsed),
+                drives: decayedDrives,
+                current: applyDecay(state.current, effectiveBaseline, minutesElapsed),
                 updatedAt: now.toISOString(),
             };
         }
         // Classify user stimulus and apply chemistry
         let appliedStimulus = null;
         if (text.length > 0) {
+            // Check for existential threats → direct survival drive hit
+            const survivalHit = detectExistentialThreat(text);
+            if (survivalHit < 0) {
+                state = {
+                    ...state,
+                    drives: {
+                        ...state.drives,
+                        survival: Math.max(0, state.drives.survival + survivalHit),
+                    },
+                };
+            }
             const classifications = classifyStimulus(text);
             const primary = classifications[0];
             if (primary && primary.confidence >= 0.5) {
                 appliedStimulus = primary.type;
+                // Feed drives from stimulus
+                state = {
+                    ...state,
+                    drives: feedDrives(state.drives, primary.type),
+                };
+                // Apply stimulus with drive-modified sensitivity
+                const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, primary.type);
                 state = {
                     ...state,
-                    current: applyStimulus(state.current, primary.type, getSensitivity(state.mbti), this.cfg.maxChemicalDelta, NOOP_LOGGER),
+                    current: applyStimulus(state.current, primary.type, effectiveSensitivity, this.cfg.maxChemicalDelta, NOOP_LOGGER),
                 };
             }
         }
+        // Conversation warmth: sustained interaction → gentle DA/OT rise, CORT drop
+        // Simulates the natural "warm glow" of being in continuous conversation
+        const turnsSoFar = (state.emotionalHistory ?? []).length;
+        if (minutesElapsed < 5 && turnsSoFar > 0) {
+            const warmth = Math.min(3, 1 + turnsSoFar * 0.2);
+            state = {
+                ...state,
+                current: {
+                    ...state.current,
+                    DA: clamp(state.current.DA + warmth),
+                    OT: clamp(state.current.OT + warmth),
+                    CORT: clamp(state.current.CORT - 1),
+                },
+            };
+        }
         // Push snapshot to emotional history
         state = pushSnapshot(state, appliedStimulus);
+        // Increment interaction count
+        state = {
+            ...state,
+            meta: { ...state.meta, totalInteractions: state.meta.totalInteractions + 1 },
+        };
         // Persist
         this.state = state;
         await this.storage.save(state);
@@ -170,10 +216,11 @@ export class PsycheEngine {
         const selfModel = getDefaultSelfModel(mbti);
         const now = new Date().toISOString();
         return {
-            version: 2,
+            version: 3,
             mbti,
             baseline,
             current: { ...baseline },
+            drives: { ...DEFAULT_DRIVES },
             updatedAt: now,
             relationships: { _default: { ...DEFAULT_RELATIONSHIP } },
             empathyLog: null,

package/dist/index.d.ts

@@ -2,8 +2,12 @@ export { PsycheEngine } from "./core.js";
 export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult } from "./core.js";
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
 export type { StorageAdapter } from "./storage.js";
-export type { PsycheState, PsycheConfig, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, } from "./types.js";
-export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP } from "./types.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 { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
+export type { SelfReflection } from "./self-recognition.js";
+export { PsycheInteraction } from "./interaction.js";
+export type { ExchangeResult, ContagionResult, RelationshipSummary, InteractionPhase } from "./interaction.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

@@ -1,7 +1,7 @@
 // ============================================================
 // psyche-ai — Universal AI Emotional Intelligence Plugin
 //
-// Main entry point: re-exports core, storage, types, utilities.
+// Main entry point: re-exports core, storage, types.
 // Framework adapters available via subpath imports:
 //   psyche-ai/openclaw   — OpenClaw plugin
 //   psyche-ai/vercel-ai  — Vercel AI SDK middleware
@@ -12,8 +12,12 @@
 export { PsycheEngine } from "./core.js";
 // Storage
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
-export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP } from "./types.js";
-// Utilities (for advanced / custom adapter use)
+export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
+// Self-recognition
+export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
+// Multi-agent interaction
+export { PsycheInteraction } from "./interaction.js";
+// Utilities — for custom adapter / advanced use
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
 export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";