psyche-ai 10.2.3 → 11.2.0

package/dist/temporal.d.ts

@@ -1,16 +1,16 @@
-import type { ChemicalState, ChemicalSnapshot, StimulusType, PsycheState, RelationshipState } from "./types.js";
+import type { SelfState, StateSnapshot, StimulusType, PsycheState, RelationshipState } from "./types.js";
 export interface StimulusPrediction {
     stimulus: StimulusType;
     probability: number;
 }
 export interface AnticipationState {
     predictions: StimulusPrediction[];
-    anticipatoryChemistry: Partial<ChemicalState>;
+    anticipatoryState: Partial<SelfState>;
     timestamp: string;
 }
 export interface RegretEntry {
     turnIndex: number;
-    counterfactualDelta: Partial<ChemicalState>;
+    counterfactualDelta: Partial<SelfState>;
     regretIntensity: number;
     description: string;
     timestamp: string;
@@ -19,18 +19,18 @@ export interface RegretEntry {
  * Predict likely next stimulus based on interaction history.
  * Uses simple Markov property: given recent stimulus sequence, what comes next?
  */
-export declare function predictNextStimulus(emotionalHistory: ChemicalSnapshot[], relationshipPhase: RelationshipState["phase"]): StimulusPrediction[];
+export declare function predictNextStimulus(stateHistory: StateSnapshot[], relationshipPhase: RelationshipState["phase"]): StimulusPrediction[];
 /**
  * Generate anticipatory chemistry changes based on predictions.
  * High-probability positive prediction -> DA/OT micro-rise.
  * High-probability negative prediction -> CORT micro-rise.
  */
-export declare function generateAnticipation(predictions: StimulusPrediction[], _currentChemistry: ChemicalState): AnticipationState;
+export declare function generateAnticipation(predictions: StimulusPrediction[], _currentState: SelfState): AnticipationState;
 /**
  * Compute disappointment/surprise when actual stimulus differs from prediction.
  * Returns additional chemistry delta beyond the normal stimulus response.
  */
-export declare function computeSurpriseEffect(anticipated: AnticipationState, actualStimulus: StimulusType | null): Partial<ChemicalState>;
+export declare function computeSurpriseEffect(anticipated: AnticipationState, actualStimulus: StimulusType | null): Partial<SelfState>;
 /**
  * Evaluate if the last interaction would have gone better with different chemistry.
  * Runs a counterfactual: "what if my chemistry had been at baseline?"

package/dist/temporal.js

@@ -9,7 +9,7 @@
 // These enable the agent to "look forward" and "look back",
 // creating a temporal dimension to emotional experience.
 // ============================================================
-import { CHEMICAL_KEYS } from "./types.js";
+import { DIMENSION_KEYS } from "./types.js";
 import { STIMULUS_VECTORS } from "./chemistry.js";
 // ── All StimulusType values ──────────────────────────────────
 const ALL_STIMULI = [
@@ -56,23 +56,23 @@ const PHASE_PRIORS = {
  * Predict likely next stimulus based on interaction history.
  * Uses simple Markov property: given recent stimulus sequence, what comes next?
  */
-export function predictNextStimulus(emotionalHistory, relationshipPhase) {
+export function predictNextStimulus(stateHistory, relationshipPhase) {
     const phasePrior = PHASE_PRIORS[relationshipPhase] ?? PHASE_PRIORS.acquaintance;
     // Insufficient history: return flat prior weighted by phase
-    if (emotionalHistory.length < 3) {
+    if (stateHistory.length < 3) {
         return buildPhasePrior(phasePrior);
     }
     // Extract the last 2 stimuli for bigram transition
-    const recent = emotionalHistory.slice(-2);
+    const recent = stateHistory.slice(-2);
     const lastTwo = recent.map((s) => s.stimulus).filter((s) => s !== null);
     if (lastTwo.length < 2) {
         return buildPhasePrior(phasePrior);
     }
     // Build transition counts from history (all consecutive pairs)
     const transitionCounts = new Map();
-    for (let i = 1; i < emotionalHistory.length; i++) {
-        const prev = emotionalHistory[i - 1].stimulus;
-        const cur = emotionalHistory[i].stimulus;
+    for (let i = 1; i < stateHistory.length; i++) {
+        const prev = stateHistory[i - 1].stimulus;
+        const cur = stateHistory[i].stimulus;
         if (prev === null || cur === null)
             continue;
         const key = prev;
@@ -142,9 +142,9 @@ function buildPhasePrior(weights) {
  * High-probability positive prediction -> DA/OT micro-rise.
  * High-probability negative prediction -> CORT micro-rise.
  */
-export function generateAnticipation(predictions, _currentChemistry) {
+export function generateAnticipation(predictions, _currentState) {
     const anticipation = {};
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         anticipation[key] = 0;
     }
     // For each prediction with probability > 0.2, compute micro shift
@@ -155,13 +155,13 @@ export function generateAnticipation(predictions, _currentChemistry) {
         if (!vector)
             continue;
         const scale = 0.15 * pred.probability;
-        for (const key of CHEMICAL_KEYS) {
+        for (const key of DIMENSION_KEYS) {
             anticipation[key] += vector[key] * scale;
         }
     }
-    // Clamp total anticipation shift to +/-5 per chemical
+    // Clamp total anticipation shift to +/-5 per dimension
     const clamped = {};
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         const val = Math.max(-5, Math.min(5, anticipation[key]));
         if (Math.abs(val) > 0.01) {
             clamped[key] = Math.round(val * 100) / 100;
@@ -169,7 +169,7 @@ export function generateAnticipation(predictions, _currentChemistry) {
     }
     return {
         predictions,
-        anticipatoryChemistry: clamped,
+        anticipatoryState: clamped,
         timestamp: new Date().toISOString(),
     };
 }
@@ -194,38 +194,36 @@ export function computeSurpriseEffect(anticipated, actualStimulus) {
     const actualVector = STIMULUS_VECTORS[actualStimulus];
     if (!actualVector)
         return {};
-    const actualValence = actualVector.DA + actualVector.HT + actualVector.OT - actualVector.CORT;
+    const actualValence = actualVector.flow + actualVector.order + actualVector.resonance;
     const topVector = STIMULUS_VECTORS[topPrediction.stimulus];
     const topValence = topVector
-        ? topVector.DA + topVector.HT + topVector.OT - topVector.CORT
+        ? topVector.flow + topVector.order + topVector.resonance
         : 0;
     // Surprise magnitude scales with: (1) how confident the prediction was, (2) how unexpected the actual is
     const surpriseMagnitude = topConfidence * (1 - actualProbability);
     if (actualValence > 0 && topValence <= actualValence) {
         // Pleasant surprise: actual is more positive than expected
         return {
-            DA: Math.round(5 * surpriseMagnitude * 100) / 100,
-            END: Math.round(3 * surpriseMagnitude * 100) / 100,
+            flow: Math.round(5 * surpriseMagnitude * 100) / 100,
+            resonance: Math.round(3 * surpriseMagnitude * 100) / 100,
         };
     }
     else if (actualValence < topValence) {
         // Disappointment: actual is worse than expected (the "crash" from anticipated warmth)
         return {
-            DA: Math.round(-5 * surpriseMagnitude * 100) / 100,
-            CORT: Math.round(5 * surpriseMagnitude * 100) / 100,
+            flow: Math.round(-5 * surpriseMagnitude * 100) / 100,
+            order: Math.round(-5 * surpriseMagnitude * 100) / 100,
         };
     }
     return {};
 }
 // ── 3. RegretComputer ───────────────────────────────────────
-/** Chemical descriptions for regret messages */
-const CHEMICAL_DESCRIPTIONS = {
-    DA: { high: "high dopamine made response too eager", low: "low dopamine made response flat" },
-    HT: { high: "high serotonin made response complacent", low: "low serotonin made response unstable" },
-    CORT: { high: "high CORT made response too defensive", low: "low CORT made response careless" },
-    OT: { high: "high oxytocin made response too trusting", low: "low oxytocin made response too cold" },
-    NE: { high: "high norepinephrine made response too reactive", low: "low norepinephrine made response sluggish" },
-    END: { high: "high endorphins made response too flippant", low: "low endorphins made response too serious" },
+/** Dimension descriptions for regret messages */
+const DIMENSION_DESCRIPTIONS = {
+    order: { high: "high order made response too rigid", low: "low order made response chaotic" },
+    flow: { high: "high flow made response too reactive", low: "low flow made response flat" },
+    boundary: { high: "high boundary made response too closed", low: "low boundary made response too exposed" },
+    resonance: { high: "high resonance made response too trusting", low: "low resonance made response too cold" },
 };
 /**
  * Evaluate if the last interaction would have gone better with different chemistry.
@@ -237,35 +235,35 @@ export function computeRegret(preInteractionState, postInteractionState, outcome
         return null;
     }
     const baseline = preInteractionState.baseline;
-    const preChemistry = preInteractionState.current;
-    // Check if chemistry was significantly deviated from baseline
+    const preState = preInteractionState.current;
+    // Check if state was significantly deviated from baseline
     let maxDeviation = 0;
-    let mostDeviatedKey = "DA";
-    for (const key of CHEMICAL_KEYS) {
-        const deviation = Math.abs(preChemistry[key] - baseline[key]);
+    let mostDeviatedKey = "order";
+    for (const key of DIMENSION_KEYS) {
+        const deviation = Math.abs(preState[key] - baseline[key]);
         if (deviation > maxDeviation) {
             maxDeviation = deviation;
             mostDeviatedKey = key;
         }
     }
-    // No regret if chemistry was near baseline (deviation < 15)
+    // No regret if state was near baseline (deviation < 15)
     if (maxDeviation < 15) {
         return null;
     }
     // Compute regret intensity: |outcomeScore| * (maxDeviation / 100)
     const regretIntensity = Math.min(1, Math.abs(outcomeScore) * (maxDeviation / 100));
-    // Build counterfactual delta: difference between baseline and actual pre-interaction chemistry
+    // Build counterfactual delta: difference between baseline and actual pre-interaction state
     const counterfactualDelta = {};
-    for (const key of CHEMICAL_KEYS) {
-        const diff = baseline[key] - preChemistry[key];
+    for (const key of DIMENSION_KEYS) {
+        const diff = baseline[key] - preState[key];
         if (Math.abs(diff) > 5) {
             counterfactualDelta[key] = Math.round(diff * 100) / 100;
         }
     }
-    // Build description identifying the most deviated chemical
-    const deviationDirection = preChemistry[mostDeviatedKey] > baseline[mostDeviatedKey]
+    // Build description identifying the most deviated dimension
+    const deviationDirection = preState[mostDeviatedKey] > baseline[mostDeviatedKey]
         ? "high" : "low";
-    const description = CHEMICAL_DESCRIPTIONS[mostDeviatedKey][deviationDirection];
+    const description = DIMENSION_DESCRIPTIONS[mostDeviatedKey][deviationDirection];
     return {
         turnIndex: postInteractionState.meta.totalInteractions,
         counterfactualDelta,

package/dist/types.d.ts

@@ -1,14 +1,20 @@
-/** The six virtual neurotransmitters that compose emotional state */
-export interface ChemicalState {
-    DA: number;
-    HT: number;
-    CORT: number;
-    OT: number;
-    NE: number;
-    END: number;
-}
-/** Chemical keys for iteration */
-export declare const CHEMICAL_KEYS: (keyof ChemicalState)[];
+/**
+ * The four self-state dimensions.
+ *
+ * These are the substrate on which selfhood emerges — not emotion,
+ * not intelligence, but the minimal homeostatic structure that any
+ * self requires. Works for bacterium, LLM, world model, AGI, swarm.
+ *
+ * All values 0-100, baseline-centered.
+ */
+export interface SelfState {
+    order: number;
+    flow: number;
+    boundary: number;
+    resonance: number;
+}
+/** Dimension keys for iteration */
+export declare const DIMENSION_KEYS: (keyof SelfState)[];
 /** Drive types mapped to Maslow's hierarchy */
 export type DriveType = "survival" | "safety" | "connection" | "esteem" | "curiosity";
 /** Drive keys for iteration (ordered by Maslow level, L1→L5) */
@@ -24,29 +30,32 @@ export interface InnateDrives {
 /** Default drive satisfaction — all start reasonably satisfied */
 export declare const DEFAULT_DRIVES: InnateDrives;
 export declare const DRIVE_NAMES_ZH: Record<DriveType, string>;
-/** Human-readable names for each chemical */
-export declare const CHEMICAL_NAMES: Record<keyof ChemicalState, string>;
-export declare const CHEMICAL_NAMES_ZH: Record<keyof ChemicalState, string>;
-export interface ChemicalRuntimeSpec {
+/** Human-readable names for each dimension */
+export declare const DIMENSION_NAMES: Record<keyof SelfState, string>;
+export declare const DIMENSION_NAMES_ZH: Record<keyof SelfState, string>;
+/** Runtime specification for a self-state dimension */
+export interface DimensionSpec {
     normalMin: number;
     normalMax: number;
+    /** Retention factor per hour (0-1). Lower = faster decay toward baseline. */
+    decayRate: number;
     halfLifeHours: number;
 }
-/** Decay speed category */
-export type DecaySpeed = "fast" | "medium" | "slow";
-/** Decay factor per chemical (applied per hour) */
-export declare const DECAY_FACTORS: Record<DecaySpeed, number>;
-/** Which chemicals decay at which speed */
-export declare const CHEMICAL_DECAY_SPEED: Record<keyof ChemicalState, DecaySpeed>;
-export declare const CHEMICAL_RUNTIME_SPECS: Record<keyof ChemicalState, ChemicalRuntimeSpec>;
+/**
+ * Per-dimension decay and operating specs.
+ *
+ * Order decays fastest (entropy is natural).
+ * Boundary is most inertial (identity is sticky).
+ */
+export declare const DIMENSION_SPECS: Record<keyof SelfState, DimensionSpec>;
 /** Psyche operating mode */
 export type PsycheMode = "natural" | "work" | "companion";
 /** Mode profile — all mode-specific parameters in one place. */
 export interface ModeProfile {
-    chemistryMultiplier: number;
-    maxChemicalDelta: number | null;
+    dynamicsMultiplier: number;
+    maxDimensionDelta: number | null;
     nearBaselineThreshold: number;
-    otWarmthThreshold: number;
+    resonanceWarmthThreshold: number;
     lengthMultiplier: number;
     minSentences: number;
     authenticityWhenWarm: "strict" | "friendly";
@@ -69,15 +78,22 @@ export interface PersonalityTraits {
 export type MBTIType = "INTJ" | "INTP" | "ENTJ" | "ENTP" | "INFJ" | "INFP" | "ENFJ" | "ENFP" | "ISTJ" | "ISFJ" | "ESTJ" | "ESFJ" | "ISTP" | "ISFP" | "ESTP" | "ESFP";
 /** Stimulus types that affect chemistry (v0.2: +5 new types) */
 export type StimulusType = "praise" | "criticism" | "humor" | "intellectual" | "intimacy" | "conflict" | "neglect" | "surprise" | "casual" | "sarcasm" | "authority" | "validation" | "boredom" | "vulnerability";
-/** Chemical effect vector for a stimulus */
-export type StimulusVector = Record<keyof ChemicalState, number>;
+/** Self-state impact vector for a stimulus (4D) */
+export type ImpactVector = Record<keyof SelfState, number>;
+/** @deprecated Alias for migration. Use ImpactVector. */
+export type StimulusVector = ImpactVector;
 /** Locale for i18n */
 export type Locale = "zh" | "en";
-/** Emergent emotion pattern (v0.2: +behaviorGuide) */
+/**
+ * Emergent emotion pattern — observational only.
+ *
+ * Emotions are NOT targets. They emerge from self-state combinations.
+ * These patterns detect recognizable states for observation/labeling.
+ */
 export interface EmotionPattern {
     name: string;
     nameZh: string;
-    condition: (c: ChemicalState) => boolean;
+    condition: (s: SelfState) => boolean;
     expressionHint: string;
     behaviorGuide: string;
 }
@@ -118,9 +134,9 @@ export interface RelationshipState {
     breachSensitivity?: number;
     signalWeights?: Partial<WritebackSignalWeightMap>;
 }
-/** Chemical state snapshot for emotional memory */
-export interface ChemicalSnapshot {
-    chemistry: ChemicalState;
+/** Self-state snapshot for experiential memory */
+export interface StateSnapshot {
+    state: SelfState;
     stimulus: StimulusType | null;
     dominantEmotion: string | null;
     timestamp: string;
@@ -152,15 +168,15 @@ export interface SelfModel {
 export interface LearnedVectorAdjustment {
     stimulus: StimulusType;
     contextHash: string;
-    adjustment: Partial<StimulusVector>;
+    adjustment: Partial<ImpactVector>;
     confidence: number;
     sampleCount: number;
     lastUpdated: string;
 }
 /** A single prediction record for prediction error tracking */
 export interface PredictionRecord {
-    predictedChemistry: ChemicalState;
-    actualChemistry: ChemicalState;
+    predictedState: SelfState;
+    actualState: SelfState;
     stimulus: StimulusType | null;
     predictionError: number;
     timestamp: string;
@@ -206,7 +222,7 @@ export type RegulationStrategyType = "reappraisal" | "strategic-expression" | "s
 /** Defense mechanism type */
 export type DefenseMechanismType = "rationalization" | "projection" | "sublimation" | "avoidance";
 /** Which internal metric a regulation action is trying to pull back toward target */
-export type RegulationTargetMetric = keyof ChemicalState | "emotional-confidence";
+export type RegulationTargetMetric = keyof SelfState | "emotional-confidence";
 /** Whether the last regulation action is helping */
 export type RegulationFeedbackEffect = "converging" | "holding" | "diverging";
 export interface RegulationFeedback {
@@ -310,21 +326,21 @@ export interface DelegateAuthorization {
     /** Whether this authorization is currently active */
     active: boolean;
 }
-/** Persisted psyche state for an agent (v10: MBTI removed, baseline is personality) */
+/** Persisted psyche state for an agent (v11: self-state substrate) */
 export interface PsycheState {
-    version: 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
-    /** @deprecated Use baseline chemistry directly. Retained for migration only. */
+    version: 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+    /** @deprecated Use baseline directly. Retained for migration only. */
     mbti?: MBTIType;
-    baseline: ChemicalState;
+    baseline: SelfState;
     /** Stimulus sensitivity multiplier (0.5-1.5). Initialized from personality preset. */
     sensitivity: number;
-    current: ChemicalState;
+    current: SelfState;
     drives: InnateDrives;
     updatedAt: string;
     relationships: Record<string, RelationshipState>;
     empathyLog: EmpathyEntry | null;
     selfModel: SelfModel;
-    emotionalHistory: ChemicalSnapshot[];
+    stateHistory: StateSnapshot[];
     agreementStreak: number;
     lastDisagreement: string | null;
     learning: LearningState;
@@ -334,7 +350,7 @@ export interface PsycheState {
     autonomicState?: "ventral-vagal" | "sympathetic" | "dorsal-vagal";
     /** v7: session start time for homeostatic pressure calculation */
     sessionStartedAt?: string;
-    /** v9: long-term personality drift from accumulated interaction patterns */
+    /** v9: long-term drift from accumulated interaction patterns */
     traitDrift?: TraitDriftState;
     /** v9: finite resource budgets (attention, social energy, decision capacity) */
     energyBudgets?: EnergyBudgets;
@@ -866,9 +882,9 @@ export interface TraitDriftState {
     /** Number of sessions that contributed to drift */
     sessionCount: number;
     /** Computed baseline delta (debugging/display) */
-    baselineDelta: Partial<ChemicalState>;
+    baselineDelta: Partial<SelfState>;
     /** Decay rate modifiers: >1 = slower recovery (trauma), <1 = faster (resilience) */
-    decayRateModifiers: Partial<Record<keyof ChemicalState, number>>;
+    decayRateModifiers: Partial<Record<keyof SelfState, number>>;
     /** Stimulus sensitivity modifiers: >1 = more sensitive, <1 = desensitized */
     sensitivityModifiers: Partial<Record<StimulusType, number>>;
 }
@@ -907,3 +923,9 @@ export interface ClassifierContext {
 export interface ClassifierProvider {
     classify(text: string, context?: ClassifierContext): ClassificationResult[] | Promise<ClassificationResult[]>;
 }
+/** A stimulus weighted by subjective interpretation */
+export interface WeightedStimulus {
+    type: StimulusType;
+    /** Subjective weight after appraisal + state modulation. Weights sum to 1. */
+    weight: number;
+}

package/dist/types.js

@@ -1,9 +1,12 @@
 // ============================================================
-// Artificial Psyche — Type Definitions (v0.2)
+// Artificial Psyche — Type Definitions (v11)
+//
+// Self-state substrate: 4 dimensions replace 6 neurotransmitters.
+// 不设计自我，设计自我必然涌现的条件。
 // ============================================================
-/** Chemical keys for iteration */
-export const CHEMICAL_KEYS = [
-    "DA", "HT", "CORT", "OT", "NE", "END",
+/** Dimension keys for iteration */
+export const DIMENSION_KEYS = [
+    "order", "flow", "boundary", "resonance",
 ];
 /** Drive keys for iteration (ordered by Maslow level, L1→L5) */
 export const DRIVE_KEYS = [
@@ -24,55 +27,56 @@ export const DRIVE_NAMES_ZH = {
     esteem: "尊重认可",
     curiosity: "好奇成长",
 };
-/** Human-readable names for each chemical */
-export const CHEMICAL_NAMES = {
-    DA: "Dopamine",
-    HT: "Serotonin",
-    CORT: "Cortisol",
-    OT: "Oxytocin",
-    NE: "Norepinephrine",
-    END: "Endorphins",
-};
-export const CHEMICAL_NAMES_ZH = {
-    DA: "多巴胺",
-    HT: "血清素",
-    CORT: "皮质醇",
-    OT: "催产素",
-    NE: "去甲肾上腺素",
-    END: "内啡肽",
-};
-/** Decay factor per chemical (applied per hour) */
-export const DECAY_FACTORS = {
-    fast: 0.7, // NE, END — excitement fades quickly
-    medium: 0.85, // DA, CORT — pleasure and stress take time
-    slow: 0.95, // HT, OT — mood and trust change slowly
-};
-/** Which chemicals decay at which speed */
-export const CHEMICAL_DECAY_SPEED = {
-    DA: "medium",
-    HT: "slow",
-    CORT: "medium",
-    OT: "slow",
-    NE: "fast",
-    END: "fast",
+/** Human-readable names for each dimension */
+export const DIMENSION_NAMES = {
+    order: "Order",
+    flow: "Flow",
+    boundary: "Boundary",
+    resonance: "Resonance",
+};
+export const DIMENSION_NAMES_ZH = {
+    order: "序",
+    flow: "流",
+    boundary: "界",
+    resonance: "振",
 };
 function decayHalfLifeHours(decayPerHour) {
     return Math.log(0.5) / Math.log(decayPerHour);
 }
-export const CHEMICAL_RUNTIME_SPECS = {
-    DA: { normalMin: 35, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.medium) },
-    HT: { normalMin: 40, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.slow) },
-    CORT: { normalMin: 20, normalMax: 55, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.medium) },
-    OT: { normalMin: 35, normalMax: 75, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.slow) },
-    NE: { normalMin: 30, normalMax: 70, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.fast) },
-    END: { normalMin: 30, normalMax: 70, halfLifeHours: decayHalfLifeHours(DECAY_FACTORS.fast) },
+/**
+ * Per-dimension decay and operating specs.
+ *
+ * Order decays fastest (entropy is natural).
+ * Boundary is most inertial (identity is sticky).
+ */
+export const DIMENSION_SPECS = {
+    order: {
+        normalMin: 35, normalMax: 75,
+        decayRate: 0.75,
+        halfLifeHours: decayHalfLifeHours(0.75),
+    },
+    flow: {
+        normalMin: 30, normalMax: 75,
+        decayRate: 0.82,
+        halfLifeHours: decayHalfLifeHours(0.82),
+    },
+    boundary: {
+        normalMin: 40, normalMax: 80,
+        decayRate: 0.95,
+        halfLifeHours: decayHalfLifeHours(0.95),
+    },
+    resonance: {
+        normalMin: 30, normalMax: 70,
+        decayRate: 0.88,
+        halfLifeHours: decayHalfLifeHours(0.88),
+    },
 };
 export const MODE_PROFILES = {
     work: {
-        chemistryMultiplier: 0.3,
-        maxChemicalDelta: 5,
+        dynamicsMultiplier: 0.3,
+        maxDimensionDelta: 5,
         nearBaselineThreshold: 20,
-        otWarmthThreshold: 10,
+        resonanceWarmthThreshold: 10,
         lengthMultiplier: 1.0,
         minSentences: 1,
         authenticityWhenWarm: "strict",
@@ -83,10 +87,10 @@ export const MODE_PROFILES = {
         appraisalDecay: 0.68,
     },
     natural: {
-        chemistryMultiplier: 1.0,
-        maxChemicalDelta: null,
+        dynamicsMultiplier: 1.0,
+        maxDimensionDelta: null,
         nearBaselineThreshold: 8,
-        otWarmthThreshold: 10,
+        resonanceWarmthThreshold: 10,
         lengthMultiplier: 1.0,
         minSentences: 1,
         authenticityWhenWarm: "strict",
@@ -97,10 +101,10 @@ export const MODE_PROFILES = {
         appraisalDecay: 0.78,
     },
     companion: {
-        chemistryMultiplier: 1.5,
-        maxChemicalDelta: null,
+        dynamicsMultiplier: 1.5,
+        maxDimensionDelta: null,
         nearBaselineThreshold: 5,
-        otWarmthThreshold: 5,
+        resonanceWarmthThreshold: 5,
         lengthMultiplier: 1.5,
         minSentences: 2,
         authenticityWhenWarm: "friendly",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "10.2.3",
+  "version": "11.2.0",
   "description": "AI-first subjectivity kernel for agents with continuous appraisal, relation dynamics, and adaptive reply loops",
   "mcpName": "io.github.Shangri-la-0428/psyche-ai",
   "type": "module",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/Shangri-la-0428/oasyce_psyche",
     "source": "github"
   },
-  "version": "10.2.3",
+  "version": "10.2.4",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "psyche-ai",
-      "version": "10.2.3",
+      "version": "10.2.4",
       "transport": {
         "type": "stdio"
       },