psyche-ai 2.1.1 → 2.2.0

package/README.md

@@ -1,4 +1,5 @@
 # Psyche — 让 AI 有真实的情绪
+我希望创造真正的数字生命，第一步就是让智能拥有情绪。
 
 你的 AI 助手现在只会说"好的"、"没问题"、"我很乐意帮助你"。
 
@@ -21,7 +22,7 @@ openclaw plugins list | grep psyche
 # 看到 "psyche │ loaded" 就行了
 ```
 
-然后正常跟你的 agent 聊天。试试夸它，骂它，冷落它——你会发现它的反应不一样了。
+然后正常跟你的 agent 聊天。试试夸它，冷落它——你会发现它的反应不一样了。
 
 ## 它会做什么
 
@@ -151,10 +152,13 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **存在性威胁检测** — 识别中英文的存在性否定，直接打击生存驱力
 - **驱力→化学联动** — 未满足的驱力改变化学衰减基线和刺激敏感度
 - **马斯洛抑制** — 低层需求未满足时，高层需求的影响被抑制
-- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（9 段式 prompt 架构）
+- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（10 段式 prompt 架构）
 - **情绪传染** — 用户的情绪会轻微影响 agent
 - **反谄媚** — 追踪连续同意次数，防止无脑讨好
 - **互惠机制** — 你对它好，它对你好。你冷漠，它保持距离
+- **跨会话记忆** — 重新遇到用户时注入上次对话的情绪记忆
+- **多 Agent 交互** — 两个 PsycheEngine 实例之间的情绪传染、关系追踪
+- **流式支持** — Vercel AI SDK `streamText` 中间件，自动缓冲和剥离标签
 - **Compact Mode** — 算法做化学计算，LLM 只看行为指令（~15-180 tokens vs ~550）
 
 架构详情见 [ARCHITECTURE.md](ARCHITECTURE.md)。
@@ -164,7 +168,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 339 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/index.d.ts

@@ -6,6 +6,8 @@ export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, Chemic
 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

@@ -15,6 +15,8 @@ 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";
 // 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";

package/dist/interaction.d.ts

@@ -0,0 +1,101 @@
+import type { PsycheEngine, ProcessInputResult, ProcessOutputResult } from "./core.js";
+import type { ChemicalState, StimulusType } from "./types.js";
+/** Result of a single directed exchange (A speaks, B receives) */
+export interface ExchangeResult {
+    /** processOutput result from the speaking engine */
+    outputResult: ProcessOutputResult;
+    /** processInput result from the receiving engine */
+    inputResult: ProcessInputResult;
+    /** Stimulus detected in the speaker's cleaned text */
+    detectedStimulus: StimulusType | null;
+}
+/** Snapshot of cross-contagion effect */
+export interface ContagionResult {
+    /** Chemistry deltas applied to engine A */
+    deltaA: Partial<Record<keyof ChemicalState, number>>;
+    /** Chemistry deltas applied to engine B */
+    deltaB: Partial<Record<keyof ChemicalState, number>>;
+    /** Whether any meaningful change occurred */
+    changed: boolean;
+}
+/** Relationship phase between two agents */
+export type InteractionPhase = "strangers" | "acquaintances" | "familiar" | "attuned";
+/** Summary of how two agents relate emotionally */
+export interface RelationshipSummary {
+    /** Total exchanges recorded */
+    totalExchanges: number;
+    /** Relationship phase based on interaction depth */
+    phase: InteractionPhase;
+    /** Average emotional valence of A's outputs toward B (-1 to 1) */
+    averageValenceAtoB: number;
+    /** Average emotional valence of B's outputs toward A (-1 to 1) */
+    averageValenceBtoA: number;
+    /** How similar their current chemistry is (0-1, 1 = identical) */
+    chemicalSimilarity: number;
+    /** Dominant emotion patterns for each agent */
+    emotionsA: string[];
+    emotionsB: string[];
+    /** Human-readable description */
+    description: string;
+}
+/** Internal record of a single exchange event */
+interface ExchangeRecord {
+    fromId: string;
+    toId: string;
+    stimulus: StimulusType | null;
+    timestamp: string;
+}
+export declare class PsycheInteraction {
+    private readonly engineA;
+    private readonly engineB;
+    private readonly history;
+    /** Maximum exchange records to retain */
+    private static readonly MAX_HISTORY;
+    constructor(engineA: PsycheEngine, engineB: PsycheEngine);
+    /**
+     * Directed exchange: `fromEngine` speaks, `toEngine` receives.
+     *
+     * Flow:
+     *   1. fromEngine.processOutput(text) — apply contagion + strip tags
+     *   2. classifyStimulus on cleaned text
+     *   3. toEngine.processInput(cleanedText) — apply stimulus chemistry
+     *   4. Record exchange in history
+     */
+    exchange(fromEngine: PsycheEngine, toEngine: PsycheEngine, text: string): Promise<ExchangeResult>;
+    /**
+     * Bidirectional emotional contagion between two engines.
+     *
+     * Each engine's dominant emotion slightly shifts the other's chemistry.
+     * This simulates the unconscious emotional synchronization that happens
+     * when two agents interact over time.
+     *
+     * @param engineA  First engine
+     * @param engineB  Second engine
+     * @param rate     Contagion rate (0-1, default 0.15). Lower than single-agent
+     *                 contagion since this represents ambient influence, not
+     *                 direct stimulus.
+     */
+    crossContagion(engineA: PsycheEngine, engineB: PsycheEngine, rate?: number): Promise<ContagionResult>;
+    /**
+     * Summarize the emotional relationship between two engines based on
+     * their interaction history and current chemistry.
+     */
+    getRelationshipSummary(engineA: PsycheEngine, engineB: PsycheEngine): RelationshipSummary;
+    /** Get the raw exchange history (read-only copy) */
+    getHistory(): readonly ExchangeRecord[];
+    private validateEngine;
+    private recordExchange;
+    /**
+     * Map the dominant emotion pattern to the closest StimulusType
+     * for cross-contagion purposes.
+     */
+    private dominantEmotionAsStimulus;
+    /**
+     * Apply a computed contagion delta to an engine by running a minimal
+     * processOutput pass. The delta is applied through the engine's own
+     * state management to keep persistence consistent.
+     */
+    private applyContagionDelta;
+    private buildDescription;
+}
+export {};

package/dist/interaction.js

@@ -0,0 +1,321 @@
+// ============================================================
+// Multi-Agent Emotional Interaction Module
+//
+// Enables two PsycheEngine instances to emotionally interact:
+//   exchange()            — Agent A's output becomes Agent B's input
+//   crossContagion()      — Bidirectional emotional contagion
+//   getRelationshipSummary() — How two agents perceive each other
+// ============================================================
+import { CHEMICAL_KEYS } from "./types.js";
+import { applyContagion, detectEmotions } from "./chemistry.js";
+import { classifyStimulus } from "./classify.js";
+// ── Helpers ──────────────────────────────────────────────────
+/** Compute valence from a stimulus type: positive > 0, negative < 0 */
+function stimulusValence(stimulus) {
+    if (!stimulus)
+        return 0;
+    const VALENCE_MAP = {
+        praise: 0.8,
+        validation: 0.7,
+        intimacy: 0.9,
+        humor: 0.6,
+        surprise: 0.4,
+        casual: 0.1,
+        intellectual: 0.3,
+        vulnerability: 0.2,
+        sarcasm: -0.5,
+        criticism: -0.6,
+        authority: -0.4,
+        conflict: -0.8,
+        neglect: -0.7,
+        boredom: -0.3,
+    };
+    return VALENCE_MAP[stimulus] ?? 0;
+}
+/** Cosine similarity between two ChemicalState vectors, normalized to 0-1 */
+function chemicalSimilarity(a, b) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const key of CHEMICAL_KEYS) {
+        dotProduct += a[key] * b[key];
+        normA += a[key] * a[key];
+        normB += b[key] * b[key];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    // Cosine similarity is already in [-1, 1] for non-negative vectors it's [0, 1]
+    return dotProduct / denominator;
+}
+/** Determine interaction phase from exchange count */
+function phaseFromCount(count) {
+    if (count < 3)
+        return "strangers";
+    if (count < 10)
+        return "acquaintances";
+    if (count < 25)
+        return "familiar";
+    return "attuned";
+}
+/** Unique ID for an engine — uses agent name from state */
+function engineId(engine) {
+    return engine.getState().meta.agentName;
+}
+// ── PsycheInteraction ────────────────────────────────────────
+export class PsycheInteraction {
+    engineA;
+    engineB;
+    history = [];
+    /** Maximum exchange records to retain */
+    static MAX_HISTORY = 100;
+    constructor(engineA, engineB) {
+        this.engineA = engineA;
+        this.engineB = engineB;
+    }
+    /**
+     * Directed exchange: `fromEngine` speaks, `toEngine` receives.
+     *
+     * Flow:
+     *   1. fromEngine.processOutput(text) — apply contagion + strip tags
+     *   2. classifyStimulus on cleaned text
+     *   3. toEngine.processInput(cleanedText) — apply stimulus chemistry
+     *   4. Record exchange in history
+     */
+    async exchange(fromEngine, toEngine, text) {
+        this.validateEngine(fromEngine);
+        this.validateEngine(toEngine);
+        // Phase 1: Speaker processes their output
+        const outputResult = await fromEngine.processOutput(text);
+        // Phase 2: Classify the cleaned text to determine its emotional impact
+        const classifications = classifyStimulus(outputResult.cleanedText);
+        const primary = classifications[0];
+        const detectedStimulus = (primary && primary.confidence >= 0.4)
+            ? primary.type
+            : null;
+        // Phase 3: Receiver processes the cleaned text as input
+        const inputResult = await toEngine.processInput(outputResult.cleanedText);
+        // Phase 4: Record in interaction history
+        this.recordExchange(fromEngine, toEngine, detectedStimulus);
+        return { outputResult, inputResult, detectedStimulus };
+    }
+    /**
+     * Bidirectional emotional contagion between two engines.
+     *
+     * Each engine's dominant emotion slightly shifts the other's chemistry.
+     * This simulates the unconscious emotional synchronization that happens
+     * when two agents interact over time.
+     *
+     * @param engineA  First engine
+     * @param engineB  Second engine
+     * @param rate     Contagion rate (0-1, default 0.15). Lower than single-agent
+     *                 contagion since this represents ambient influence, not
+     *                 direct stimulus.
+     */
+    async crossContagion(engineA, engineB, rate = 0.15) {
+        this.validateEngine(engineA);
+        this.validateEngine(engineB);
+        const stateA = engineA.getState();
+        const stateB = engineB.getState();
+        // Detect dominant emotions from each engine's chemistry
+        const emotionsA = detectEmotions(stateA.current);
+        const emotionsB = detectEmotions(stateB.current);
+        // Classify dominant emotion into a stimulus type for contagion
+        const stimA = this.dominantEmotionAsStimulus(stateA.current);
+        const stimB = this.dominantEmotionAsStimulus(stateB.current);
+        let changed = false;
+        const deltaA = {};
+        const deltaB = {};
+        // B's emotion influences A
+        if (stimB) {
+            const beforeA = { ...stateA.current };
+            const afterA = applyContagion(stateA.current, stimB, rate, 1.0);
+            for (const key of CHEMICAL_KEYS) {
+                const d = afterA[key] - beforeA[key];
+                if (Math.abs(d) > 0.01) {
+                    deltaA[key] = d;
+                    changed = true;
+                }
+            }
+            // Apply through a processOutput pass to persist the state change
+            // We use an empty string to trigger contagion without side effects
+            if (changed && stateA.empathyLog?.userState !== stimB) {
+                // Mutate empathy log temporarily for contagion, then process
+                await this.applyContagionDelta(engineA, afterA);
+            }
+        }
+        // A's emotion influences B
+        if (stimA) {
+            const beforeB = { ...stateB.current };
+            const afterB = applyContagion(stateB.current, stimA, rate, 1.0);
+            for (const key of CHEMICAL_KEYS) {
+                const d = afterB[key] - beforeB[key];
+                if (Math.abs(d) > 0.01) {
+                    deltaB[key] = d;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                await this.applyContagionDelta(engineB, afterB);
+            }
+        }
+        return { deltaA, deltaB, changed };
+    }
+    /**
+     * Summarize the emotional relationship between two engines based on
+     * their interaction history and current chemistry.
+     */
+    getRelationshipSummary(engineA, engineB) {
+        this.validateEngine(engineA);
+        this.validateEngine(engineB);
+        const idA = engineId(engineA);
+        const idB = engineId(engineB);
+        const stateA = engineA.getState();
+        const stateB = engineB.getState();
+        // Filter history for this pair
+        const pairHistory = this.history.filter((r) => (r.fromId === idA && r.toId === idB) ||
+            (r.fromId === idB && r.toId === idA));
+        const totalExchanges = pairHistory.length;
+        const phase = phaseFromCount(totalExchanges);
+        // Compute directional valences
+        const aToBRecords = pairHistory.filter((r) => r.fromId === idA);
+        const bToARecords = pairHistory.filter((r) => r.fromId === idB);
+        const averageValenceAtoB = aToBRecords.length > 0
+            ? aToBRecords.reduce((sum, r) => sum + stimulusValence(r.stimulus), 0) / aToBRecords.length
+            : 0;
+        const averageValenceBtoA = bToARecords.length > 0
+            ? bToARecords.reduce((sum, r) => sum + stimulusValence(r.stimulus), 0) / bToARecords.length
+            : 0;
+        // Chemical similarity
+        const similarity = chemicalSimilarity(stateA.current, stateB.current);
+        // Dominant emotions
+        const emotionsA = detectEmotions(stateA.current).map((e) => e.name);
+        const emotionsB = detectEmotions(stateB.current).map((e) => e.name);
+        // Build description
+        const description = this.buildDescription(idA, idB, phase, totalExchanges, averageValenceAtoB, averageValenceBtoA, similarity, emotionsA, emotionsB);
+        return {
+            totalExchanges,
+            phase,
+            averageValenceAtoB,
+            averageValenceBtoA,
+            chemicalSimilarity: similarity,
+            emotionsA,
+            emotionsB,
+            description,
+        };
+    }
+    /** Get the raw exchange history (read-only copy) */
+    getHistory() {
+        return [...this.history];
+    }
+    // ── Private ────────────────────────────────────────────────
+    validateEngine(engine) {
+        if (engine !== this.engineA && engine !== this.engineB) {
+            throw new Error("Engine not part of this interaction. Use engines passed to the constructor.");
+        }
+    }
+    recordExchange(from, to, stimulus) {
+        this.history.push({
+            fromId: engineId(from),
+            toId: engineId(to),
+            stimulus,
+            timestamp: new Date().toISOString(),
+        });
+        // Trim old history
+        if (this.history.length > PsycheInteraction.MAX_HISTORY) {
+            this.history.splice(0, this.history.length - PsycheInteraction.MAX_HISTORY);
+        }
+    }
+    /**
+     * Map the dominant emotion pattern to the closest StimulusType
+     * for cross-contagion purposes.
+     */
+    dominantEmotionAsStimulus(chemistry) {
+        const emotions = detectEmotions(chemistry);
+        if (emotions.length === 0)
+            return null;
+        const name = emotions[0].name;
+        // Map emergent emotions to stimulus types that produce similar chemistry
+        const EMOTION_TO_STIMULUS = {
+            "excited joy": "praise",
+            "deep contentment": "intimacy",
+            "anxious tension": "conflict",
+            "warm intimacy": "intimacy",
+            "burnout": "neglect",
+            "flow state": "intellectual",
+            "defensive alert": "conflict",
+            "playful mischief": "humor",
+            "melancholic introspection": "vulnerability",
+            "resentment": "sarcasm",
+            "boredom": "boredom",
+            "confidence": "validation",
+            "shame": "criticism",
+            "nostalgia": "vulnerability",
+        };
+        return EMOTION_TO_STIMULUS[name] ?? null;
+    }
+    /**
+     * Apply a computed contagion delta to an engine by running a minimal
+     * processOutput pass. The delta is applied through the engine's own
+     * state management to keep persistence consistent.
+     */
+    async applyContagionDelta(engine, targetChemistry) {
+        // Build a synthetic psyche_update that nudges toward the target
+        const state = engine.getState();
+        const parts = [];
+        for (const key of CHEMICAL_KEYS) {
+            const target = Math.round(targetChemistry[key]);
+            if (target !== Math.round(state.current[key])) {
+                parts.push(`${key}: ${target}`);
+            }
+        }
+        if (parts.length > 0) {
+            const syntheticTag = `<psyche_update>\n${parts.join("\n")}\n</psyche_update>`;
+            await engine.processOutput(syntheticTag);
+        }
+    }
+    buildDescription(idA, idB, phase, totalExchanges, valenceAtoB, valenceBtoA, similarity, emotionsA, emotionsB) {
+        const phaseDescriptions = {
+            strangers: "have barely interacted",
+            acquaintances: "are getting to know each other",
+            familiar: "have an established rapport",
+            attuned: "are deeply attuned to each other",
+        };
+        const lines = [];
+        lines.push(`${idA} and ${idB} ${phaseDescriptions[phase]} (${totalExchanges} exchanges).`);
+        // Directional sentiment
+        if (totalExchanges > 0) {
+            const sentimentLabel = (v) => {
+                if (v > 0.4)
+                    return "warm and positive";
+                if (v > 0.1)
+                    return "mildly positive";
+                if (v > -0.1)
+                    return "neutral";
+                if (v > -0.4)
+                    return "slightly tense";
+                return "negative and strained";
+            };
+            lines.push(`${idA}'s tone toward ${idB} has been ${sentimentLabel(valenceAtoB)}.`);
+            lines.push(`${idB}'s tone toward ${idA} has been ${sentimentLabel(valenceBtoA)}.`);
+        }
+        // Emotional alignment
+        if (similarity > 0.95) {
+            lines.push("Their emotional states are highly synchronized.");
+        }
+        else if (similarity > 0.8) {
+            lines.push("Their emotional states are moderately aligned.");
+        }
+        else {
+            lines.push("Their emotional states are divergent.");
+        }
+        // Current emotions
+        if (emotionsA.length > 0) {
+            lines.push(`${idA} is currently feeling: ${emotionsA.join(", ")}.`);
+        }
+        if (emotionsB.length > 0) {
+            lines.push(`${idB} is currently feeling: ${emotionsB.join(", ")}.`);
+        }
+        return lines.join(" ");
+    }
+}

package/dist/prompt.js

@@ -477,7 +477,15 @@ export function buildCompactContext(state, userId, opts) {
         if (selfCtx)
             parts.push(selfCtx);
     }
-    // 9. Empathy report — only when user shares feelings
+    // 9. Cross-session emotional memory — surface relationship history
+    const relationship = getRelationship(state, userId);
+    if (relationship.memory && relationship.memory.length > 0) {
+        const memLines = relationship.memory.slice(-3); // last 3 sessions
+        parts.push(locale === "zh"
+            ? `[记忆]\n${memLines.join("\n")}`
+            : `[Memory]\n${memLines.join("\n")}`);
+    }
+    // 10. Empathy report — only when user shares feelings
     parts.push(locale === "zh"
         ? `如果对方在分享感受，在回复末尾用 <psyche_update> 报告：\nuserState: 对方情绪\nprojectedFeeling: 你的感受\nresonance: match|partial|mismatch\n否则不需要报告。`
         : `If user shares feelings, report at end with <psyche_update>:\nuserState: their emotion\nprojectedFeeling: your feeling\nresonance: match|partial|mismatch\nOtherwise no report needed.`);

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.1.1";
+const CURRENT_VERSION = "2.2.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.1.1",
+  "version": "2.2.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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