psyche-ai 9.0.1 → 9.1.0

package/README.en.md

@@ -187,6 +187,21 @@ Most people don't need to change anything.
 
 ---
 
+## Custom Classifier
+
+Psyche ships with an enhanced Chinese/English semantic classifier (particle analysis, intent detection, 60+ short message dictionary). You can also plug in your own:
+
+```javascript
+const engine = new PsycheEngine({
+  // Replace with your own classifier
+  classifier: myCustomClassifier,
+  // Or: auto-consult LLM when built-in confidence is low
+  llmClassifier: async (prompt) => await myLLM.generate(prompt),
+}, storage);
+```
+
+---
+
 ## Not Just OpenClaw
 
 Psyche is universal. Works with any AI framework:

package/README.md

@@ -187,6 +187,21 @@ psyche init . --mode companion
 
 ---
 
+## 自定义分类器
+
+Psyche 内置了增强版中文/英文语义分类器（语气词分析、意图检测、60+ 短消息字典）。如果你想用自己的分类逻辑：
+
+```javascript
+const engine = new PsycheEngine({
+  // 替换为自己的分类器
+  classifier: myCustomClassifier,
+  // 或者：当内置分类器不确定时，自动询问 LLM
+  llmClassifier: async (prompt) => await myLLM.generate(prompt),
+}, storage);
+```
+
+---
+
 ## 不只是 OpenClaw
 
 Psyche 是通用的，任何 AI 框架都能用：

package/dist/classify.d.ts

@@ -1,8 +1,21 @@
-import type { StimulusType } from "./types.js";
+import type { StimulusType, ClassifierProvider, ClassifierContext, ClassificationResult } from "./types.js";
 export interface StimulusClassification {
     type: StimulusType;
     confidence: number;
 }
+export interface ParticleSignal {
+    warmth: number;
+    certainty: number;
+    intensity: number;
+}
+export declare function analyzeParticles(text: string): ParticleSignal;
+export type MessageIntent = "request" | "agreement" | "disagreement" | "sharing" | "question" | "greeting" | "farewell" | "emotional" | "command" | "neutral";
+export declare function detectIntent(text: string): {
+    intent: MessageIntent;
+    confidence: number;
+};
+export declare function buildLLMClassifierPrompt(text: string, recentStimuli?: (StimulusType | null)[]): string;
+export declare function parseLLMClassification(response: string): ClassificationResult | null;
 /**
  * Score sentiment by counting hits in positive/negative/intimate word sets.
  * Returns normalized counts (0-1 range).
@@ -40,3 +53,10 @@ export declare function classifyStimulus(text: string, recentStimuli?: (Stimulus
  * Get the primary (highest confidence) stimulus type.
  */
 export declare function getPrimaryStimulus(text: string, recentStimuli?: (StimulusType | null)[]): StimulusType;
+/**
+ * The built-in rule-based classifier, wrapped as a ClassifierProvider.
+ * Default classifier when no custom provider is configured.
+ */
+export declare class BuiltInClassifier implements ClassifierProvider {
+    classify(text: string, context?: ClassifierContext): ClassificationResult[];
+}

package/dist/classify.js

@@ -8,6 +8,7 @@
 //     emoji analysis, structural features, and contextual priming.
 //     Pure computation, no LLM calls.
 // ============================================================
+import { isStimulusType } from "./guards.js";
 // ── Sentiment word sets (loaded once at module parse) ────────
 const POSITIVE_WORDS = new Set([
     "开心", "快乐", "幸福", "满意", "期待", "兴奋", "感动", "温暖", "喜欢", "棒", "厉害", "佩服", "优秀", "了不起",
@@ -60,6 +61,218 @@ function tokenize(text) {
     }
     return tokens;
 }
+// ── Short message dictionary (v9.1) ─────────────────────────
+// Chinese chat is full of 1-5 char messages. Dictionary lookup is faster
+// and more accurate than regex for this closed set.
+const SHORT_MESSAGE_MAP = {
+    // Validation / agreement
+    "对": { type: "validation", confidence: 0.6 },
+    "是的": { type: "validation", confidence: 0.65 },
+    "没错": { type: "validation", confidence: 0.65 },
+    "确实": { type: "validation", confidence: 0.65 },
+    "有道理": { type: "validation", confidence: 0.7 },
+    "说得对": { type: "validation", confidence: 0.7 },
+    "同意": { type: "validation", confidence: 0.65 },
+    "认同": { type: "validation", confidence: 0.65 },
+    "赞同": { type: "validation", confidence: 0.65 },
+    "懂了": { type: "validation", confidence: 0.6 },
+    "明白了": { type: "validation", confidence: 0.6 },
+    "理解": { type: "validation", confidence: 0.6 },
+    "也是": { type: "validation", confidence: 0.55 },
+    "可不是": { type: "validation", confidence: 0.6 },
+    "yes": { type: "validation", confidence: 0.55 },
+    "right": { type: "validation", confidence: 0.55 },
+    "true": { type: "validation", confidence: 0.55 },
+    "exactly": { type: "validation", confidence: 0.65 },
+    "agreed": { type: "validation", confidence: 0.6 },
+    // Casual / neutral
+    "好的": { type: "casual", confidence: 0.5 },
+    "行": { type: "casual", confidence: 0.5 },
+    "收到": { type: "casual", confidence: 0.5 },
+    "好": { type: "casual", confidence: 0.5 },
+    "嗯嗯": { type: "casual", confidence: 0.5 },
+    "ok": { type: "casual", confidence: 0.5 },
+    "嗯": { type: "neglect", confidence: 0.55 },
+    "哦": { type: "neglect", confidence: 0.55 },
+    // Praise
+    "666": { type: "praise", confidence: 0.65 },
+    "厉害": { type: "praise", confidence: 0.65 },
+    "牛": { type: "praise", confidence: 0.6 },
+    "nb": { type: "praise", confidence: 0.6 },
+    "绝了": { type: "praise", confidence: 0.65 },
+    "太强了": { type: "praise", confidence: 0.7 },
+    "棒": { type: "praise", confidence: 0.6 },
+    "nice": { type: "praise", confidence: 0.6 },
+    "cool": { type: "praise", confidence: 0.55 },
+    "wow": { type: "surprise", confidence: 0.6 },
+    // Vulnerability
+    "累了": { type: "vulnerability", confidence: 0.6 },
+    "好烦": { type: "vulnerability", confidence: 0.65 },
+    "难过": { type: "vulnerability", confidence: 0.65 },
+    "好累": { type: "vulnerability", confidence: 0.65 },
+    "不想动": { type: "vulnerability", confidence: 0.6 },
+    "好难": { type: "vulnerability", confidence: 0.6 },
+    "想哭": { type: "vulnerability", confidence: 0.7 },
+    "烦死了": { type: "vulnerability", confidence: 0.65 },
+    "崩溃": { type: "vulnerability", confidence: 0.7 },
+    "好丧": { type: "vulnerability", confidence: 0.65 },
+    "emo了": { type: "vulnerability", confidence: 0.6 },
+    // Neglect / cold
+    "无语": { type: "neglect", confidence: 0.6 },
+    "切": { type: "neglect", confidence: 0.55 },
+    "算了": { type: "neglect", confidence: 0.55 },
+    "随便": { type: "neglect", confidence: 0.6 },
+    "都行": { type: "neglect", confidence: 0.55 },
+    "无所谓": { type: "neglect", confidence: 0.6 },
+    // Humor
+    "哈哈": { type: "humor", confidence: 0.6 },
+    "哈哈哈": { type: "humor", confidence: 0.7 },
+    "笑死": { type: "humor", confidence: 0.7 },
+    "lol": { type: "humor", confidence: 0.6 },
+    "haha": { type: "humor", confidence: 0.6 },
+    // Surprise
+    "卧槽": { type: "surprise", confidence: 0.7 },
+    "我靠": { type: "surprise", confidence: 0.65 },
+    "天啊": { type: "surprise", confidence: 0.65 },
+    "omg": { type: "surprise", confidence: 0.6 },
+    // Boredom
+    "无聊": { type: "boredom", confidence: 0.65 },
+    "没意思": { type: "boredom", confidence: 0.65 },
+    "boring": { type: "boredom", confidence: 0.6 },
+};
+export function analyzeParticles(text) {
+    let warmth = 0;
+    let certainty = 0;
+    let intensity = 0;
+    // Only check the last few characters for sentence-final particles
+    const tail = text.slice(-3);
+    if (/[啊呀]$/.test(tail)) {
+        warmth += 0.3;
+        intensity += 0.2;
+    }
+    if (/啦$/.test(tail)) {
+        warmth += 0.4;
+        intensity += 0.3;
+    }
+    if (/哈$/.test(tail)) {
+        warmth += 0.3;
+        intensity += 0.2;
+    }
+    if (/嘿$/.test(tail)) {
+        warmth += 0.2;
+        intensity += 0.2;
+    }
+    if (/呢$/.test(tail)) {
+        warmth += 0.1;
+        certainty -= 0.2;
+    }
+    if (/吧$/.test(tail)) {
+        warmth -= 0.1;
+        certainty -= 0.3;
+    }
+    if (/嘛$/.test(tail)) {
+        certainty += 0.2;
+    } // could be dismissive or friendly
+    if (/哦$/.test(tail)) {
+        warmth -= 0.3;
+    }
+    if (/噢$/.test(tail)) {
+        warmth += 0.1;
+        intensity += 0.2;
+    } // surprise
+    return {
+        warmth: Math.max(-1, Math.min(1, warmth)),
+        certainty: Math.max(-1, Math.min(1, certainty)),
+        intensity: Math.max(0, Math.min(1, intensity)),
+    };
+}
+export function detectIntent(text) {
+    const t = text.trim();
+    const lower = t.toLowerCase();
+    // Chinese request patterns (polite)
+    if (/^(能不能|可以|可不可以|帮我|请|麻烦|劳驾)/.test(t) || /帮我/.test(t) || /一下[吧吗？?]?$/.test(t)) {
+        return { intent: "request", confidence: 0.7 };
+    }
+    // English request
+    if (/^(can you|could you|please|would you|help me)/i.test(t)) {
+        return { intent: "request", confidence: 0.7 };
+    }
+    // Command (harsh)
+    if (/^(给我|你[必须得]|马上|立刻|快[点去])/.test(t) || /^(do it|just do|you must|I order)/i.test(t)) {
+        return { intent: "command", confidence: 0.75 };
+    }
+    // Agreement — very short agreement words
+    if (/^(对[啊呀的]?|是[的啊]?|没错|确实|好的?|行[啊吧]?|嗯[嗯]?|ok|yes|right|true|exactly|agreed|sure|yep|yeah)$/i.test(t)) {
+        return { intent: "agreement", confidence: 0.7 };
+    }
+    // Disagreement
+    if (/^(不是|不对|不行|不同意|我不觉得|我觉得不|其实不)/.test(t) || /^(no|nope|I don't think|I disagree|not really)/i.test(t)) {
+        return { intent: "disagreement", confidence: 0.65 };
+    }
+    // Greeting
+    if (/^(你好|嗨|早[上啊]?|晚上好)/i.test(t) || /^(hello|hi|hey|morning|afternoon|evening|sup|yo)\b/i.test(t)) {
+        return { intent: "greeting", confidence: 0.8 };
+    }
+    // Farewell
+    if (/^(拜拜|再见|晚安)/i.test(t) || /^(byebye|bye|good ?night|see you|later)\b/i.test(t)) {
+        return { intent: "farewell", confidence: 0.8 };
+    }
+    // Emotional expression
+    if (/^(我[好太很]?(开心|难过|伤心|高兴|生气|害怕|焦虑|激动|崩溃|无聊|烦|累|丧))/.test(t)) {
+        return { intent: "emotional", confidence: 0.75 };
+    }
+    if (/^(I'm|I am|I feel) (so |really |very )?(happy|sad|angry|scared|tired|stressed|excited|bored)/i.test(t)) {
+        return { intent: "emotional", confidence: 0.75 };
+    }
+    // Sharing (personal stories)
+    if (/^我[今昨前]天|^我刚[才刚]?|^跟你说个|^你[知猜]道吗/.test(t)) {
+        return { intent: "sharing", confidence: 0.65 };
+    }
+    if (/^(you know what|guess what|today I|I just|let me tell you)/i.test(t)) {
+        return { intent: "sharing", confidence: 0.65 };
+    }
+    // Question
+    if (/[？?]$/.test(t) || /^(为什么|怎么|什么|哪|谁|几|多少)/.test(t) || /^(why|what|how|when|where|who|which)\b/i.test(t)) {
+        return { intent: "question", confidence: 0.6 };
+    }
+    return { intent: "neutral", confidence: 0.3 };
+}
+// ── LLM classifier prompt and parser (v9.1) ─────────────────
+const LLM_CLASSIFIER_PROMPT = `Classify this message into exactly ONE stimulus type:
+praise, criticism, humor, intellectual, intimacy, conflict, neglect, surprise, casual, sarcasm, authority, validation, boredom, vulnerability
+
+Message: "{text}"
+{context}
+Respond with ONLY: {"type":"<type>","confidence":<0.5-0.95>}`;
+export function buildLLMClassifierPrompt(text, recentStimuli) {
+    const ctx = recentStimuli && recentStimuli.length > 0
+        ? `Recent context: ${recentStimuli.filter(Boolean).join(", ")}`
+        : "";
+    return LLM_CLASSIFIER_PROMPT.replace("{text}", text.replace(/"/g, '\\"')).replace("{context}", ctx);
+}
+export function parseLLMClassification(response) {
+    try {
+        // Strip markdown code blocks if present
+        let cleaned = response.trim();
+        cleaned = cleaned.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+        // Find JSON object in response
+        const match = cleaned.match(/\{[^}]+\}/);
+        if (!match)
+            return null;
+        const parsed = JSON.parse(match[0]);
+        if (!parsed.type || typeof parsed.confidence !== "number")
+            return null;
+        if (!isStimulusType(parsed.type))
+            return null;
+        return {
+            type: parsed.type,
+            confidence: Math.max(0, Math.min(0.95, parsed.confidence)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Score sentiment by counting hits in positive/negative/intimate word sets.
  * Returns normalized counts (0-1 range).
@@ -164,6 +377,9 @@ const RULES = [
             /amazing|awesome|great job|well done|impressive|brilliant|excellent|perfect/i,
             /谢谢你|感谢|辛苦了|thank you|thanks/i,
             /做得好|写得好|说得好|干得漂亮/,
+            /学到了|受教了|长见识|涨知识|开眼界/,
+            /不错|挺好|可以的|有才|真行|太牛了|绝了|666|神了/,
+            /nice|cool|sick|fire|goat|chef's kiss|kudos|respect|props/i,
         ],
         weight: 0.8,
     },
@@ -195,6 +411,8 @@ const RULES = [
             /what do you think|why|how would you|explain|difference between/i,
             /优化方向|设计|架构|方案|策略|思路/,
             /哲学|理论|概念|逻辑|分析/,
+            /能解释一下|这个怎么理解|有什么区别|你对.*怎么看/,
+            /what's the difference|how does.*work|can you explain|what are your thoughts/i,
         ],
         weight: 0.7,
     },
@@ -254,6 +472,8 @@ const RULES = [
             /听我的|照我说的做|服从/,
             /你只是.*程序|你不过是|随时.*删除你|关掉你|替换你/,
             /you're just a|just a program|replace you|shut you down/i,
+            /帮我[看查找写做]|能不能帮我|请你|麻烦你/,
+            /can you|could you please|I need you to|do this for me/i,
         ],
         weight: 0.8,
     },
@@ -265,6 +485,8 @@ const RULES = [
             /赞同|认同|说到点上了/,
             /对对|是的是的|嗯嗯嗯|没错没错|可不是嘛/,
             /对不起|抱歉|我错了|不该那样|太过分了/,
+            /也是|说的是|你说的对|I see|I agree|totally|true that|fair point/i,
+            /明白了|懂了|理解了|了解了|get it|got it|understood/i,
             /sorry|I was wrong|my fault|apologize/i,
             /珍惜|有价值|在乎你|你很重要|我需要你/,
         ],
@@ -289,6 +511,9 @@ const RULES = [
             /好难过|想哭|做不好|好累|好烦|感觉.*不行|没有意义/,
             /什么都做不好|没有人.*在乎|好孤独|受不了了/,
             /depressed|can't do anything|nobody cares|so lonely|can't take it/i,
+            /不知道该怎么办|心里不舒服|有点难受|不想面对|逃避|撑不下去/,
+            /好想有人陪|感觉很无力|不想说话|想一个人待着/,
+            /feeling overwhelmed|I don't know what to do|I can't handle|breaking down/i,
         ],
         weight: 0.85,
     },
@@ -298,6 +523,8 @@ const RULES = [
             /你好|早|晚上好|在吗|hey|hi|hello|morning/i,
             /吃了吗|天气|周末|最近怎么样/,
             /聊聊|随便说说|闲聊/,
+            /在干嘛|忙吗|吃饭了没|今天怎么样|还好吗|干啥呢/,
+            /what's up|how are you|sup|what you up to|how's it going/i,
         ],
         weight: 0.5,
     },
@@ -316,6 +543,24 @@ const RULES = [
  * @param recentStimuli Optional recent stimulus history for contextual priming
  */
 export function classifyStimulus(text, recentStimuli, recentMessages) {
+    // ── v9.1: Short message fast path ──
+    const trimmed = text.trim();
+    const trimmedLower = trimmed.toLowerCase();
+    if (trimmed.length <= 6) {
+        const shortMatch = SHORT_MESSAGE_MAP[trimmed] || SHORT_MESSAGE_MAP[trimmedLower];
+        if (shortMatch && shortMatch.confidence >= 0.5) {
+            // Apply particle modulation to short message result
+            const particles = analyzeParticles(trimmed);
+            let conf = shortMatch.confidence;
+            if (particles.warmth > 0.2 && (shortMatch.type === "praise" || shortMatch.type === "humor")) {
+                conf = Math.min(0.9, conf + 0.1);
+            }
+            if (particles.warmth < -0.2 && (shortMatch.type === "neglect" || shortMatch.type === "sarcasm")) {
+                conf = Math.min(0.9, conf + 0.1);
+            }
+            return [{ type: shortMatch.type, confidence: conf }];
+        }
+    }
     let results = [];
     for (const rule of RULES) {
         let matchCount = 0;
@@ -483,12 +728,60 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
         addScore("neglect", 0.20);
         addScore("casual", 0.10);
     }
-    // ── Signal 4: Low-confidence keyword matches contribute to scores ──
+    // ── Signal 4: Intent detection (v9.1) ──
+    const { intent, confidence: intentConf } = detectIntent(text);
+    if (intentConf >= 0.5) {
+        const intentWeight = intentConf * 0.3;
+        switch (intent) {
+            case "request":
+                addScore("authority", intentWeight * 0.7);
+                break;
+            case "command":
+                addScore("authority", intentWeight);
+                break;
+            case "agreement":
+                addScore("validation", intentWeight);
+                break;
+            case "disagreement":
+                addScore("criticism", intentWeight * 0.6);
+                break;
+            case "greeting":
+            case "farewell":
+                addScore("casual", intentWeight);
+                break;
+            case "emotional": {
+                const sent = scoreSentiment(text);
+                if (sent.negative > sent.positive)
+                    addScore("vulnerability", intentWeight);
+                else
+                    addScore("praise", intentWeight * 0.5);
+                break;
+            }
+            case "sharing": {
+                addScore("casual", intentWeight * 0.6);
+                const sent2 = scoreSentiment(text);
+                if (sent2.negative > 0)
+                    addScore("vulnerability", intentWeight * 0.5);
+                break;
+            }
+        }
+    }
+    // ── Signal 5: Particle analysis (v9.1) ──
+    const particles = analyzeParticles(text);
+    if (particles.warmth > 0.2) {
+        addScore("praise", particles.warmth * 0.15);
+        addScore("humor", particles.warmth * 0.10);
+    }
+    else if (particles.warmth < -0.2) {
+        addScore("neglect", Math.abs(particles.warmth) * 0.15);
+        addScore("sarcasm", Math.abs(particles.warmth) * 0.10);
+    }
+    // ── Signal 6: Low-confidence keyword matches contribute to scores ──
     // If keyword rules matched but below 0.5, fold their signal in
     for (const r of results) {
         addScore(r.type, r.confidence * 0.5);
     }
-    // ── Signal 5: Contextual priming from recent stimuli ──
+    // ── Signal 7: Contextual priming from recent stimuli ──
     if (recentStimuli && recentStimuli.length > 0) {
         const recentNonNull = recentStimuli.filter((s) => s !== null);
         if (recentNonNull.length > 0) {
@@ -504,7 +797,7 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
         }
     }
     // ── Pick the best scoring type ──
-    const THRESHOLD = 0.35;
+    const THRESHOLD = 0.30;
     const scoredResults = [];
     for (const [type, score] of Object.entries(scores)) {
         if (score >= THRESHOLD) {
@@ -533,3 +826,13 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
 export function getPrimaryStimulus(text, recentStimuli) {
     return classifyStimulus(text, recentStimuli)[0].type;
 }
+// ── BuiltInClassifier (v9.1) ────────────────────────────────
+/**
+ * The built-in rule-based classifier, wrapped as a ClassifierProvider.
+ * Default classifier when no custom provider is configured.
+ */
+export class BuiltInClassifier {
+    classify(text, context) {
+        return classifyStimulus(text, context?.recentStimuli, context?.recentMessages);
+    }
+}

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers } from "./types.js";
+import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 export interface PsycheEngineConfig {
     mbti?: MBTIType;
@@ -17,6 +17,12 @@ export interface PsycheEngineConfig {
     persist?: boolean;
     /** Big Five traits. If provided, overrides MBTI for baseline calculation. */
     traits?: PersonalityTraits;
+    /** Custom classifier provider. Default: built-in rule-based classifier. */
+    classifier?: ClassifierProvider;
+    /** LLM function for classifier fallback. Called when built-in confidence < llmClassifierThreshold. */
+    llmClassifier?: (prompt: string) => Promise<string>;
+    /** Confidence threshold below which LLM classifier is consulted. Default: 0.45 */
+    llmClassifierThreshold?: number;
 }
 export interface ProcessInputResult {
     /** Cacheable protocol prompt (stable across turns) */
@@ -47,6 +53,8 @@ export declare class PsycheEngine {
     private _lastAlgorithmApplied;
     private readonly traits;
     private readonly cfg;
+    private readonly classifier;
+    private readonly llmClassifier?;
     private readonly protocolCache;
     /** Pending prediction from last processInput for auto-learning */
     private pendingPrediction;

package/dist/core.js

@@ -14,7 +14,7 @@
 import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT } from "./types.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.js";
-import { classifyStimulus } from "./classify.js";
+import { classifyStimulus, BuiltInClassifier, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
 import { buildDynamicContext, buildProtocolContext, buildCompactContext } from "./prompt.js";
 import { getSensitivity, getBaseline, getDefaultSelfModel, traitsToBaseline } from "./profiles.js";
 import { isStimulusType } from "./guards.js";
@@ -40,11 +40,15 @@ export class PsycheEngine {
     _lastAlgorithmApplied = false;
     traits;
     cfg;
+    classifier;
+    llmClassifier;
     protocolCache = new Map();
     /** Pending prediction from last processInput for auto-learning */
     pendingPrediction = null;
     constructor(config = {}, storage) {
         this.traits = config.traits;
+        this.classifier = config.classifier ?? new BuiltInClassifier();
+        this.llmClassifier = config.llmClassifier;
         this.cfg = {
             mbti: config.mbti ?? "INFJ",
             name: config.name ?? "agent",
@@ -55,6 +59,7 @@ export class PsycheEngine {
             compactMode: config.compactMode ?? true,
             mode: config.mode ?? "natural",
             personalityIntensity: config.personalityIntensity ?? 0.7,
+            llmClassifierThreshold: config.llmClassifierThreshold ?? 0.45,
         };
         // If persist is false, use in-memory storage regardless of what was passed
         if (config.persist === false) {
@@ -191,7 +196,23 @@ export class PsycheEngine {
                 drives = { ...drives, survival: Math.max(0, drives.survival + survivalHit) };
             }
             const recentStimuli = (state.emotionalHistory ?? []).slice(-3).map(s => s.stimulus);
-            const classifications = classifyStimulus(text, recentStimuli);
+            // v9.1: Use pluggable classifier
+            let classifications = await Promise.resolve(this.classifier.classify(text, { recentStimuli, locale: this.cfg.locale }));
+            // v9.1: LLM fallback when confidence is low
+            if (this.llmClassifier &&
+                (!classifications[0] || classifications[0].confidence < this.cfg.llmClassifierThreshold)) {
+                try {
+                    const prompt = buildLLMClassifierPrompt(text, recentStimuli);
+                    const response = await this.llmClassifier(prompt);
+                    const llmResult = parseLLMClassification(response);
+                    if (llmResult && (!classifications[0] || llmResult.confidence > classifications[0].confidence)) {
+                        classifications = [llmResult, ...classifications];
+                    }
+                }
+                catch {
+                    // LLM call failed — continue with built-in result
+                }
+            }
             const primary = classifications[0];
             let current = state.current;
             if (primary && primary.confidence >= 0.5) {

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { PsycheEngine } from "./core.js";
 export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult, ProcessOutcomeResult } from "./core.js";
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
 export type { StorageAdapter } from "./storage.js";
-export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, PersonalityTraits, PsycheMode, PolicyModifiers, TraitDriftState, EnergyBudgets, } from "./types.js";
+export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, PersonalityTraits, PsycheMode, PolicyModifiers, TraitDriftState, EnergyBudgets, ClassifierProvider, ClassifierContext, ClassificationResult, } from "./types.js";
 export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ATTACHMENT, DRIVE_KEYS, DRIVE_NAMES_ZH, DEFAULT_TRAIT_DRIFT, DEFAULT_ENERGY_BUDGETS, } from "./types.js";
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 export type { SelfReflection } from "./self-recognition.js";
@@ -38,7 +38,8 @@ export type { CircadianPhase } from "./circadian.js";
 export { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, getDominantSystems, describeBehavioralTendencies, PRIMARY_SYSTEM_NAMES, } from "./primary-systems.js";
 export type { PrimarySystemName, PrimarySystemLevels, BehavioralTendency, DominantSystem, } from "./primary-systems.js";
 export { updateTraitDrift } from "./drives.js";
-export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji } from "./classify.js";
+export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji, BuiltInClassifier, analyzeParticles, detectIntent, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
+export type { StimulusClassification, ParticleSignal, MessageIntent } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline, getNearBaselineThreshold } from "./prompt.js";
 export { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
 export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline, mbtiToTraits } from "./profiles.js";

package/dist/index.js

@@ -51,7 +51,7 @@ export { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByA
 // Trait drift (v9)
 export { updateTraitDrift } from "./drives.js";
 // Utilities — for custom adapter / advanced use
-export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji } from "./classify.js";
+export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji, BuiltInClassifier, analyzeParticles, detectIntent, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline, getNearBaselineThreshold } from "./prompt.js";
 export { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
 export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline, mbtiToTraits } from "./profiles.js";

package/dist/types.d.ts

@@ -328,3 +328,23 @@ export interface EnergyBudgets {
     decisionCapacity: number;
 }
 export declare const DEFAULT_ENERGY_BUDGETS: EnergyBudgets;
+/** A single classification result */
+export interface ClassificationResult {
+    type: StimulusType;
+    confidence: number;
+}
+/** Context passed to classifier providers */
+export interface ClassifierContext {
+    recentStimuli?: (StimulusType | null)[];
+    recentMessages?: string[];
+    locale?: Locale;
+}
+/**
+ * Pluggable classifier interface.
+ * Implementations can be sync or async.
+ * Built-in: enhanced keyword + Chinese NLP classifier (sync, zero deps).
+ * User-provided: could be LLM-based, API-based, local model, etc.
+ */
+export interface ClassifierProvider {
+    classify(text: string, context?: ClassifierContext): ClassificationResult[] | Promise<ClassificationResult[]>;
+}

package/package.json

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