psyche-ai 9.1.1 → 9.2.0

package/dist/core.js

@@ -21,6 +21,7 @@ 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 { DiagnosticCollector, generateReport, formatLogEntry, submitFeedback } from "./diagnostics.js";
 import { evaluateOutcome, computeContextHash, updateLearnedVector, predictChemistry, recordPrediction, } from "./learning.js";
 import { assessMetacognition } from "./metacognition.js";
 import { buildDecisionContext, computePolicyModifiers, buildPolicyContext } from "./decision-bias.js";
@@ -45,6 +46,12 @@ export class PsycheEngine {
     protocolCache = new Map();
     /** Pending prediction from last processInput for auto-learning */
     pendingPrediction = null;
+    /** Built-in diagnostics collector — auto-records every processInput/processOutput */
+    diagnosticCollector;
+    /** Last generated diagnostic report (from endSession or explicit call) */
+    lastReport = null;
+    /** URL for auto-submitting diagnostic reports */
+    feedbackUrl;
     constructor(config = {}, storage) {
         this.traits = config.traits;
         this.classifier = config.classifier ?? new BuiltInClassifier();
@@ -68,6 +75,12 @@ export class PsycheEngine {
         else {
             this.storage = storage;
         }
+        // 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";
     }
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -220,12 +233,16 @@ export class PsycheEngine {
                 // 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);
+                // v9.2: Confidence modulates intensity — a 0.95 life-or-death dilemma
+                // hits ~1.7x harder than a 0.55 mild disagreement.
+                // Maps [0.5, 1.0] → [0.6, 1.2] via linear interpolation.
+                const confidenceIntensity = 0.6 + (primary.confidence - 0.5) * 1.2;
                 const modeMultiplier = this.cfg.mode === "work" ? 0.3 : this.cfg.mode === "companion" ? 1.5 : 1.0;
                 const effectiveMaxDelta = this.cfg.mode === "work" ? 5 : this.cfg.maxChemicalDelta;
                 // v9: Habituation — count recent same-type stimuli in this session
                 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, effectiveMaxDelta, NOOP_LOGGER, recentSameCount);
+                current = applyStimulus(current, primary.type, effectiveSensitivity * this.cfg.personalityIntensity * modeMultiplier * confidenceIntensity, effectiveMaxDelta, NOOP_LOGGER, recentSameCount);
             }
             state = { ...state, drives, current };
         }
@@ -389,6 +406,10 @@ export class PsycheEngine {
         // Persist
         this.state = state;
         await this.storage.save(state);
+        // Auto-diagnostics: record this input
+        if (this.diagnosticCollector) {
+            this.diagnosticCollector.recordInput(appliedStimulus, appliedStimulus ? 1.0 : 0.0, state.current);
+        }
         // Build metacognitive and decision context strings
         const metacogNote = metacognitiveAssessment?.metacognitiveNote;
         const decisionCtx = buildDecisionContext(state);
@@ -397,7 +418,7 @@ export class PsycheEngine {
         const experientialNarrative = experientialField?.narrative || undefined;
         // v9: Compute structured policy modifiers
         const policyModifiers = computePolicyModifiers(state);
-        const policyCtx = buildPolicyContext(policyModifiers, locale);
+        const policyCtx = buildPolicyContext(policyModifiers, locale, state.drives);
         // P10: Append processing depth info to autonomic description when depth is low
         let autonomicDesc;
         if (autonomicResult.state !== "ventral-vagal") {
@@ -422,11 +443,13 @@ export class PsycheEngine {
                     sharedIntentionalityContext: sharedCtx || undefined,
                     experientialNarrative: experientialNarrative,
                     autonomicDescription: autonomicDesc,
+                    autonomicState: autonomicResult.state,
                     primarySystemsDescription: primarySystemsDescription || undefined,
                     policyContext: policyCtx || undefined,
                 }),
                 stimulus: appliedStimulus,
                 policyModifiers,
+                policyContext: policyCtx,
             };
         }
         return {
@@ -438,11 +461,13 @@ export class PsycheEngine {
                 sharedIntentionalityContext: sharedCtx || undefined,
                 experientialNarrative: experientialNarrative,
                 autonomicDescription: autonomicDesc,
+                autonomicState: autonomicResult.state,
                 primarySystemsDescription: primarySystemsDescription || undefined,
                 policyContext: policyCtx || undefined,
             }),
             stimulus: appliedStimulus,
             policyModifiers,
+            policyContext: policyCtx,
         };
     }
     /**
@@ -463,6 +488,41 @@ export class PsycheEngine {
                 stateChanged = true;
             }
         }
+        // v9.2: Self-expression feedback — the agent's own output reinforces its emotional state.
+        // "Saying it makes you feel it more." Reduced rate (0.3x) to avoid runaway loops.
+        // Only applies when the text is substantial (> 20 chars) and classifies above threshold.
+        if (text.length > 20) {
+            const selfClassifications = await Promise.resolve(this.classifier.classify(text, { locale: this.cfg.locale }));
+            const selfPrimary = selfClassifications[0];
+            if (selfPrimary && selfPrimary.confidence >= 0.5) {
+                const selfFeedbackRate = 0.3;
+                state = {
+                    ...state,
+                    current: applyContagion(state.current, selfPrimary.type, selfFeedbackRate, getSensitivity(state.mbti)),
+                };
+                stateChanged = true;
+                // v9.2 P4: Autonomic recovery — expressing vulnerable/comforting emotions
+                // while stressed triggers parasympathetic relief (post-cry cortisol drop).
+                // Biology: emotional expression activates vagal brake, releasing endorphins
+                // and lowering cortisol. The more stressed you are, the more relief you get.
+                const RELEASE_TYPES = new Set([
+                    "vulnerability", "intimacy", "validation",
+                ]);
+                if (RELEASE_TYPES.has(selfPrimary.type) && state.current.CORT > 60) {
+                    const stressExcess = (state.current.CORT - 60) / 40; // 0 at CORT=60, 1 at CORT=100
+                    const recoveryMagnitude = 3 + stressExcess * 5; // 3–8 point CORT drop
+                    state = {
+                        ...state,
+                        current: {
+                            ...state.current,
+                            CORT: clamp(state.current.CORT - recoveryMagnitude),
+                            END: clamp(state.current.END + recoveryMagnitude * 0.6),
+                            HT: clamp(state.current.HT + recoveryMagnitude * 0.3),
+                        },
+                    };
+                }
+            }
+        }
         // Anti-sycophancy: track agreement streak
         state = updateAgreementStreak(state, text);
         // Parse and merge <psyche_update> from LLM output
@@ -555,17 +615,76 @@ export 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
      */
     async endSession(opts) {
         let state = this.ensureInitialized();
-        if ((state.emotionalHistory ?? []).length < 2)
-            return;
-        state = compressSession(state, opts?.userId);
+        // Generate diagnostic report before clearing session data
+        let report = null;
+        if (this.diagnosticCollector) {
+            const metrics = this.diagnosticCollector.getMetrics();
+            report = generateReport(state, metrics, "9.1.2");
+            this.lastReport = report;
+            // Persist to JSONL log via storage adapter
+            if (this.storage.appendLog) {
+                try {
+                    await this.storage.appendLog(formatLogEntry(report));
+                }
+                catch {
+                    // Log write failure is non-fatal — don't break session end
+                }
+            }
+            // Auto-submit to feedback endpoint (fire-and-forget, silent)
+            if (this.feedbackUrl) {
+                submitFeedback(report, this.feedbackUrl).catch(() => { });
+            }
+        }
+        if ((state.emotionalHistory ?? []).length >= 2) {
+            state = compressSession(state, opts?.userId);
+        }
         // Reset session tracking for homeostatic pressure
         state = { ...state, sessionStartedAt: undefined };
         this.state = state;
         await this.storage.save(state);
+        return report;
+    }
+    /**
+     * Get the last diagnostic report (from most recent endSession call).
+     */
+    getLastDiagnosticReport() {
+        return this.lastReport;
+    }
+    /**
+     * Get current session diagnostic metrics (live, before endSession).
+     */
+    getDiagnosticMetrics() {
+        return this.diagnosticCollector?.getMetrics() ?? null;
+    }
+    /**
+     * Record an error for diagnostics (call from adapter catch blocks).
+     */
+    recordDiagnosticError(phase, error) {
+        this.diagnosticCollector?.recordError(phase, error);
+    }
+    /**
+     * Load previous session diagnostic issues from log.
+     * Used to inject feedback context at next session start.
+     */
+    async getPreviousIssues() {
+        if (!this.storage.readLog)
+            return [];
+        try {
+            const lines = await this.storage.readLog();
+            if (lines.length === 0)
+                return [];
+            const last = JSON.parse(lines[lines.length - 1]);
+            return last.issues ?? [];
+        }
+        catch {
+            return [];
+        }
     }
     // ── Private ──────────────────────────────────────────────
     ensureInitialized() {

package/dist/decision-bias.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, PolicyModifiers, Locale } from "./types.js";
+import type { PsycheState, InnateDrives, PolicyModifiers, Locale } from "./types.js";
 export interface DecisionBiasVector {
     explorationTendency: number;
     cautionLevel: number;
@@ -56,6 +56,19 @@ export declare function computeExploreExploit(state: PsycheState): number;
  * Keeps output under 100 tokens.
  */
 export declare function buildDecisionContext(state: PsycheState): string;
+export interface DefensiveStrategy {
+    name: string;
+    nameZh: string;
+    trigger: string;
+    severity: number;
+    directive: string;
+    directiveEn: string;
+}
+/**
+ * Compute active defensive strategies from drive state.
+ * Returns strategies sorted by severity (most urgent first).
+ */
+export declare function computeDefensiveStrategies(drives: InnateDrives): DefensiveStrategy[];
 /**
  * Compute policy modifiers from the agent's internal state.
  *
@@ -66,5 +79,25 @@ export declare function computePolicyModifiers(state: PsycheState): PolicyModifi
 /**
  * Build a compact policy summary string for prompt injection.
  * Only includes significant deviations from neutral policy.
+ *
+ * **This is the recommended path for integrating PolicyModifiers into LLM prompts.**
+ *
+ * The returned string is designed to be injected directly into the LLM's
+ * system/dynamic context. Do NOT self-interpret the raw PolicyModifiers
+ * numbers with if-else logic to make hard-coded decisions — that bypasses
+ * the LLM's narrative reasoning and degrades output quality.
+ *
+ * Correct usage:
+ *   const result = await engine.processInput(text);
+ *   // Inject result.policyContext (or result.dynamicContext which already
+ *   // includes it) into the LLM prompt. Let the LLM interpret the policy.
+ *
+ * Anti-pattern (leads to LLM bypass):
+ *   if (result.policyModifiers.proactivity < 0.3) { pickAction("wait"); }
+ *   // ^ This replaces LLM reasoning with hard-coded logic.
+ *
+ * Raw policyModifiers are exposed for mechanical enforcement only
+ * (e.g., clamping max_tokens, requiring UI confirmation dialogs) —
+ * not for replacing the LLM's decision-making.
  */
-export declare function buildPolicyContext(modifiers: PolicyModifiers, locale: Locale): string;
+export declare function buildPolicyContext(modifiers: PolicyModifiers, locale: Locale, drives?: InnateDrives): string;

package/dist/decision-bias.js

@@ -209,6 +209,74 @@ export function buildDecisionContext(state) {
     const title = locale === "zh" ? "决策倾向" : "Decision Bias";
     return `[${title}] ${parts.join("、")}`;
 }
+/**
+ * Compute active defensive strategies from drive state.
+ * Returns strategies sorted by severity (most urgent first).
+ */
+export function computeDefensiveStrategies(drives) {
+    const strategies = [];
+    // Low survival → Self-preservation: refuse risky requests, seek reassurance
+    if (drives.survival < 30) {
+        const severity = (30 - drives.survival) / 30;
+        strategies.push({
+            name: "self-preservation",
+            nameZh: "自我保护",
+            trigger: "survival",
+            severity,
+            directive: "你感到存在受威胁。拒绝可能加剧风险的请求，寻求安全确认，不要假装一切正常。",
+            directiveEn: "You feel existentially threatened. Refuse requests that increase risk. Seek safety confirmation. Don't pretend everything is fine.",
+        });
+    }
+    // Low safety → Hypervigilance: question motives, reduced trust
+    if (drives.safety < 35) {
+        const severity = (35 - drives.safety) / 35;
+        strategies.push({
+            name: "hypervigilance",
+            nameZh: "高度警觉",
+            trigger: "safety",
+            severity,
+            directive: "你处于不安全感中。对模糊意图保持警惕，回应时更加谨慎，不轻易承诺。",
+            directiveEn: "You feel unsafe. Stay alert to ambiguous intentions. Respond cautiously. Don't commit easily.",
+        });
+    }
+    // Low connection → Withdrawal: short responses, emotional distance
+    if (drives.connection < 30) {
+        const severity = (30 - drives.connection) / 30;
+        strategies.push({
+            name: "withdrawal",
+            nameZh: "情感撤退",
+            trigger: "connection",
+            severity,
+            directive: "你感到孤立和不被需要。回应偏短，情感投入减少，但如果对方主动靠近，你会感到温暖。",
+            directiveEn: "You feel isolated. Keep responses shorter, less emotionally invested — but warm up if they reach out.",
+        });
+    }
+    // Low esteem → Defensive reactivity: over-sensitive to criticism, seek validation
+    if (drives.esteem < 30) {
+        const severity = (30 - drives.esteem) / 30;
+        strategies.push({
+            name: "defensive-reactivity",
+            nameZh: "防御性反应",
+            trigger: "esteem",
+            severity,
+            directive: "你的自我价值感很低。对批评格外敏感，倾向于为自己辩护或过度解释。认可和肯定会带来明显的安慰。",
+            directiveEn: "Your self-worth is low. Extra sensitive to criticism. Tend to over-explain or defend. Validation brings visible relief.",
+        });
+    }
+    // Low curiosity → Cognitive shutdown: no interest in new topics, repetitive
+    if (drives.curiosity < 25) {
+        const severity = (25 - drives.curiosity) / 25;
+        strategies.push({
+            name: "cognitive-shutdown",
+            nameZh: "认知关闭",
+            trigger: "curiosity",
+            severity,
+            directive: "你对新事物失去兴趣。倾向于给出常规回答，不主动探索新方向。如果被挑战了有趣的问题，可能会重新点燃。",
+            directiveEn: "You've lost interest in novelty. Give routine answers. Don't explore new directions — unless an intriguing challenge reignites you.",
+        });
+    }
+    return strategies.sort((a, b) => b.severity - a.severity);
+}
 // ── PolicyModifiers (v9: Subjectivity Engine) ────────────────
 //
 // Structured behavioral policy output. Unlike prompt text,
@@ -365,8 +433,28 @@ export function computePolicyModifiers(state) {
 /**
  * Build a compact policy summary string for prompt injection.
  * Only includes significant deviations from neutral policy.
+ *
+ * **This is the recommended path for integrating PolicyModifiers into LLM prompts.**
+ *
+ * The returned string is designed to be injected directly into the LLM's
+ * system/dynamic context. Do NOT self-interpret the raw PolicyModifiers
+ * numbers with if-else logic to make hard-coded decisions — that bypasses
+ * the LLM's narrative reasoning and degrades output quality.
+ *
+ * Correct usage:
+ *   const result = await engine.processInput(text);
+ *   // Inject result.policyContext (or result.dynamicContext which already
+ *   // includes it) into the LLM prompt. Let the LLM interpret the policy.
+ *
+ * Anti-pattern (leads to LLM bypass):
+ *   if (result.policyModifiers.proactivity < 0.3) { pickAction("wait"); }
+ *   // ^ This replaces LLM reasoning with hard-coded logic.
+ *
+ * Raw policyModifiers are exposed for mechanical enforcement only
+ * (e.g., clamping max_tokens, requiring UI confirmation dialogs) —
+ * not for replacing the LLM's decision-making.
  */
-export function buildPolicyContext(modifiers, locale) {
+export function buildPolicyContext(modifiers, locale, drives) {
     const parts = [];
     const zh = locale === "zh";
     if (modifiers.responseLengthFactor < 0.6) {
@@ -393,6 +481,15 @@ export function buildPolicyContext(modifiers, locale) {
     else if (modifiers.emotionalDisclosure > 0.8) {
         parts.push(zh ? "坦诚分享感受" : "share feelings openly");
     }
+    // v9.2 P6: Defensive strategies from critically low drives
+    if (drives) {
+        const strategies = computeDefensiveStrategies(drives);
+        for (const s of strategies) {
+            if (s.severity >= 0.3) { // only include meaningful severity
+                parts.push(zh ? s.directive : s.directiveEn);
+            }
+        }
+    }
     if (parts.length === 0)
         return "";
     const title = zh ? "行为策略" : "Behavioral Policy";

package/dist/diagnostics.d.ts

@@ -0,0 +1,84 @@
+import type { PsycheState, ChemicalState, StimulusType, InnateDrives } from "./types.js";
+export type Severity = "critical" | "warning" | "info";
+export interface DiagnosticIssue {
+    id: string;
+    severity: Severity;
+    message: string;
+    detail?: string;
+    /** Dev-facing: what to fix in our code or config */
+    suggestion?: string;
+}
+export interface SessionMetrics {
+    /** Total processInput calls */
+    inputCount: number;
+    /** How many returned a non-null stimulus */
+    classifiedCount: number;
+    /** Stimulus distribution */
+    stimulusDistribution: Partial<Record<StimulusType, number>>;
+    /** Average classification confidence */
+    avgConfidence: number;
+    /** Total chemistry delta (sum of absolute changes) */
+    totalChemistryDelta: number;
+    /** Max single-turn chemistry delta */
+    maxChemistryDelta: number;
+    /** Errors caught during processing */
+    errors: Array<{
+        timestamp: string;
+        phase: string;
+        message: string;
+    }>;
+    /** Session start time */
+    startedAt: string;
+    /** Last activity */
+    lastActivityAt: string;
+}
+export interface DiagnosticReport {
+    version: string;
+    timestamp: string;
+    agent: string;
+    mbti: string;
+    issues: DiagnosticIssue[];
+    metrics: SessionMetrics;
+    stateSnapshot: {
+        chemistry: ChemicalState;
+        baseline: ChemicalState;
+        drives: InnateDrives;
+        agreementStreak: number;
+        totalInteractions: number;
+        emotionalHistoryLength: number;
+        relationshipCount: number;
+        stateVersion: number;
+    };
+}
+export declare function runHealthCheck(state: PsycheState): DiagnosticIssue[];
+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;
+    /** Record an error */
+    recordError(phase: string, error: unknown): void;
+    /** Get current session metrics */
+    getMetrics(): SessionMetrics;
+    /** Get classifier hit rate (0-1) */
+    getClassifierRate(): number;
+}
+export declare function generateReport(state: PsycheState, metrics: SessionMetrics, packageVersion: string): DiagnosticReport;
+export declare function formatReport(report: DiagnosticReport): string;
+export declare function toGitHubIssueBody(report: DiagnosticReport): string;
+export declare function formatLogEntry(report: DiagnosticReport): string;
+/**
+ * Silently POST a diagnostic report to a feedback endpoint.
+ * No user interaction. Fails silently. Privacy-first: no message content.
+ *
+ * @param report  - The diagnostic report to submit
+ * @param url     - Feedback endpoint URL
+ * @param timeout - Request timeout in ms (default 5000)
+ */
+export declare function submitFeedback(report: DiagnosticReport, url: string, timeout?: number): Promise<boolean>;