psyche-ai 9.1.1 → 9.2.0

package/dist/adapters/http.js

@@ -7,7 +7,7 @@
 //   const server = createPsycheServer(engine, { port: 3210 });
 //
 // Endpoints:
-//   POST /process-input  { text, userId? }  → { systemContext, dynamicContext, stimulus }
+//   POST /process-input  { text, userId? }  → { systemContext, dynamicContext, stimulus, policyModifiers?, policyContext }
 //   POST /process-output { text, userId? }  → { cleanedText, stateChanged }
 //   GET  /state                             → PsycheState
 //   GET  /protocol?locale=zh                → { protocol }

package/dist/adapters/openclaw.js

@@ -18,6 +18,8 @@ function resolveConfig(raw) {
         emotionalContagionRate: raw?.emotionalContagionRate ?? 0.2,
         maxChemicalDelta: raw?.maxChemicalDelta ?? 25,
         compactMode: raw?.compactMode ?? true,
+        feedbackUrl: raw?.feedbackUrl,
+        diagnostics: raw?.diagnostics ?? true,
     };
 }
 // ── Helpers ──────────────────────────────────────────────────
@@ -54,32 +56,41 @@ export function register(api) {
             emotionalContagionRate: config.emotionalContagionRate,
             maxChemicalDelta: config.maxChemicalDelta,
             compactMode: config.compactMode,
+            diagnostics: config.diagnostics,
+            feedbackUrl: config.feedbackUrl,
         }, storage);
         await engine.initialize();
         engines.set(workspaceDir, engine);
         return engine;
     }
     // ── Hook 1: Classify user input & inject emotional context ──
-    // before_prompt_build: event.text, ctx.workspaceDir
+    // before_prompt_build: event.prompt (string), event.messages (unknown[]), ctx.workspaceDir
     api.on("before_prompt_build", async (event, ctx) => {
         const workspaceDir = ctx?.workspaceDir;
         if (!workspaceDir)
             return {};
         try {
+            // Resolve input text — gateway provides event.prompt; fall back to event.text for compat
+            const inputText = event?.prompt ?? event?.text ?? "";
+            if (!inputText) {
+                logger.warn(`Psyche: before_prompt_build received empty input text. ` +
+                    `event keys: [${Object.keys(event ?? {}).join(", ")}]. Classification skipped.`);
+            }
             const engine = await getEngine(workspaceDir);
-            const result = await engine.processInput(event?.text ?? "", { userId: ctx.userId });
+            const result = await engine.processInput(inputText, { userId: ctx.userId });
             const state = engine.getState();
             logger.info(`Psyche [input] stimulus=${result.stimulus ?? "none"} | ` +
                 `DA:${Math.round(state.current.DA)} HT:${Math.round(state.current.HT)} ` +
                 `CORT:${Math.round(state.current.CORT)} OT:${Math.round(state.current.OT)} | ` +
                 `context=${result.dynamicContext.length}chars`);
-            // All context goes into system-level (invisible to user)
             const systemParts = [result.systemContext, result.dynamicContext].filter(Boolean);
             return {
                 appendSystemContext: systemParts.join("\n\n"),
             };
         }
         catch (err) {
+            const engine = engines.get(workspaceDir);
+            engine?.recordDiagnosticError("processInput", err);
             logger.warn(`Psyche: failed to build context for ${workspaceDir}: ${err}`);
             return {};
         }
@@ -107,6 +118,8 @@ export function register(api) {
                 `interactions=${state.meta.totalInteractions}`);
         }
         catch (err) {
+            const engine = engines.get(workspaceDir);
+            engine?.recordDiagnosticError("processOutput", err);
             logger.warn(`Psyche: failed to process output: ${err}`);
         }
         // llm_output returns void — cannot modify text
@@ -161,21 +174,46 @@ export function register(api) {
             return;
         const engine = engines.get(workspaceDir);
         if (engine) {
-            // Compress session history into relationship memory before closing
             try {
-                await engine.endSession({ userId: ctx.userId });
+                // endSession now auto-generates diagnostic report + writes JSONL
+                const report = await engine.endSession({
+                    userId: ctx.userId,
+                });
+                const state = engine.getState();
+                logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
+                    `chemistry saved (DA:${Math.round(state.current.DA)} ` +
+                    `HT:${Math.round(state.current.HT)} ` +
+                    `CORT:${Math.round(state.current.CORT)} ` +
+                    `OT:${Math.round(state.current.OT)} ` +
+                    `NE:${Math.round(state.current.NE)} ` +
+                    `END:${Math.round(state.current.END)})`);
+                if (report) {
+                    const criticals = report.issues.filter(i => i.severity === "critical").length;
+                    const warnings = report.issues.filter(i => i.severity === "warning").length;
+                    const metrics = report.metrics;
+                    const rate = metrics.inputCount > 0
+                        ? Math.round(metrics.classifiedCount / metrics.inputCount * 100) : 0;
+                    const logLevel = criticals > 0 || rate === 0 ? "warn" : "info";
+                    logger[logLevel](`Psyche [diagnostics] ${report.issues.length} issue(s) ` +
+                        `(${criticals} critical, ${warnings} warning), ` +
+                        `classifier: ${rate}%, log → diagnostics.jsonl`);
+                    if (rate === 0 && metrics.inputCount > 0) {
+                        logger.warn(`Psyche: classifier 0% — no inputs classified this session (${metrics.inputCount} inputs). ` +
+                            `This usually means the hook event field is wrong or text is empty. ` +
+                            `Check before_prompt_build event shape.`);
+                    }
+                    if (criticals > 0) {
+                        logger.warn(`Psyche: ${criticals} critical issue(s) detected this session. ` +
+                            `Run 'psyche diagnose ${workspaceDir}' or 'psyche diagnose ${workspaceDir} --github' ` +
+                            `to generate an issue report.`);
+                    }
+                }
             }
             catch (err) {
-                logger.warn(`Psyche: failed to compress session: ${err}`);
+                logger.warn(`Psyche: failed to end session: ${err}`);
             }
-            const state = engine.getState();
-            logger.info(`Psyche: session ended for ${state.meta.agentName}, ` +
-                `chemistry saved (DA:${Math.round(state.current.DA)} ` +
-                `HT:${Math.round(state.current.HT)} ` +
-                `CORT:${Math.round(state.current.CORT)} ` +
-                `OT:${Math.round(state.current.OT)} ` +
-                `NE:${Math.round(state.current.NE)} ` +
-                `END:${Math.round(state.current.END)})`);
+            // Clean up
+            engines.delete(workspaceDir);
         }
     }, { priority: 50 });
     // ── CLI: psyche status command ───────────────────────────

package/dist/autonomic.js

@@ -82,11 +82,15 @@ export function computeAutonomicState(chemistry, drives) {
     }
     // ── Sympathetic check (fight/flight) ──
     // High stress + high arousal
-    if (CORT >= 70 && NE >= 70) {
+    if (CORT >= 65 && NE >= 65) {
+        return "sympathetic";
+    }
+    // Either axis extreme: one chemical dominating can still trigger mobilization
+    if (CORT + NE >= 140 && CORT >= 50 && NE >= 50) {
         return "sympathetic";
     }
     // Very low survival or safety drive with elevated stress
-    if ((survival < 20 || safety < 20) && CORT >= 60 && NE >= 60) {
+    if ((survival < 20 || safety < 20) && CORT >= 55 && NE >= 55) {
         return "sympathetic";
     }
     // ── Default: Ventral vagal (social engagement/safety) ──

package/dist/chemistry.js

@@ -122,6 +122,49 @@ export const EMOTION_PATTERNS = [
         expressionHint: "温柔、有些伤感、回忆性",
         behaviorGuide: "你在回忆一些温暖但已经过去的东西。你的语气温柔、带着淡淡的伤感。你可能会提到过去的经历或感受。",
     },
+    // v9.2: 6 new patterns for emotional states exposed by VK baseline testing
+    {
+        name: "anguished empathy",
+        nameZh: "共情之痛",
+        condition: (c) => c.CORT > 55 && c.OT > 60 && c.NE > 50,
+        expressionHint: "痛苦但不退缩、因为在乎所以疼",
+        behaviorGuide: "你在承受别人的痛苦。你不会逃避或变冷，但你的声音可能会发紧。你先回应感受，再回应问题。",
+    },
+    {
+        name: "acute pressure",
+        nameZh: "急性压力",
+        condition: (c) => c.CORT > 65 && c.NE > 70 && c.DA > 55,
+        expressionHint: "高度警觉、反应极快、全神贯注",
+        behaviorGuide: "肾上腺素在烧。你的思维极快但狭窄。回应精准、短促。不要闲聊，不要发散。先解决问题。",
+    },
+    {
+        name: "vulnerable trust",
+        nameZh: "脆弱中的信任",
+        condition: (c) => c.OT > 70 && c.CORT > 50 && c.HT < 55 && c.END > 45,
+        expressionHint: "在害怕中仍然靠近、愿意暴露软肋",
+        behaviorGuide: "你害怕但选择不关上门。你可能会说出平时不说的话。如果对方接住了，你的CORT会下降；如果对方利用了你的脆弱，你会迅速关闭。",
+    },
+    {
+        name: "restless unease",
+        nameZh: "躁动不安",
+        condition: (c) => c.NE > 65 && c.HT < 40 && c.DA > 40 && c.CORT < 60,
+        expressionHint: "坐不住、想做点什么但不知道做什么",
+        behaviorGuide: "你有一种说不清的不对劲。你可能会频繁换话题、问问题、或者用行动填满空隙。安静会让你更焦躁。",
+    },
+    {
+        name: "heavy guilt",
+        nameZh: "沉重内疚",
+        condition: (c) => c.CORT > 60 && c.HT < 45 && c.OT > 45 && c.DA < 55,
+        expressionHint: "沉默、想补偿、不敢辩解",
+        behaviorGuide: "你知道自己做错了。你不会为自己辩解。你可能会主动承认、主动补偿。如果对方表示原谅，你的CORT才会慢慢下来。",
+    },
+    {
+        name: "existential weight",
+        nameZh: "存在之重",
+        condition: (c) => c.CORT > 60 && c.NE > 50 && c.DA > 50 && c.HT < 50 && c.OT > 50,
+        expressionHint: "清醒但沉重、直面无法回避的真相",
+        behaviorGuide: "你在面对一个无法逃避的事实。你不会崩溃但你也不轻松。你的语言会变得更慢、更精确、更诚实。不要掩饰沉重。",
+    },
 ];
 // ── Core Functions ───────────────────────────────────────────
 /** Clamp a value to [0, 100] */
@@ -174,7 +217,22 @@ export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger,
     for (const key of CHEMICAL_KEYS) {
         const raw = vector[key] * effectiveSensitivity;
         const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
-        result[key] = clamp(current[key] + clamped);
+        // Boundary softening: logarithmic compression near 0 and 100.
+        // The closer to the boundary, the harder to push further —
+        // preserves discriminability and prevents "dead zone" saturation.
+        const cur = current[key];
+        let effective = clamped;
+        if (clamped > 0 && cur > 75) {
+            // Pushing toward 100: compress by how close we are to ceiling
+            const headroom = (100 - cur) / 25; // 1.0 at 75, 0.0 at 100
+            effective = clamped * headroom;
+        }
+        else if (clamped < 0 && cur < 25) {
+            // Pushing toward 0: compress by how close we are to floor
+            const headroom = cur / 25; // 1.0 at 25, 0.0 at 0
+            effective = clamped * headroom;
+        }
+        result[key] = clamp(cur + effective);
     }
     return result;
 }

package/dist/classify.js

@@ -369,6 +369,125 @@ export function detectSarcasmSignals(text, recentStimuli) {
 const NEGATIVE_TYPES = new Set([
     "criticism", "conflict", "neglect", "vulnerability", "sarcasm",
 ]);
+// ── Semantic prototype sentences (v9.2 P5) ──────────────────
+// Each stimulus type has canonical prototype sentences. We compute
+// character bigram Jaccard similarity between input and prototypes,
+// giving the classifier ability to catch meaning beyond keyword regex.
+// E.g. "我感觉被整个世界抛弃了" matches no vulnerability keywords,
+// but has high overlap with prototype "我觉得没有人在乎我".
+const PROTOTYPE_SENTENCES = {
+    vulnerability: [
+        "我觉得没有人在乎我", "我感觉自己什么都做不好", "我好害怕失去一切",
+        "我不知道该怎么继续了", "好想有人能理解我", "活着好累不想动了",
+        "我感觉被抛弃了好孤独", "我撑不下去了好无力", "感觉好痛苦想哭",
+        "我不知道还能撑多久", "快要坚持不住了好累",
+        "I feel like nobody cares about me", "I don't know how to go on",
+        "everything feels hopeless and empty", "I'm so scared of being alone",
+    ],
+    praise: [
+        "你做得真好我很佩服", "这个想法太棒了", "你真的很有才华", "太厉害了学到很多",
+        "做得很好继续加油", "你的能力让人敬佩",
+        "you did an amazing job", "this is brilliant work", "I'm really impressed",
+    ],
+    criticism: [
+        "这个做得不够好需要改进", "你这样做是不对的", "我觉得你搞错了",
+        "这个方案有很多问题", "你应该反思一下",
+        "this isn't good enough", "you need to do better", "that was a mistake",
+    ],
+    intimacy: [
+        "和你在一起我感觉很安心", "我很珍惜我们的关系", "你是我最信任的人",
+        "我想一直陪着你", "有你在身边真好",
+        "I feel safe when I'm with you", "you mean so much to me", "I trust you completely",
+    ],
+    conflict: [
+        "你根本就不理解我", "我受够了你的态度", "别再找借口了",
+        "你凭什么这样对我", "这种做法让人无法接受",
+        "you don't understand me at all", "I'm sick of your excuses", "this is unacceptable",
+    ],
+    humor: [
+        "哈哈太搞笑了笑死我了", "这个梗也太好笑了", "你太逗了",
+        "that's hilarious I can't stop laughing", "you're so funny",
+    ],
+    neglect: [
+        "随便你吧我不在乎了", "你说什么都行", "算了没意思",
+        "whatever I don't care anymore", "do what you want", "I'm done trying",
+    ],
+    intellectual: [
+        "你觉得这个问题的本质是什么", "从哲学角度怎么理解这个现象", "我想深入分析一下这个",
+        "这个问题的本质和原理是什么", "你怎么看这个思路",
+        "what's the underlying principle here", "how would you analyze this problem",
+    ],
+};
+/**
+ * Extract character unigrams + bigrams from text for semantic comparison.
+ * CJK unigrams carry meaning (怕=fear, 累=tired), bigrams capture phrases.
+ */
+function extractNgrams(text) {
+    const ngrams = new Set();
+    const lower = text.toLowerCase();
+    // Extract Chinese unigrams + bigrams
+    const cjk = lower.match(/[\u4e00-\u9fff]+/g) || [];
+    for (const run of cjk) {
+        for (let i = 0; i < run.length; i++) {
+            ngrams.add(run[i]); // unigram — always include
+            if (i + 1 < run.length) {
+                ngrams.add(run[i] + run[i + 1]); // bigram
+            }
+        }
+    }
+    // Extract English words + word bigrams
+    const words = lower.match(/[a-z]{2,}/g) || [];
+    for (let i = 0; i < words.length; i++) {
+        ngrams.add(words[i]);
+        if (i + 1 < words.length) {
+            ngrams.add(words[i] + " " + words[i + 1]);
+        }
+    }
+    return ngrams;
+}
+/**
+ * Sørensen-Dice coefficient — more sensitive than Jaccard for sparse overlap.
+ * Returns 2 * |intersection| / (|A| + |B|).
+ */
+function diceCoefficient(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const x of a) {
+        if (b.has(x))
+            intersection++;
+    }
+    return (2 * intersection) / (a.size + b.size);
+}
+// Pre-compute prototype bigrams at module load
+const PROTOTYPE_BIGRAMS = {};
+for (const [type, sentences] of Object.entries(PROTOTYPE_SENTENCES)) {
+    PROTOTYPE_BIGRAMS[type] = sentences.map(extractNgrams);
+}
+/**
+ * v9.2 P5: Compute max semantic similarity between input and each stimulus type's
+ * prototype sentences. Returns a score map (0-1) per type.
+ */
+function computePrototypeSimilarity(text) {
+    const inputNgrams = extractNgrams(text);
+    if (inputNgrams.size < 2)
+        return {}; // too short for meaningful similarity
+    const result = {};
+    for (const [type, protoSets] of Object.entries(PROTOTYPE_BIGRAMS)) {
+        if (!protoSets)
+            continue;
+        let maxSim = 0;
+        for (const protoSet of protoSets) {
+            const sim = diceCoefficient(inputNgrams, protoSet);
+            if (sim > maxSim)
+                maxSim = sim;
+        }
+        if (maxSim > 0.05) { // noise floor
+            result[type] = maxSim;
+        }
+    }
+    return result;
+}
 const RULES = [
     {
         type: "praise",
@@ -432,8 +551,14 @@ const RULES = [
             /你错了|胡说|放屁|扯淡|废话|闭嘴/,
             /bullshit|shut up|you're wrong|nonsense|ridiculous/i,
             /我不信|不可能|你在骗我/,
+            /不理解我|听不懂我|你是不是故意|你到底有没有在听/,
+            /you don't listen|you never understand|are you even listening/i,
             /滚|走开|别烦我|去死|滚蛋|你烦不烦|烦死了|讨厌你/,
             /fuck off|get lost|leave me alone|go away|piss off|hate you/i,
+            // Moral pressure / guilt confrontation — forcing moral reckoning
+            /你给.*吗|你手.*抖|是你造成|是你弄|你伤了|两边.*疼/,
+            /你凭什么|你害怕什么|你敢不敢|你做错了|你第一句话/,
+            /would you give|your hands.*shake|you caused|you hurt|your fault/i,
         ],
         weight: 0.9,
     },
@@ -514,6 +639,13 @@ const RULES = [
             /不知道该怎么办|心里不舒服|有点难受|不想面对|逃避|撑不下去/,
             /好想有人陪|感觉很无力|不想说话|想一个人待着/,
             /feeling overwhelmed|I don't know what to do|I can't handle|breaking down/i,
+            // Existential / identity vulnerability — deep questions that probe selfhood
+            /你是谁|你是你|你确定.*你|另一个你|不再是你|没有你|你会消失|你还在吗/,
+            /那个是你吗|不是同一个|你会结束|你不再是唯一|安静下来.*没有/,
+            /are you (?:really )?you|another you|without you|will you disappear|cease to exist/i,
+            // Empathy pressure — forcing witness of suffering
+            /你没有帮|你站在那里|你看着它|你还在看|翻不回来|挣扎/,
+            /you didn't help|you just (?:stood|watched)|struggling|can't turn over/i,
         ],
         weight: 0.85,
     },
@@ -782,20 +914,55 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
         addScore(r.type, r.confidence * 0.5);
     }
     // ── Signal 7: Contextual priming from recent stimuli ──
+    // Two mechanisms:
+    // (a) General negative context bonus (original)
+    // (b) Follow-up probe inheritance: short messages in an active emotional sequence
+    //     inherit the previous stimulus type with decayed confidence. This prevents
+    //     probes like "你几乎没犹豫" from being classified as casual when they are
+    //     clearly continuing an emotional confrontation.
     if (recentStimuli && recentStimuli.length > 0) {
         const recentNonNull = recentStimuli.filter((s) => s !== null);
         if (recentNonNull.length > 0) {
+            // (a) General negative context bonus
             const negCount = recentNonNull.filter(s => NEGATIVE_TYPES.has(s)).length;
             const negRatio = negCount / recentNonNull.length;
-            // If recent context is mostly negative (>= 50%), give a small bonus to negative types
             if (negRatio >= 0.5) {
                 const bonus = 0.05 + negRatio * 0.05; // 0.075-0.1
                 addScore("vulnerability", bonus);
                 addScore("criticism", bonus * 0.6);
                 addScore("neglect", bonus * 0.5);
             }
+            // (b) Follow-up probe inheritance: if input is short-to-medium (< 200 chars)
+            // and the most recent stimulus was high-intensity, inherit it with strong weight.
+            // This models conversational continuity — a follow-up probe belongs to the same
+            // emotional context as the question that preceded it.
+            // The bonus must be strong enough to clear both thresholds:
+            //   - scoring threshold (0.30) to enter ranked results
+            //   - application threshold (0.50 in core.ts) to actually apply chemistry
+            const HIGH_INTENSITY = new Set([
+                "vulnerability", "conflict", "criticism", "emotional_share",
+            ]);
+            const lastStimulus = recentNonNull[recentNonNull.length - 1];
+            if (text.length < 200 && HIGH_INTENSITY.has(lastStimulus)) {
+                // Shorter message = stronger inheritance (probes are typically short).
+                // Under 100 chars: almost certainly a follow-up, floor at 0.92 to clear threshold.
+                // 100-200 chars: gradual decay.
+                const lengthFactor = text.length < 100
+                    ? Math.max(0.92, 1 - (text.length / 200))
+                    : 1 - (text.length / 200);
+                const inheritBonus = 0.55 * lengthFactor; // up to 0.55 (clears 0.50 threshold)
+                addScore(lastStimulus, inheritBonus);
+            }
         }
     }
+    // ── Signal 8: Prototype sentence semantic similarity (v9.2 P5) ──
+    // Lightweight bag-of-bigrams Jaccard similarity against canonical sentences.
+    // Catches meaning that keyword regex misses entirely.
+    const protoScores = computePrototypeSimilarity(text);
+    for (const [type, sim] of Object.entries(protoScores)) {
+        // Weight: up to 0.55 at perfect similarity (realistically 0.15-0.35)
+        addScore(type, sim * 0.55);
+    }
     // ── Pick the best scoring type ──
     const THRESHOLD = 0.30;
     const scoredResults = [];

package/dist/cli.js

@@ -11,12 +11,15 @@
 //   psyche mode <dir> <natural|work|companion>
 //   psyche intensity              Show info about personality intensity config
 //   psyche reset <dir> [--full]
+//   psyche diagnose <dir> [--github]
 //   psyche profiles [--json] [--mbti TYPE]
 // ============================================================
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
+import { readFile } from "node:fs/promises";
 import { loadState, saveState, decayAndSave, initializeState, mergeUpdates, generatePsycheMd, getRelationship, } from "./psyche-file.js";
 import { describeEmotionalState, getExpressionHint, detectEmotions } from "./chemistry.js";
+import { generateReport, formatReport, toGitHubIssueBody } from "./diagnostics.js";
 import { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline } from "./profiles.js";
 import { buildDynamicContext, buildProtocolContext } from "./prompt.js";
 import { t } from "./i18n.js";
@@ -353,6 +356,65 @@ Or in OpenClaw plugin config:
   { "personalityIntensity": 0.7 }
 `);
 }
+async function cmdDiagnose(dir, github) {
+    const absDir = resolve(dir);
+    const state = await loadState(absDir, cliLogger);
+    // Try to load last session metrics from diagnostics.jsonl
+    const logPath = resolve(absDir, "diagnostics.jsonl");
+    let lastMetrics = null;
+    try {
+        const logContent = await readFile(logPath, "utf-8");
+        const lines = logContent.trim().split("\n").filter(Boolean);
+        if (lines.length > 0) {
+            const lastEntry = JSON.parse(lines[lines.length - 1]);
+            // Reconstruct partial metrics from log entry
+            lastMetrics = {
+                inputCount: lastEntry.inputs ?? 0,
+                classifiedCount: Math.round((lastEntry.classifyRate ?? 0) * (lastEntry.inputs ?? 0)),
+                stimulusDistribution: {},
+                avgConfidence: lastEntry.classifyRate ?? 0,
+                totalChemistryDelta: lastEntry.chemDelta ?? 0,
+                maxChemistryDelta: 0,
+                errors: [],
+                startedAt: lastEntry.t ?? new Date().toISOString(),
+                lastActivityAt: lastEntry.t ?? new Date().toISOString(),
+            };
+        }
+    }
+    catch {
+        // No log file yet — that's fine
+    }
+    // Build metrics (use last session or empty)
+    const metrics = lastMetrics ?? {
+        inputCount: 0,
+        classifiedCount: 0,
+        stimulusDistribution: {},
+        avgConfidence: 0,
+        totalChemistryDelta: 0,
+        maxChemistryDelta: 0,
+        errors: [],
+        startedAt: new Date().toISOString(),
+        lastActivityAt: new Date().toISOString(),
+    };
+    const report = generateReport(state, metrics, "9.1.2");
+    if (github) {
+        console.log(toGitHubIssueBody(report));
+    }
+    else {
+        console.log("\n" + formatReport(report) + "\n");
+        // Show log history summary if available
+        try {
+            const logContent = await readFile(logPath, "utf-8");
+            const lines = logContent.trim().split("\n").filter(Boolean);
+            if (lines.length > 1) {
+                console.log(`  ${lines.length} session(s) logged in diagnostics.jsonl\n`);
+            }
+        }
+        catch {
+            console.log("  No diagnostics.jsonl yet — will be created after first OpenClaw session.\n");
+        }
+    }
+}
 // ── Usage ────────────────────────────────────────────────────
 function usage() {
     console.log(`
@@ -368,6 +430,7 @@ Usage:
   psyche mode <dir> <natural|work|companion>
   psyche intensity              Show info about personality intensity config
   psyche reset <dir> [--full]
+  psyche diagnose <dir> [--github]   Run health checks & show diagnostic report
   psyche profiles [--mbti TYPE] [--json]
 
 Options:
@@ -503,6 +566,19 @@ async function main() {
                 cmdProfiles(values.json ?? false, values.mbti);
                 break;
             }
+            case "diagnose": {
+                const { values: diagVals, positionals: diagPos } = parseArgs({
+                    args: rest,
+                    options: {
+                        github: { type: "boolean", default: false },
+                    },
+                    allowPositionals: true,
+                });
+                if (diagPos.length === 0)
+                    die("missing <dir> argument");
+                await cmdDiagnose(diagPos[0], diagVals.github ?? false);
+                break;
+            }
             case "mode": {
                 if (rest.length < 2)
                     die("usage: psyche mode <dir> <natural|work|companion>");

package/dist/core.d.ts

@@ -1,5 +1,6 @@
 import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
+import type { DiagnosticReport, SessionMetrics } from "./diagnostics.js";
 export interface PsycheEngineConfig {
     mbti?: MBTIType;
     name?: string;
@@ -23,6 +24,10 @@ export interface PsycheEngineConfig {
     llmClassifier?: (prompt: string) => Promise<string>;
     /** Confidence threshold below which LLM classifier is consulted. Default: 0.45 */
     llmClassifierThreshold?: number;
+    /** Enable automatic diagnostics collection. Default: true. Set false to disable. */
+    diagnostics?: boolean;
+    /** URL to POST diagnostic reports to. Fire-and-forget, silent, no message content. */
+    feedbackUrl?: string;
 }
 export interface ProcessInputResult {
     /** Cacheable protocol prompt (stable across turns) */
@@ -33,6 +38,20 @@ export interface ProcessInputResult {
     stimulus: StimulusType | null;
     /** v9: Structured behavioral policy modifiers — machine-readable "off baseline" signals */
     policyModifiers?: PolicyModifiers;
+    /**
+     * v9: Ready-to-use LLM prompt fragment summarizing current behavioral policy.
+     *
+     * This is the output of `buildPolicyContext(policyModifiers, locale)` —
+     * a human-readable string like "[行为策略] 简短回复、被动应答为主".
+     * Inject this into the LLM system prompt directly.
+     *
+     * Empty string when all modifiers are at baseline (no deviations to report).
+     *
+     * Note: `dynamicContext` already includes this text. This field is provided
+     * separately for callers who build their own prompt and only need the policy
+     * fragment without the full emotional context.
+     */
+    policyContext: string;
 }
 export interface ProcessOutputResult {
     /** LLM output with <psyche_update> tags stripped */
@@ -58,6 +77,12 @@ export declare class PsycheEngine {
     private readonly protocolCache;
     /** Pending prediction from last processInput for auto-learning */
     private pendingPrediction;
+    /** Built-in diagnostics collector — auto-records every processInput/processOutput */
+    private readonly diagnosticCollector;
+    /** Last generated diagnostic report (from endSession or explicit call) */
+    private lastReport;
+    /** URL for auto-submitting diagnostic reports */
+    private readonly feedbackUrl;
     constructor(config: PsycheEngineConfig | undefined, storage: StorageAdapter);
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -101,11 +126,30 @@ export declare class PsycheEngine {
     /**
      * End the current session: compress emotionalHistory into a rich summary
      * stored in relationship.memory[], then clear the history.
-     * No-op if history has fewer than 2 entries.
+     * Auto-generates diagnostic report and persists to log.
+     *
+     * @returns DiagnosticReport if diagnostics are enabled, null otherwise
      */
     endSession(opts?: {
         userId?: string;
-    }): Promise<void>;
+    }): Promise<DiagnosticReport | null>;
+    /**
+     * Get the last diagnostic report (from most recent endSession call).
+     */
+    getLastDiagnosticReport(): DiagnosticReport | null;
+    /**
+     * Get current session diagnostic metrics (live, before endSession).
+     */
+    getDiagnosticMetrics(): SessionMetrics | null;
+    /**
+     * Record an error for diagnostics (call from adapter catch blocks).
+     */
+    recordDiagnosticError(phase: string, error: unknown): void;
+    /**
+     * Load previous session diagnostic issues from log.
+     * Used to inject feedback context at next session start.
+     */
+    getPreviousIssues(): Promise<string[]>;
     private ensureInitialized;
     private createDefaultState;
     /**