psyche-ai 10.2.4 → 11.3.0

package/dist/attachment.js

@@ -1,14 +1,5 @@
 // ============================================================
-// Attachment Dynamics — Bowlby-inspired attachment formation
-//
-// Models relationship attachment through interaction patterns:
-//   1. AttachmentModel    — style classification + strength tracking
-//   2. SeparationAnxiety  — absence effects on chemistry
-//   3. ReunionEffect      — return effects on chemistry
-//
-// Attachment style emerges from interaction history, not from
-// configuration. Consistent positive interaction → secure.
-// Inconsistency → anxious. Rejection/neglect → avoidant.
+// Attachment Dynamics — v11: effects in 4D self-state
 // ============================================================
 // ── Defaults ─────────────────────────────────────────────────
 export const DEFAULT_ATTACHMENT = {
@@ -30,51 +21,32 @@ const NEGATIVE_STIMULI = new Set([
 const REJECTION_STIMULI = new Set([
     "neglect", "authority", "boredom",
 ]);
-// EMA smoothing factor: weight given to new observation
 const EMA_ALPHA = 0.15;
 // ── 1. AttachmentModel ──────────────────────────────────────
-/**
- * Determine attachment style from scores.
- */
 function determineStyle(securityScore, anxietyScore, avoidanceScore) {
-    // Disorganized: both anxiety and avoidance elevated
-    if (anxietyScore > 50 && avoidanceScore > 50) {
+    if (anxietyScore > 50 && avoidanceScore > 50)
         return "disorganized";
-    }
-    // Anxious: high anxiety
-    if (anxietyScore > 60) {
+    if (anxietyScore > 60)
         return "anxious";
-    }
-    // Avoidant: high avoidance
-    if (avoidanceScore > 60) {
+    if (avoidanceScore > 60)
         return "avoidant";
-    }
-    // Secure: high security, low anxiety, low avoidance
-    if (securityScore > 60 && anxietyScore < 40 && avoidanceScore < 40) {
+    if (securityScore > 60 && anxietyScore < 40 && avoidanceScore < 40)
         return "secure";
-    }
-    // Default to current trajectory — mild insecurity stays secure
     if (securityScore >= 50)
         return "secure";
     if (anxietyScore > avoidanceScore)
         return "anxious";
     return "avoidant";
 }
-/**
- * Update attachment based on interaction outcome.
- */
 export function updateAttachment(attachment, stimulus, outcomeScore) {
     const result = { ...attachment };
-    // Strength increases slowly with interaction count
     result.interactionCount = attachment.interactionCount + 1;
     result.strength = Math.min(100, attachment.strength + 1);
     result.lastInteractionAt = new Date().toISOString();
     if (stimulus === null) {
-        // No stimulus — just update count/strength, reclassify
         result.style = determineStyle(result.securityScore, result.anxietyScore, result.avoidanceScore);
         return result;
     }
-    // SecurityScore: EMA with positive/negative stimuli
     const isPositive = POSITIVE_STIMULI.has(stimulus);
     const isNegative = NEGATIVE_STIMULI.has(stimulus);
     if (isPositive) {
@@ -85,107 +57,88 @@ export function updateAttachment(attachment, stimulus, outcomeScore) {
         const target = Math.max(0, result.securityScore - 5);
         result.securityScore = result.securityScore * (1 - EMA_ALPHA) + target * EMA_ALPHA;
     }
-    // AnxietyScore: increases with inconsistency (rapid alternation between positive and negative)
-    // We detect inconsistency by checking if outcomeScore diverges from the security trend
     const expectedDirection = result.securityScore > 50 ? 1 : -1;
     const actualDirection = outcomeScore >= 0 ? 1 : -1;
     const isInconsistent = expectedDirection !== actualDirection;
     if (isInconsistent) {
-        // Inconsistency → anxiety rises
         const anxietyTarget = Math.min(100, result.anxietyScore + 8);
         result.anxietyScore = result.anxietyScore * (1 - EMA_ALPHA) + anxietyTarget * EMA_ALPHA;
     }
     else {
-        // Consistency → anxiety decreases
         const anxietyTarget = Math.max(0, result.anxietyScore - 3);
         result.anxietyScore = result.anxietyScore * (1 - EMA_ALPHA) + anxietyTarget * EMA_ALPHA;
     }
-    // AvoidanceScore: increases with rejection/neglect stimuli
     if (REJECTION_STIMULI.has(stimulus)) {
         const avoidTarget = Math.min(100, result.avoidanceScore + 6);
         result.avoidanceScore = result.avoidanceScore * (1 - EMA_ALPHA) + avoidTarget * EMA_ALPHA;
     }
     else if (isPositive) {
-        // Positive interactions reduce avoidance
         const avoidTarget = Math.max(0, result.avoidanceScore - 3);
         result.avoidanceScore = result.avoidanceScore * (1 - EMA_ALPHA) + avoidTarget * EMA_ALPHA;
     }
-    // Clamp all scores
     result.securityScore = Math.max(0, Math.min(100, result.securityScore));
     result.anxietyScore = Math.max(0, Math.min(100, result.anxietyScore));
     result.avoidanceScore = Math.max(0, Math.min(100, result.avoidanceScore));
-    // Determine style
     result.style = determineStyle(result.securityScore, result.anxietyScore, result.avoidanceScore);
     return result;
 }
-// ── 2. SeparationAnxiety ────────────────────────────────────
-/**
- * Compute chemistry effects of absence based on attachment.
- * Called when time since last interaction is significant.
- */
+// ── 2. SeparationEffect (4D) ────────────────────────────────
 export function computeSeparationEffect(attachment, minutesSinceLastInteraction) {
-    // No effect for short absence or weak attachment
     if (minutesSinceLastInteraction < 60 || attachment.strength < 20) {
         return null;
     }
     const hours = minutesSinceLastInteraction / 60;
-    // Intensity scales with attachment strength and time (logarithmic growth, capped at 1)
     const baseIntensity = (attachment.strength / 100) * Math.min(1, Math.log2(hours + 1) / 5);
     switch (attachment.style) {
         case "secure": {
-            // Mild longing after 24h
             if (hours < 24)
                 return null;
             const intensity = baseIntensity * 0.5;
             return {
-                chemistryDelta: {
-                    OT: -5 * intensity,
-                    DA: -3 * intensity,
+                stateDelta: {
+                    resonance: -5 * intensity,
+                    order: -3 * intensity,
                 },
                 description: "gentle longing from sustained absence",
                 intensity: Math.min(1, intensity),
             };
         }
         case "anxious": {
-            // Distress after 4h, grows with time
             if (hours < 4)
                 return null;
             const intensity = baseIntensity * 1.5;
-            // OT oscillation: represented as net negative with anxiety
             return {
-                chemistryDelta: {
-                    CORT: 10 * intensity,
-                    OT: -5 * intensity,
-                    NE: 8 * intensity,
-                    DA: -3 * intensity,
+                stateDelta: {
+                    resonance: -8 * intensity,
+                    order: -10 * intensity,
+                    boundary: -5 * intensity,
+                    flow: +5 * intensity,
                 },
                 description: "anxious distress from absence — fear of abandonment",
                 intensity: Math.min(1, intensity),
             };
         }
         case "avoidant": {
-            // Relief initially, discomfort after 48h
             if (hours < 48)
                 return null;
             const intensity = baseIntensity * 0.4;
             return {
-                chemistryDelta: {
-                    OT: -3 * intensity,
+                stateDelta: {
+                    resonance: -3 * intensity,
                 },
                 description: "subtle discomfort surfacing through avoidant defense",
                 intensity: Math.min(1, intensity),
             };
         }
         case "disorganized": {
-            // Conflicting signals
             if (hours < 4)
                 return null;
             const intensity = baseIntensity * 1.0;
             return {
-                chemistryDelta: {
-                    CORT: 5 * intensity,
-                    OT: 5 * intensity,
-                    NE: 3 * intensity,
+                stateDelta: {
+                    resonance: +5 * intensity,
+                    order: -5 * intensity,
+                    flow: +3 * intensity,
                 },
                 description: "conflicting signals — wanting closeness and fearing it",
                 intensity: Math.min(1, intensity),
@@ -193,48 +146,43 @@ export function computeSeparationEffect(attachment, minutesSinceLastInteraction)
         }
     }
 }
-// ── 3. ReunionEffect ────────────────────────────────────────
-/**
- * Compute chemistry effects when reuniting after absence.
- */
+// ── 3. ReunionEffect (4D) ───────────────────────────────────
 export function computeReunionEffect(attachment, minutesSinceLastInteraction) {
-    // No effect for short absence or weak attachment
     if (minutesSinceLastInteraction < 60 || attachment.strength < 20) {
         return null;
     }
     const hours = minutesSinceLastInteraction / 60;
-    // Scale with time (logarithmic) and attachment strength
     const scale = (attachment.strength / 100) * Math.min(1, Math.log2(hours + 1) / 5);
     switch (attachment.style) {
         case "secure": {
-            // Warm reunion
+            // Warm reunion: resonance↑, order↑
             return {
-                OT: 8 * scale,
-                DA: 5 * scale,
-                END: 3 * scale,
+                resonance: 8 * scale,
+                order: 5 * scale,
+                flow: 3 * scale,
             };
         }
         case "anxious": {
-            // Intense but short-lived relief (CORT still elevated)
+            // Intense relief but order still shaky
             return {
-                OT: 15 * scale,
-                DA: 10 * scale,
-                CORT: 5 * scale,
+                resonance: 15 * scale,
+                flow: 8 * scale,
+                order: -3 * scale,
             };
         }
         case "avoidant": {
-            // Cautious re-engagement
+            // Cautious: boundary stays high, mild flow increase
             return {
-                OT: 3 * scale,
-                NE: 5 * scale,
+                boundary: 3 * scale,
+                flow: 5 * scale,
             };
         }
         case "disorganized": {
-            // Mixed signals
+            // Mixed
             return {
-                OT: 5 * scale,
-                CORT: 5 * scale,
-                NE: 5 * scale,
+                resonance: 5 * scale,
+                order: -3 * scale,
+                flow: 5 * scale,
             };
         }
     }

package/dist/autonomic.d.ts

@@ -1,4 +1,4 @@
-import type { ChemicalState, InnateDrives, Locale, EnergyBudgets } from "./types.js";
+import type { SelfState, InnateDrives, Locale, EnergyBudgets } from "./types.js";
 export type AutonomicState = "ventral-vagal" | "sympathetic" | "dorsal-vagal";
 export interface AutonomicResult {
     state: AutonomicState;
@@ -17,7 +17,7 @@ export interface AutonomicTransition {
  * Compute the raw autonomic state from chemistry and drives.
  * No transition inertia — returns the "target" state.
  */
-export declare function computeAutonomicState(chemistry: ChemicalState, drives: InnateDrives): AutonomicState;
+export declare function computeAutonomicState(state: SelfState, drives: InnateDrives): AutonomicState;
 /**
  * Gate emotions based on autonomic state.
  * - Ventral vagal: all emotions pass through
@@ -44,7 +44,7 @@ export declare function describeAutonomicState(state: AutonomicState, locale: Lo
  * This is a natural extension of autonomic state: you can't deeply reflect
  * when your nervous system is in fight/flight/freeze mode.
  */
-export declare function computeProcessingDepth(autonomicState: AutonomicState, chemistry: ChemicalState, baseline: ChemicalState, energyBudgets?: EnergyBudgets): {
+export declare function computeProcessingDepth(autonomicState: AutonomicState, current: SelfState, baseline: SelfState, energyBudgets?: EnergyBudgets): {
     depth: number;
     skippedStages: string[];
 };
@@ -56,4 +56,4 @@ export declare function computeProcessingDepth(autonomicState: AutonomicState, c
  *
  * Includes P10 processing depth (dual-process cognitive gating).
  */
-export declare function computeAutonomicResult(chemistry: ChemicalState, drives: InnateDrives, previousState: AutonomicState | null, minutesSinceLastUpdate: number, locale?: Locale, baseline?: ChemicalState, energyBudgets?: EnergyBudgets): AutonomicResult;
+export declare function computeAutonomicResult(current: SelfState, drives: InnateDrives, previousState: AutonomicState | null, minutesSinceLastUpdate: number, locale?: Locale, baseline?: SelfState, energyBudgets?: EnergyBudgets): AutonomicResult;

package/dist/autonomic.js

@@ -2,12 +2,13 @@
 // Autonomic Nervous System — Polyvagal Theory Implementation
 // ============================================================
 //
-// Maps chemical state + innate drives to autonomic nervous system
+// Maps self-state dimensions + innate drives to autonomic nervous system
 // states based on Stephen Porges' Polyvagal Theory:
 //
 // - Ventral vagal: social engagement, safety (default)
 // - Sympathetic: fight/flight mobilization
 // - Dorsal vagal: freeze/shutdown/collapse
+import { DIMENSION_KEYS } from "./types.js";
 // ── i18n Strings ─────────────────────────────────────────────
 const AUTONOMIC_STRINGS = {
     zh: {
@@ -65,32 +66,36 @@ const DORSAL_ALLOWED = new Set([
  * Compute the raw autonomic state from chemistry and drives.
  * No transition inertia — returns the "target" state.
  */
-export function computeAutonomicState(chemistry, drives) {
-    const { CORT, NE, DA } = chemistry;
+export function computeAutonomicState(state, drives) {
+    const { order, flow, boundary } = state;
     const { survival, safety, connection } = drives;
+    // Inverse order = stress (low order = high entropy/distress)
+    const stress = 100 - order;
+    // Flow maps to arousal/activation
+    const arousal = flow;
     // Count drives that are critically low (< 20)
     const lowDriveCount = [survival, safety, connection, drives.esteem, drives.curiosity]
         .filter((d) => d < 20).length;
     // ── Dorsal vagal check (freeze/shutdown) ──
     // Very high stress + low arousal + low motivation = collapse
-    if (CORT >= 80 && NE <= 25 && DA <= 20) {
+    if (stress >= 80 && arousal <= 25 && flow <= 20) {
         return "dorsal-vagal";
     }
-    // Multiple critically low drives with depleted chemistry
-    if (lowDriveCount >= 3 && CORT >= 70 && (NE <= 30 || DA <= 20)) {
+    // Multiple critically low drives with depleted state
+    if (lowDriveCount >= 3 && stress >= 70 && (arousal <= 30 || flow <= 20)) {
         return "dorsal-vagal";
     }
     // ── Sympathetic check (fight/flight) ──
     // High stress + high arousal
-    if (CORT >= 65 && NE >= 65) {
+    if (stress >= 65 && arousal >= 65) {
         return "sympathetic";
     }
-    // Either axis extreme: one chemical dominating can still trigger mobilization
-    if (CORT + NE >= 140 && CORT >= 50 && NE >= 50) {
+    // Either axis extreme: one dimension dominating can still trigger mobilization
+    if (stress + arousal >= 140 && stress >= 50 && arousal >= 50) {
         return "sympathetic";
     }
     // Very low survival or safety drive with elevated stress
-    if ((survival < 20 || safety < 20) && CORT >= 55 && NE >= 55) {
+    if ((survival < 20 || safety < 20) && stress >= 55 && arousal >= 55) {
         return "sympathetic";
     }
     // ── Default: Ventral vagal (social engagement/safety) ──
@@ -135,30 +140,29 @@ export function describeAutonomicState(state, locale) {
  * This is a natural extension of autonomic state: you can't deeply reflect
  * when your nervous system is in fight/flight/freeze mode.
  */
-export function computeProcessingDepth(autonomicState, chemistry, baseline, energyBudgets) {
-    const { CORT } = chemistry;
-    // Chemical deviation from baseline (0-1)
+export function computeProcessingDepth(autonomicState, current, baseline, energyBudgets) {
+    const stress = 100 - current.order;
+    // State deviation from baseline (0-1)
     let totalDeviation = 0;
-    const keys = ["DA", "HT", "CORT", "OT", "NE", "END"];
-    for (const k of keys) {
-        totalDeviation += Math.abs(chemistry[k] - baseline[k]);
+    for (const k of DIMENSION_KEYS) {
+        totalDeviation += Math.abs(current[k] - baseline[k]);
     }
-    const chemDeviation = Math.min(1, totalDeviation / 600);
+    const stateDeviation = Math.min(1, totalDeviation / 400);
     // Base depth from autonomic state
     let baseDepth;
     if (autonomicState === "dorsal-vagal") {
         baseDepth = 0;
     }
     else if (autonomicState === "sympathetic") {
-        // Higher CORT in sympathetic = less cognitive resource
-        baseDepth = CORT >= 60 ? 0.15 : 0.35;
+        // Higher stress in sympathetic = less cognitive resource
+        baseDepth = stress >= 60 ? 0.15 : 0.35;
     }
     else {
         // ventral-vagal: safe, most cognitive resource available
         baseDepth = 0.85;
     }
-    // Chemical deviation reduces depth (strong emotions = less reflection)
-    let depth = Math.max(0, Math.min(1, baseDepth * (1 - chemDeviation * 0.5)));
+    // State deviation reduces depth (strong shifts = less reflection)
+    let depth = Math.max(0, Math.min(1, baseDepth * (1 - stateDeviation * 0.5)));
     // v9: Low attention energy further reduces processing depth
     if (energyBudgets && energyBudgets.attention < 30) {
         const attentionPenalty = (30 - energyBudgets.attention) / 30 * 0.3;
@@ -186,12 +190,12 @@ export function computeProcessingDepth(autonomicState, chemistry, baseline, ener
  *
  * Includes P10 processing depth (dual-process cognitive gating).
  */
-export function computeAutonomicResult(chemistry, drives, previousState, minutesSinceLastUpdate, locale = "zh", baseline, energyBudgets) {
-    const targetState = computeAutonomicState(chemistry, drives);
-    const effectiveBaseline = baseline ?? { DA: 50, HT: 50, CORT: 50, OT: 50, NE: 50, END: 50 };
+export function computeAutonomicResult(current, drives, previousState, minutesSinceLastUpdate, locale = "zh", baseline, energyBudgets) {
+    const targetState = computeAutonomicState(current, drives);
+    const effectiveBaseline = baseline ?? { order: 50, flow: 50, boundary: 50, resonance: 50 };
     // Helper to build full result with processing depth
     const buildResult = (state, transitionProgress) => {
-        const { depth, skippedStages } = computeProcessingDepth(state, chemistry, effectiveBaseline, energyBudgets);
+        const { depth, skippedStages } = computeProcessingDepth(state, current, effectiveBaseline, energyBudgets);
         return {
             state,
             transitionProgress,

package/dist/chemistry.d.ts

@@ -1,41 +1,67 @@
-import { type ChemicalState, type StimulusType, type StimulusVector, type EmotionPattern, type Locale } from "./types.js";
-export declare const STIMULUS_VECTORS: Record<StimulusType, StimulusVector>;
+import { type SelfState, type StimulusType, type ImpactVector, type EmotionPattern, type Locale } from "./types.js";
+export declare const STIMULUS_VECTORS: Record<StimulusType, ImpactVector>;
 export declare const EMOTION_PATTERNS: EmotionPattern[];
 /** Clamp a value to [0, 100] */
 export declare function clamp(v: number): number;
 /**
  * Apply time-based decay: pull current values toward baseline.
  *
- *   decayed = baseline + (current - baseline) * factor^(minutes/60)
+ * Each dimension decays at its own rate (order fastest, boundary slowest).
+ * decayRateModifiers alter speed per dimension (>1 = slower, <1 = faster).
  */
-export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number, decayRateModifiers?: Partial<Record<keyof ChemicalState, number>>): ChemicalState;
+export declare function applyDecay(current: SelfState, baseline: SelfState, minutesElapsed: number, decayRateModifiers?: Partial<Record<keyof SelfState, number>>): SelfState;
 /**
- * Apply a stimulus to the current state.
- * Respects emotional inertia (maxDelta) and personality sensitivity.
- * Logs a warning for unknown stimulus types.
+ * Mutual influence between dimensions.
+ *
+ * Dimensions are not independent — they affect each other:
+ * - Collapsing order drags boundary down (incoherent self loses distinction)
+ * - High flow raises order (engagement creates coherence)
+ * - High resonance stabilizes boundary (attunement reinforces self)
+ * - Low boundary amplifies order loss (dissolution spiral)
+ */
+export declare function applyMutualInfluence(state: SelfState, baseline: SelfState): SelfState;
+/**
+ * Apply an impact vector to the current state.
+ * Core substrate-independent function — operates on 4D vectors, not labels.
+ * Respects inertia (maxDelta), sensitivity, and habituation.
  */
-export declare function applyStimulus(current: ChemicalState, stimulus: StimulusType, sensitivity: number, maxDelta: number, logger?: {
+export declare function applyImpact(current: SelfState, vector: ImpactVector, sensitivity: number, maxDelta: number, recentSameCount?: number): SelfState;
+/**
+ * Apply a labeled stimulus to the current state.
+ * Perception-layer convenience — looks up the ImpactVector from STIMULUS_VECTORS.
+ */
+export declare function applyStimulus(current: SelfState, stimulus: StimulusType, sensitivity: number, maxDelta: number, logger?: {
     warn: (msg: string) => void;
-}, recentSameCount?: number): ChemicalState;
+}, recentSameCount?: number): SelfState;
+/**
+ * Apply emotional contagion from a labeled stimulus.
+ */
+export declare function applyContagion(agentState: SelfState, detectedUserEmotion: StimulusType, contagionRate: number, sensitivity: number): SelfState;
 /**
- * Apply emotional contagion: the detected user emotion partially
- * influences the agent's chemistry.
+ * Apply contagion from a raw impact vector.
+ * Core substrate-independent function.
  */
-export declare function applyContagion(agentState: ChemicalState, detectedUserEmotion: StimulusType, contagionRate: number, sensitivity: number): ChemicalState;
+export declare function applyImpactContagion(agentState: SelfState, vector: ImpactVector, contagionRate: number, sensitivity: number): SelfState;
+/** True if the net impact across all dimensions is positive. */
+export declare function isPositiveImpact(v: ImpactVector): boolean;
+/** True if the impact has significant resonance magnitude. */
+export declare function isEmotionalImpact(v: ImpactVector): boolean;
+/** True if the impact threatens self-coherence (order or boundary). */
+export declare function isThreateningImpact(v: ImpactVector): boolean;
 /**
- * Detect the dominant emergent emotion(s) from the current chemistry.
- * Returns all matching patterns.
+ * Detect emergent emotion patterns from the current self-state.
+ * Returns all matching patterns — emotions emerge, they are not designed.
  */
-export declare function detectEmotions(current: ChemicalState): EmotionPattern[];
+export declare function detectEmotions(current: SelfState): EmotionPattern[];
 /**
- * Generate a human-readable emotion summary from chemistry.
+ * Human-readable emotion summary from self-state.
  */
-export declare function describeEmotionalState(current: ChemicalState, locale?: Locale): string;
+export declare function describeEmotionalState(current: SelfState, locale?: Locale): string;
 /**
- * Generate concise expression guidance from the current chemistry.
+ * Concise expression guidance from self-state.
  */
-export declare function getExpressionHint(current: ChemicalState, locale?: Locale): string;
+export declare function getExpressionHint(current: SelfState, locale?: Locale): string;
 /**
- * Get behavior guide for the current emotional state.
+ * Behavior guide for the current emergent emotional state.
  */
-export declare function getBehaviorGuide(current: ChemicalState, locale?: Locale): string | null;
+export declare function getBehaviorGuide(current: SelfState, locale?: Locale): string | null;