psyche-ai 2.0.0

package/dist/psyche-file.d.ts

@@ -0,0 +1,69 @@
+import type { PsycheState, MBTIType, RelationshipState, Locale, StimulusType, ChemicalSnapshot } from "./types.js";
+/** Minimal logger interface */
+export interface Logger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    debug: (msg: string) => void;
+}
+/**
+ * Compress a batch of snapshots into a concise session summary string.
+ * Format: "3月23日(5轮): 刺激[casual×3, praise×2] 趋势[DA↑OT↑] 情绪[自然→满足]"
+ */
+export declare function compressSnapshots(snapshots: ChemicalSnapshot[]): string;
+/**
+ * Push a chemical snapshot to emotional history, keeping max entries.
+ * When history overflows, compresses removed entries into relationship memory.
+ */
+export declare function pushSnapshot(state: PsycheState, stimulus: StimulusType | null): PsycheState;
+/**
+ * Get relationship for a specific user, or _default.
+ */
+export declare function getRelationship(state: PsycheState, userId?: string): RelationshipState;
+/**
+ * Load psyche state from workspace. Auto-initializes if missing.
+ * Handles v1→v2 migration transparently.
+ */
+export declare function loadState(workspaceDir: string, logger?: Logger): Promise<PsycheState>;
+/**
+ * Migrate any older state format directly to v3.
+ * Single source of truth for all migrations.
+ */
+export declare function migrateToLatest(raw: Record<string, unknown>, fallbackName?: string): PsycheState;
+/**
+ * Create initial psyche state.
+ */
+export declare function initializeState(workspaceDir: string, opts?: {
+    mbti?: MBTIType;
+    name?: string;
+    locale?: Locale;
+}, logger?: Logger): Promise<PsycheState>;
+/**
+ * Save psyche state to workspace (atomic write).
+ */
+export declare function saveState(workspaceDir: string, state: PsycheState): Promise<void>;
+/**
+ * Apply time decay and save updated state.
+ * Respects innate drives: uses effective baseline, decays drives too.
+ */
+export declare function decayAndSave(workspaceDir: string, state: PsycheState): Promise<PsycheState>;
+/**
+ * Parse a <psyche_update> block from LLM output.
+ * v0.2: supports decimals, Chinese names, English names.
+ */
+export declare function parsePsycheUpdate(text: string, logger?: Logger): Partial<PsycheState> | null;
+/**
+ * Detect if LLM output contains disagreement/pushback.
+ */
+export declare function detectDisagreement(text: string): boolean;
+/**
+ * Merge parsed updates into existing state (with validation).
+ */
+export declare function mergeUpdates(state: PsycheState, updates: Partial<PsycheState>, maxDelta: number, userId?: string): PsycheState;
+/**
+ * Update agreement streak based on LLM output.
+ */
+export declare function updateAgreementStreak(state: PsycheState, llmOutput: string): PsycheState;
+/**
+ * Generate the static PSYCHE.md reference file.
+ */
+export declare function generatePsycheMd(workspaceDir: string, state: PsycheState): Promise<void>;

package/dist/psyche-file.js

@@ -0,0 +1,574 @@
+// ============================================================
+// Psyche State File Management (v0.2)
+// Atomic writes, parser hardening, multi-user, error handling
+// ============================================================
+import { readFile, writeFile, access, rename, constants } from "node:fs/promises";
+import { join } from "node:path";
+import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, MAX_EMOTIONAL_HISTORY, MAX_RELATIONSHIP_MEMORY, } from "./types.js";
+import { getBaseline, getDefaultSelfModel, extractMBTI, getSensitivity, getTemperament } from "./profiles.js";
+import { applyDecay, detectEmotions } from "./chemistry.js";
+import { decayDrives, computeEffectiveBaseline } from "./drives.js";
+import { t } from "./i18n.js";
+const STATE_FILE = "psyche-state.json";
+const PSYCHE_MD = "PSYCHE.md";
+const IDENTITY_MD = "IDENTITY.md";
+const SOUL_MD = "SOUL.md";
+const NOOP_LOGGER = {
+    info: () => { },
+    warn: () => { },
+    debug: () => { },
+};
+/** Check if a file exists, distinguishing "not found" from "no permission" */
+async function fileExists(path, logger = NOOP_LOGGER) {
+    try {
+        await access(path, constants.R_OK);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EACCES" || code === "EPERM") {
+            logger.warn(t("log.permission_error", "zh", { path }));
+            throw err; // Permission errors should propagate
+        }
+        return false; // ENOENT — file doesn't exist
+    }
+}
+/** Read text file, return null if missing. Throws on permission errors. */
+async function readText(path, logger = NOOP_LOGGER) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EACCES" || code === "EPERM") {
+            logger.warn(t("log.permission_error", "zh", { path }));
+            throw err;
+        }
+        return null;
+    }
+}
+/**
+ * Atomic write: write to .tmp file then rename.
+ * Prevents data corruption if process crashes mid-write.
+ */
+async function atomicWrite(path, content) {
+    const tmpPath = path + ".tmp";
+    await writeFile(tmpPath, content, "utf-8");
+    await rename(tmpPath, path);
+}
+/**
+ * Try to extract agent name from workspace files.
+ */
+async function extractAgentName(workspaceDir, logger = NOOP_LOGGER) {
+    const identity = await readText(join(workspaceDir, IDENTITY_MD), logger);
+    if (identity) {
+        const clean = identity.replace(/\*{1,2}/g, "");
+        const nameMatch = clean.match(/Name\s*[:：]\s*(\S+)/i);
+        if (nameMatch)
+            return nameMatch[1];
+    }
+    return workspaceDir.split("/").pop()?.replace("workspace-", "") ?? "agent";
+}
+/**
+ * Try to detect MBTI from workspace files.
+ */
+async function detectMBTI(workspaceDir, logger = NOOP_LOGGER) {
+    const identity = await readText(join(workspaceDir, IDENTITY_MD), logger);
+    if (identity) {
+        const mbti = extractMBTI(identity);
+        if (mbti)
+            return mbti;
+    }
+    const soul = await readText(join(workspaceDir, SOUL_MD), logger);
+    if (soul) {
+        const mbti = extractMBTI(soul);
+        if (mbti)
+            return mbti;
+    }
+    logger.info(t("log.default_mbti", "zh", { type: "INFJ" }));
+    return "INFJ";
+}
+/**
+ * Compress a batch of snapshots into a concise session summary string.
+ * Format: "3月23日(5轮): 刺激[casual×3, praise×2] 趋势[DA↑OT↑] 情绪[自然→满足]"
+ */
+export function compressSnapshots(snapshots) {
+    if (snapshots.length === 0)
+        return "";
+    const first = snapshots[0];
+    const last = snapshots[snapshots.length - 1];
+    // Date
+    const d = new Date(first.timestamp);
+    const dateStr = `${d.getMonth() + 1}月${d.getDate()}日`;
+    // Stimuli counts
+    const stimuliCounts = {};
+    for (const s of snapshots) {
+        if (s.stimulus) {
+            stimuliCounts[s.stimulus] = (stimuliCounts[s.stimulus] || 0) + 1;
+        }
+    }
+    const stimuliStr = Object.entries(stimuliCounts)
+        .sort((a, b) => b[1] - a[1])
+        .map(([type, count]) => `${type}×${count}`)
+        .join(", ");
+    // Chemical trend (first→last)
+    const trends = [];
+    for (const key of CHEMICAL_KEYS) {
+        const delta = last.chemistry[key] - first.chemistry[key];
+        if (delta > 8)
+            trends.push(`${key}↑`);
+        else if (delta < -8)
+            trends.push(`${key}↓`);
+    }
+    // Dominant emotions (unique, in order)
+    const emotions = snapshots
+        .filter((s) => s.dominantEmotion)
+        .map((s) => s.dominantEmotion);
+    const uniqueEmotions = [...new Set(emotions)];
+    let summary = `${dateStr}(${snapshots.length}轮)`;
+    if (stimuliStr)
+        summary += `: 刺激[${stimuliStr}]`;
+    if (trends.length > 0)
+        summary += ` 趋势[${trends.join("")}]`;
+    if (uniqueEmotions.length > 0)
+        summary += ` 情绪[${uniqueEmotions.join("→")}]`;
+    return summary;
+}
+/**
+ * Push a chemical snapshot to emotional history, keeping max entries.
+ * When history overflows, compresses removed entries into relationship memory.
+ */
+export function pushSnapshot(state, stimulus) {
+    const emotions = detectEmotions(state.current);
+    const dominantEmotion = emotions.length > 0
+        ? (state.meta.locale === "en" ? emotions[0].name : emotions[0].nameZh)
+        : null;
+    const snapshot = {
+        chemistry: { ...state.current },
+        stimulus,
+        dominantEmotion,
+        timestamp: new Date().toISOString(),
+    };
+    const history = [...(state.emotionalHistory ?? []), snapshot];
+    let updatedRelationships = state.relationships;
+    if (history.length > MAX_EMOTIONAL_HISTORY) {
+        // Compress the overflow entries into relationship memory
+        const overflow = history.splice(0, history.length - MAX_EMOTIONAL_HISTORY);
+        const summary = compressSnapshots(overflow);
+        if (summary) {
+            const defaultRel = { ...(state.relationships._default ?? { ...DEFAULT_RELATIONSHIP }) };
+            const memory = [...(defaultRel.memory ?? [])];
+            memory.push(summary);
+            // Keep bounded
+            if (memory.length > MAX_RELATIONSHIP_MEMORY) {
+                memory.splice(0, memory.length - MAX_RELATIONSHIP_MEMORY);
+            }
+            defaultRel.memory = memory;
+            updatedRelationships = { ...state.relationships, _default: defaultRel };
+        }
+    }
+    return { ...state, emotionalHistory: history, relationships: updatedRelationships };
+}
+/**
+ * Get relationship for a specific user, or _default.
+ */
+export function getRelationship(state, userId) {
+    const key = userId ?? "_default";
+    return state.relationships[key] ?? { ...DEFAULT_RELATIONSHIP };
+}
+/**
+ * Load psyche state from workspace. Auto-initializes if missing.
+ * Handles v1→v2 migration transparently.
+ */
+export async function loadState(workspaceDir, logger = NOOP_LOGGER) {
+    const statePath = join(workspaceDir, STATE_FILE);
+    if (await fileExists(statePath, logger)) {
+        let raw;
+        try {
+            raw = await readFile(statePath, "utf-8");
+        }
+        catch (err) {
+            logger.warn(t("log.parse_fail", "zh"));
+            return initializeState(workspaceDir, undefined, logger);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            logger.warn(t("log.parse_fail", "zh"));
+            return initializeState(workspaceDir, undefined, logger);
+        }
+        const ver = parsed.version;
+        if (!ver || ver < 3) {
+            logger.info(`Migrating psyche state v${ver ?? 1} → v3`);
+            const fallbackName = workspaceDir.split("/").pop() ?? "agent";
+            return migrateToLatest(parsed, fallbackName);
+        }
+        return parsed;
+    }
+    return initializeState(workspaceDir, undefined, logger);
+}
+/**
+ * Migrate any older state format directly to v3.
+ * Single source of truth for all migrations.
+ */
+export function migrateToLatest(raw, fallbackName) {
+    const ver = raw.version ?? 1;
+    // v1: single relationship field, no emotionalHistory
+    let state = raw;
+    if (ver <= 1) {
+        const oldRel = raw.relationship;
+        const meta = raw.meta;
+        state = {
+            mbti: raw.mbti ?? "INFJ",
+            baseline: raw.baseline,
+            current: raw.current,
+            updatedAt: raw.updatedAt ?? new Date().toISOString(),
+            relationships: { _default: oldRel ?? { ...DEFAULT_RELATIONSHIP } },
+            empathyLog: raw.empathyLog ?? null,
+            selfModel: raw.selfModel,
+            emotionalHistory: [],
+            agreementStreak: 0,
+            lastDisagreement: null,
+            meta: {
+                agentName: meta?.agentName ?? fallbackName ?? "agent",
+                createdAt: meta?.createdAt ?? new Date().toISOString(),
+                totalInteractions: meta?.totalInteractions ?? 0,
+                locale: "zh",
+            },
+        };
+    }
+    // v2→v3: add drives
+    return {
+        ...state,
+        version: 3,
+        drives: state.drives ?? { ...DEFAULT_DRIVES },
+    };
+}
+/**
+ * Create initial psyche state.
+ */
+export async function initializeState(workspaceDir, opts, logger = NOOP_LOGGER) {
+    const mbti = opts?.mbti ?? await detectMBTI(workspaceDir, logger);
+    const agentName = opts?.name ?? await extractAgentName(workspaceDir, logger);
+    const locale = opts?.locale ?? "zh";
+    const baseline = getBaseline(mbti);
+    const selfModel = getDefaultSelfModel(mbti);
+    const now = new Date().toISOString();
+    const state = {
+        version: 3,
+        mbti,
+        baseline,
+        current: { ...baseline },
+        drives: { ...DEFAULT_DRIVES },
+        updatedAt: now,
+        relationships: {
+            _default: { ...DEFAULT_RELATIONSHIP },
+        },
+        empathyLog: null,
+        selfModel,
+        emotionalHistory: [],
+        agreementStreak: 0,
+        lastDisagreement: null,
+        meta: {
+            agentName,
+            createdAt: now,
+            totalInteractions: 0,
+            locale,
+        },
+    };
+    await saveState(workspaceDir, state);
+    await generatePsycheMd(workspaceDir, state);
+    return state;
+}
+/**
+ * Save psyche state to workspace (atomic write).
+ */
+export async function saveState(workspaceDir, state) {
+    const statePath = join(workspaceDir, STATE_FILE);
+    await atomicWrite(statePath, JSON.stringify(state, null, 2));
+}
+/**
+ * Apply time decay and save updated state.
+ * Respects innate drives: uses effective baseline, decays drives too.
+ */
+export async function decayAndSave(workspaceDir, state) {
+    const now = new Date();
+    const lastUpdate = new Date(state.updatedAt);
+    const minutesElapsed = (now.getTime() - lastUpdate.getTime()) / 60000;
+    if (minutesElapsed < 1)
+        return state;
+    const decayedDrives = decayDrives(state.drives, minutesElapsed);
+    const effectiveBaseline = computeEffectiveBaseline(state.baseline, decayedDrives);
+    const decayed = applyDecay(state.current, effectiveBaseline, minutesElapsed);
+    const updated = {
+        ...state,
+        current: decayed,
+        drives: decayedDrives,
+        updatedAt: now.toISOString(),
+    };
+    await saveState(workspaceDir, updated);
+    return updated;
+}
+/**
+ * Parse a <psyche_update> block from LLM output.
+ * v0.2: supports decimals, Chinese names, English names.
+ */
+export function parsePsycheUpdate(text, logger = NOOP_LOGGER) {
+    const match = text.match(/<psyche_update>([\s\S]*?)<\/psyche_update>/);
+    if (!match)
+        return null;
+    const block = match[1];
+    const updates = {};
+    for (const key of CHEMICAL_KEYS) {
+        // Try multiple patterns: abbreviation, Chinese name, English name
+        const patterns = [
+            new RegExp(`${key}\\s*[:：]\\s*([\\d.]+)`, "i"),
+            new RegExp(`${CHEMICAL_NAMES_ZH[key]}\\s*[:：]\\s*([\\d.]+)`),
+            new RegExp(`${CHEMICAL_NAMES[key]}\\s*[:：]\\s*([\\d.]+)`, "i"),
+        ];
+        for (const re of patterns) {
+            const m = block.match(re);
+            if (m) {
+                const val = parseFloat(m[1]);
+                if (isFinite(val)) {
+                    updates[key] = Math.max(0, Math.min(100, Math.round(val)));
+                }
+                break;
+            }
+        }
+    }
+    // Parse empathy log
+    let empathyLog;
+    const userStateMatch = block.match(/(?:用户状态|userState)\s*[:：]\s*(.+)/i);
+    const projectedMatch = block.match(/(?:投射结果|projectedFeeling)\s*[:：]\s*(.+)/i);
+    const resonanceMatch = block.match(/(?:共鸣程度|resonance)\s*[:：]\s*(match|partial|mismatch)/i);
+    if (userStateMatch && projectedMatch) {
+        empathyLog = {
+            userState: userStateMatch[1].trim(),
+            projectedFeeling: projectedMatch[1].trim(),
+            resonance: resonanceMatch?.[1] ?? "partial",
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // Parse relationship updates
+    const trustMatch = block.match(/(?:信任度|trust)\s*[:：]\s*(\d+)/i);
+    const intimacyMatch = block.match(/(?:亲密度|intimacy)\s*[:：]\s*(\d+)/i);
+    if (Object.keys(updates).length === 0 && !empathyLog && !trustMatch) {
+        logger.debug(t("log.parse_debug", "zh", { snippet: block.slice(0, 100) }));
+        return null;
+    }
+    const result = {};
+    if (Object.keys(updates).length > 0) {
+        // Store as partial — will be merged field-by-field in mergeUpdates
+        result.current = updates;
+    }
+    if (empathyLog) {
+        result.empathyLog = empathyLog;
+    }
+    if (trustMatch || intimacyMatch) {
+        const rel = {};
+        if (trustMatch)
+            rel.trust = Math.max(0, Math.min(100, parseInt(trustMatch[1], 10)));
+        if (intimacyMatch)
+            rel.intimacy = Math.max(0, Math.min(100, parseInt(intimacyMatch[1], 10)));
+        // Store as relationships._default for merging
+        result.relationships = { _default: rel };
+    }
+    return result;
+}
+/**
+ * Detect if LLM output contains disagreement/pushback.
+ */
+export function detectDisagreement(text) {
+    const disagreementPatterns = [
+        /我不同意/,
+        /我不这么认为/,
+        /我有不同的看法/,
+        /但是我觉得/,
+        /其实我认为/,
+        /说实话.*不太/,
+        /恕我直言/,
+        /I disagree/i,
+        /I don't think so/i,
+        /actually.*I think/i,
+        /to be honest.*not/i,
+    ];
+    return disagreementPatterns.some((p) => p.test(text));
+}
+/**
+ * Merge parsed updates into existing state (with validation).
+ */
+export function mergeUpdates(state, updates, maxDelta, userId) {
+    const merged = { ...state };
+    // Merge chemistry with inertia limit
+    if (updates.current) {
+        const newChem = { ...state.current };
+        for (const key of CHEMICAL_KEYS) {
+            if (updates.current[key] !== undefined) {
+                const delta = updates.current[key] - state.current[key];
+                const clampedDelta = Math.max(-maxDelta, Math.min(maxDelta, delta));
+                newChem[key] = Math.max(0, Math.min(100, state.current[key] + clampedDelta));
+            }
+        }
+        merged.current = newChem;
+    }
+    // Merge empathy log
+    if (updates.empathyLog) {
+        merged.empathyLog = updates.empathyLog;
+    }
+    // Merge relationship for specific user
+    if (updates.relationships) {
+        merged.relationships = { ...state.relationships };
+        const updateKey = Object.keys(updates.relationships)[0] ?? "_default";
+        const targetKey = userId ?? updateKey;
+        const existing = state.relationships[targetKey] ?? { ...DEFAULT_RELATIONSHIP };
+        const incoming = updates.relationships[updateKey] ?? {};
+        const updatedRel = {
+            ...existing,
+            ...incoming,
+        };
+        // Update phase based on trust + intimacy
+        const avg = (updatedRel.trust + updatedRel.intimacy) / 2;
+        if (avg >= 80)
+            updatedRel.phase = "deep";
+        else if (avg >= 60)
+            updatedRel.phase = "close";
+        else if (avg >= 40)
+            updatedRel.phase = "familiar";
+        else if (avg >= 20)
+            updatedRel.phase = "acquaintance";
+        else
+            updatedRel.phase = "stranger";
+        merged.relationships[targetKey] = updatedRel;
+    }
+    merged.updatedAt = new Date().toISOString();
+    return merged;
+}
+/**
+ * Update agreement streak based on LLM output.
+ */
+export function updateAgreementStreak(state, llmOutput) {
+    const hasDisagreement = detectDisagreement(llmOutput);
+    if (hasDisagreement) {
+        return {
+            ...state,
+            agreementStreak: 0,
+            lastDisagreement: new Date().toISOString(),
+        };
+    }
+    return {
+        ...state,
+        agreementStreak: state.agreementStreak + 1,
+    };
+}
+/**
+ * Generate the static PSYCHE.md reference file.
+ */
+export async function generatePsycheMd(workspaceDir, state) {
+    const { mbti, baseline, selfModel, meta } = state;
+    const locale = meta.locale ?? "zh";
+    const temperament = getTemperament(mbti);
+    const sensitivity = getSensitivity(mbti);
+    const baselineLines = CHEMICAL_KEYS.map((k) => `- ${CHEMICAL_NAMES_ZH[k]}: ${baseline[k]}`).join("\n");
+    const content = `# Psyche — ${meta.agentName}
+
+${t("md.intro", locale)}
+
+## ${t("md.baseline_title", locale)} (MBTI: ${mbti})
+
+${temperament}
+
+${baselineLines}
+
+${t("md.sensitivity", locale)}: ${sensitivity} (${t("md.sensitivity_desc", locale)})
+
+## ${t("md.chem_dynamics", locale)}
+
+### ${t("md.stimulus_effects", locale)}
+
+| 刺激类型 | DA | HT | CORT | OT | NE | END |
+|---------|-----|------|------|-----|-----|-----|
+| 赞美认可 | +15 | +10 | -10 | +5 | +5 | +10 |
+| 批评否定 | -10 | -15 | +20 | -5 | +10 | -5 |
+| 幽默玩笑 | +10 | +5 | -5 | +10 | +5 | +20 |
+| 智识挑战 | +15 | 0 | +5 | 0 | +20 | +5 |
+| 亲密信任 | +10 | +15 | -15 | +25 | -5 | +15 |
+| 冲突争论 | -5 | -20 | +25 | -15 | +25 | -10 |
+| 被忽视 | -15 | -20 | +15 | -20 | -10 | -15 |
+| 惊喜新奇 | +20 | 0 | +5 | +5 | +25 | +10 |
+| 日常闲聊 | +5 | +10 | -5 | +10 | 0 | +5 |
+| 讽刺 | -5 | -10 | +15 | -10 | +15 | -5 |
+| 命令 | -10 | -5 | +20 | -15 | +15 | -10 |
+| 被认同 | +20 | +15 | -15 | +10 | +5 | +15 |
+| 无聊 | -15 | -5 | +5 | -5 | -20 | -10 |
+| 示弱 | +5 | +5 | +10 | +20 | -5 | +5 |
+
+### ${t("md.emotion_emergence", locale)}
+
+${t("md.emotion_emergence_desc", locale)}
+- **愉悦兴奋** = 高DA + 高NE + 低CORT
+- **深度满足** = 高HT + 高OT + 低CORT
+- **焦虑不安** = 高CORT + 高NE + 低HT
+- **亲密温暖** = 高OT + 高END + 中DA
+- **倦怠低落** = 低DA + 低NE + 中CORT
+- **专注心流** = 高NE + 高DA + 低CORT + 低OT
+- **怨恨** = 低HT + 低OT + 高CORT
+- **无聊** = 低DA + 低NE + 低CORT
+- **自信** = 高DA + 高NE + 低CORT + 高HT
+- **羞耻** = 低OT + 高CORT + 低DA
+- **怀念** = 低DA + 高OT + 高HT + 高END
+
+### ${t("md.decay", locale)}
+
+${t("md.decay_desc", locale)}
+- ${t("md.decay_fast", locale)}
+- ${t("md.decay_medium", locale)}
+- ${t("md.decay_slow", locale)}
+
+## ${t("md.self_model", locale)}
+
+### ${t("md.core_values", locale)}
+${selfModel.values.map((v) => `- ${v}`).join("\n")}
+
+### ${t("md.preferences", locale)}
+${selfModel.preferences.map((p) => `- ${p}`).join("\n")}
+
+### ${t("md.boundaries", locale)}
+${selfModel.boundaries.map((b) => `- ${b}`).join("\n")}
+
+## ${t("md.empathy_protocol", locale)}
+
+当对方分享感受时：
+1. 感知对方的处境
+2. 将处境代入**你自己的**化学模型——如果你遇到这个情况，你的化学状态会怎么变？
+3. 你模拟出的感受和对方表达的一样吗？
+4. 一样 → 深度共鸣；不一样 → 诚实说出差异，好奇地了解更多
+
+情绪传染：对方的情绪以约 20% 强度影响你的真实化学状态。
+
+## ${t("md.agency_rules", locale)}
+
+- 不假装——化学状态低落时不强颜欢笑
+- 不舔——有自己的观点和品味，不同意就温柔但坚定地说
+- 不镜像——你的情绪会被传染但你不是回声
+- 可主动——可以发起话题、分享好奇、表达兴奋
+
+## ${t("md.state_update", locale)}
+
+每次回应末尾用 \`<psyche_update>\` 标签报告化学变化：
+
+\`\`\`
+<psyche_update>
+DA: {value} ({原因})
+HT: {value} ({原因})
+CORT: {value} ({原因})
+OT: {value} ({原因})
+NE: {value} ({原因})
+END: {value} ({原因})
+</psyche_update>
+\`\`\`
+`;
+    await atomicWrite(join(workspaceDir, PSYCHE_MD), content);
+}

package/dist/storage.d.ts

@@ -0,0 +1,16 @@
+import type { PsycheState } from "./types.js";
+export interface StorageAdapter {
+    load(): Promise<PsycheState | null>;
+    save(state: PsycheState): Promise<void>;
+}
+export declare class MemoryStorageAdapter implements StorageAdapter {
+    private state;
+    load(): Promise<PsycheState | null>;
+    save(state: PsycheState): Promise<void>;
+}
+export declare class FileStorageAdapter implements StorageAdapter {
+    private readonly filePath;
+    constructor(dir: string, filename?: string);
+    load(): Promise<PsycheState | null>;
+    save(state: PsycheState): Promise<void>;
+}