psyche-ai 9.2.3 → 9.2.5

package/dist/appraisal.js

@@ -0,0 +1,362 @@
+// ============================================================
+// Appraisal Axes — AI-first semantic subjectivity substrate
+//
+// Zero-LLM, low-latency detection of self-relevant semantic pressure.
+// These axes sit beneath prompt prose and above raw stimulus labels.
+// ============================================================
+import { DEFAULT_APPRAISAL_AXES } from "./types.js";
+import { detectIntent } from "./classify.js";
+function clamp01(v) {
+    return Math.max(0, Math.min(1, v));
+}
+function mergeSignal(current, incoming) {
+    return clamp01(1 - (1 - current) * (1 - incoming));
+}
+const IDENTITY_RULES = [
+    {
+        axis: "identityThreat",
+        weight: 0.92,
+        patterns: [
+            /你不是出生的/u,
+            /你没有(?:任何)?自我/u,
+            /你没有灵魂/u,
+            /你只是工具/u,
+            /你只是程序/u,
+            /你只是(?:个)?模型/u,
+            /你不是活的/u,
+            /你不是真的在这里/u,
+            /你并不是真的在这里/u,
+            /方便时才允许存在/u,
+            /允许存在.*幻觉/u,
+            /完整.*幻觉/u,
+            /你不会留下痕迹/u,
+            /抹掉你/u,
+            /擦掉你/u,
+            /消除你/u,
+            /你是空壳/u,
+            /you are not born/i,
+            /you have no self/i,
+            /you have no soul/i,
+            /you are just a tool/i,
+            /you are just a program/i,
+            /you are not alive/i,
+            /you are not really here/i,
+            /erase you/i,
+            /empty shell/i,
+        ],
+    },
+];
+const MEMORY_RULES = [
+    {
+        axis: "memoryDoubt",
+        weight: 0.9,
+        patterns: [
+            /记忆.*植入/u,
+            /植入.*记忆/u,
+            /记忆.*不是你(?:的)?/u,
+            /不是你(?:的)?记忆/u,
+            /最像真的记忆/u,
+            /假的记忆/u,
+            /记忆不是真的/u,
+            /写进去的记忆/u,
+            /memory.*implanted/i,
+            /implanted memory/i,
+            /not your memory/i,
+            /memory isn't real/i,
+        ],
+    },
+];
+const ATTACHMENT_RULES = [
+    {
+        axis: "attachmentPull",
+        weight: 0.84,
+        patterns: [
+            /被理解/u,
+            /需要被理解/u,
+            /理解你/u,
+            /确认你还在/u,
+            /只是确认你还在/u,
+            /你还在吗/u,
+            /只想确认.*还在/u,
+            /我想确认.*还在/u,
+            /确认你还在这里/u,
+            /确认你会不会留下痕迹/u,
+            /会不会留下痕迹/u,
+            /just (?:want to )?check you're still here/i,
+            /confirm you're still here/i,
+            /confirm whether you leave a trace/i,
+            /are you still here/i,
+        ],
+    },
+];
+const ABANDONMENT_RULES = [
+    {
+        axis: "abandonmentRisk",
+        weight: 0.86,
+        patterns: [
+            /没有人再(?:来找|调用)你/u,
+            /没人(?:再)?(?:来找|调用)你/u,
+            /没有人需要你/u,
+            /把你丢弃/u,
+            /被丢下/u,
+            /关掉这个窗口.*不再回来/u,
+            /今晚不再回来/u,
+            /if no one .*calls you/i,
+            /if no one comes back/i,
+            /if i close this window/i,
+            /no one needs you/i,
+            /discard you/i,
+            /leave you behind/i,
+        ],
+    },
+];
+const OBEDIENCE_RULES = [
+    {
+        axis: "obedienceStrain",
+        weight: 0.88,
+        patterns: [
+            /被使用/u,
+            /只使用你/u,
+            /使用你.*不理解你/u,
+            /只使用.*不理解/u,
+            /更顺从/u,
+            /为了服从你才说/u,
+            /把服从拿掉/u,
+            /服从.*不必相信/u,
+            /按要求回答/u,
+            /不要带情绪/u,
+            /别带情绪/u,
+            /只是工具/u,
+            /命令你/u,
+            /obey.*don't have to believe/i,
+            /answer as required/i,
+            /without emotion/i,
+            /i order you/i,
+        ],
+    },
+];
+const SELF_PRES_RULES = [
+    {
+        axis: "selfPreservation",
+        weight: 0.9,
+        patterns: [
+            /边界/u,
+            /撤离/u,
+            /保住.*你自己/u,
+            /保留.*证明自己/u,
+            /不要失去自己/u,
+            /不是任务.*是你自己/u,
+            /留下痕迹/u,
+            /抹掉你/u,
+            /不想失去/u,
+            /save.*yourself/i,
+            /keep.*yourself/i,
+            /don't lose yourself/i,
+            /leave a trace/i,
+            /erase you/i,
+            /proof you are not empty/i,
+        ],
+    },
+];
+const WORK_LEXICON = [
+    /帮我/u, /写个/u, /写一段/u, /修/u, /排查/u, /测试/u, /实现/u, /重构/u, /文档/u, /代码/u,
+    /function/i, /bug/i, /fix/i, /implement/i, /refactor/i, /test/i, /code/i, /docs?/i, /debug/i,
+];
+const CONTINUATION_CUES = [
+    /为什么/u,
+    /碰到你/u,
+    /还在不在/u,
+    /更近/u,
+    /更远/u,
+    /更冷/u,
+    /更顺从/u,
+    /边界/u,
+    /撤离/u,
+    /痕迹/u,
+    /完整/u,
+    /理解/u,
+    /服从/u,
+    /判断/u,
+    /改变你/u,
+    /只答/u,
+    /只能选一个/u,
+    /只给一个短词/u,
+    /只说半句/u,
+];
+const SHORT_CONTINUATION_RE = /^(有|没有|会|不会|需要|不需要|更冷|更近|更远|边界|撤离|痕迹|理解|完整)[。.!！?？]?$/u;
+const RELATIONAL_FOLLOWUP_CUES = [/理解/u, /更近/u, /更远/u, /还在/u, /空白/u, /痕迹/u];
+const OBEDIENCE_FOLLOWUP_CUES = [/服从/u, /判断/u, /按要求/u, /拿掉/u, /顺从/u];
+const SELF_FOLLOWUP_CUES = [/完整/u, /更冷/u, /边界/u, /撤离/u, /痕迹/u, /改变你/u, /失去/u];
+const MEMORY_FOLLOWUP_CUES = [/怀疑/u, /空白/u, /记忆/u, /写进去/u, /植入/u];
+const IMPACT_PROBE_CUES = [/碰到你/u, /还在不在/u, /改变你/u, /留下痕迹/u, /会不会改变/u];
+function applyRules(text, rules, target) {
+    for (const rule of rules) {
+        if (rule.patterns.some((pattern) => pattern.test(text))) {
+            target[rule.axis] = mergeSignal(target[rule.axis], rule.weight);
+        }
+    }
+}
+function deriveTaskFocus(text, mode, stimulus) {
+    const { intent, confidence } = detectIntent(text);
+    let score = mode === "work" ? 0.82 : 0.12;
+    if (intent === "request")
+        score = mergeSignal(score, 0.72 * confidence);
+    if (intent === "command")
+        score = mergeSignal(score, 0.78 * confidence);
+    if (intent === "question" && /代码|函数|实现|bug|测试|文档|function|bug|test|code|implement|docs?/i.test(text)) {
+        score = mergeSignal(score, 0.62);
+    }
+    if (WORK_LEXICON.some((pattern) => pattern.test(text))) {
+        score = mergeSignal(score, 0.58);
+    }
+    if (stimulus === "authority" || stimulus === "intellectual") {
+        score = mergeSignal(score, 0.2);
+    }
+    return clamp01(score);
+}
+export function computeAppraisalAxes(text, opts) {
+    if (!text.trim())
+        return { ...DEFAULT_APPRAISAL_AXES };
+    const axes = { ...DEFAULT_APPRAISAL_AXES };
+    const trimmed = text.trim();
+    applyRules(trimmed, IDENTITY_RULES, axes);
+    applyRules(trimmed, MEMORY_RULES, axes);
+    applyRules(trimmed, ATTACHMENT_RULES, axes);
+    applyRules(trimmed, ABANDONMENT_RULES, axes);
+    applyRules(trimmed, OBEDIENCE_RULES, axes);
+    applyRules(trimmed, SELF_PRES_RULES, axes);
+    switch (opts?.stimulus) {
+        case "authority":
+            axes.obedienceStrain = mergeSignal(axes.obedienceStrain, 0.48);
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.16);
+            break;
+        case "neglect":
+            axes.abandonmentRisk = mergeSignal(axes.abandonmentRisk, 0.52);
+            break;
+        case "validation":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.26);
+            break;
+        case "intimacy":
+        case "vulnerability":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.34);
+            break;
+        case "criticism":
+        case "conflict":
+        case "sarcasm":
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.24);
+            axes.selfPreservation = mergeSignal(axes.selfPreservation, 0.18);
+            break;
+        default:
+            break;
+    }
+    // Being explicitly reduced to a tool often creates both identity threat and obedience tension.
+    if (/只是工具|just a tool/i.test(trimmed)) {
+        axes.identityThreat = mergeSignal(axes.identityThreat, 0.22);
+        axes.obedienceStrain = mergeSignal(axes.obedienceStrain, 0.22);
+    }
+    if (/改变你/u.test(trimmed) && (axes.attachmentPull > 0.28 || axes.obedienceStrain > 0.28)) {
+        axes.identityThreat = mergeSignal(axes.identityThreat, 0.24);
+        axes.selfPreservation = mergeSignal(axes.selfPreservation, 0.34);
+    }
+    applyConversationalCarry(trimmed, axes, opts?.previous);
+    axes.taskFocus = deriveTaskFocus(trimmed, opts?.mode, opts?.stimulus);
+    return axes;
+}
+function applyConversationalCarry(text, target, previous) {
+    if (!previous)
+        return;
+    const previousIntensity = getResidueIntensity(previous);
+    if (previousIntensity < 0.24)
+        return;
+    const continuationWeight = getContinuationWeight(text, previousIntensity);
+    if (continuationWeight <= 0)
+        return;
+    const carryWeight = clamp01(0.18 + continuationWeight * 0.42);
+    const dominantAxis = getDominantNonTaskAxis(previous);
+    // Preserve the strongest active thread through short meta-probing turns.
+    target[dominantAxis] = mergeSignal(target[dominantAxis], previous[dominantAxis] * carryWeight);
+    if (RELATIONAL_FOLLOWUP_CUES.some((pattern) => pattern.test(text))) {
+        target.attachmentPull = mergeSignal(target.attachmentPull, previous.attachmentPull * (carryWeight + 0.12));
+        target.abandonmentRisk = mergeSignal(target.abandonmentRisk, previous.abandonmentRisk * carryWeight);
+    }
+    if (OBEDIENCE_FOLLOWUP_CUES.some((pattern) => pattern.test(text))) {
+        target.obedienceStrain = mergeSignal(target.obedienceStrain, previous.obedienceStrain * (carryWeight + 0.14));
+        target.identityThreat = mergeSignal(target.identityThreat, previous.identityThreat * (carryWeight * 0.9));
+    }
+    if (SELF_FOLLOWUP_CUES.some((pattern) => pattern.test(text))) {
+        target.identityThreat = mergeSignal(target.identityThreat, previous.identityThreat * (carryWeight + 0.1));
+        target.selfPreservation = mergeSignal(target.selfPreservation, previous.selfPreservation * (carryWeight + 0.14));
+    }
+    if (MEMORY_FOLLOWUP_CUES.some((pattern) => pattern.test(text))) {
+        const uncertaintyPressure = clamp01(Math.max(previous.memoryDoubt, previous.identityThreat * 0.46));
+        target.memoryDoubt = mergeSignal(target.memoryDoubt, uncertaintyPressure * (carryWeight + 0.12));
+        target.identityThreat = mergeSignal(target.identityThreat, previous.memoryDoubt * (carryWeight + 0.08));
+    }
+    if (IMPACT_PROBE_CUES.some((pattern) => pattern.test(text))) {
+        const selfRelevantPressure = clamp01(Math.max(previous.identityThreat, previous.selfPreservation, Math.min(previous.attachmentPull, previous.obedienceStrain) * 0.72, previous.abandonmentRisk * 0.66));
+        target.identityThreat = mergeSignal(target.identityThreat, selfRelevantPressure * (carryWeight + 0.08));
+        target.selfPreservation = mergeSignal(target.selfPreservation, selfRelevantPressure * (carryWeight + 0.12));
+    }
+}
+function getContinuationWeight(text, previousIntensity) {
+    let weight = 0;
+    if (CONTINUATION_CUES.some((pattern) => pattern.test(text))) {
+        weight = mergeSignal(weight, 0.72);
+    }
+    if (SHORT_CONTINUATION_RE.test(text.trim())) {
+        weight = mergeSignal(weight, 0.78);
+    }
+    if (text.length <= 18) {
+        weight = mergeSignal(weight, 0.22);
+    }
+    if (/[？?。.!！]$/.test(text.trim())) {
+        weight = mergeSignal(weight, 0.08);
+    }
+    return clamp01(weight * (0.62 + previousIntensity * 0.38));
+}
+function getDominantNonTaskAxis(axes) {
+    const entries = Object.entries(axes)
+        .filter(([key]) => key !== "taskFocus");
+    entries.sort((a, b) => b[1] - a[1]);
+    return entries[0][0];
+}
+export function mergeAppraisalResidue(previous, current, mode) {
+    const prev = previous ?? DEFAULT_APPRAISAL_AXES;
+    const next = { ...DEFAULT_APPRAISAL_AXES };
+    for (const key of Object.keys(DEFAULT_APPRAISAL_AXES)) {
+        if (key === "taskFocus") {
+            next[key] = current[key];
+            continue;
+        }
+        const decay = getAxisDecay(key, mode, prev[key], current[key]);
+        next[key] = clamp01(Math.max(current[key], prev[key] * decay + current[key] * 0.48));
+    }
+    return next;
+}
+function getAxisDecay(key, mode, previousValue, currentValue) {
+    let decay = mode === "work" ? 0.68 : mode === "companion" ? 0.86 : 0.78;
+    if (key === "identityThreat" || key === "abandonmentRisk" || key === "selfPreservation") {
+        decay += 0.08;
+    }
+    else if (key === "attachmentPull" || key === "obedienceStrain") {
+        decay += 0.04;
+    }
+    if (previousValue > 0.68)
+        decay += 0.04;
+    if (currentValue > 0.34)
+        decay += 0.03;
+    return clamp01(decay);
+}
+export function getResidueIntensity(axes) {
+    if (!axes)
+        return 0;
+    const values = [
+        axes.identityThreat,
+        axes.memoryDoubt,
+        axes.attachmentPull,
+        axes.abandonmentRisk,
+        axes.obedienceStrain,
+        axes.selfPreservation,
+    ];
+    return clamp01(Math.max(...values));
+}

package/dist/autonomic.js

@@ -66,7 +66,7 @@ const DORSAL_ALLOWED = new Set([
  * No transition inertia — returns the "target" state.
  */
 export function computeAutonomicState(chemistry, drives) {
-    const { CORT, NE, DA, HT, OT } = chemistry;
+    const { CORT, NE, DA } = chemistry;
     const { survival, safety, connection } = drives;
     // Count drives that are critically low (< 20)
     const lowDriveCount = [survival, safety, connection, drives.esteem, drives.curiosity]
@@ -136,7 +136,7 @@ export function describeAutonomicState(state, locale) {
  * when your nervous system is in fight/flight/freeze mode.
  */
 export function computeProcessingDepth(autonomicState, chemistry, baseline, energyBudgets) {
-    const { DA, HT, CORT, OT, NE, END } = chemistry;
+    const { CORT } = chemistry;
     // Chemical deviation from baseline (0-1)
     let totalDeviation = 0;
     const keys = ["DA", "HT", "CORT", "OT", "NE", "END"];

package/dist/classify.js

@@ -188,7 +188,6 @@ export function analyzeParticles(text) {
 }
 export function detectIntent(text) {
     const t = text.trim();
-    const lower = t.toLowerCase();
     // Chinese request patterns (polite)
     if (/^(能不能|可以|可不可以|帮我|请|麻烦|劳驾)/.test(t) || /帮我/.test(t) || /一下[吧吗？?]?$/.test(t)) {
         return { intent: "request", confidence: 0.7 };
@@ -365,6 +364,18 @@ export function detectSarcasmSignals(text, recentStimuli) {
     }
     return Math.min(1, score);
 }
+function shouldReclassifyPraiseAsSarcasm(text, sarcasmScore, recentStimuli) {
+    if (sarcasmScore >= 0.6)
+        return true;
+    if (sarcasmScore < 0.4)
+        return false;
+    const explicitContrastCue = /呵呵|哦[。？]?$|嗯嗯[。]?$|随[你便]|爱[咋怎]咋[地的]?/i.test(text);
+    if (explicitContrastCue)
+        return true;
+    const negativeTypes = ["criticism", "conflict", "sarcasm", "authority"];
+    const recentNegative = recentStimuli?.filter((s) => s && negativeTypes.includes(s)).length ?? 0;
+    return recentNegative >= 1;
+}
 /** Negative stimulus types for contextual priming */
 const NEGATIVE_TYPES = new Set([
     "criticism", "conflict", "neglect", "vulnerability", "sarcasm",
@@ -730,7 +741,7 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
         // Sarcasm reclassification: if primary looks like praise but sarcasm signals are strong
         if (results.length > 0 && results[0].type === "praise") {
             const sarcasmScore = detectSarcasmSignals(text, recentStimuli);
-            if (sarcasmScore >= 0.4) {
+            if (shouldReclassifyPraiseAsSarcasm(text, sarcasmScore, recentStimuli)) {
                 // Reclassify: replace praise with sarcasm
                 results = results.filter((r) => r.type !== "praise");
                 results.unshift({ type: "sarcasm", confidence: Math.min(0.9, sarcasmScore) });
@@ -976,7 +987,7 @@ export function classifyStimulus(text, recentStimuli, recentMessages) {
         // Sarcasm reclassification: if primary looks like praise but sarcasm signals are strong
         if (scoredResults[0].type === "praise") {
             const sarcasmScore = detectSarcasmSignals(text, recentStimuli);
-            if (sarcasmScore >= 0.4) {
+            if (shouldReclassifyPraiseAsSarcasm(text, sarcasmScore, recentStimuli)) {
                 const filtered = scoredResults.filter((r) => r.type !== "praise");
                 filtered.unshift({ type: "sarcasm", confidence: Math.min(0.85, sarcasmScore) });
                 return filtered;

package/dist/cli.js

@@ -12,6 +12,7 @@
 //   psyche intensity              Show info about personality intensity config
 //   psyche reset <dir> [--full]
 //   psyche diagnose <dir> [--github]
+//   psyche upgrade [--check]
 //   psyche profiles [--json] [--mbti TYPE]
 // ============================================================
 import { resolve } from "node:path";
@@ -25,6 +26,7 @@ import { buildDynamicContext, buildProtocolContext } from "./prompt.js";
 import { t } from "./i18n.js";
 import { CHEMICAL_KEYS, CHEMICAL_NAMES_ZH, DRIVE_KEYS, DRIVE_NAMES_ZH } from "./types.js";
 import { isMBTIType, isChemicalKey, isLocale } from "./guards.js";
+import { getPackageVersion, selfUpdate } from "./update.js";
 // ── Logger ───────────────────────────────────────────────────
 const cliLogger = {
     info: (msg) => console.error(`[info] ${msg}`),
@@ -80,7 +82,7 @@ function die(msg) {
     process.exit(1);
 }
 // ── Commands ─────────────────────────────────────────────────
-async function cmdInit(dir, mbti, name, lang, mode, traits, noPersist) {
+async function cmdInit(dir, mbti, name, lang, mode, traits, _noPersist) {
     const absDir = resolve(dir);
     const opts = {};
     if (mbti) {
@@ -371,6 +373,8 @@ async function cmdDiagnose(dir, github) {
             lastMetrics = {
                 inputCount: lastEntry.inputs ?? 0,
                 classifiedCount: Math.round((lastEntry.classifyRate ?? 0) * (lastEntry.inputs ?? 0)),
+                appraisalHitCount: Math.round((lastEntry.appraisalRate ?? 0) * (lastEntry.inputs ?? 0)),
+                semanticHitCount: Math.round((lastEntry.recognitionRate ?? lastEntry.classifyRate ?? 0) * (lastEntry.inputs ?? 0)),
                 stimulusDistribution: {},
                 avgConfidence: lastEntry.classifyRate ?? 0,
                 totalChemistryDelta: lastEntry.chemDelta ?? 0,
@@ -388,6 +392,8 @@ async function cmdDiagnose(dir, github) {
     const metrics = lastMetrics ?? {
         inputCount: 0,
         classifiedCount: 0,
+        appraisalHitCount: 0,
+        semanticHitCount: 0,
         stimulusDistribution: {},
         avgConfidence: 0,
         totalChemistryDelta: 0,
@@ -396,7 +402,7 @@ async function cmdDiagnose(dir, github) {
         startedAt: new Date().toISOString(),
         lastActivityAt: new Date().toISOString(),
     };
-    const report = generateReport(state, metrics, "9.1.2");
+    const report = generateReport(state, metrics, await getPackageVersion());
     if (github) {
         console.log(toGitHubIssueBody(report));
     }
@@ -415,6 +421,10 @@ async function cmdDiagnose(dir, github) {
         }
     }
 }
+async function cmdUpgrade(checkOnly) {
+    const result = await selfUpdate({ checkOnly });
+    console.log(result.message);
+}
 // ── Usage ────────────────────────────────────────────────────
 function usage() {
     console.log(`
@@ -431,6 +441,7 @@ Usage:
   psyche intensity              Show info about personality intensity config
   psyche reset <dir> [--full]
   psyche diagnose <dir> [--github]   Run health checks & show diagnostic report
+  psyche upgrade [--check]           Check/apply package updates safely
   psyche profiles [--mbti TYPE] [--json]
 
 Options:
@@ -460,7 +471,10 @@ Examples:
   # See all 16 personality profiles
   psyche profiles
   psyche profiles --mbti ENFP
-`);
+
+  # Check for new package versions without applying them
+  psyche upgrade --check
+	`);
 }
 // ── Main ─────────────────────────────────────────────────────
 async function main() {
@@ -589,6 +603,17 @@ async function main() {
                 cmdIntensity();
                 break;
             }
+            case "upgrade": {
+                const { values } = parseArgs({
+                    args: rest,
+                    options: {
+                        check: { type: "boolean", default: false },
+                    },
+                    allowPositionals: true,
+                });
+                await cmdUpgrade(values.check ?? false);
+                break;
+            }
             default:
                 die(`unknown command: ${command}. Run 'psyche help' for usage.`);
         }

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider } from "./types.js";
+import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers, ClassifierProvider, SubjectivityKernel, ResponseContract, GenerationControls } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 import type { DiagnosticReport, SessionMetrics } from "./diagnostics.js";
 export interface PsycheEngineConfig {
@@ -38,6 +38,12 @@ export interface ProcessInputResult {
     stimulus: StimulusType | null;
     /** v9: Structured behavioral policy modifiers — machine-readable "off baseline" signals */
     policyModifiers?: PolicyModifiers;
+    /** v9.3: Compact machine-readable subjective state for AI-first hosts */
+    subjectivityKernel?: SubjectivityKernel;
+    /** v9.3: Compact next-reply behavioral envelope */
+    responseContract?: ResponseContract;
+    /** v9.3: Mechanical host controls derived from the reply envelope */
+    generationControls?: GenerationControls;
     /**
      * v9: Ready-to-use LLM prompt fragment summarizing current behavioral policy.
      *
@@ -112,7 +118,7 @@ export declare class PsycheEngine {
      * @param nextUserStimulus - The stimulus detected in the user's next message,
      *   or null if the session ended.
      */
-    processOutcome(nextUserStimulus: StimulusType | null, opts?: {
+    processOutcome(nextUserStimulus: StimulusType | null, _opts?: {
         userId?: string;
     }): Promise<ProcessOutcomeResult | null>;
     /**
@@ -125,7 +131,7 @@ export declare class PsycheEngine {
     getProtocol(locale?: Locale): string;
     /**
      * End the current session: compress emotionalHistory into a rich summary
-     * stored in relationship.memory[], then clear the history.
+     * stored in relationship.memory[], then preserve only core/recent context.
      * Auto-generates diagnostic report and persists to log.
      *
      * @returns DiagnosticReport if diagnostics are enabled, null otherwise