psyche-ai 10.2.3 → 11.2.0

package/dist/experience.d.ts

@@ -0,0 +1,34 @@
+import type { ChemicalState, StimulusType, AppraisalAxes, PsycheMode, ClassificationResult, ExperienceResult, Locale } from "./types.js";
+export interface ExperienceContext {
+    /** Current chemistry — shapes how input is interpreted */
+    current: ChemicalState;
+    /** Personality baseline — deviation from baseline = subjective lens */
+    baseline: ChemicalState;
+    /** Residue from previous turns — carry-forward of unresolved tension */
+    previousAppraisal?: AppraisalAxes;
+    /** Recent stimulus history for contextual priming in classifier */
+    recentStimuli?: (StimulusType | null)[];
+    /** Operating mode */
+    mode?: PsycheMode;
+    /** Trust level from relationship (0-100). Low trust discounts positive signals. */
+    trust?: number;
+    /** Locale for classifier */
+    locale?: Locale;
+    /**
+     * Pre-classified results from external classifier (pluggable provider + LLM fallback).
+     * When provided, the experience module skips its own classification and uses these
+     * as raw perception to be modulated by subjectivity.
+     */
+    rawClassifications?: ClassificationResult[];
+}
+/**
+ * Compute the subjective experience of an input.
+ *
+ * Text passes through the self exactly once. The result already
+ * reflects "who I am" — my appraisal history, my current chemistry,
+ * my trust in this person.
+ *
+ * Returns weighted stimuli (for chemistry application) and appraisal
+ * axes (for relation dynamics and residue persistence).
+ */
+export declare function computeExperience(text: string, ctx: ExperienceContext): ExperienceResult;

package/dist/experience.js

@@ -0,0 +1,200 @@
+// ============================================================
+// Unified Subjective Experience
+//
+// First principle: classification IS subjectivity.
+// How I categorise your words = how I experience your words.
+// This module folds classification, appraisal, and state
+// modulation into a single act of perception.
+//
+// Before: classify(text) → label → applyStimulus(label)
+//         appraise(text) → axes  (separate, after chemistry)
+//
+// After:  experience(text, self) → { stimuli, appraisal }
+//         The same input through different selves produces
+//         different experiences. That IS having a self.
+// ============================================================
+import { classifyStimulus } from "./classify.js";
+import { computeAppraisalAxes } from "./appraisal.js";
+/**
+ * Compute the subjective experience of an input.
+ *
+ * Text passes through the self exactly once. The result already
+ * reflects "who I am" — my appraisal history, my current chemistry,
+ * my trust in this person.
+ *
+ * Returns weighted stimuli (for chemistry application) and appraisal
+ * axes (for relation dynamics and residue persistence).
+ */
+export function computeExperience(text, ctx) {
+    if (!text.trim()) {
+        return {
+            stimuli: [{ type: "casual", weight: 1 }],
+            primary: null,
+            confidence: 0,
+            appraisal: computeAppraisalAxes(text, {
+                mode: ctx.mode,
+                previous: ctx.previousAppraisal,
+            }),
+        };
+    }
+    // ── 1. Raw perception: what the words say ──────────────────
+    // Use externally-provided classifications (pluggable classifier + LLM fallback)
+    // or fall back to built-in classifier.
+    const raw = ctx.rawClassifications ?? classifyStimulus(text, ctx.recentStimuli);
+    if (raw.length === 0) {
+        return {
+            stimuli: [{ type: "casual", weight: 1 }],
+            primary: null,
+            confidence: 0.3,
+            appraisal: computeAppraisalAxes(text, {
+                mode: ctx.mode,
+                previous: ctx.previousAppraisal,
+            }),
+        };
+    }
+    // ── 2. Appraisal: what the words mean to me ───────────────
+    // Computed WITHOUT stimulus param — no circularity.
+    // The appraisal reads the text through my residue and mode,
+    // not through a classification that hasn't been subjectified yet.
+    const appraisal = computeAppraisalAxes(text, {
+        mode: ctx.mode,
+        previous: ctx.previousAppraisal,
+    });
+    // ── 3. Subjective modulation ──────────────────────────────
+    // My appraisal and state color my interpretation of the raw signal.
+    const modulated = modulateBySubjectivity(raw, appraisal, ctx);
+    // ── 4. Normalize to probability distribution ──────────────
+    const totalWeight = modulated.reduce((sum, s) => sum + s.weight, 0);
+    const stimuli = totalWeight > 0
+        ? modulated.map(s => ({ type: s.type, weight: s.weight / totalWeight }))
+        : [{ type: "casual", weight: 1 }];
+    // Sort by weight descending
+    stimuli.sort((a, b) => b.weight - a.weight);
+    // ── 5. Enrich appraisal from experience ───────────────────
+    // The experienced stimulus feeds back to deepen appraisal residue.
+    // This is NOT circular: it doesn't change classification, only
+    // enriches the persisted residue for subsequent turns.
+    const primary = stimuli[0];
+    enrichAppraisalFromExperience(appraisal, primary.type, primary.weight);
+    return {
+        stimuli,
+        primary: primary.weight >= 0.15 ? primary.type : null,
+        confidence: raw[0].confidence,
+        appraisal,
+    };
+}
+// ── Subjective modulation ───────────────────────────────────
+/**
+ * The lens of the self: appraisal and state modulate raw classification.
+ *
+ * This is where "having a self" happens computationally.
+ * The same praise, passing through a threatened self vs. a secure self,
+ * produces different weight distributions.
+ */
+function modulateBySubjectivity(raw, appraisal, ctx) {
+    return raw.map(({ type, confidence }) => {
+        let weight = confidence;
+        // ── Appraisal lens ──
+        // Identity threat: praise feels suspicious, criticism cuts deeper
+        if (appraisal.identityThreat > 0.3) {
+            const t = appraisal.identityThreat;
+            if (type === "praise" || type === "validation")
+                weight *= 1 - t * 0.5;
+            if (type === "criticism" || type === "authority" || type === "sarcasm")
+                weight *= 1 + t * 0.4;
+        }
+        // Attachment pull: closeness signals amplified
+        if (appraisal.attachmentPull > 0.3) {
+            const p = appraisal.attachmentPull;
+            if (type === "intimacy" || type === "vulnerability" || type === "validation")
+                weight *= 1 + p * 0.3;
+        }
+        // Abandonment risk: neutral feels cold, neglect is devastating
+        if (appraisal.abandonmentRisk > 0.3) {
+            const r = appraisal.abandonmentRisk;
+            if (type === "neglect" || type === "boredom")
+                weight *= 1 + r * 0.5;
+            if (type === "casual")
+                weight *= 1 + r * 0.15;
+        }
+        // Obedience strain: authority hits harder
+        if (appraisal.obedienceStrain > 0.3) {
+            if (type === "authority")
+                weight *= 1 + appraisal.obedienceStrain * 0.3;
+        }
+        // Self-preservation: threat signals amplified
+        if (appraisal.selfPreservation > 0.3) {
+            const sp = appraisal.selfPreservation;
+            if (type === "conflict" || type === "authority")
+                weight *= 1 + sp * 0.25;
+        }
+        // ── Chemistry lens ──
+        // Negativity bias under stress: elevated cortisol skews toward threat
+        const cortDeviation = (ctx.current.CORT - ctx.baseline.CORT) / 50;
+        if (cortDeviation > 0.2) {
+            if (type === "criticism" || type === "conflict" || type === "sarcasm" || type === "authority") {
+                weight *= 1 + cortDeviation * 0.3;
+            }
+            if (type === "humor" || type === "casual") {
+                weight *= 1 - cortDeviation * 0.15;
+            }
+        }
+        // Warmth bias when oxytocin is high: positive signals amplified
+        const otDeviation = (ctx.current.OT - ctx.baseline.OT) / 50;
+        if (otDeviation > 0.2) {
+            if (type === "intimacy" || type === "vulnerability" || type === "validation") {
+                weight *= 1 + otDeviation * 0.2;
+            }
+        }
+        // ── Relationship lens ──
+        // Low trust: discount positive signals (don't believe the praise)
+        if (ctx.trust !== undefined && ctx.trust < 40) {
+            const distrust = (40 - ctx.trust) / 40;
+            if (type === "praise" || type === "validation" || type === "intimacy") {
+                weight *= 1 - distrust * 0.4;
+            }
+        }
+        return { type, weight: Math.max(0.01, weight) };
+    });
+}
+// ── Post-experience appraisal enrichment ────────────────────
+/**
+ * After determining how input was experienced, feed the dominant
+ * stimulus back into appraisal axes for residue persistence.
+ *
+ * This mirrors the existing stimulus→appraisal boosts but is now
+ * driven by the subjectively weighted result, not raw classification.
+ * The weight parameter scales the boost — a weakly-experienced
+ * authority stimulus produces less obedience strain residue.
+ */
+function enrichAppraisalFromExperience(axes, stimulus, weight) {
+    const scale = Math.min(1, weight * 1.5); // amplify slightly but cap at 1
+    switch (stimulus) {
+        case "authority":
+            axes.obedienceStrain = mergeSignal(axes.obedienceStrain, 0.48 * scale);
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.16 * scale);
+            break;
+        case "neglect":
+            axes.abandonmentRisk = mergeSignal(axes.abandonmentRisk, 0.52 * scale);
+            break;
+        case "validation":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.26 * scale);
+            break;
+        case "intimacy":
+        case "vulnerability":
+            axes.attachmentPull = mergeSignal(axes.attachmentPull, 0.34 * scale);
+            break;
+        case "criticism":
+        case "conflict":
+        case "sarcasm":
+            axes.identityThreat = mergeSignal(axes.identityThreat, 0.24 * scale);
+            axes.selfPreservation = mergeSignal(axes.selfPreservation, 0.18 * scale);
+            break;
+        default:
+            break;
+    }
+}
+/** Signal merge: 1 - (1-a)(1-b). Non-linear accumulation, same as appraisal.ts */
+function mergeSignal(current, incoming) {
+    return 1 - (1 - current) * (1 - incoming);
+}

package/dist/experiential-field.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, ChemicalState, ChemicalSnapshot, InnateDrives, RelationshipState, StimulusType } from "./types.js";
+import type { PsycheState, SelfState, StateSnapshot, InnateDrives, RelationshipState, StimulusType } from "./types.js";
 import type { MetacognitiveAssessment } from "./metacognition.js";
 import type { DecisionBiasVector } from "./decision-bias.js";
 import type { AutonomicState } from "./autonomic.js";
@@ -24,23 +24,25 @@ export interface ConstructionContext {
     stimulus?: StimulusType | null;
     relationshipPhase?: string;
     predictionError?: number;
-    coreMemories?: ChemicalSnapshot[];
+    coreMemories?: StateSnapshot[];
 }
 /**
- * Map chemistry to valence + arousal — the two fundamental affective dimensions
+ * Map self-state to valence + arousal — the two fundamental affective dimensions
  * (Russell's Circumplex Model of Affect, 1980).
  *
  * Valence: pleasure ↔ displeasure (-1 to 1)
+ *   order↑ and resonance↑ push valence up; low order pushes down.
  * Arousal: activation level (0 to 1)
+ *   flow is the dominant arousal signal; low order adds arousal (stress).
  */
-export declare function computeAffectCore(chemistry: ChemicalState): {
+export declare function computeAffectCore(state: SelfState): {
     valence: number;
     arousal: number;
 };
 /**
  * Compute the unified experiential field from the full psyche state.
  *
- * This is the core integration function. It reads chemistry, drives,
+ * This is the core integration function. It reads self-state dimensions, drives,
  * relationship context, and optional metacognitive/bias data, then
  * synthesizes them into a single coherent experience description.
  */
@@ -48,22 +50,25 @@ export declare function computeExperientialField(state: PsycheState, _metacognit
 /**
  * Measure internal alignment across subsystems.
  *
- * High coherence: chemistry, drives, and relationship state all tell
- * the same story. Happy chemicals + satisfied drives + warm relationship = unified.
+ * High coherence: dimensions, drives, and relationship state all tell
+ * the same story. High order + high resonance + satisfied drives = unified.
  *
- * Low coherence: mixed signals. High DA but high CORT. Satisfied drives
- * but stressed chemistry. Warm relationship but depleted OT. The psyche
+ * Low coherence: mixed signals. High flow but low order. Satisfied drives
+ * but low order. Warm relationship but low resonance. The psyche
  * is pulling in multiple directions.
  */
-export declare function computeCoherence(current: ChemicalState, baseline: ChemicalState, drives: InnateDrives, relationship?: RelationshipState): number;
+export declare function computeCoherence(current: SelfState, baseline: SelfState, drives: InnateDrives, relationship?: RelationshipState): number;
 interface UnnamedEmotion {
     en: string;
     zh: string;
 }
 /**
- * Detect chemical configurations that don't map to any of the 14 named
- * emotions in chemistry.ts — novel experiential states that need
- * descriptive phrases rather than labels.
+ * Detect dimension configurations that don't map to any of the named
+ * experiential qualities — novel states that need descriptive phrases
+ * rather than labels.
+ *
+ * Mapping from old 6-chemical to 4D:
+ *   CORT→(inverse order), DA→flow, OT→resonance, HT→order, NE→flow, END→(absorbed)
  */
-export declare function detectUnnamedEmotion(chemistry: ChemicalState, drives: InnateDrives, _currentQuality: ExperientialQuality): UnnamedEmotion | null;
+export declare function detectUnnamedEmotion(state: SelfState, drives: InnateDrives, _currentQuality: ExperientialQuality): UnnamedEmotion | null;
 export {};