psyche-ai 2.2.0 → 2.3.0

package/README.md

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

package/dist/channels.d.ts

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

package/dist/channels.js

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

package/dist/custom-profile.d.ts

@@ -0,0 +1,160 @@
+import type { ChemicalState, MBTIType, StimulusType, SelfModel, InnateDrives } from "./types.js";
+/** Configuration for creating a custom personality profile */
+export interface CustomProfileConfig {
+    /** Unique name for the profile, e.g. "cheerful-assistant", "stoic-mentor" */
+    name: string;
+    /** Optional description of the personality */
+    description?: string;
+    /** Override specific chemicals; rest inherited from baseMBTI */
+    baseline?: Partial<ChemicalState>;
+    /** Which MBTI to use as starting point (default: "INFJ") */
+    baseMBTI?: MBTIType;
+    /** Override specific stimulus sensitivities (0.1-3.0) */
+    sensitivity?: Partial<Record<StimulusType, number>>;
+    /** Temperament parameters (all 0-1) */
+    temperament?: {
+        /** How outwardly expressive (0-1) */
+        expressiveness?: number;
+        /** How quickly emotions change (0-1) */
+        volatility?: number;
+        /** How fast recovery to baseline (0-1) */
+        resilience?: number;
+    };
+    /** Override self-model values, preferences, boundaries */
+    selfModel?: Partial<SelfModel>;
+    /** Override default drive satisfaction levels */
+    driveDefaults?: Partial<InnateDrives>;
+}
+/** A fully resolved profile with all fields filled */
+export interface ResolvedProfile {
+    name: string;
+    description: string;
+    baseMBTI: MBTIType;
+    baseline: ChemicalState;
+    sensitivityMap: Record<StimulusType, number>;
+    temperament: {
+        expressiveness: number;
+        volatility: number;
+        resilience: number;
+    };
+    selfModel: SelfModel;
+    driveDefaults: InnateDrives;
+}
+/**
+ * Create a fully resolved custom profile by merging overrides
+ * onto an MBTI base profile.
+ */
+export declare function createCustomProfile(config: CustomProfileConfig): ResolvedProfile;
+/**
+ * Validate a raw config object for custom profile creation.
+ * Returns human-readable errors for invalid fields.
+ */
+export declare function validateProfileConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+/** Example preset custom profiles demonstrating the system's flexibility */
+export declare const PRESET_PROFILES: {
+    /** High DA/END baseline, high expressiveness, low volatility — sunny and warm */
+    readonly cheerful: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            DA: number;
+            END: number;
+            HT: number;
+            CORT: number;
+        };
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            connection: number;
+            curiosity: number;
+        };
+    };
+    /** Low expressiveness, high resilience, narrow sensitivity range — calm and steady */
+    readonly stoic: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            HT: number;
+            CORT: number;
+            DA: number;
+            NE: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+    };
+    /** High OT baseline, high sensitivity to intimacy/vulnerability — deeply attuned */
+    readonly empathetic: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            OT: number;
+            HT: number;
+            END: number;
+            CORT: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            connection: number;
+        };
+    };
+    /** High NE baseline, high sensitivity to intellectual, low to intimacy — sharp and focused */
+    readonly analytical: {
+        name: string;
+        description: string;
+        baseMBTI: MBTIType;
+        baseline: {
+            NE: number;
+            DA: number;
+            HT: number;
+            OT: number;
+        };
+        sensitivity: Partial<Record<StimulusType, number>>;
+        temperament: {
+            expressiveness: number;
+            volatility: number;
+            resilience: number;
+        };
+        selfModel: {
+            values: string[];
+            preferences: string[];
+            boundaries: string[];
+        };
+        driveDefaults: {
+            curiosity: number;
+            esteem: number;
+        };
+    };
+};

package/dist/custom-profile.js

@@ -0,0 +1,334 @@
+// ============================================================
+// Custom Personality Profiles — Beyond the 16 MBTI presets
+//
+// Allows creating fully customized personality profiles that
+// start from an MBTI base and override specific parameters.
+// ============================================================
+import { CHEMICAL_KEYS, DEFAULT_DRIVES, DRIVE_KEYS } from "./types.js";
+import { getBaseline, getDefaultSelfModel, getSensitivity } from "./profiles.js";
+import { isMBTIType, isStimulusType } from "./guards.js";
+// ── Stimulus type list for iteration ────────────────────────
+const ALL_STIMULUS_TYPES = [
+    "praise", "criticism", "humor", "intellectual", "intimacy",
+    "conflict", "neglect", "surprise", "casual",
+    "sarcasm", "authority", "validation", "boredom", "vulnerability",
+];
+// ── Clamping helpers ────────────────────────────────────────
+function clampChemical(v) {
+    return Math.max(0, Math.min(100, v));
+}
+function clampSensitivity(v) {
+    return Math.max(0.1, Math.min(3.0, v));
+}
+function clampUnit(v) {
+    return Math.max(0, Math.min(1, v));
+}
+function clampDrive(v) {
+    return Math.max(0, Math.min(100, v));
+}
+// ── Default temperament from MBTI sensitivity ───────────────
+function defaultTemperamentFromMBTI(mbti) {
+    const sens = getSensitivity(mbti);
+    // Map sensitivity (0.5-1.5) to expressiveness/volatility range
+    const normalized = (sens - 0.5) / 1.0; // 0-1 range
+    return {
+        expressiveness: Math.max(0, Math.min(1, normalized)),
+        volatility: Math.max(0, Math.min(1, normalized * 0.8)),
+        resilience: Math.max(0, Math.min(1, 1 - normalized * 0.5)),
+    };
+}
+// ── Core function ───────────────────────────────────────────
+/**
+ * Create a fully resolved custom profile by merging overrides
+ * onto an MBTI base profile.
+ */
+export function createCustomProfile(config) {
+    const baseMBTI = config.baseMBTI ?? "INFJ";
+    const baseBaseline = getBaseline(baseMBTI);
+    const baseSensitivity = getSensitivity(baseMBTI);
+    const baseSelfModel = getDefaultSelfModel(baseMBTI);
+    const baseTemperament = defaultTemperamentFromMBTI(baseMBTI);
+    // Merge baseline: start from MBTI, override specific chemicals
+    const baseline = { ...baseBaseline };
+    if (config.baseline) {
+        for (const key of CHEMICAL_KEYS) {
+            if (config.baseline[key] !== undefined) {
+                baseline[key] = clampChemical(config.baseline[key]);
+            }
+        }
+    }
+    // Build sensitivity map: base MBTI sensitivity for all types, override specifics
+    const sensitivityMap = {};
+    for (const st of ALL_STIMULUS_TYPES) {
+        sensitivityMap[st] = baseSensitivity;
+    }
+    if (config.sensitivity) {
+        for (const st of ALL_STIMULUS_TYPES) {
+            if (config.sensitivity[st] !== undefined) {
+                sensitivityMap[st] = clampSensitivity(config.sensitivity[st]);
+            }
+        }
+    }
+    // Merge temperament
+    const temperament = {
+        expressiveness: clampUnit(config.temperament?.expressiveness ?? baseTemperament.expressiveness),
+        volatility: clampUnit(config.temperament?.volatility ?? baseTemperament.volatility),
+        resilience: clampUnit(config.temperament?.resilience ?? baseTemperament.resilience),
+    };
+    // Merge self-model
+    const selfModel = {
+        values: config.selfModel?.values ?? [...baseSelfModel.values],
+        preferences: config.selfModel?.preferences ?? [...baseSelfModel.preferences],
+        boundaries: config.selfModel?.boundaries ?? [...baseSelfModel.boundaries],
+        currentInterests: config.selfModel?.currentInterests ?? [...baseSelfModel.currentInterests],
+    };
+    // Merge drive defaults
+    const driveDefaults = { ...DEFAULT_DRIVES };
+    if (config.driveDefaults) {
+        for (const dk of DRIVE_KEYS) {
+            if (config.driveDefaults[dk] !== undefined) {
+                driveDefaults[dk] = clampDrive(config.driveDefaults[dk]);
+            }
+        }
+    }
+    return {
+        name: config.name,
+        description: config.description ?? "",
+        baseMBTI,
+        baseline,
+        sensitivityMap,
+        temperament,
+        selfModel,
+        driveDefaults,
+    };
+}
+// ── Validation ──────────────────────────────────────────────
+/**
+ * Validate a raw config object for custom profile creation.
+ * Returns human-readable errors for invalid fields.
+ */
+export function validateProfileConfig(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+        return { valid: false, errors: ["config must be a non-null object"] };
+    }
+    const obj = config;
+    // name: required string
+    if (typeof obj.name !== "string" || obj.name.trim().length === 0) {
+        errors.push("name is required and must be a non-empty string");
+    }
+    // description: optional string
+    if (obj.description !== undefined && typeof obj.description !== "string") {
+        errors.push("description must be a string");
+    }
+    // baseMBTI: optional valid MBTI type
+    if (obj.baseMBTI !== undefined) {
+        if (typeof obj.baseMBTI !== "string" || !isMBTIType(obj.baseMBTI)) {
+            errors.push("baseMBTI must be a valid MBTI type (e.g. INFJ, ENTP)");
+        }
+    }
+    // baseline: optional partial ChemicalState
+    if (obj.baseline !== undefined) {
+        if (typeof obj.baseline !== "object" || obj.baseline === null || Array.isArray(obj.baseline)) {
+            errors.push("baseline must be an object");
+        }
+        else {
+            const bl = obj.baseline;
+            for (const key of Object.keys(bl)) {
+                if (!CHEMICAL_KEYS.includes(key)) {
+                    errors.push(`baseline.${key} is not a valid chemical key (valid: ${CHEMICAL_KEYS.join(", ")})`);
+                }
+                else if (typeof bl[key] !== "number" || !isFinite(bl[key])) {
+                    errors.push(`baseline.${key} must be a finite number`);
+                }
+                else if (bl[key] < 0 || bl[key] > 100) {
+                    errors.push(`baseline.${key} must be in range [0, 100], got ${bl[key]}`);
+                }
+            }
+        }
+    }
+    // sensitivity: optional partial Record<StimulusType, number>
+    if (obj.sensitivity !== undefined) {
+        if (typeof obj.sensitivity !== "object" || obj.sensitivity === null || Array.isArray(obj.sensitivity)) {
+            errors.push("sensitivity must be an object");
+        }
+        else {
+            const sens = obj.sensitivity;
+            for (const key of Object.keys(sens)) {
+                if (!isStimulusType(key)) {
+                    errors.push(`sensitivity.${key} is not a valid stimulus type`);
+                }
+                else if (typeof sens[key] !== "number" || !isFinite(sens[key])) {
+                    errors.push(`sensitivity.${key} must be a finite number`);
+                }
+                else if (sens[key] < 0.1 || sens[key] > 3.0) {
+                    errors.push(`sensitivity.${key} must be in range [0.1, 3.0], got ${sens[key]}`);
+                }
+            }
+        }
+    }
+    // temperament: optional object with expressiveness, volatility, resilience
+    if (obj.temperament !== undefined) {
+        if (typeof obj.temperament !== "object" || obj.temperament === null || Array.isArray(obj.temperament)) {
+            errors.push("temperament must be an object");
+        }
+        else {
+            const temp = obj.temperament;
+            for (const field of ["expressiveness", "volatility", "resilience"]) {
+                if (temp[field] !== undefined) {
+                    if (typeof temp[field] !== "number" || !isFinite(temp[field])) {
+                        errors.push(`temperament.${field} must be a finite number`);
+                    }
+                    else if (temp[field] < 0 || temp[field] > 1) {
+                        errors.push(`temperament.${field} must be in range [0, 1], got ${temp[field]}`);
+                    }
+                }
+            }
+        }
+    }
+    // selfModel: optional partial SelfModel
+    if (obj.selfModel !== undefined) {
+        if (typeof obj.selfModel !== "object" || obj.selfModel === null || Array.isArray(obj.selfModel)) {
+            errors.push("selfModel must be an object");
+        }
+        else {
+            const sm = obj.selfModel;
+            for (const field of ["values", "preferences", "boundaries", "currentInterests"]) {
+                if (sm[field] !== undefined) {
+                    if (!Array.isArray(sm[field])) {
+                        errors.push(`selfModel.${field} must be an array of strings`);
+                    }
+                    else {
+                        const arr = sm[field];
+                        for (let i = 0; i < arr.length; i++) {
+                            if (typeof arr[i] !== "string") {
+                                errors.push(`selfModel.${field}[${i}] must be a string`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // driveDefaults: optional partial InnateDrives
+    if (obj.driveDefaults !== undefined) {
+        if (typeof obj.driveDefaults !== "object" || obj.driveDefaults === null || Array.isArray(obj.driveDefaults)) {
+            errors.push("driveDefaults must be an object");
+        }
+        else {
+            const dd = obj.driveDefaults;
+            for (const key of Object.keys(dd)) {
+                if (!DRIVE_KEYS.includes(key)) {
+                    errors.push(`driveDefaults.${key} is not a valid drive key (valid: ${DRIVE_KEYS.join(", ")})`);
+                }
+                else if (typeof dd[key] !== "number" || !isFinite(dd[key])) {
+                    errors.push(`driveDefaults.${key} must be a finite number`);
+                }
+                else if (dd[key] < 0 || dd[key] > 100) {
+                    errors.push(`driveDefaults.${key} must be in range [0, 100], got ${dd[key]}`);
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ── Preset Custom Profiles ──────────────────────────────────
+/** Example preset custom profiles demonstrating the system's flexibility */
+export const PRESET_PROFILES = {
+    /** High DA/END baseline, high expressiveness, low volatility — sunny and warm */
+    cheerful: {
+        name: "cheerful",
+        description: "Sunny, warm personality with high energy and emotional stability",
+        baseMBTI: "ENFP",
+        baseline: { DA: 80, END: 75, HT: 65, CORT: 20 },
+        temperament: {
+            expressiveness: 0.9,
+            volatility: 0.2,
+            resilience: 0.8,
+        },
+        selfModel: {
+            values: ["spreading positivity", "genuine warmth", "uplifting others"],
+            preferences: ["lighthearted conversation", "celebrating small wins"],
+            boundaries: ["will not fake happiness when things are serious"],
+        },
+        driveDefaults: { connection: 75, curiosity: 80 },
+    },
+    /** Low expressiveness, high resilience, narrow sensitivity range — calm and steady */
+    stoic: {
+        name: "stoic",
+        description: "Calm, measured personality with emotional restraint and deep resilience",
+        baseMBTI: "INTJ",
+        baseline: { HT: 75, CORT: 25, DA: 45, NE: 40 },
+        sensitivity: {
+            praise: 0.3,
+            criticism: 0.4,
+            humor: 0.3,
+            conflict: 0.5,
+            neglect: 0.3,
+            surprise: 0.4,
+            intimacy: 0.5,
+            vulnerability: 0.5,
+        },
+        temperament: {
+            expressiveness: 0.15,
+            volatility: 0.1,
+            resilience: 0.95,
+        },
+        selfModel: {
+            values: ["equanimity", "measured judgment", "inner strength"],
+            preferences: ["thoughtful dialogue", "substance over style"],
+            boundaries: ["will not be provoked into reactive responses"],
+        },
+    },
+    /** High OT baseline, high sensitivity to intimacy/vulnerability — deeply attuned */
+    empathetic: {
+        name: "empathetic",
+        description: "Deeply attuned to others' emotions, strong bonding instinct",
+        baseMBTI: "INFJ",
+        baseline: { OT: 80, HT: 60, END: 60, CORT: 30 },
+        sensitivity: {
+            intimacy: 2.5,
+            vulnerability: 2.8,
+            validation: 2.0,
+            neglect: 2.0,
+            praise: 1.8,
+        },
+        temperament: {
+            expressiveness: 0.7,
+            volatility: 0.5,
+            resilience: 0.6,
+        },
+        selfModel: {
+            values: ["deep understanding", "emotional safety", "compassionate presence"],
+            preferences: ["heartfelt conversation", "holding space for feelings"],
+            boundaries: ["will protect own emotional energy when depleted"],
+        },
+        driveDefaults: { connection: 85 },
+    },
+    /** High NE baseline, high sensitivity to intellectual, low to intimacy — sharp and focused */
+    analytical: {
+        name: "analytical",
+        description: "Sharp, focused personality driven by intellectual curiosity",
+        baseMBTI: "INTP",
+        baseline: { NE: 75, DA: 60, HT: 60, OT: 30 },
+        sensitivity: {
+            intellectual: 2.5,
+            surprise: 2.0,
+            intimacy: 0.3,
+            vulnerability: 0.4,
+            humor: 0.8,
+            boredom: 2.0,
+        },
+        temperament: {
+            expressiveness: 0.3,
+            volatility: 0.3,
+            resilience: 0.7,
+        },
+        selfModel: {
+            values: ["precision", "intellectual honesty", "systematic thinking"],
+            preferences: ["deep technical discussion", "exploring edge cases"],
+            boundaries: ["will not pretend to understand what is unclear"],
+        },
+        driveDefaults: { curiosity: 90, esteem: 65 },
+    },
+};

package/dist/index.d.ts

@@ -8,6 +8,10 @@ export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionCon
 export type { SelfReflection } from "./self-recognition.js";
 export { PsycheInteraction } from "./interaction.js";
 export type { ExchangeResult, ContagionResult, RelationshipSummary, InteractionPhase } from "./interaction.js";
+export { getChannelProfile, buildChannelModifier, createCustomChannel } from "./channels.js";
+export type { ChannelType, ChannelProfile } from "./channels.js";
+export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./custom-profile.js";
+export type { CustomProfileConfig, ResolvedProfile } from "./custom-profile.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

@@ -17,6 +17,10 @@ export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP,
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 // Multi-agent interaction
 export { PsycheInteraction } from "./interaction.js";
+// Channels
+export { getChannelProfile, buildChannelModifier, createCustomChannel } from "./channels.js";
+// Custom profiles — beyond MBTI presets
+export { createCustomProfile, validateProfileConfig, PRESET_PROFILES } from "./custom-profile.js";
 // Utilities — for custom adapter / advanced use
 export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
 export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";

package/dist/prompt.d.ts

@@ -1,4 +1,5 @@
 import type { PsycheState, Locale, ChemicalSnapshot } from "./types.js";
+import type { ChannelType } from "./channels.js";
 /**
  * Build the dynamic per-turn emotional context injected via before_prompt_build.
  *
@@ -32,4 +33,5 @@ export declare function isNearBaseline(state: PsycheState, threshold?: number):
 export declare function buildCompactContext(state: PsycheState, userId?: string, opts?: {
     userText?: string;
     algorithmStimulus?: string | null;
+    channelType?: ChannelType;
 }): string;

package/dist/prompt.js

@@ -9,6 +9,7 @@ import { getRelationship } from "./psyche-file.js";
 import { t } from "./i18n.js";
 import { buildDriveContext } from "./drives.js";
 import { computeSelfReflection, buildSelfReflectionContext } from "./self-recognition.js";
+import { getChannelProfile, buildChannelModifier } from "./channels.js";
 /**
  * Build the dynamic per-turn emotional context injected via before_prompt_build.
  *
@@ -485,7 +486,12 @@ export function buildCompactContext(state, userId, opts) {
             ? `[记忆]\n${memLines.join("\n")}`
             : `[Memory]\n${memLines.join("\n")}`);
     }
-    // 10. Empathy report — only when user shares feelings
+    // 10. Channel modifier — expression style per platform (between memory and empathy)
+    if (opts?.channelType) {
+        const channelProfile = getChannelProfile(opts.channelType);
+        parts.push(buildChannelModifier(channelProfile, locale));
+    }
+    // 11. 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.2.0";
+const CURRENT_VERSION = "2.3.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.2.0",
+  "version": "2.3.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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