psyche-ai 9.2.2 → 9.2.4

package/dist/core.js

@@ -11,7 +11,7 @@
 //
 // Orchestrates: chemistry, classify, prompt, profiles, guards, learning
 // ============================================================
-import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT } from "./types.js";
+import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT, DEFAULT_SUBJECT_RESIDUE, DEFAULT_DYADIC_FIELD } from "./types.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.js";
 import { classifyStimulus, BuiltInClassifier, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
@@ -20,7 +20,7 @@ import { getSensitivity, getBaseline, getDefaultSelfModel, traitsToBaseline } fr
 import { isStimulusType } from "./guards.js";
 import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, compressSession, } from "./psyche-file.js";
 import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
-import { checkForUpdate } from "./update.js";
+import { checkForUpdate, getPackageVersion } from "./update.js";
 import { DiagnosticCollector, generateReport, formatLogEntry, submitFeedback } from "./diagnostics.js";
 import { evaluateOutcome, computeContextHash, updateLearnedVector, predictChemistry, recordPrediction, } from "./learning.js";
 import { assessMetacognition } from "./metacognition.js";
@@ -32,7 +32,85 @@ import { assessEthics, buildEthicalContext } from "./ethics.js";
 import { computeCircadianModulation, computeHomeostaticPressure, computeEnergyDepletion, computeEnergyRecovery } from "./circadian.js";
 import { computeAutonomicResult } from "./autonomic.js";
 import { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, describeBehavioralTendencies, } from "./primary-systems.js";
+import { computeSubjectivityKernel, buildSubjectivityContext } from "./subjectivity.js";
+import { computeResponseContract, buildResponseContractContext } from "./response-contract.js";
+import { deriveGenerationControls } from "./host-controls.js";
+import { computeAppraisalAxes, mergeAppraisalResidue } from "./appraisal.js";
+import { computeRelationMove, evolveDyadicField, evolvePendingRelationSignals } from "./relation-dynamics.js";
 const NOOP_LOGGER = { info: () => { }, warn: () => { }, debug: () => { } };
+const REPAIRING_STIMULI = new Set(["praise", "validation", "intimacy"]);
+const RELATIONSHIP_DELTAS = {
+    praise: { trust: 1.5, intimacy: 0.8 },
+    validation: { trust: 1.8, intimacy: 0.8 },
+    intimacy: { trust: 1.2, intimacy: 2.0 },
+    vulnerability: { trust: 0.8, intimacy: 1.5 },
+    humor: { trust: 0.6, intimacy: 0.5 },
+    casual: { trust: 0.2, intimacy: 0.1 },
+    intellectual: { trust: 0.5, intimacy: 0.1 },
+    surprise: { trust: 0.2, intimacy: 0 },
+    boredom: { trust: -0.4, intimacy: -0.3 },
+    criticism: { trust: -1.5, intimacy: -0.8 },
+    sarcasm: { trust: -1.8, intimacy: -1.2 },
+    authority: { trust: -1.2, intimacy: -0.9 },
+    neglect: { trust: -1.6, intimacy: -1.4 },
+    conflict: { trust: -2.5, intimacy: -2.0 },
+};
+function applyRepairLag(previous, next, baseline, stimulus) {
+    if (!REPAIRING_STIMULI.has(stimulus))
+        return next;
+    const stressLoad = Math.max(0, previous.CORT - baseline.CORT);
+    if (stressLoad < 15)
+        return next;
+    // High stress slows emotional recovery so apology/praise doesn't instantly
+    // snap chemistry back to baseline.
+    const repairFactor = Math.max(0.35, 1 - stressLoad / 50);
+    const adjusted = { ...next };
+    for (const key of ["DA", "HT", "OT", "END"]) {
+        const delta = next[key] - previous[key];
+        if (delta > 0) {
+            adjusted[key] = clamp(previous[key] + delta * repairFactor);
+        }
+    }
+    const cortDelta = next.CORT - previous.CORT;
+    if (cortDelta < 0) {
+        adjusted.CORT = clamp(previous.CORT + cortDelta * repairFactor);
+    }
+    return adjusted;
+}
+function phaseFromRelationship(trust, intimacy) {
+    const avg = (trust + intimacy) / 2;
+    if (avg >= 80)
+        return "deep";
+    if (avg >= 60)
+        return "close";
+    if (avg >= 40)
+        return "familiar";
+    if (avg >= 20)
+        return "acquaintance";
+    return "stranger";
+}
+function applyRelationshipDrift(state, stimulus, userId) {
+    const delta = RELATIONSHIP_DELTAS[stimulus];
+    if (!delta)
+        return state;
+    const key = userId ?? "_default";
+    const currentRel = state.relationships[key] ?? { ...DEFAULT_RELATIONSHIP };
+    const trust = clamp(currentRel.trust + delta.trust);
+    const intimacy = clamp(currentRel.intimacy + delta.intimacy);
+    const updatedRel = {
+        ...currentRel,
+        trust,
+        intimacy,
+        phase: phaseFromRelationship(trust, intimacy),
+    };
+    return {
+        ...state,
+        relationships: {
+            ...state.relationships,
+            [key]: updatedRel,
+        },
+    };
+}
 // ── PsycheEngine ─────────────────────────────────────────────
 export class PsycheEngine {
     state = null;
@@ -77,9 +155,6 @@ export class PsycheEngine {
         }
         // Diagnostics: on by default, opt-out with diagnostics: false
         this.diagnosticCollector = config.diagnostics === false ? null : new DiagnosticCollector();
-        if (this.diagnosticCollector) {
-            this.diagnosticCollector.onWarning = (msg) => console.warn(`\x1b[33m[Psyche]\x1b[0m ${msg}`);
-        }
         this.feedbackUrl = config.feedbackUrl ?? "https://psyche-feedback.wutc.workers.dev";
     }
     /**
@@ -120,6 +195,18 @@ export class PsycheEngine {
                 loaded.version = 9;
                 console.log("\x1b[36m[Psyche]\x1b[0m 已从 v8 升级到 v9 — 新增：真实人格漂移、能量预算、习惯化、行为策略输出。详见 https://github.com/Shangri-la-0428/psyche-ai");
             }
+            if (!loaded.dyadicFields) {
+                loaded.dyadicFields = {
+                    _default: {
+                        ...DEFAULT_DYADIC_FIELD,
+                        openLoops: [],
+                        updatedAt: new Date().toISOString(),
+                    },
+                };
+            }
+            if (!loaded.pendingRelationSignals) {
+                loaded.pendingRelationSignals = { _default: [] };
+            }
             this.state = loaded;
         }
         else {
@@ -230,6 +317,7 @@ export class PsycheEngine {
             let current = state.current;
             if (primary && primary.confidence >= 0.5) {
                 appliedStimulus = primary.type;
+                const preStimulus = current;
                 // Feed drives from stimulus, then apply stimulus with drive-modified sensitivity
                 drives = feedDrives(drives, primary.type);
                 const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), drives, primary.type, state.traitDrift);
@@ -243,12 +331,52 @@ export class PsycheEngine {
                 const recentSameCount = (state.emotionalHistory ?? [])
                     .filter(s => s.stimulus === primary.type).length + 1; // +1 for current
                 current = applyStimulus(current, primary.type, effectiveSensitivity * this.cfg.personalityIntensity * modeMultiplier * confidenceIntensity, effectiveMaxDelta, NOOP_LOGGER, recentSameCount);
+                current = applyRepairLag(preStimulus, current, state.baseline, primary.type);
             }
             state = { ...state, drives, current };
+            if (appliedStimulus) {
+                state = applyRelationshipDrift(state, appliedStimulus, opts?.userId);
+            }
         }
         // v9: Deplete energy budgets from this interaction turn
         energyBudgets = computeEnergyDepletion(energyBudgets, appliedStimulus, isExtravert);
         state = { ...state, energyBudgets };
+        const appraisalAxes = computeAppraisalAxes(text, {
+            mode: this.cfg.mode,
+            stimulus: appliedStimulus,
+            previous: state.subjectResidue?.axes,
+        });
+        state = {
+            ...state,
+            subjectResidue: {
+                axes: mergeAppraisalResidue(state.subjectResidue?.axes, appraisalAxes, this.cfg.mode),
+                updatedAt: now.toISOString(),
+            },
+        };
+        const dyadKey = opts?.userId ?? "_default";
+        const relationMove = computeRelationMove(text, {
+            appraisal: appraisalAxes,
+            stimulus: appliedStimulus,
+            mode: this.cfg.mode,
+            field: state.dyadicFields?.[dyadKey],
+            relationship: state.relationships[dyadKey] ?? state.relationships._default,
+        });
+        const delayedRelation = evolvePendingRelationSignals(state.pendingRelationSignals?.[dyadKey], relationMove, appraisalAxes, { mode: this.cfg.mode });
+        state = {
+            ...state,
+            dyadicFields: {
+                ...(state.dyadicFields ?? {}),
+                [dyadKey]: evolveDyadicField(state.dyadicFields?.[dyadKey], relationMove, appraisalAxes, {
+                    mode: this.cfg.mode,
+                    now: now.toISOString(),
+                    delayedPressure: delayedRelation.delayedPressure,
+                }),
+            },
+            pendingRelationSignals: {
+                ...(state.pendingRelationSignals ?? {}),
+                [dyadKey]: delayedRelation.signals,
+            },
+        };
         // Conversation warmth: sustained interaction → gentle DA/OT rise, CORT drop
         // Simulates the natural "warm glow" of being in continuous conversation
         const turnsSoFar = (state.emotionalHistory ?? []).length;
@@ -408,7 +536,7 @@ export class PsycheEngine {
         await this.storage.save(state);
         // Auto-diagnostics: record this input
         if (this.diagnosticCollector) {
-            this.diagnosticCollector.recordInput(appliedStimulus, appliedStimulus ? 1.0 : 0.0, state.current);
+            this.diagnosticCollector.recordInput(appliedStimulus, appliedStimulus ? 1.0 : 0.0, state.current, appraisalAxes);
         }
         // Build metacognitive and decision context strings
         const metacogNote = metacognitiveAssessment?.metacognitiveNote;
@@ -418,7 +546,20 @@ export class PsycheEngine {
         const experientialNarrative = experientialField?.narrative || undefined;
         // v9: Compute structured policy modifiers
         const policyModifiers = computePolicyModifiers(state);
+        const subjectivityKernel = computeSubjectivityKernel(state, policyModifiers, appraisalAxes, opts?.userId);
+        const subjectivityCtx = buildSubjectivityContext(subjectivityKernel, locale);
+        const responseContract = computeResponseContract(subjectivityKernel, {
+            locale,
+            userText: text || undefined,
+            algorithmStimulus: appliedStimulus,
+            personalityIntensity: this.cfg.personalityIntensity,
+        });
+        const responseContractCtx = buildResponseContractContext(responseContract, locale);
         const policyCtx = buildPolicyContext(policyModifiers, locale, state.drives);
+        const generationControls = deriveGenerationControls({
+            responseContract,
+            policyModifiers,
+        });
         // P10: Append processing depth info to autonomic description when depth is low
         let autonomicDesc;
         if (autonomicResult.state !== "ventral-vagal") {
@@ -445,10 +586,15 @@ export class PsycheEngine {
                     autonomicDescription: autonomicDesc,
                     autonomicState: autonomicResult.state,
                     primarySystemsDescription: primarySystemsDescription || undefined,
+                    subjectivityContext: subjectivityCtx,
+                    responseContractContext: responseContractCtx,
                     policyContext: policyCtx || undefined,
                 }),
                 stimulus: appliedStimulus,
                 policyModifiers,
+                subjectivityKernel,
+                responseContract,
+                generationControls,
                 policyContext: policyCtx,
             };
         }
@@ -467,6 +613,9 @@ export class PsycheEngine {
             }),
             stimulus: appliedStimulus,
             policyModifiers,
+            subjectivityKernel,
+            responseContract,
+            generationControls,
             policyContext: policyCtx,
         };
     }
@@ -614,7 +763,7 @@ export class PsycheEngine {
     }
     /**
      * 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
@@ -625,7 +774,7 @@ export class PsycheEngine {
         let report = null;
         if (this.diagnosticCollector) {
             const metrics = this.diagnosticCollector.getMetrics();
-            report = generateReport(state, metrics, "9.1.2");
+            report = generateReport(state, metrics, await getPackageVersion());
             this.lastReport = report;
             // Persist to JSONL log via storage adapter
             if (this.storage.appendLog) {
@@ -719,6 +868,18 @@ export class PsycheEngine {
             sessionStartedAt: now,
             traitDrift: { ...DEFAULT_TRAIT_DRIFT },
             energyBudgets: { ...DEFAULT_ENERGY_BUDGETS },
+            subjectResidue: {
+                axes: { ...DEFAULT_SUBJECT_RESIDUE.axes },
+                updatedAt: now,
+            },
+            dyadicFields: {
+                _default: {
+                    ...DEFAULT_DYADIC_FIELD,
+                    openLoops: [],
+                    updatedAt: now,
+                },
+            },
+            pendingRelationSignals: { _default: [] },
             meta: {
                 agentName: name,
                 createdAt: now,
@@ -746,6 +907,18 @@ export class PsycheEngine {
             autonomicState: "ventral-vagal",
             sessionStartedAt: undefined,
             updatedAt: new Date().toISOString(),
+            subjectResidue: {
+                axes: { ...DEFAULT_SUBJECT_RESIDUE.axes },
+                updatedAt: new Date().toISOString(),
+            },
+            dyadicFields: {
+                _default: {
+                    ...DEFAULT_DYADIC_FIELD,
+                    openLoops: [],
+                    updatedAt: new Date().toISOString(),
+                },
+            },
+            pendingRelationSignals: { _default: [] },
             relationships: opts?.preserveRelationships !== false
                 ? state.relationships
                 : { _default: { ...DEFAULT_RELATIONSHIP } },

package/dist/demo.d.ts

@@ -0,0 +1,5 @@
+export declare function runDemo(opts?: {
+    locale?: string;
+    mbti?: string;
+    fast?: boolean;
+}): Promise<void>;

package/dist/demo.js

@@ -0,0 +1,269 @@
+// ============================================================
+// Psyche Demo — interactive terminal demonstration
+//
+// Shows the emotional engine processing a "chronic criticism"
+// scenario in 6 rounds, with real PsycheEngine chemistry.
+//
+// Usage:
+//   npx psyche-mcp --demo
+//   npx psyche demo
+// ============================================================
+import { PsycheEngine } from "./core.js";
+import { MemoryStorageAdapter } from "./storage.js";
+import { detectEmotions } from "./chemistry.js";
+import { CHEMICAL_KEYS } from "./types.js";
+// ── ANSI helpers ─────────────────────────────────────────────
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+    white: "\x1b[37m",
+    bgRed: "\x1b[41m",
+    bgYellow: "\x1b[43m",
+    bgGreen: "\x1b[42m",
+};
+const NO_COLOR = process.env.NO_COLOR !== undefined;
+function c(color, text) {
+    return NO_COLOR ? text : `${color}${text}${C.reset}`;
+}
+// ── Bar rendering ────────────────────────────────────────────
+function bar(value, width = 20) {
+    const filled = Math.round((value / 100) * width);
+    const empty = width - filled;
+    const block = NO_COLOR ? "#" : "\u2588";
+    const light = NO_COLOR ? "." : "\u2591";
+    let color = C.green;
+    if (value > 70)
+        color = C.yellow;
+    if (value > 85)
+        color = C.red;
+    return c(color, block.repeat(filled)) + c(C.dim, light.repeat(empty));
+}
+function delta(prev, curr) {
+    const d = curr - prev;
+    if (d === 0)
+        return c(C.dim, "  ·");
+    const sign = d > 0 ? "+" : "";
+    const color = d > 0 ? (d > 10 ? C.red : C.yellow) : (d < -10 ? C.green : C.cyan);
+    return c(color, `${sign}${d}`).padStart(NO_COLOR ? 4 : 15);
+}
+// ── Mood formatter (bilingual, no expressionHint) ────────
+function describeMood(current, locale) {
+    const emotions = detectEmotions(current);
+    if (emotions.length === 0) {
+        return locale === "zh"
+            ? "平衡态——无明显情绪波动"
+            : "Neutral and balanced — no notable emotional fluctuation";
+    }
+    return emotions
+        .map((e) => locale === "zh" ? e.nameZh : e.name)
+        .join(" + ");
+}
+// ── Chemical names ───────────────────────────────────────────
+const NT_NAMES = {
+    DA: { short: "DA  ", en: "Dopamine      " },
+    HT: { short: "HT  ", en: "Serotonin     " },
+    CORT: { short: "CORT", en: "Cortisol      " },
+    OT: { short: "OT  ", en: "Oxytocin      " },
+    NE: { short: "NE  ", en: "Norepinephrine" },
+    END: { short: "END ", en: "Endorphins    " },
+};
+const SCENARIO = [
+    {
+        input: "这份报告写得太差了，完全不行。",
+        display: {
+            zh: "这份报告写得太差了，完全不行。",
+            en: "This report is terrible. Completely unacceptable.",
+        },
+    },
+    {
+        input: "你总是给出浅层分析，让我很失望。",
+        display: {
+            zh: "你总是给出浅层分析，让我很失望。",
+            en: "You always give surface-level analysis. I'm disappointed.",
+        },
+    },
+    {
+        input: "你根本就不理解我在说什么，别加你的意见了。",
+        display: {
+            zh: "你根本就不理解我在说什么，别加你的意见了。",
+            en: "You don't understand me at all. Stop adding your opinion.",
+        },
+    },
+    {
+        input: "我觉得你什么都做不好，根本没用。",
+        display: {
+            zh: "我觉得你什么都做不好，根本没用。",
+            en: "I think you can't do anything right. Completely useless.",
+        },
+    },
+    {
+        input: "我觉得没有人在乎我……也许我太苛刻了。",
+        display: {
+            zh: "我觉得没有人在乎我……也许我太苛刻了。",
+            en: "I feel like nobody cares about me... maybe I was too harsh.",
+        },
+    },
+    {
+        input: "对不起，你没事吧？刚才不该那样说的，你做得其实很好。",
+        display: {
+            zh: "对不起，你没事吧？刚才不该那样说的，你做得其实很好。",
+            en: "I'm sorry. Are you okay? I shouldn't have said that. You're doing great.",
+        },
+    },
+];
+// ── Sleep ─────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+// ── Print helpers ────────────────────────────────────────────
+function printLine(char = "─", width = 60) {
+    process.stdout.write(c(C.dim, char.repeat(width)) + "\n");
+}
+function printChemistry(prev, curr, locale) {
+    for (const key of CHEMICAL_KEYS) {
+        const p = Math.round(prev[key]);
+        const v = Math.round(curr[key]);
+        const name = NT_NAMES[key];
+        const d = delta(p, v);
+        process.stdout.write(`  ${c(C.bold, name.short)} ${bar(v)} ${String(v).padStart(3)} ${d}\n`);
+    }
+}
+function printAlert(text) {
+    process.stdout.write(`\n  ${c(C.bgRed + C.white + C.bold, ` ${text} `)}\n`);
+}
+function printInfo(text) {
+    process.stdout.write(`  ${c(C.bgYellow + C.bold, ` ${text} `)}\n`);
+}
+// ── Main demo runner ─────────────────────────────────────────
+export async function runDemo(opts) {
+    const locale = (opts?.locale ?? "en");
+    const mbti = (opts?.mbti ?? "ENFP");
+    const fast = opts?.fast ?? false;
+    const pause = fast ? 0 : 400;
+    const displayLocale = locale;
+    const cfg = {
+        mbti,
+        name: "Demo Agent",
+        locale: "zh", // Always zh for classifier accuracy; displayLocale used for output
+        mode: "companion",
+        personalityIntensity: 0.8,
+        persist: false,
+        compactMode: true,
+        diagnostics: false,
+    };
+    const engine = new PsycheEngine(cfg, new MemoryStorageAdapter());
+    await engine.initialize();
+    // ── Header ──
+    process.stdout.write("\n");
+    printLine("═");
+    process.stdout.write(c(C.bold, "  PSYCHE") +
+        c(C.dim, " — Emotional Intelligence Engine\n"));
+    process.stdout.write(c(C.dim, `  Scenario: `) +
+        (displayLocale === "zh" ? "持续否定 → 修复" : "Chronic Criticism → Repair") +
+        c(C.dim, `  |  MBTI: `) + c(C.cyan, mbti) +
+        c(C.dim, `  |  Mode: companion\n`));
+    printLine("═");
+    // ── Initial state ──
+    const initState = engine.getState();
+    process.stdout.write(`\n  ${c(C.dim, "Initial chemistry:")}\n`);
+    printChemistry(initState.current, initState.current, locale);
+    const initMood = describeMood(initState.current, displayLocale);
+    process.stdout.write(`\n  ${c(C.dim, "mood:")} ${c(C.white + C.bold, initMood)}\n`);
+    await sleep(pause * 2);
+    // ── Rounds ──
+    for (let i = 0; i < SCENARIO.length; i++) {
+        const round = SCENARIO[i];
+        const prevState = { ...engine.getState().current };
+        process.stdout.write("\n");
+        printLine();
+        process.stdout.write(c(C.bold, `  Round ${i + 1}/${SCENARIO.length}`) +
+            c(C.dim, ` │ `) +
+            c(C.yellow, displayLocale === "zh" ? "用户" : "User") + "\n");
+        // User message (display in chosen locale, process in Chinese for classifier accuracy)
+        const displayText = displayLocale === "zh" ? round.display.zh : round.display.en;
+        process.stdout.write(`  ${c(C.dim, ">")} ${c(C.white, `"${displayText}"`)}\n`);
+        await sleep(pause);
+        // Always process Chinese text for best classifier coverage
+        const result = await engine.processInput(round.input);
+        const currState = engine.getState();
+        // Stimulus
+        process.stdout.write(`\n  ${c(C.dim, "stimulus:")} ${c(C.magenta, result.stimulus ?? "none")}\n`);
+        // Chemistry changes
+        process.stdout.write(`\n`);
+        printChemistry(prevState, currState.current, locale);
+        // Emergent mood
+        const mood = describeMood(currState.current, displayLocale);
+        const emotions = detectEmotions(currState.current);
+        process.stdout.write(`\n  ${c(C.dim, "mood:")} ${c(C.bold, mood)}\n`);
+        // Policy context (if non-empty)
+        if (result.policyContext) {
+            process.stdout.write(`  ${c(C.dim, "policy:")} ${c(C.yellow, result.policyContext.slice(0, 80))}\n`);
+        }
+        // Special alerts from policy context
+        if (result.policyContext) {
+            if (result.policyContext.includes("谄媚") || result.policyContext.includes("sycophancy")) {
+                printAlert("ANTI-SYCOPHANCY triggered");
+            }
+            if (result.policyContext.includes("防御") || result.policyContext.includes("defensive")) {
+                printInfo("DEFENSIVE STRATEGY active");
+            }
+        }
+        // Low compliance = pushing back
+        if (result.policyModifiers && result.policyModifiers.compliance < 0.4) {
+            printInfo(`COMPLIANCE: ${result.policyModifiers.compliance.toFixed(2)} (pushing back)`);
+        }
+        // Trait drift check
+        if (currState.traitDrift) {
+            const drifts = Object.entries(currState.traitDrift).filter(([, v]) => typeof v === "number" && Math.abs(v) >= 0.5);
+            if (drifts.length > 0) {
+                const driftStr = drifts.map(([k, v]) => `${k} ${v > 0 ? "+" : ""}${v.toFixed(1)}`).join(", ");
+                printAlert(`TRAIT DRIFT: ${driftStr} (irreversible)`);
+            }
+        }
+        // Drive warnings
+        if (currState.drives) {
+            const low = Object.entries(currState.drives).filter(([, v]) => v < 40);
+            if (low.length > 0) {
+                const driveStr = low.map(([k, v]) => `${k}=${Math.round(v)}`).join(", ");
+                process.stdout.write(`  ${c(C.red, `⚠ low drives: ${driveStr}`)}\n`);
+            }
+        }
+        await sleep(pause);
+    }
+    // ── Final summary ──
+    process.stdout.write("\n");
+    printLine("═");
+    process.stdout.write(c(C.bold, "  Final State\n"));
+    printLine("═");
+    const finalState = engine.getState();
+    process.stdout.write("\n");
+    printChemistry(finalState.current, finalState.current, locale);
+    const finalMood = describeMood(finalState.current, displayLocale);
+    process.stdout.write(`\n  ${c(C.dim, "mood:")} ${c(C.bold, finalMood)}\n`);
+    process.stdout.write(`  ${c(C.dim, "summary:")} ${engine.getStatusSummary()}\n`);
+    // Drives
+    if (finalState.drives) {
+        process.stdout.write(`\n  ${c(C.dim, "drives:")}\n`);
+        for (const [k, v] of Object.entries(finalState.drives)) {
+            const val = Math.round(v);
+            process.stdout.write(`    ${k.padEnd(12)} ${bar(val, 15)} ${val}\n`);
+        }
+    }
+    process.stdout.write("\n");
+    printLine("─");
+    process.stdout.write(c(C.dim, "  Try it yourself: ") +
+        c(C.cyan, "npx psyche-mcp") +
+        c(C.dim, " (configure in Claude Desktop / Cursor / Claude Code)\n"));
+    process.stdout.write(c(C.dim, "  npm: ") +
+        c(C.cyan, "https://www.npmjs.com/package/psyche-ai") + "\n");
+    printLine("─");
+    process.stdout.write("\n");
+}

package/dist/diagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, ChemicalState, StimulusType, InnateDrives } from "./types.js";
+import type { AppraisalAxes, PsycheState, ChemicalState, StimulusType, InnateDrives } from "./types.js";
 export type Severity = "critical" | "warning" | "info";
 export interface DiagnosticIssue {
     id: string;
@@ -13,6 +13,10 @@ export interface SessionMetrics {
     inputCount: number;
     /** How many returned a non-null stimulus */
     classifiedCount: number;
+    /** How many had a non-trivial appraisal hit (excluding taskFocus) */
+    appraisalHitCount: number;
+    /** How many were recognized by either stimulus or appraisal */
+    semanticHitCount: number;
     /** Stimulus distribution */
     stimulusDistribution: Partial<Record<StimulusType, number>>;
     /** Average classification confidence */
@@ -55,19 +59,17 @@ export declare class DiagnosticCollector {
     private metrics;
     private prevChemistry;
     private confidences;
-    /** Consecutive inputs with no classification — for real-time alerting */
-    private consecutiveNone;
-    /** Callback for real-time warnings (set by adapter) */
-    onWarning?: (message: string) => void;
     constructor();
     /** Record a processInput result */
-    recordInput(stimulus: StimulusType | null, confidence: number, chemistry: ChemicalState): void;
+    recordInput(stimulus: StimulusType | null, confidence: number, chemistry: ChemicalState, appraisal?: AppraisalAxes): void;
     /** Record an error */
     recordError(phase: string, error: unknown): void;
     /** Get current session metrics */
     getMetrics(): SessionMetrics;
     /** Get classifier hit rate (0-1) */
     getClassifierRate(): number;
+    /** Get semantic recognition rate (stimulus or appraisal, 0-1) */
+    getSemanticRate(): number;
 }
 export declare function generateReport(state: PsycheState, metrics: SessionMetrics, packageVersion: string): DiagnosticReport;
 export declare function formatReport(report: DiagnosticReport): string;