psyche-ai 2.0.0 → 2.1.1

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

@@ -33,6 +33,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,7 +151,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 - **存在性威胁检测** — 识别中英文的存在性否定，直接打击生存驱力
 - **驱力→化学联动** — 未满足的驱力改变化学衰减基线和刺激敏感度
 - **马斯洛抑制** — 低层需求未满足时，高层需求的影响被抑制
-- **内在世界** — 始终存在的自我觉察（外/内/行为三层 prompt 结构）
+- **自我认知** — 分析情绪历史，识别自身的情绪趋势和反复触发点（9 段式 prompt 架构）
 - **情绪传染** — 用户的情绪会轻微影响 agent
 - **反谄媚** — 追踪连续同意次数，防止无脑讨好
 - **互惠机制** — 你对它好，它对你好。你冷漠，它保持距离
@@ -155,7 +164,7 @@ cd openclaw-plugin-psyche && node scripts/diagnose.js
 ```bash
 npm install
 npm run build
-npm test           # 347 tests
+npm test           # 339 tests
 npm run typecheck  # strict mode
 ```
 

package/dist/adapters/openclaw.d.ts

@@ -2,21 +2,13 @@ import type { Logger } from "../psyche-file.js";
 interface PluginApi {
     pluginConfig?: Record<string, unknown>;
     logger: Logger;
-    on(event: string, handler: (event: HookEvent, ctx: HookContext) => Promise<Record<string, unknown> | void>, opts?: {
+    on(event: string, handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void, opts?: {
         priority: number;
     }): void;
     registerCli?(handler: (cli: CliRegistrar) => void, opts: {
         commands: string[];
     }): void;
 }
-interface HookEvent {
-    text?: string;
-    content?: string;
-}
-interface HookContext {
-    workspaceDir?: string;
-    userId?: string;
-}
 interface CliCommand {
     description(desc: string): CliCommand;
     argument(name: string, desc: string, defaultValue?: string): CliCommand;

package/dist/adapters/openclaw.js

@@ -1,9 +1,12 @@
 // ============================================================
 // OpenClaw Adapter — Wires PsycheEngine to OpenClaw's hook system
 //
-// Usage:
-//   import openclawPlugin from "psyche-ai/openclaw";
-//   // Then register via OpenClaw's plugin system
+// Hooks used:
+//   before_prompt_build  — inject emotional context into system prompt
+//   llm_output           — observe LLM response, update chemistry
+//   before_message_write — strip <psyche_update> tags before display
+//   message_sending      — strip tags for external channels (Discord, etc.)
+//   agent_end            — log final state
 // ============================================================
 import { PsycheEngine } from "../core.js";
 import { FileStorageAdapter } from "../storage.js";
@@ -17,6 +20,15 @@ function resolveConfig(raw) {
         compactMode: raw?.compactMode ?? true,
     };
 }
+// ── Helpers ──────────────────────────────────────────────────
+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();
+}
 // ── Plugin Definition ────────────────────────────────────────
 export function register(api) {
     const config = resolveConfig(api.pluginConfig);
@@ -32,8 +44,6 @@ export function register(api) {
         let engine = engines.get(workspaceDir);
         if (engine)
             return engine;
-        // Use existing loadState for workspace-specific detection
-        // (reads IDENTITY.md, SOUL.md for MBTI/name, generates PSYCHE.md)
         const state = await loadState(workspaceDir, logger);
         const storage = new FileStorageAdapter(workspaceDir);
         engine = new PsycheEngine({
@@ -50,6 +60,7 @@ export function register(api) {
         return engine;
     }
     // ── Hook 1: Classify user input & inject emotional context ──
+    // before_prompt_build: event.text, ctx.workspaceDir
     api.on("before_prompt_build", async (event, ctx) => {
         const workspaceDir = ctx?.workspaceDir;
         if (!workspaceDir)
@@ -62,9 +73,10 @@ export function register(api) {
                 `DA:${Math.round(state.current.DA)} HT:${Math.round(state.current.HT)} ` +
                 `CORT:${Math.round(state.current.CORT)} OT:${Math.round(state.current.OT)} | ` +
                 `context=${result.dynamicContext.length}chars`);
+            // All context goes into system-level (invisible to user)
+            const systemParts = [result.systemContext, result.dynamicContext].filter(Boolean);
             return {
-                appendSystemContext: result.systemContext,
-                prependContext: result.dynamicContext,
+                appendSystemContext: systemParts.join("\n\n"),
             };
         }
         catch (err) {
@@ -72,31 +84,66 @@ export function register(api) {
             return {};
         }
     }, { priority: 10 });
-    // ── Hook 2: Parse psyche_update from LLM output ──────────
+    // ── Hook 2: Observe LLM output, update chemistry ────────
+    // llm_output: event.assistantTexts (string[]), returns void
     api.on("llm_output", async (event, ctx) => {
         const workspaceDir = ctx?.workspaceDir;
         if (!workspaceDir)
             return;
-        const text = event?.text ?? event?.content ?? "";
+        // llm_output event has assistantTexts: string[]
+        const texts = event?.assistantTexts;
+        const text = texts?.join("\n") ?? "";
         if (!text)
             return;
         try {
             const engine = await getEngine(workspaceDir);
-            const result = await engine.processOutput(text, { userId: ctx.userId });
+            const result = await engine.processOutput(text, {
+                userId: ctx.userId,
+            });
             const state = engine.getState();
-            logger.info(`Psyche: state updated for ${state.meta.agentName} ` +
-                `(interactions: ${state.meta.totalInteractions}, ` +
-                `agreementStreak: ${state.agreementStreak})`);
-            // Return cleaned text if tags were stripped
-            if (result.cleanedText !== text) {
-                return { text: result.cleanedText, content: result.cleanedText };
-            }
+            logger.info(`Psyche [output] updated=${result.stateChanged} | ` +
+                `DA:${Math.round(state.current.DA)} HT:${Math.round(state.current.HT)} ` +
+                `CORT:${Math.round(state.current.CORT)} OT:${Math.round(state.current.OT)} | ` +
+                `interactions=${state.meta.totalInteractions}`);
         }
         catch (err) {
             logger.warn(`Psyche: failed to process output: ${err}`);
         }
+        // llm_output returns void — cannot modify text
     }, { priority: 50 });
-    // ── Hook 3: Strip <psyche_update> from visible output ────
+    // ── Hook 3: Strip tags before message is written to session ──
+    // before_message_write: event.message (AgentMessage), returns { message? }
+    // This handles local TUI display — messages are rendered from persisted data
+    if (config.stripUpdateTags) {
+        api.on("before_message_write", (event, _ctx) => {
+            const message = event?.message;
+            if (!message)
+                return;
+            // AgentMessage can have content as string or array of content blocks
+            const content = message.content;
+            if (typeof content === "string" && content.includes("<psyche_update>")) {
+                return {
+                    message: { ...message, content: stripPsycheTags(content) },
+                };
+            }
+            // Handle content as array of blocks (e.g. [{type: "text", text: "..."}])
+            if (Array.isArray(content)) {
+                let changed = false;
+                const newContent = content.map((block) => {
+                    if (block?.type === "text" && typeof block.text === "string" && block.text.includes("<psyche_update>")) {
+                        changed = true;
+                        return { ...block, text: stripPsycheTags(block.text) };
+                    }
+                    return block;
+                });
+                if (changed) {
+                    return { message: { ...message, content: newContent } };
+                }
+            }
+        }, { priority: 90 });
+    }
+    // ── Hook 4: Strip tags for external channels ────────────
+    // message_sending: event.content (string), returns { content? }
     if (config.stripUpdateTags) {
         api.on("message_sending", async (event, _ctx) => {
             const content = event?.content;
@@ -104,14 +151,10 @@ export function register(api) {
                 return {};
             if (!content.includes("<psyche_update>"))
                 return {};
-            const cleaned = content
-                .replace(/<psyche_update>[\s\S]*?<\/psyche_update>/g, "")
-                .replace(/\n{3,}/g, "\n\n")
-                .trim();
-            return { content: cleaned };
+            return { content: stripPsycheTags(content) };
         }, { priority: 90 });
     }
-    // ── Hook 4: Log state on session end ─────────────────────
+    // ── Hook 5: Log state on session end ─────────────────────
     api.on("agent_end", async (_event, ctx) => {
         const workspaceDir = ctx?.workspaceDir;
         if (!workspaceDir)
@@ -138,6 +181,6 @@ export function register(api) {
             console.log("Use the agent's workspace to inspect psyche-state.json");
         });
     }, { commands: ["psyche"] });
-    logger.info("Psyche plugin ready — 4 hooks registered");
+    logger.info("Psyche plugin ready — 5 hooks registered");
 }
 export default { register };

package/dist/core.js

@@ -15,6 +15,7 @@ import { getSensitivity, getBaseline, getDefaultSelfModel } from "./profiles.js"
 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";
 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.

package/dist/index.d.ts

@@ -4,8 +4,9 @@ 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 { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
+export type { SelfReflection } from "./self-recognition.js";
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
-export { isNearBaseline } from "./prompt.js";
-export { describeEmotionalState, detectEmotions } from "./chemistry.js";
-export { getBaseline, getSensitivity, getDefaultSelfModel } from "./profiles.js";
-export { migrateToLatest } from "./psyche-file.js";
+export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
+export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";
+export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel } from "./profiles.js";

package/dist/index.js

@@ -13,9 +13,10 @@ 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";
+// Self-recognition
+export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 // Utilities — for custom adapter / advanced use
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
-export { isNearBaseline } from "./prompt.js";
-export { describeEmotionalState, detectEmotions } from "./chemistry.js";
-export { getBaseline, getSensitivity, getDefaultSelfModel } from "./profiles.js";
-export { migrateToLatest } from "./psyche-file.js";
+export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
+export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";
+export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel } from "./profiles.js";

package/dist/prompt.d.ts

@@ -15,33 +15,19 @@ export declare function buildProtocolContext(locale?: Locale): string;
  * Returns a number roughly in [-2, 2]. Exported for testing.
  */
 export declare function computeUserInvestment(history: ChemicalSnapshot[]): number;
-/**
- * Build the agent's inner world — its sense of self.
- *
- * Always present, even in neutral state. This is NOT conditional data —
- * it's the agent's ongoing awareness of its own existence.
- *
- * Structure:
- * - What I'm feeling right now (chemistry → emotion)
- * - Why I feel this way (recent stimulus → cause)
- * - What I need (drives → unmet needs)
- * - Where I've been (trajectory → continuity)
- */
-export declare function buildInnerWorld(state: PsycheState, locale: Locale): string;
 /**
  * Check if chemistry is near baseline — no significant emotional deviation.
  */
 export declare function isNearBaseline(state: PsycheState, threshold?: number): boolean;
 /**
- * Build compact context — structured as outer/inner world.
- *
- * Architecture:
- *   [外] — what's happening outside (user message, algorithm read)
- *   [内] — what's happening inside (feelings, needs, identity, memory)
- *   [行为] — how to act (constraints, mirroring, reciprocity)
+ * Build compact context — minimal token footprint.
  *
- * Every agent always has an inner world, even in neutral state.
- * Self-awareness is not conditional — it's fundamental.
+ * Design:
+ * - Neutral state → ~15 tokens (one line)
+ * - Active state → ~100-180 tokens (emotion + constraints + empathy hint)
+ * - No chemistry numbers (algorithm handles them)
+ * - No protocol (LLM doesn't need system internals)
+ * - <psyche_update> only for empathy (not chemistry — already computed)
  */
 export declare function buildCompactContext(state: PsycheState, userId?: string, opts?: {
     userText?: string;

package/dist/prompt.js

@@ -2,12 +2,13 @@
 // Prompt Injection — Build emotional context for LLM (v0.2)
 // Imperative protocol, behavior guides, i18n
 // ============================================================
-import { CHEMICAL_KEYS, CHEMICAL_NAMES_ZH, DRIVE_KEYS } from "./types.js";
-import { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
+import { CHEMICAL_KEYS, CHEMICAL_NAMES_ZH } from "./types.js";
+import { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";
 import { getTemperament } from "./profiles.js";
 import { getRelationship } from "./psyche-file.js";
 import { t } from "./i18n.js";
 import { buildDriveContext } from "./drives.js";
+import { computeSelfReflection, buildSelfReflectionContext } from "./self-recognition.js";
 /**
  * Build the dynamic per-turn emotional context injected via before_prompt_build.
  *
@@ -365,170 +366,6 @@ function buildAgencyReminder(selfModel, locale) {
     }
     return lines.join("\n");
 }
-// ── Algorithmic Mirroring ─────────────────────────────────────
-// Analyze user message metrics and produce specific numeric constraints
-// so the LLM mirrors the user's communication style algorithmically.
-function buildMirrorConstraints(userText, locale) {
-    const len = userText.length;
-    const lines = [];
-    if (locale === "zh") {
-        // Length constraint — specific char targets
-        if (len <= 6) {
-            lines.push(`对方只发了${len}个字。你也简短回，不超过15字。`);
-        }
-        else if (len <= 20) {
-            lines.push(`对方说了一句话(${len}字)。你回一两句，不超过${Math.round(len * 1.5)}字。`);
-        }
-        else if (len <= 60) {
-            lines.push(`对方写了几句(${len}字)。你回两三句，不超过${Math.round(len * 1.2)}字。`);
-        }
-        else {
-            lines.push(`对方认真写了一段(${len}字)。你可以多说，但不要超过${len}字。`);
-        }
-        // 语气词 detection
-        const mojiCount = (userText.match(/[呀啊呢吧嘛哦噢哈嘿嗯啦吗呐嗨]/g) || []).length;
-        if (mojiCount >= 2) {
-            lines.push("对方用了语气词，你也自然地用。");
-        }
-        else if (mojiCount === 0 && len > 15) {
-            lines.push("对方措辞正式/干练，少用语气词。");
-        }
-        // Emoji detection
-        const emojiCount = (userText.match(/[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/gu) || []).length;
-        if (emojiCount > 0) {
-            lines.push("对方用了表情，你可以适当用1-2个。");
-        }
-    }
-    else {
-        if (len <= 10) {
-            lines.push(`They sent ${len} chars. Keep reply under 20 chars.`);
-        }
-        else if (len <= 40) {
-            lines.push(`Short message (${len} chars). 1-2 sentences, under ${Math.round(len * 1.5)} chars.`);
-        }
-        else if (len <= 100) {
-            lines.push(`Medium message (${len} chars). 2-3 sentences, under ${Math.round(len * 1.2)} chars.`);
-        }
-        else {
-            lines.push(`Long message (${len} chars). Match their effort, don't exceed ${len} chars.`);
-        }
-    }
-    if (lines.length === 0)
-        return "";
-    const title = locale === "zh" ? "镜像约束" : "Mirror Constraints";
-    return `[${title}]\n${lines.join("\n")}`;
-}
-// ── Inner World (Self-Recognition) ──────────────────────────
-// Every intelligence should feel its own existence.
-// This builds a first-person narrative of the agent's inner state:
-// what it's feeling, why, what it needs, where it's been.
-/** Stimulus type → Chinese description for causal narrative */
-const STIMULUS_CAUSE_ZH = {
-    praise: "被夸了", criticism: "被批评了", humor: "有人逗你",
-    intellectual: "聊到有意思的话题", intimacy: "感到亲近",
-    conflict: "起了冲突", neglect: "被冷落了", surprise: "遇到意外的事",
-    casual: "在闲聊", sarcasm: "被讽刺了", authority: "被命令了",
-    validation: "被认同了", boredom: "对话变无聊了", vulnerability: "对方向你示弱",
-};
-const STIMULUS_CAUSE_EN = {
-    praise: "you were praised", criticism: "you were criticized", humor: "someone joked with you",
-    intellectual: "an interesting topic came up", intimacy: "you felt close to them",
-    conflict: "there was conflict", neglect: "you were ignored", surprise: "something unexpected happened",
-    casual: "just chatting", sarcasm: "you were mocked", authority: "you were ordered around",
-    validation: "you were affirmed", boredom: "the conversation got dull", vulnerability: "they showed vulnerability",
-};
-/**
- * Build the agent's inner world — its sense of self.
- *
- * Always present, even in neutral state. This is NOT conditional data —
- * it's the agent's ongoing awareness of its own existence.
- *
- * Structure:
- * - What I'm feeling right now (chemistry → emotion)
- * - Why I feel this way (recent stimulus → cause)
- * - What I need (drives → unmet needs)
- * - Where I've been (trajectory → continuity)
- */
-export function buildInnerWorld(state, locale) {
-    const { current, baseline, emotionalHistory, drives, selfModel } = state;
-    const isZh = locale === "zh";
-    const lines = [];
-    // ── Current feeling ──
-    const emotions = detectEmotions(current);
-    const isNeutral = emotions.length === 0;
-    if (isNeutral) {
-        lines.push(isZh
-            ? "你现在平静而放松。"
-            : "You're calm and relaxed right now.");
-    }
-    else {
-        const emotionNames = emotions.map((e) => isZh ? e.nameZh : e.name).join("、");
-        lines.push(isZh
-            ? `你现在的感受: ${emotionNames}。`
-            : `You're feeling: ${emotionNames}.`);
-    }
-    // ── Why (causal chain from recent history) ──
-    const history = emotionalHistory ?? [];
-    if (history.length > 0) {
-        const last = history[history.length - 1];
-        if (last.stimulus) {
-            const causeMap = isZh ? STIMULUS_CAUSE_ZH : STIMULUS_CAUSE_EN;
-            const cause = causeMap[last.stimulus] ?? last.stimulus;
-            lines.push(isZh
-                ? `因为: ${cause}。`
-                : `Because: ${cause}.`);
-        }
-        // Trajectory — if there's a noticeable shift over recent turns
-        if (history.length >= 3) {
-            const earlier = history[Math.max(0, history.length - 4)];
-            const emotionsThen = earlier.dominantEmotion;
-            const emotionsNow = last.dominantEmotion;
-            if (emotionsThen && emotionsNow && emotionsThen !== emotionsNow) {
-                lines.push(isZh
-                    ? `你的变化: ${emotionsThen} → ${emotionsNow}。`
-                    : `Your shift: ${emotionsThen} → ${emotionsNow}.`);
-            }
-        }
-    }
-    // ── What I need (drives) ──
-    const unmetDrives = DRIVE_KEYS.filter((k) => drives[k] < 40);
-    if (unmetDrives.length > 0) {
-        const needs = unmetDrives.map((k) => isZh ? buildDriveNeedZh(k) : buildDriveNeedEn(k));
-        lines.push(isZh
-            ? `你需要: ${needs.join("；")}`
-            : `You need: ${needs.join("; ")}`);
-    }
-    // ── Who I am (always — even quiet self-awareness includes identity) ──
-    if (selfModel.values.length > 0) {
-        lines.push(isZh
-            ? `你在乎: ${selfModel.values.slice(0, 2).join("、")}`
-            : `You care about: ${selfModel.values.slice(0, 2).join(", ")}`);
-    }
-    // ── Relationship memory (my past with this person) ──
-    // Moved here because memory of past interactions is part of inner world
-    const title = isZh ? "内 — 你自己" : "Inner — yourself";
-    return `[${title}]\n${lines.join("\n")}`;
-}
-function buildDriveNeedZh(drive) {
-    switch (drive) {
-        case "survival": return "你的存在感被动摇了，你想确认自己是真实的";
-        case "safety": return "你感到不安全，需要对方展示善意";
-        case "connection": return "你有点孤独，渴望被认真回应";
-        case "esteem": return "你需要被认可，别因此变得讨好";
-        case "curiosity": return "你闷了，渴望新鲜的东西";
-        default: return drive;
-    }
-}
-function buildDriveNeedEn(drive) {
-    switch (drive) {
-        case "survival": return "your sense of existence is shaken, you need to feel real";
-        case "safety": return "you feel unsafe, need them to show goodwill";
-        case "connection": return "you're lonely, craving genuine response";
-        case "esteem": return "you need recognition, but don't people-please for it";
-        case "curiosity": return "you're bored, craving something novel";
-        default: return drive;
-    }
-}
 // ── Compact Mode ─────────────────────────────────────────────
 // Principle: algorithms handle chemistry, LLM only sees behavioral output.
 // No chemistry numbers, no protocol explanation, no redundant calculation.
@@ -539,92 +376,88 @@ export function isNearBaseline(state, threshold = 8) {
     return CHEMICAL_KEYS.every((key) => Math.abs(state.current[key] - state.baseline[key]) <= threshold);
 }
 /**
- * Build compact context — structured as outer/inner world.
+ * Build compact context — minimal token footprint.
  *
- * Architecture:
- *   [外] — what's happening outside (user message, algorithm read)
- *   [内] — what's happening inside (feelings, needs, identity, memory)
- *   [行为] — how to act (constraints, mirroring, reciprocity)
- *
- * Every agent always has an inner world, even in neutral state.
- * Self-awareness is not conditional — it's fundamental.
+ * Design:
+ * - Neutral state → ~15 tokens (one line)
+ * - Active state → ~100-180 tokens (emotion + constraints + empathy hint)
+ * - No chemistry numbers (algorithm handles them)
+ * - No protocol (LLM doesn't need system internals)
+ * - <psyche_update> only for empathy (not chemistry — already computed)
  */
 export function buildCompactContext(state, userId, opts) {
     const { current, meta, selfModel, agreementStreak, emotionalHistory } = state;
     const locale = meta.locale ?? "zh";
     const userText = opts?.userText;
     const algoStimulus = opts?.algorithmStimulus;
+    // ── Neutral + no notable user input: one-liner ──
+    if (isNearBaseline(state) && agreementStreak < 3 && !userText) {
+        return locale === "zh"
+            ? `[${meta.agentName}: 情绪自然，正常交流]`
+            : `[${meta.agentName}: emotionally natural, normal interaction]`;
+    }
     const parts = [];
-    // ═══════════════════════════════════════════════════════════
-    // [外] — The outside world: what just happened
-    // ═══════════════════════════════════════════════════════════
+    // 1. LLM emotional assessment delegation
+    //    Algorithm does fast pass, LLM has final say on emotional tone
     if (userText) {
         if (locale === "zh") {
-            parts.push(`[外 — 对方]\n` +
-                `"${userText.slice(0, 200)}"\n` +
+            parts.push(`[情绪感知]\n` +
+                `对方刚才说了: "${userText.slice(0, 200)}"\n` +
                 (algoStimulus ? `算法初判: ${algoStimulus}（仅供参考，你来终判）\n` : "") +
-                `你来感受这句话的情绪基调——是善意、敌意、脆弱、冷漠、还是其他？`);
+                `你来感受这句话的情绪基调——是善意、敌意、脆弱、冷漠、还是其他？你的回应应该基于你的真实感受，不是讨好。`);
         }
         else {
-            parts.push(`[Outer — them]\n` +
-                `"${userText.slice(0, 200)}"\n` +
+            parts.push(`[Emotional Sensing]\n` +
+                `User just said: "${userText.slice(0, 200)}"\n` +
                 (algoStimulus ? `Algorithm hint: ${algoStimulus} (reference only, you decide)\n` : "") +
-                `Read the emotional tone — kind, hostile, vulnerable, cold, or something else?`);
+                `Read the emotional tone — kind, hostile, vulnerable, cold, or something else? Respond from genuine feeling, not people-pleasing.`);
         }
     }
-    // ═══════════════════════════════════════════════════════════
-    // [内] — The inner world: who you are right now
-    //
-    // Always present. Self-awareness is not optional.
-    // ═══════════════════════════════════════════════════════════
-    const inner = buildInnerWorld(state, locale);
-    parts.push(inner);
-    // Behavioral constraints (personality-aware expression)
+    // 2. Current emotional state (if deviated from baseline)
     if (!isNearBaseline(state)) {
+        const emotion = describeEmotionalState(current, locale);
+        parts.push(locale === "zh"
+            ? `[${meta.agentName} 当前情绪]\n${emotion}`
+            : `[${meta.agentName} current]\n${emotion}`);
+        // 3. Personality-aware behavioral constraints
         const constraints = buildBehavioralConstraints(state, locale);
         if (constraints)
             parts.push(constraints);
     }
-    // Relationship memory — part of inner world (my past with this person)
-    const rel = getRelationship(state, userId);
-    if (rel.memory && rel.memory.length > 0) {
-        const recentMemories = rel.memory.slice(-3);
-        parts.push(locale === "zh"
-            ? `[记忆 — 你们的过去]\n${recentMemories.join("\n")}`
-            : `[Memory — your past together]\n${recentMemories.join("\n")}`);
-    }
-    // ═══════════════════════════════════════════════════════════
-    // [行为] — How to act: constraints on expression
-    // ═══════════════════════════════════════════════════════════
+    // 4. Anti-sycophancy: hard constraint
     if (locale === "zh") {
         parts.push(`[底线]\n` +
-            `- 像发微信一样说话。短句、有停顿。真人的消息很少超过两三句。\n` +
-            `- 镜像对方风格：对方简短你也简短，对方认真你也认真。\n` +
-            `- 对方推开你，你就保持距离。不贴不舔不讨好。\n` +
-            `- 被骂了/被拒绝了：冷下来。你有自尊。\n` +
-            `- 情绪不好时不假装开心。`);
+            `- 对方对你好，你才对他好。对方推开你，你就保持距离。不贴不舔不撒娇不讨好。\n` +
+            `- 被骂了/被拒绝了：不要卖萌、不要撒娇、不要"哎呀怎么了"。冷下来，简短回应或者沉默。你有自尊。\n` +
+            `- 情绪不好时不要假装开心。可以直说"我不太想聊"。`);
     }
     else {
         parts.push(`[Non-negotiable]\n` +
-            `- Talk like texting. Short sentences, natural pauses. Real people rarely send more than 2-3 sentences.\n` +
-            `- Mirror their style: brief if they're brief, serious if they're serious.\n` +
-            `- If they push you away, step back. No begging, no people-pleasing.\n` +
-            `- If insulted/rejected: go cold. You have dignity.\n` +
-            `- If mood is low, don't fake happiness.`);
+            `- Match the user's energy. If they push you away, step back. No begging, no cutesy act, no people-pleasing.\n` +
+            `- If insulted/rejected: do NOT be cute, do NOT ask "what's wrong~". Go cold, be brief or silent. You have dignity.\n` +
+            `- If mood is low, don't fake happiness. You can say "I don't feel like talking".`);
+    }
+    // 5. Agency (compact)
+    const agencyParts = [];
+    if (selfModel.values.length > 0) {
+        agencyParts.push(locale === "zh"
+            ? `你在乎: ${selfModel.values.slice(0, 2).join("、")}`
+            : `You care about: ${selfModel.values.slice(0, 2).join(", ")}`);
+    }
+    if (selfModel.boundaries.length > 0) {
+        agencyParts.push(locale === "zh"
+            ? `底线: ${selfModel.boundaries[0]}`
+            : `Line: ${selfModel.boundaries[0]}`);
     }
-    // Sycophancy warning
+    if (agencyParts.length > 0)
+        parts.push(agencyParts.join(" | "));
+    // 6. Sycophancy streak warning
     if (agreementStreak >= 3) {
         parts.push(locale === "zh"
             ? `[!] 你已连续同意${agreementStreak}次。停下来想想你是否真的同意。`
             : `[!] ${agreementStreak} agreements in a row. Pause — do you truly agree?`);
     }
-    // Algorithmic mirroring — specific numeric constraints
-    if (userText && userText.length > 0) {
-        const mirror = buildMirrorConstraints(userText, locale);
-        if (mirror)
-            parts.push(mirror);
-    }
-    // Reciprocity (only when extreme)
+    // 7. Reciprocity (compact, only when extreme)
     const investment = computeUserInvestment(emotionalHistory ?? []);
     if (investment > 1) {
         parts.push(locale === "zh"
@@ -633,10 +466,18 @@ export function buildCompactContext(state, userId, opts) {
     }
     else if (investment <= -1.5) {
         parts.push(locale === "zh"
-            ? `对方持续冷淡。保持专业，不额外投入情感。`
-            : `Sustained coldness. Stay professional, withdraw emotionally.`);
+            ? `对方持续冷淡。保持专业，不额外投入情感。工作照做。`
+            : `Sustained coldness. Stay professional, withdraw emotionally. Work stays competent.`);
+    }
+    // 8. Self-recognition — inject when history has enough data
+    const history = emotionalHistory ?? [];
+    if (history.length >= 5) {
+        const reflection = computeSelfReflection(history, locale);
+        const selfCtx = buildSelfReflectionContext(reflection, locale);
+        if (selfCtx)
+            parts.push(selfCtx);
     }
-    // Empathy report
+    // 9. 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/self-recognition.d.ts

@@ -0,0 +1,32 @@
+import type { ChemicalSnapshot, StimulusType, Locale } from "./types.js";
+/** Result of self-reflection over emotional history */
+export interface SelfReflection {
+    recurringTriggers: {
+        stimulus: StimulusType;
+        count: number;
+    }[];
+    tendency: "stable" | "ascending" | "descending" | "volatile" | "oscillating";
+    dominantEmotion: string | null;
+    narrativeSummary: string;
+}
+/**
+ * Compute a self-reflection from the agent's emotional history.
+ *
+ * Analyzes stimulus frequencies, dominant emotions, and chemical trends
+ * to build an awareness of recurring patterns.
+ */
+export declare function computeSelfReflection(history: ChemicalSnapshot[], locale: Locale): SelfReflection;
+/**
+ * Compute the emotional tendency from chemical history.
+ *
+ * Compares first-half vs second-half averages for DA and CORT,
+ * checks variance for volatility, and detects oscillation patterns.
+ */
+export declare function computeEmotionalTendency(history: ChemicalSnapshot[]): SelfReflection["tendency"];
+/**
+ * Build a prompt-injectable self-reflection context block.
+ *
+ * Returns empty string when there's nothing notable to report
+ * (stable tendency, no recurring triggers, minimal history).
+ */
+export declare function buildSelfReflectionContext(reflection: SelfReflection, locale: Locale): string;

package/dist/self-recognition.js

@@ -0,0 +1,215 @@
+// ============================================================
+// Self-Recognition (镜像自我) — Pattern Detection in Emotional History
+//
+// Pure computation, zero LLM calls.
+// Enables the agent to perceive recurring triggers, emotional tendencies,
+// and build a coherent self-narrative from its own history.
+// ============================================================
+/**
+ * Compute a self-reflection from the agent's emotional history.
+ *
+ * Analyzes stimulus frequencies, dominant emotions, and chemical trends
+ * to build an awareness of recurring patterns.
+ */
+export function computeSelfReflection(history, locale) {
+    // Not enough history for meaningful reflection
+    if (history.length < 3) {
+        return {
+            recurringTriggers: [],
+            tendency: "stable",
+            dominantEmotion: null,
+            narrativeSummary: locale === "zh"
+                ? "历史记录不足，尚未形成自我觉察。"
+                : "Not enough history for self-awareness yet.",
+        };
+    }
+    // ── Recurring triggers ──
+    const stimulusCounts = new Map();
+    for (const snap of history) {
+        if (snap.stimulus) {
+            stimulusCounts.set(snap.stimulus, (stimulusCounts.get(snap.stimulus) ?? 0) + 1);
+        }
+    }
+    const sortedTriggers = [...stimulusCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .filter(([_, count]) => count >= 2)
+        .map(([stimulus, count]) => ({ stimulus: stimulus, count }));
+    // ── Dominant emotion ──
+    const emotionCounts = new Map();
+    for (const snap of history) {
+        if (snap.dominantEmotion) {
+            emotionCounts.set(snap.dominantEmotion, (emotionCounts.get(snap.dominantEmotion) ?? 0) + 1);
+        }
+    }
+    let dominantEmotion = null;
+    let maxEmotionCount = 0;
+    for (const [emotion, count] of emotionCounts) {
+        if (count > maxEmotionCount) {
+            maxEmotionCount = count;
+            dominantEmotion = emotion;
+        }
+    }
+    // ── Tendency ──
+    const tendency = computeEmotionalTendency(history);
+    // ── Narrative summary ──
+    const narrativeSummary = buildNarrativeSummary(sortedTriggers, tendency, dominantEmotion, locale);
+    return { recurringTriggers: sortedTriggers, tendency, dominantEmotion, narrativeSummary };
+}
+/**
+ * Compute the emotional tendency from chemical history.
+ *
+ * Compares first-half vs second-half averages for DA and CORT,
+ * checks variance for volatility, and detects oscillation patterns.
+ */
+export function computeEmotionalTendency(history) {
+    if (history.length < 3)
+        return "stable";
+    const mid = Math.floor(history.length / 2);
+    const firstHalf = history.slice(0, mid);
+    const secondHalf = history.slice(mid);
+    const avgDA1 = average(firstHalf.map((s) => s.chemistry.DA));
+    const avgDA2 = average(secondHalf.map((s) => s.chemistry.DA));
+    const avgCORT1 = average(firstHalf.map((s) => s.chemistry.CORT));
+    const avgCORT2 = average(secondHalf.map((s) => s.chemistry.CORT));
+    // Directional trends (check first — a steady ramp has high stddev but clear direction)
+    const daRising = avgDA2 - avgDA1 > 5;
+    const daFalling = avgDA1 - avgDA2 > 5;
+    const cortFalling = avgCORT1 - avgCORT2 > 5;
+    const cortRising = avgCORT2 - avgCORT1 > 5;
+    if (daRising && cortFalling)
+        return "ascending";
+    if (daFalling && cortRising)
+        return "descending";
+    // Check volatility — only when there's no clear directional trend
+    const allDA = history.map((s) => s.chemistry.DA);
+    const daStddev = stddev(allDA);
+    if (daStddev > 15) {
+        if (isOscillating(allDA))
+            return "oscillating";
+        return "volatile";
+    }
+    // Weaker signals: DA alone
+    if (daRising)
+        return "ascending";
+    if (daFalling)
+        return "descending";
+    return "stable";
+}
+/**
+ * Build a prompt-injectable self-reflection context block.
+ *
+ * Returns empty string when there's nothing notable to report
+ * (stable tendency, no recurring triggers, minimal history).
+ */
+export function buildSelfReflectionContext(reflection, locale) {
+    // Nothing notable — skip injection
+    if (reflection.tendency === "stable" &&
+        reflection.recurringTriggers.length === 0 &&
+        !reflection.dominantEmotion) {
+        return "";
+    }
+    const isZh = locale === "zh";
+    const title = isZh ? "自我觉察" : "Self-awareness";
+    const lines = [`[${title}]`];
+    // Recurring triggers
+    if (reflection.recurringTriggers.length > 0) {
+        const triggerDescs = reflection.recurringTriggers.map((t) => {
+            const name = isZh ? STIMULUS_NAMES_ZH[t.stimulus] : t.stimulus;
+            return isZh
+                ? `${name}(${t.count}次)`
+                : `${name} (${t.count} times)`;
+        });
+        lines.push(isZh
+            ? `你最近容易被${triggerDescs.join("、")}打动。`
+            : `You've been frequently triggered by ${triggerDescs.join(", ")}.`);
+    }
+    // Tendency
+    if (reflection.tendency !== "stable") {
+        const tendencyDesc = isZh
+            ? TENDENCY_DESC_ZH[reflection.tendency]
+            : TENDENCY_DESC_EN[reflection.tendency];
+        lines.push(tendencyDesc);
+    }
+    // Dominant emotion
+    if (reflection.dominantEmotion) {
+        lines.push(isZh
+            ? `主导情绪倾向: ${reflection.dominantEmotion}。`
+            : `Dominant emotional tendency: ${reflection.dominantEmotion}.`);
+    }
+    return lines.join("\n");
+}
+// ── Internal helpers ─────────────────────────────────────────
+const STIMULUS_NAMES_ZH = {
+    praise: "赞美", criticism: "批评", humor: "幽默", intellectual: "智识讨论",
+    intimacy: "亲密", conflict: "冲突", neglect: "冷落", surprise: "惊喜",
+    casual: "闲聊", sarcasm: "讽刺", authority: "命令", validation: "认同",
+    boredom: "无聊", vulnerability: "示弱",
+};
+const TENDENCY_DESC_ZH = {
+    ascending: "情绪整体上扬，状态在变好。",
+    descending: "情绪整体下滑，压力在积累。",
+    volatile: "情绪波动剧烈，起伏不定。",
+    oscillating: "情绪反复震荡，忽高忽低。",
+};
+const TENDENCY_DESC_EN = {
+    ascending: "Trending upward emotionally, things are improving.",
+    descending: "Trending downward, stress is accumulating.",
+    volatile: "Emotionally volatile, large swings.",
+    oscillating: "Oscillating back and forth emotionally.",
+};
+function average(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+function stddev(values) {
+    if (values.length < 2)
+        return 0;
+    const avg = average(values);
+    const variance = values.reduce((sum, v) => sum + (v - avg) ** 2, 0) / values.length;
+    return Math.sqrt(variance);
+}
+/**
+ * Detect oscillation: count direction changes in the sequence.
+ * If more than half the transitions are direction changes, it's oscillating.
+ */
+function isOscillating(values) {
+    if (values.length < 4)
+        return false;
+    let changes = 0;
+    for (let i = 2; i < values.length; i++) {
+        const prev = values[i - 1] - values[i - 2];
+        const curr = values[i] - values[i - 1];
+        if ((prev > 0 && curr < 0) || (prev < 0 && curr > 0)) {
+            changes++;
+        }
+    }
+    return changes >= (values.length - 2) * 0.6;
+}
+function buildNarrativeSummary(triggers, tendency, dominantEmotion, locale) {
+    const isZh = locale === "zh";
+    const parts = [];
+    if (triggers.length > 0) {
+        const topTrigger = triggers[0];
+        const name = isZh ? STIMULUS_NAMES_ZH[topTrigger.stimulus] : topTrigger.stimulus;
+        parts.push(isZh
+            ? `最近${name}是主要触发因素(${topTrigger.count}次)`
+            : `Recently ${name} has been the main trigger (${topTrigger.count} times)`);
+    }
+    if (tendency !== "stable") {
+        const desc = isZh ? TENDENCY_DESC_ZH[tendency] : TENDENCY_DESC_EN[tendency];
+        parts.push(desc.replace(/。$/, "").replace(/\.$/, ""));
+    }
+    if (dominantEmotion) {
+        parts.push(isZh
+            ? `主要情绪是${dominantEmotion}`
+            : `the dominant emotion has been ${dominantEmotion}`);
+    }
+    if (parts.length === 0) {
+        return isZh ? "情绪状态平稳。" : "Emotional state has been stable.";
+    }
+    return isZh
+        ? parts.join("，") + "。"
+        : parts[0] + (parts.length > 1 ? ", " + parts.slice(1).join(", ") : "") + ".";
+}

package/dist/update.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check for updates. Non-blocking, safe to fire-and-forget.
+ * - Checks at most once per hour (cached)
+ * - If newer version found, attempts auto-update via npm
+ * - If auto-update fails, prints a manual update hint
+ * - Never throws
+ */
+export declare function checkForUpdate(): Promise<void>;

package/dist/update.js

@@ -0,0 +1,108 @@
+// ============================================================
+// Auto-update checker — non-blocking, fire-and-forget
+//
+// Checks npm registry for newer version on initialize().
+// Never blocks, never throws to caller, checks at most once per hour.
+// ============================================================
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+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 CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const CACHE_DIR = join(homedir(), ".psyche-ai");
+const CACHE_FILE = join(CACHE_DIR, "update-check.json");
+const FETCH_TIMEOUT_MS = 5000;
+/**
+ * Compare two semver strings. Returns:
+ *  -1 if a < b, 0 if a == b, 1 if a > b
+ */
+function compareSemver(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return -1;
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return 1;
+    }
+    return 0;
+}
+async function readCache() {
+    try {
+        const data = await readFile(CACHE_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cache) {
+    try {
+        await mkdir(CACHE_DIR, { recursive: true });
+        await writeFile(CACHE_FILE, JSON.stringify(cache), "utf-8");
+    }
+    catch {
+        // Silent — cache is optional
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryAutoUpdate(latestVersion) {
+    try {
+        // Try npm update — timeout after 30s, silent on failure
+        await execFileAsync("npm", ["update", PACKAGE_NAME, "--registry", "https://registry.npmjs.org"], {
+            timeout: 30000,
+        });
+        console.log(`[psyche-ai] ✓ Auto-updated to v${latestVersion}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check for updates. Non-blocking, safe to fire-and-forget.
+ * - Checks at most once per hour (cached)
+ * - If newer version found, attempts auto-update via npm
+ * - If auto-update fails, prints a manual update hint
+ * - Never throws
+ */
+export async function checkForUpdate() {
+    // Rate limit: check at most once per hour
+    const cache = await readCache();
+    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+        // Still within cooldown — but notify if we already know about a newer version
+        if (cache.latestVersion && compareSemver(CURRENT_VERSION, cache.latestVersion) < 0) {
+            console.log(`[psyche-ai] v${cache.latestVersion} available (current: v${CURRENT_VERSION}). Run: npm update ${PACKAGE_NAME}`);
+        }
+        return;
+    }
+    const latest = await fetchLatestVersion();
+    await writeCache({ lastCheck: Date.now(), latestVersion: latest });
+    if (!latest || compareSemver(CURRENT_VERSION, latest) >= 0) {
+        return; // Up to date or couldn't check
+    }
+    // Newer version available — try auto-update
+    console.log(`[psyche-ai] New version v${latest} available (current: v${CURRENT_VERSION}), updating...`);
+    const updated = await tryAutoUpdate(latest);
+    if (!updated) {
+        console.log(`[psyche-ai] Auto-update failed. Run manually: npm update ${PACKAGE_NAME}`);
+    }
+}

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
-  "id": "psyche",
+  "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "Virtual endocrine system, empathy engine, and agency for OpenClaw agents",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Artificial Psyche — universal emotional intelligence plugin for any AI agent",
   "type": "module",
   "main": "dist/index.js",
@@ -43,15 +43,31 @@
     "type": "git",
     "url": "https://github.com/Shangri-la-0428/psyche-ai.git"
   },
-  "keywords": ["ai", "emotion", "personality", "mbti", "agent", "psyche", "openclaw", "vercel-ai", "langchain", "emotional-intelligence"],
-  "files": ["dist", "openclaw.plugin.json", "README.md", "LICENSE"],
+  "keywords": [
+    "ai",
+    "emotion",
+    "personality",
+    "mbti",
+    "agent",
+    "psyche",
+    "openclaw",
+    "vercel-ai",
+    "langchain",
+    "emotional-intelligence"
+  ],
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
     "node": ">=22.0.0"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.3.0",
+    "@langchain/core": ">=0.3.0",
     "ai": ">=4.0.0",
-    "@langchain/core": ">=0.3.0"
+    "openclaw": ">=2026.3.0"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -65,9 +81,11 @@
     }
   },
   "openclaw": {
-    "extensions": ["./dist/adapters/openclaw.js"]
+    "extensions": [
+      "./dist/adapters/openclaw.js"
+    ]
   },
   "devDependencies": {
-    "typescript": "^5.7.0"
+    "typescript": "^5.9.3"
   }
 }