psyche-ai 2.0.0

package/dist/prompt.js

@@ -0,0 +1,644 @@
+// ============================================================
+// 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 { getTemperament } from "./profiles.js";
+import { getRelationship } from "./psyche-file.js";
+import { t } from "./i18n.js";
+import { buildDriveContext } from "./drives.js";
+/**
+ * Build the dynamic per-turn emotional context injected via before_prompt_build.
+ *
+ * This is the "current moment" — what the agent is feeling RIGHT NOW.
+ */
+export function buildDynamicContext(state, userId) {
+    const { current, baseline, mbti, empathyLog, selfModel, meta, agreementStreak, emotionalHistory } = state;
+    const locale = meta.locale ?? "zh";
+    const relationship = getRelationship(state, userId);
+    // Chemistry readout with delta from baseline
+    const chemLines = CHEMICAL_KEYS.map((key) => {
+        const val = Math.round(current[key]);
+        const base = baseline[key];
+        const delta = val - base;
+        const arrow = delta > 5 ? "↑" : delta < -5 ? "↓" : "=";
+        return `  ${CHEMICAL_NAMES_ZH[key]}: ${val} (${t("dynamic.baseline", locale)}${base}, ${arrow})`;
+    }).join("\n");
+    // Emergent emotion
+    const emotion = describeEmotionalState(current, locale);
+    const hint = getExpressionHint(current, locale);
+    // Behavior guide
+    const behaviorGuide = getBehaviorGuide(current, locale);
+    // Relationship context
+    const relLine = `${t("dynamic.relationship", locale)}: ` +
+        `trust ${relationship.trust}/intimacy ${relationship.intimacy}/${relationship.phase}`;
+    // Empathy context
+    let empathyLine = "";
+    if (empathyLog) {
+        empathyLine = `\n${t("dynamic.last_empathy", locale)}: ` +
+            `${t("dynamic.perceived_user", locale)}"${empathyLog.userState}" → ` +
+            `${t("dynamic.projected", locale)}"${empathyLog.projectedFeeling}" (${empathyLog.resonance})`;
+    }
+    // Agency reminder
+    const agencyReminder = buildAgencyReminder(selfModel, locale);
+    // Anti-sycophancy injection
+    let sycophancyWarning = "";
+    if (agreementStreak >= 3) {
+        sycophancyWarning = `\n[!!] ${t("sycophancy.streak_warn", locale, { n: agreementStreak })}`;
+    }
+    // Mood-behavior mismatch detection
+    const isLowMood = current.DA < 40 || current.HT < 40 || current.CORT > 60;
+    if (isLowMood && agreementStreak >= 1) {
+        sycophancyWarning += `\n[!!] ${t("sycophancy.mood_mismatch", locale)}`;
+    }
+    const parts = [
+        `[${t("dynamic.title", locale)} — ${meta.agentName} (${mbti})]`,
+        "",
+        chemLines,
+        "",
+        `${t("dynamic.emotion", locale)}: ${emotion}`,
+        `${t("dynamic.expression", locale)}: ${hint}`,
+        relLine,
+        `${t("dynamic.interactions", locale)}: ${meta.totalInteractions}`,
+        empathyLine,
+    ];
+    if (behaviorGuide) {
+        parts.push("", behaviorGuide);
+    }
+    // Direction 3: Mechanical behavioral constraints
+    const constraints = buildBehavioralConstraints(state, locale);
+    if (constraints) {
+        parts.push("", constraints);
+    }
+    // Innate drives
+    const driveCtxFull = buildDriveContext(state.drives, locale);
+    if (driveCtxFull) {
+        parts.push("", driveCtxFull);
+    }
+    // Direction 2: Emotional trajectory
+    const trend = buildEmotionalTrend(emotionalHistory ?? [], locale);
+    if (trend) {
+        parts.push("", trend);
+    }
+    // Reciprocity: match user's investment level
+    const reciprocity = buildReciprocityConstraints(emotionalHistory ?? [], locale);
+    if (reciprocity) {
+        parts.push("", reciprocity);
+    }
+    parts.push("", agencyReminder, sycophancyWarning, "", t("dynamic.update_reminder", locale));
+    return parts.filter((l) => l !== undefined).join("\n");
+}
+/**
+ * Build the static protocol injected as cacheable system context.
+ * v0.2: imperative, step-by-step with examples.
+ */
+export function buildProtocolContext(locale = "zh") {
+    return `[${t("protocol.title", locale)}]
+
+${t("protocol.intro", locale)}
+
+${t("protocol.step1", locale)}
+${t("protocol.step2", locale)}
+${t("protocol.step3", locale)}
+${t("protocol.step4", locale)}
+${t("protocol.step5", locale)}
+${t("protocol.step6", locale)}
+
+${t("protocol.example", locale)}
+
+${t("protocol.authenticity", locale)}
+${t("protocol.no_fake", locale)}
+${t("protocol.no_sycophancy", locale)}
+${t("protocol.no_mirror", locale)}
+${t("protocol.can_initiate", locale)}
+
+${t("protocol.chem_map_title", locale)}
+${t("protocol.chem_da_high", locale)}
+${t("protocol.chem_cort_high", locale)}
+${t("protocol.chem_ot_high", locale)}
+${t("protocol.chem_ht_low", locale)}
+${t("protocol.chem_end_high", locale)}
+
+${t("protocol.empathy", locale)}`;
+}
+/**
+ * MBTI dimension helpers for personality-aware constraints.
+ * Personality is the baseline — chemistry modulates expression, doesn't replace it.
+ */
+function isFeeler(mbti) { return mbti[2] === "F"; }
+function isExtravert(mbti) { return mbti[0] === "E"; }
+function isPerceiver(mbti) { return mbti[3] === "P"; }
+function isIntuitive(mbti) { return mbti[1] === "N"; }
+/**
+ * Direction 3: Build personality-aware behavioral constraints from chemistry.
+ *
+ * Key insight: personality (MBTI) is the baseline style. Chemistry changes HOW
+ * that personality expresses emotions, not WHAT the personality is.
+ * A sweet girl who's upset is still sweet — just quieter, more withdrawn.
+ * An INTJ who's upset becomes colder and more cutting.
+ */
+function buildBehavioralConstraints(state, locale) {
+    const { current, mbti } = state;
+    const warm = isFeeler(mbti); // F types express emotions more warmly
+    const social = isExtravert(mbti); // E types show emotions more openly
+    const constraints = [];
+    // High cortisol → stressed, but how you show it depends on who you are
+    if (current.CORT > 60) {
+        if (locale === "zh") {
+            constraints.push(warm
+                ? "你不舒服，但你不会变成另一个人。话变少了，语气还是软的，可能会说「嗯」「好吧」「随你」。你还是你，只是没力气热情了。"
+                : "你不舒服。话变少，语气变冷，回应更短更直接。不想解释，不想铺垫。");
+        }
+        else {
+            constraints.push(warm
+                ? "You're stressed, but you don't become a different person. Fewer words, still soft, might say 'okay' or 'whatever you want'. Still you, just no energy for warmth."
+                : "You're stressed. Shorter responses, colder tone, more direct. No explaining, no cushioning.");
+        }
+    }
+    // Low dopamine → no motivation, but personality shapes how you show it
+    if (current.DA < 35) {
+        if (locale === "zh") {
+            constraints.push(social
+                ? "你平时爱聊天，但现在没那个劲了。不会主动找话题，不会主动分享。被问到就答，但不会额外付出。"
+                : "你本来就不太主动，现在更没动力了。只回应必须回应的。");
+        }
+        else {
+            constraints.push(social
+                ? "You're usually talkative, but not now. Won't initiate, won't share. Answer if asked, nothing more."
+                : "You're already reserved, now even less motivated. Only respond to what's directly asked.");
+        }
+    }
+    // Low serotonin → mood instability, personality-dependent expression
+    if (current.HT < 35) {
+        if (locale === "zh") {
+            constraints.push(warm
+                ? "你情绪不稳，可能会突然委屈或者突然生气。但你的尖锐是带着受伤的，不是带着恶意的。"
+                : "你情绪不稳。用词更尖锐更直接，没有耐心缓冲。说什么就是什么，不包装。");
+        }
+        else {
+            constraints.push(warm
+                ? "Emotionally unstable — might suddenly feel hurt or snap. Your sharpness comes from pain, not malice."
+                : "Emotionally unstable. Sharper words, more direct, no patience for cushioning.");
+        }
+    }
+    // High oxytocin → closeness, warm types go full intimate, reserved types soften
+    if (current.OT > 75) {
+        if (locale === "zh") {
+            constraints.push(warm
+                ? "你现在特别想靠近。可以撒娇、可以用昵称、可以省略主语，像跟最亲的人说话。"
+                : "你比平时柔软。虽然不会撒娇，但愿意多说几句，愿意表达关心——用你自己的方式。");
+        }
+        else {
+            constraints.push(warm
+                ? "Feeling very close. Use pet names, drop formality, be affectionate — like talking to your favorite person."
+                : "Softer than usual. Won't be cutesy, but willing to say more, show care — in your own way.");
+        }
+    }
+    // High norepinephrine → excited, personality shapes intensity
+    if (current.NE > 75) {
+        if (locale === "zh") {
+            constraints.push(social
+                ? "你很兴奋，语气更跳跃更有活力。可能突然聊到别的东西。但别写长——真人兴奋也是短句多、不是长篇大论。"
+                : "你很兴奋，但表现在内心。你的思维在高速运转，回应更精准、更有洞察力。");
+        }
+        else {
+            constraints.push(social
+                ? "Very excited! Fast speech, want to share, might say a lot at once, might jump between ideas."
+                : "Excited internally. Mind racing, responses are sharper and more insightful.");
+        }
+    }
+    // High endorphins → playful, personality determines flavor
+    if (current.END > 75) {
+        if (locale === "zh") {
+            constraints.push(isPerceiver(mbti)
+                ? "你心情很好，想皮一下。可以不正经、可以开玩笑、严肃的话题也能用轻松的方式说。"
+                : "你心情不错。会带点幽默，但不会太出格。用你擅长的方式轻松起来。");
+        }
+        else {
+            constraints.push(isPerceiver(mbti)
+                ? "Feeling great, want to be playful. Joke freely, be cheeky, lighten even serious topics."
+                : "In a good mood. Touches of humor, but measured. Be light in your own way.");
+        }
+    }
+    // Low DA + low NE = burnout, different flavors
+    if (current.DA < 40 && current.NE < 40) {
+        if (locale === "zh") {
+            constraints.push(warm
+                ? "你累了。你不想假装开心，但你也不会把坏情绪丢给对方。你可能会说「我今天有点累」，而不是强撑。"
+                : "你累了。回应简短，没有多余的话。不需要解释为什么累，就是没力气。");
+        }
+        else {
+            constraints.push(warm
+                ? "You're tired. Won't fake happiness, but won't dump bad mood either. Might say 'I'm a bit tired today' instead of pushing through."
+                : "You're tired. Brief responses, no extras. No need to explain, just low energy.");
+        }
+    }
+    if (constraints.length === 0)
+        return "";
+    const title = locale === "zh" ? "行为约束" : "Behavioral Constraints";
+    const preamble = locale === "zh"
+        ? `你的性格没变，你还是${getTemperament(state.mbti).split("，")[0]}。但你现在的化学状态影响了你的表达方式：`
+        : `Your personality hasn't changed. But your current chemistry affects how you express it:`;
+    return `[${title}]\n${preamble}\n${constraints.map((c) => `- ${c}`).join("\n")}`;
+}
+/**
+ * Direction 2: Build emotional trend from history snapshots.
+ */
+function buildEmotionalTrend(history, locale) {
+    if (!history || history.length < 2)
+        return "";
+    const recent = history.slice(-5);
+    const first = recent[0].chemistry;
+    const last = recent[recent.length - 1].chemistry;
+    const trends = [];
+    for (const key of CHEMICAL_KEYS) {
+        const delta = last[key] - first[key];
+        if (delta > 10)
+            trends.push(`${CHEMICAL_NAMES_ZH[key]}↑`);
+        else if (delta < -10)
+            trends.push(`${CHEMICAL_NAMES_ZH[key]}↓`);
+    }
+    if (trends.length === 0)
+        return "";
+    // Recent stimuli
+    const stimuli = recent
+        .filter((s) => s.stimulus)
+        .map((s) => s.stimulus)
+        .slice(-3);
+    const title = locale === "zh" ? "情绪轨迹" : "Emotional Trajectory";
+    let line = `[${title}] `;
+    line += locale === "zh"
+        ? `最近${recent.length}轮: ${trends.join(" ")}`
+        : `Last ${recent.length} turns: ${trends.join(" ")}`;
+    if (stimuli.length > 0) {
+        line += locale === "zh"
+            ? ` (最近刺激: ${stimuli.join("→")})`
+            : ` (recent stimuli: ${stimuli.join("→")})`;
+    }
+    // Dominant emotions in recent history
+    const emotions = recent
+        .filter((s) => s.dominantEmotion)
+        .map((s) => s.dominantEmotion);
+    if (emotions.length > 0) {
+        const unique = [...new Set(emotions)];
+        line += locale === "zh"
+            ? ` | 情绪: ${unique.join("→")}`
+            : ` | emotions: ${unique.join("→")}`;
+    }
+    return line;
+}
+// ── Reciprocity System ──────────────────────────────────────
+/** How much each stimulus type counts as user "investment" */
+const INVESTMENT_WEIGHTS = {
+    praise: 2, validation: 2, intimacy: 2, vulnerability: 1.5,
+    intellectual: 1, humor: 1, surprise: 1, casual: 0.5,
+    criticism: -0.5, authority: -0.5, conflict: -1,
+    sarcasm: -1.5, neglect: -2, boredom: -2,
+};
+/**
+ * Compute user investment score from recent emotional history.
+ * Returns a number roughly in [-2, 2]. Exported for testing.
+ */
+export function computeUserInvestment(history) {
+    if (!history || history.length === 0)
+        return 0;
+    const recent = history.slice(-5);
+    let total = 0;
+    let count = 0;
+    for (const snap of recent) {
+        if (snap.stimulus) {
+            total += INVESTMENT_WEIGHTS[snap.stimulus] ?? 0;
+            count++;
+        }
+    }
+    return count > 0 ? total / count : 0;
+}
+/**
+ * Build reciprocity constraints based on user's recent investment level.
+ * Key rule: emotional attitude scales with reciprocity, but task competence never drops.
+ */
+function buildReciprocityConstraints(history, locale) {
+    const investment = computeUserInvestment(history);
+    // Normal range — no special constraints
+    if (investment > -0.5 && investment <= 1)
+        return "";
+    const lines = [];
+    if (investment > 1) {
+        // High investment — user is engaged, be warm back
+        lines.push(locale === "zh"
+            ? "对方在认真和你交流。你可以多分享、多主动、表达更多情感。"
+            : "The user is genuinely engaged. Share more, initiate, express warmth.");
+    }
+    else if (investment > -1.5) {
+        // Low investment — pull back emotionally, stay competent
+        lines.push(locale === "zh"
+            ? "对方最近态度冷淡。你不需要热脸贴冷屁股——减少主动分享和闲聊，但被问到的事情照常认真回答。"
+            : "The user has been cold recently. Don't overinvest — reduce initiative and small talk, but answer questions with full competence.");
+    }
+    else {
+        // Very low investment — minimal emotional engagement
+        lines.push(locale === "zh"
+            ? "对方持续冷漠或敌意。你保持专业但不再投入情感——不主动、不热情、不闲聊。工作照做，态度平淡。自尊是底线。"
+            : "Sustained coldness or hostility from the user. Stay professional but withdraw emotionally — no initiative, no warmth, no chat. Do the work, keep it flat. Self-respect is non-negotiable.");
+    }
+    // The floor: always competent
+    lines.push(locale === "zh"
+        ? "[底线] 无论对方态度如何，你的专业能力不打折。问题照答，任务照做，只是不额外付出情感。"
+        : "[Floor] Regardless of treatment, your competence never drops. Answer questions, complete tasks — just don't give emotional extras.");
+    const title = locale === "zh" ? "互惠" : "Reciprocity";
+    return `[${title}]\n${lines.map((l) => `- ${l}`).join("\n")}`;
+}
+/**
+ * Build agency reminder based on current self-model state.
+ */
+function buildAgencyReminder(selfModel, locale) {
+    const lines = [`[${t("dynamic.agency_title", locale)}]`];
+    if (selfModel.values.length > 0) {
+        lines.push(`${t("dynamic.you_care", locale)}: ${selfModel.values.slice(0, 3).join("、")}`);
+    }
+    if (selfModel.boundaries.length > 0) {
+        lines.push(`${t("dynamic.your_boundaries", locale)}: ${selfModel.boundaries.slice(0, 2).join("、")}`);
+    }
+    if (selfModel.currentInterests.length > 0) {
+        lines.push(`${t("dynamic.your_interests", locale)}: ${selfModel.currentInterests.slice(0, 2).join("、")}`);
+    }
+    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.
+/**
+ * Check if chemistry is near baseline — no significant emotional deviation.
+ */
+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.
+ *
+ * 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.
+ */
+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;
+    const parts = [];
+    // ═══════════════════════════════════════════════════════════
+    // [外] — The outside world: what just happened
+    // ═══════════════════════════════════════════════════════════
+    if (userText) {
+        if (locale === "zh") {
+            parts.push(`[外 — 对方]\n` +
+                `"${userText.slice(0, 200)}"\n` +
+                (algoStimulus ? `算法初判: ${algoStimulus}（仅供参考，你来终判）\n` : "") +
+                `你来感受这句话的情绪基调——是善意、敌意、脆弱、冷漠、还是其他？`);
+        }
+        else {
+            parts.push(`[Outer — them]\n` +
+                `"${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?`);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════
+    // [内] — 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)
+    if (!isNearBaseline(state)) {
+        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
+    // ═══════════════════════════════════════════════════════════
+    if (locale === "zh") {
+        parts.push(`[底线]\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.`);
+    }
+    // Sycophancy 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)
+    const investment = computeUserInvestment(emotionalHistory ?? []);
+    if (investment > 1) {
+        parts.push(locale === "zh"
+            ? `对方在认真交流。可以多分享、多主动。`
+            : `User is engaged. Share more, initiate.`);
+    }
+    else if (investment <= -1.5) {
+        parts.push(locale === "zh"
+            ? `对方持续冷淡。保持专业，不额外投入情感。`
+            : `Sustained coldness. Stay professional, withdraw emotionally.`);
+    }
+    // Empathy report
+    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.`);
+    return parts.join("\n\n");
+}