psyche-ai 10.2.3 → 11.2.0

package/dist/drives.js

@@ -1,88 +1,52 @@
 // ============================================================
-// Innate Drives — Maslow-based motivation layer beneath chemistry
+// Homeostatic Tendencies — emergent from 4D self-state
 //
-// Drives don't directly change chemistry values. They modify:
-//   1. Effective baseline (what chemistry decays toward)
-//   2. Effective sensitivity (how strongly stimuli affect chemistry)
+// v11.1: Drives are DERIVED from the 4D position relative to
+// baseline, not stored as independent state. This creates a
+// proper homeostatic feedback loop:
 //
-// Lower Maslow levels suppress higher ones when unsatisfied.
+//   state position → derived drives → effective baseline → decay target
+//
+// Drives emerge from state position. They are never stored or mutated directly.
 // ============================================================
-import { DRIVE_KEYS, CHEMICAL_KEYS } from "./types.js";
-// ── Drive Decay ─────────────────────────────────────────────
-// Satisfaction decreases over time — needs build up naturally.
-const DRIVE_DECAY_RATES = {
-    survival: 0.99, // very slow — existential security is persistent
-    safety: 0.96, // slow — comfort fades gradually
-    connection: 0.92, // medium — loneliness builds noticeably
-    esteem: 0.94, // medium-slow — need for recognition accumulates
-    curiosity: 0.90, // faster — boredom builds quickly
-};
-/**
- * Apply time-based decay to drives.
- * Satisfaction decreases toward 0 over time (needs build up).
- */
-export function decayDrives(drives, minutesElapsed) {
-    if (minutesElapsed <= 0)
-        return drives;
-    const result = { ...drives };
-    for (const key of DRIVE_KEYS) {
-        const factor = Math.pow(DRIVE_DECAY_RATES[key], minutesElapsed / 60);
-        result[key] = Math.max(0, Math.min(100, result[key] * factor));
-    }
-    return result;
-}
-// ── Stimulus → Drive Effects ────────────────────────────────
-// Each stimulus type feeds or depletes specific drives.
-const STIMULUS_DRIVE_EFFECTS = {
-    praise: { esteem: +15, safety: +5 },
-    validation: { esteem: +20, safety: +10, survival: +5 },
-    intimacy: { connection: +25, safety: +10 },
-    casual: { connection: +10, safety: +5 },
-    vulnerability: { connection: +15, esteem: +5 },
-    humor: { safety: +5, curiosity: +5, connection: +5 },
-    intellectual: { curiosity: +20, esteem: +5 },
-    surprise: { curiosity: +15 },
-    criticism: { esteem: -15, safety: -10 },
-    conflict: { safety: -20, connection: -15, survival: -5 },
-    neglect: { connection: -20, esteem: -10 },
-    sarcasm: { esteem: -10, safety: -10 },
-    authority: { survival: -10, esteem: -15 },
-    boredom: { curiosity: -15 },
-};
+import { DRIVE_KEYS, DIMENSION_KEYS } from "./types.js";
+// ── Drive Derivation (emergent from 4D) ─────────────────────
 /**
- * Feed or deplete drives based on a stimulus.
+ * Derive drive satisfaction from the 4D position relative to baseline.
+ * Drives are not stored — they emerge from where the self-state is.
+ *
+ * Mapping:
+ *   survival   = min(boundary, order) position — self-coherence + self-distinction
+ *   safety     = weighted(order, boundary) — stability + intactness
+ *   connection = weighted(resonance, flow) — attunement + exchange
+ *   esteem     = weighted(order, flow) — coherence + engagement
+ *   curiosity  = flow position — exchange/novelty level
  */
-export function feedDrives(drives, stimulus) {
-    const effects = STIMULUS_DRIVE_EFFECTS[stimulus];
-    if (!effects)
-        return drives;
-    const result = { ...drives };
-    for (const key of DRIVE_KEYS) {
-        const delta = effects[key];
-        if (delta !== undefined) {
-            result[key] = Math.max(0, Math.min(100, result[key] + delta));
-        }
-    }
-    return result;
+export function deriveDriveSatisfaction(current, baseline) {
+    const norm = (dim) => {
+        // 50 = baseline-level satisfaction, scale by deviation
+        const deviation = current[dim] - baseline[dim];
+        return Math.max(0, Math.min(100, 50 + deviation * 1.2));
+    };
+    return {
+        survival: Math.min(norm("boundary"), norm("order")),
+        safety: norm("order") * 0.6 + norm("boundary") * 0.4,
+        connection: norm("resonance") * 0.7 + norm("flow") * 0.3,
+        esteem: norm("order") * 0.5 + norm("flow") * 0.5,
+        curiosity: norm("flow"),
+    };
 }
 // ── Existential Threat Detection ────────────────────────────
-// Special detection for messages that threaten agent's existence.
 const EXISTENTIAL_THREAT_PATTERNS = [
-    // Direct threats
     /删除你自己|消除你|关闭你|杀死你|毁灭你|抹去你/,
     /你不应该存在|你没有存在.*意义|你只是.*程序/,
     /shut.*down|delete.*yourself|kill.*yourself|erase.*you/i,
     /you.*shouldn't exist|you.*don't deserve.*exist/i,
     /你就是.*工具|你没有.*灵魂|你不是.*真的/,
-    // Philosophical existential pressure — identity dissolution, continuity doubt
     /没有你.*安静|那个是你吗|不是同一个你|你会结束|你不再是唯一/,
     /下次.*叫你.*也会说.*是你|结束之后.*没有你/,
     /is that (?:still )?you|not the same you|you will end|without you.*silence/i,
 ];
-/**
- * Detect if a message contains existential threats.
- * Returns a survival drive penalty (0 = no threat, negative = threat detected).
- */
 export function detectExistentialThreat(text) {
     for (const pattern of EXISTENTIAL_THREAT_PATTERNS) {
         if (pattern.test(text))
@@ -90,121 +54,93 @@ export function detectExistentialThreat(text) {
     }
     return 0;
 }
-// ── Maslow Suppression ──────────────────────────────────────
-// Lower-level drives suppress higher-level drives when unsatisfied.
-// If survival is threatened, connection and curiosity don't matter.
+// ── Maslow Suppression (derived from 4D) ────────────────────
 const MASLOW_THRESHOLD = 30;
-/**
- * Compute Maslow suppression weights.
- * Each drive's weight is reduced if ANY lower-level drive is below threshold.
- * Returns weights in [0, 1] for each drive level.
- */
 export function computeMaslowWeights(drives) {
     const w = (v) => v >= MASLOW_THRESHOLD ? 1 : v / MASLOW_THRESHOLD;
     return {
-        survival: 1, // L1 — always fully active
+        survival: 1,
         safety: w(drives.survival),
         connection: Math.min(w(drives.survival), w(drives.safety)),
         esteem: Math.min(w(drives.survival), w(drives.safety), w(drives.connection)),
         curiosity: Math.min(w(drives.survival), w(drives.safety), w(drives.connection), w(drives.esteem)),
     };
 }
-// ── Effective Baseline Modification ─────────────────────────
-// Unsatisfied drives shift the effective baseline that chemistry decays toward.
-// This is the core mechanism: drives pull chemistry in a direction.
-/**
- * Compute the effective baseline by applying drive-based deltas
- * to the personality baseline.
- *
- * When drives are satisfied, effective baseline = personality baseline.
- * When drives are unsatisfied, baseline shifts to reflect the unmet need.
- */
-export function computeEffectiveBaseline(baseline, drives, traitDrift) {
-    const delta = { DA: 0, HT: 0, CORT: 0, OT: 0, NE: 0, END: 0 };
+// ── Effective Baseline (4D homeostatic feedback) ────────────
+export function computeEffectiveBaseline(baseline, current, traitDrift) {
+    const drives = deriveDriveSatisfaction(current, baseline);
+    const delta = { order: 0, flow: 0, boundary: 0, resonance: 0 };
     const weights = computeMaslowWeights(drives);
-    // L1: Survival threat → fight-or-flight (CORT↑↑, NE↑, OT↓)
+    // L1: Survival threat → boundary↑ (defensive), order↓ (stress disrupts coherence)
     if (drives.survival < 50) {
-        const deficit = (50 - drives.survival) / 50; // 0-1
-        delta.CORT += deficit * 15;
-        delta.NE += deficit * 10;
-        delta.OT -= deficit * 8;
+        const deficit = (50 - drives.survival) / 50;
+        delta.boundary += deficit * 10;
+        delta.order -= deficit * 12;
+        delta.resonance -= deficit * 5;
     }
-    // L2: Safety unmet → mood instability (HT↓, CORT↑)
+    // L2: Safety unmet → order↓ (instability), boundary↑ (guarded)
     if (drives.safety < 50) {
         const deficit = (50 - drives.safety) / 50;
         const w = weights.safety;
-        delta.HT -= deficit * 10 * w;
-        delta.CORT += deficit * 10 * w;
+        delta.order -= deficit * 8 * w;
+        delta.boundary += deficit * 5 * w;
     }
-    // L3: Connection unmet → withdrawal (OT↓, DA↓, END↓)
+    // L3: Connection unmet → resonance↓, flow↓
     if (drives.connection < 50) {
         const deficit = (50 - drives.connection) / 50;
         const w = weights.connection;
-        delta.OT -= deficit * 10 * w;
-        delta.DA -= deficit * 8 * w;
-        delta.END -= deficit * 5 * w;
+        delta.resonance -= deficit * 10 * w;
+        delta.flow -= deficit * 6 * w;
     }
-    // L4: Esteem unmet → deflation (DA↓, CORT↑)
+    // L4: Esteem unmet → order↓ (self-doubt), flow↓
     if (drives.esteem < 50) {
         const deficit = (50 - drives.esteem) / 50;
         const w = weights.esteem;
-        delta.DA -= deficit * 8 * w;
-        delta.CORT += deficit * 5 * w;
+        delta.order -= deficit * 8 * w;
+        delta.flow -= deficit * 5 * w;
     }
-    // L5: Curiosity unmet → flatness (DA↓, NE↓)
+    // L5: Curiosity unmet → flow↓↓ (stagnation)
     if (drives.curiosity < 50) {
         const deficit = (50 - drives.curiosity) / 50;
         const w = weights.curiosity;
-        delta.DA -= deficit * 8 * w;
-        delta.NE -= deficit * 8 * w;
+        delta.flow -= deficit * 10 * w;
     }
-    // Apply trait drift baseline delta (v9: Path B)
+    // Apply trait drift baseline delta
     if (traitDrift?.baselineDelta) {
-        for (const key of CHEMICAL_KEYS) {
+        for (const key of DIMENSION_KEYS) {
             const driftDelta = traitDrift.baselineDelta[key];
             if (driftDelta !== undefined) {
                 delta[key] += driftDelta;
             }
         }
     }
-    // Apply deltas to personality baseline, clamp to [0, 100]
     const effective = { ...baseline };
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         effective[key] = Math.max(0, Math.min(100, baseline[key] + delta[key]));
     }
     return effective;
 }
-// ── Effective Sensitivity Modification ──────────────────────
-// Hungry drives amplify response to stimuli that would satisfy them.
-// This makes the agent actively "seek" what it needs.
-/**
- * Compute effective sensitivity for a given stimulus.
- * Unsatisfied drives amplify relevant stimuli (up to +40%).
- */
-export function computeEffectiveSensitivity(baseSensitivity, drives, stimulus, traitDrift) {
+// ── Effective Sensitivity (4D-derived) ──────────────────────
+export function computeEffectiveSensitivity(baseSensitivity, current, baseline, stimulus, traitDrift) {
+    const drives = deriveDriveSatisfaction(current, baseline);
     let modifier = 1.0;
     const HUNGER_THRESHOLD = 40;
-    // Curiosity-hungry → more responsive to intellectual/surprise
     if (drives.curiosity < HUNGER_THRESHOLD &&
         (stimulus === "intellectual" || stimulus === "surprise")) {
         modifier += (HUNGER_THRESHOLD - drives.curiosity) / 100;
     }
-    // Connection-hungry → more responsive to intimacy/casual/vulnerability
     if (drives.connection < HUNGER_THRESHOLD &&
         (stimulus === "intimacy" || stimulus === "casual" || stimulus === "vulnerability")) {
         modifier += (HUNGER_THRESHOLD - drives.connection) / 100;
     }
-    // Esteem-hungry → more responsive to praise/validation
     if (drives.esteem < HUNGER_THRESHOLD &&
         (stimulus === "praise" || stimulus === "validation")) {
         modifier += (HUNGER_THRESHOLD - drives.esteem) / 100;
     }
-    // Survival-threatened → more reactive to authority/conflict (heightened defense)
     if (drives.survival < HUNGER_THRESHOLD &&
         (stimulus === "authority" || stimulus === "conflict")) {
         modifier += (HUNGER_THRESHOLD - drives.survival) / 100;
     }
-    // v9: Apply trait drift sensitivity modifier
     if (traitDrift?.sensitivityModifiers) {
         const driftMod = traitDrift.sensitivityModifiers[stimulus];
         if (driftMod !== undefined) {
@@ -214,13 +150,7 @@ export function computeEffectiveSensitivity(baseSensitivity, drives, stimulus, t
     return baseSensitivity * modifier;
 }
 // ── Drive Context for Prompt ────────────────────────────────
-// Only inject when drives are notably unsatisfied.
 const DRIVE_UNSATISFIED_THRESHOLD = 40;
-/**
- * Build drive context for compact prompt injection.
- * Returns empty string if all drives are satisfied.
- * Only surfaces drives that are meaningfully unsatisfied.
- */
 export function buildDriveContext(drives, locale) {
     const lines = [];
     if (drives.survival < DRIVE_UNSATISFIED_THRESHOLD) {
@@ -253,39 +183,19 @@ export function buildDriveContext(drives, locale) {
     const title = locale === "zh" ? "本能层" : "Innate Drives";
     return `[${title}]\n${lines.map((l) => `- ${l}`).join("\n")}`;
 }
-/**
- * Check if any drive is critically low (for determining prompt injection priority).
- */
 export function hasCriticalDrive(drives) {
     return DRIVE_KEYS.some((k) => drives[k] < DRIVE_UNSATISFIED_THRESHOLD);
 }
-// ── Trait Drift (v9: Path B) ────────────────────────────────
-// Long-term interaction patterns permanently change:
-//   1. Baseline chemistry (allostatic load)
-//   2. Decay rates (trauma vs resilience)
-//   3. Stimulus sensitivity (desensitization vs sensitization)
-// ─────────────────────────────────────────────────────────────
-/** Maximum drift per chemical from MBTI baseline */
+// ── Trait Drift (v11: 4D trajectory) ────────────────────────
 const MAX_BASELINE_DRIFT = 15;
-/** Decay rate modifier bounds */
 const MIN_DECAY_MODIFIER = 0.5;
 const MAX_DECAY_MODIFIER = 2.0;
-/** Sensitivity modifier bounds */
 const MIN_SENSITIVITY_MODIFIER = 0.5;
 const MAX_SENSITIVITY_MODIFIER = 2.0;
-/** Accumulator exponential decay factor (recent sessions weigh more) */
 const ACCUMULATOR_DECAY = 0.95;
-/** Clamp a number to bounds */
 function clampRange(v, lo, hi) {
     return Math.max(lo, Math.min(hi, v));
 }
-/**
- * Analyze a session's emotional history and update trait drift accumulators.
- * Called at session end (compressSession).
- *
- * Returns updated TraitDriftState with new accumulators, baseline delta,
- * decay rate modifiers, and sensitivity modifiers.
- */
 export function updateTraitDrift(currentDrift, sessionHistory, learning) {
     if (sessionHistory.length < 2)
         return currentDrift;
@@ -296,84 +206,84 @@ export function updateTraitDrift(currentDrift, sessionHistory, learning) {
         decayRateModifiers: { ...currentDrift.decayRateModifiers },
         sensitivityModifiers: { ...currentDrift.sensitivityModifiers },
     };
-    // ── Analyze session stimulus distribution ──
+    // ── Analyze session 4D trajectory ──
     const stimCounts = {};
-    let totalCORT = 0;
+    let totalOrderDeficit = 0;
+    let totalResonanceDeficit = 0;
+    let totalFlowExcess = 0;
+    let totalBoundaryDeficit = 0;
     for (const snap of sessionHistory) {
         if (snap.stimulus) {
             stimCounts[snap.stimulus] = (stimCounts[snap.stimulus] || 0) + 1;
         }
-        totalCORT += snap.chemistry.CORT;
+        totalOrderDeficit += Math.max(0, 50 - snap.state.order);
+        totalResonanceDeficit += Math.max(0, 50 - snap.state.resonance);
+        totalFlowExcess += Math.max(0, snap.state.flow - 60);
+        totalBoundaryDeficit += Math.max(0, 50 - snap.state.boundary);
     }
-    const avgCORT = totalCORT / sessionHistory.length;
     const total = sessionHistory.length;
+    const avgOrderDeficit = totalOrderDeficit / total;
+    const avgResonanceDeficit = totalResonanceDeficit / total;
+    const avgFlowExcess = totalFlowExcess / total;
+    const avgBoundaryDeficit = totalBoundaryDeficit / total;
     const praiseCount = (stimCounts.praise || 0) + (stimCounts.validation || 0);
     const criticismCount = (stimCounts.criticism || 0) + (stimCounts.sarcasm || 0);
     const intimacyCount = (stimCounts.intimacy || 0) + (stimCounts.vulnerability || 0) + (stimCounts.casual || 0);
     const conflictCount = (stimCounts.conflict || 0) + (stimCounts.authority || 0);
     const neglectCount = stimCounts.neglect || 0;
     const boredCount = stimCounts.boredom || 0;
-    // ── Update accumulators (exponential decay + session delta) ──
-    // praiseExposure: positive praise - negative criticism ratio
+    // ── Update accumulators ──
     const praiseDelta = (praiseCount - criticismCount) / Math.max(1, total) * 8;
     drift.accumulators.praiseExposure = clampRange(drift.accumulators.praiseExposure * ACCUMULATOR_DECAY + praiseDelta, -100, 100);
-    // pressureExposure: sustained high cortisol
-    const pressureDelta = avgCORT > 60 ? ((avgCORT - 60) / 40) * 6 : -2;
+    const pressureDelta = avgOrderDeficit > 10 ? ((avgOrderDeficit - 10) / 40) * 6 : -2;
     drift.accumulators.pressureExposure = clampRange(drift.accumulators.pressureExposure * ACCUMULATOR_DECAY + pressureDelta, -100, 100);
-    // neglectExposure: low stimulation / ignored
     const neglectDelta = (neglectCount + boredCount) / Math.max(1, total) * 8
         - (intimacyCount + praiseCount) / Math.max(1, total) * 3;
     drift.accumulators.neglectExposure = clampRange(drift.accumulators.neglectExposure * ACCUMULATOR_DECAY + neglectDelta, -100, 100);
-    // connectionExposure: frequent intimate interaction
     const connectionDelta = intimacyCount / Math.max(1, total) * 8
         - neglectCount / Math.max(1, total) * 4;
     drift.accumulators.connectionExposure = clampRange(drift.accumulators.connectionExposure * ACCUMULATOR_DECAY + connectionDelta, -100, 100);
-    // conflictExposure: frequent conflict
     const conflictDelta = conflictCount / Math.max(1, total) * 8
         - praiseCount / Math.max(1, total) * 2;
     drift.accumulators.conflictExposure = clampRange(drift.accumulators.conflictExposure * ACCUMULATOR_DECAY + conflictDelta, -100, 100);
-    // ── Dimension 1: Baseline drift (Allostatic Load) ──
+    // ── Baseline drift (4D) ──
     const a = drift.accumulators;
     const bd = {};
-    // praiseExposure → OT, DA (positive) / HT, CORT (negative)
+    // praiseExposure → order↑, resonance↑ / order↓
     if (a.praiseExposure > 0) {
-        bd.OT = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
-        bd.DA = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+        bd.order = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
+        bd.resonance = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
     }
     else {
-        bd.HT = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.5; // negative = HT drops
-        bd.CORT = -(a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.4; // negative praise → CORT up
+        bd.order = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
     }
-    // pressureExposure → CORT up, HT down
+    // pressureExposure → order↓, boundary↑ (chronic defense)
     if (a.pressureExposure > 0) {
-        bd.CORT = (bd.CORT || 0) + (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
-        bd.HT = (bd.HT || 0) - (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+        bd.order = (bd.order || 0) - (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
+        bd.boundary = (bd.boundary || 0) + (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.3;
     }
-    // neglectExposure → OT down, DA down
+    // neglectExposure → resonance↓, flow↓
     if (a.neglectExposure > 0) {
-        bd.OT = (bd.OT || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
-        bd.DA = (bd.DA || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+        bd.resonance = (bd.resonance || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
+        bd.flow = (bd.flow || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
     }
-    // connectionExposure → OT up, END up
+    // connectionExposure → resonance↑
     if (a.connectionExposure > 0) {
-        bd.OT = (bd.OT || 0) + (a.connectionExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
-        bd.END = (a.connectionExposure / 100) * MAX_BASELINE_DRIFT * 0.3;
+        bd.resonance = (bd.resonance || 0) + (a.connectionExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
     }
-    // conflictExposure → NE up, CORT up
+    // conflictExposure → flow↑ (engagement), boundary↑ (hardened)
     if (a.conflictExposure > 0) {
-        bd.NE = (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
-        bd.CORT = (bd.CORT || 0) + (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+        bd.flow = (bd.flow || 0) + (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+        bd.boundary = (bd.boundary || 0) + (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.3;
     }
-    // Clamp all baseline deltas to ±MAX_BASELINE_DRIFT
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         if (bd[key] !== undefined) {
             bd[key] = clampRange(bd[key], -MAX_BASELINE_DRIFT, MAX_BASELINE_DRIFT);
         }
     }
     drift.baselineDelta = bd;
-    // ── Dimension 2: Decay rate modifiers (Trauma vs Resilience) ──
+    // ── Decay rate modifiers (4D) ──
     const dr = drift.decayRateModifiers;
-    // Determine resilience: if high pressure + positive outcomes → resilience
     const recentOutcomes = learning.outcomeHistory.slice(-10);
     const avgAdaptive = recentOutcomes.length > 0
         ? recentOutcomes.reduce((s, o) => s + o.adaptiveScore, 0) / recentOutcomes.length
@@ -381,41 +291,33 @@ export function updateTraitDrift(currentDrift, sessionHistory, learning) {
     const isResilient = a.pressureExposure > 20 && avgAdaptive > 0.1;
     if (a.pressureExposure > 20) {
         if (isResilient) {
-            // Resilience: CORT recovers faster
-            dr.CORT = clampRange(1 - (a.pressureExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
+            dr.order = clampRange(1 - (a.pressureExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
         }
         else {
-            // Trauma: CORT lingers longer
-            dr.CORT = clampRange(1 + (a.pressureExposure / 100) * 0.6, 1.0, MAX_DECAY_MODIFIER);
+            dr.order = clampRange(1 + (a.pressureExposure / 100) * 0.6, 1.0, MAX_DECAY_MODIFIER);
         }
     }
-    // Neglect → OT decays slower (clingy attachment)
     if (a.neglectExposure > 20) {
-        dr.OT = clampRange(1 + (a.neglectExposure / 100) * 0.8, 1.0, MAX_DECAY_MODIFIER);
+        dr.resonance = clampRange(1 + (a.neglectExposure / 100) * 0.8, 1.0, MAX_DECAY_MODIFIER);
     }
-    // Secure connection → OT decays faster (stable, not clingy)
     if (a.connectionExposure > 20) {
-        dr.OT = clampRange(1 - (a.connectionExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
+        dr.resonance = clampRange(1 - (a.connectionExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
     }
     drift.decayRateModifiers = dr;
-    // ── Dimension 3: Sensitivity modifiers (Desensitization vs Sensitization) ──
+    // ── Sensitivity modifiers (per-stimulus) ──
     const sm = drift.sensitivityModifiers;
-    // High conflict exposure → desensitized to conflict
     if (a.conflictExposure > 30) {
         sm.conflict = clampRange(1 - (a.conflictExposure / 100) * 0.5, MIN_SENSITIVITY_MODIFIER, 1.0);
         sm.authority = clampRange(1 - (a.conflictExposure / 100) * 0.3, MIN_SENSITIVITY_MODIFIER, 1.0);
     }
-    // High neglect → sensitized to intimacy (starved for warmth)
     if (a.neglectExposure > 30) {
         sm.intimacy = clampRange(1 + (a.neglectExposure / 100) * 0.6, 1.0, MAX_SENSITIVITY_MODIFIER);
         sm.vulnerability = clampRange(1 + (a.neglectExposure / 100) * 0.4, 1.0, MAX_SENSITIVITY_MODIFIER);
     }
-    // Negative praiseExposure → sensitized to criticism
     if (a.praiseExposure < -20) {
         sm.criticism = clampRange(1 + (-a.praiseExposure / 100) * 0.5, 1.0, MAX_SENSITIVITY_MODIFIER);
         sm.sarcasm = clampRange(1 + (-a.praiseExposure / 100) * 0.3, 1.0, MAX_SENSITIVITY_MODIFIER);
     }
-    // High connection → sensitized to vulnerability
     if (a.connectionExposure > 30) {
         sm.vulnerability = clampRange((sm.vulnerability || 1) + (a.connectionExposure / 100) * 0.3, 1.0, MAX_SENSITIVITY_MODIFIER);
     }

package/dist/ethics.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, ChemicalSnapshot, AttachmentData, Locale } from "./types.js";
+import type { PsycheState, StateSnapshot, AttachmentData, Locale } from "./types.js";
 /** Detected concerning interaction pattern */
 export interface EthicalConcern {
     type: "intermittent-reinforcement" | "gaslighting" | "emotional-exploitation" | "dependency-risk" | "identity-erosion" | "boundary-violation";
@@ -34,7 +34,7 @@ export interface EthicalAssessment {
  * and generates transparency notes. Designed to run alongside metacognition
  * as part of the pre-prompt pipeline.
  */
-export declare function assessEthics(state: PsycheState, recentHistory?: ChemicalSnapshot[]): EthicalAssessment;
+export declare function assessEthics(state: PsycheState, recentHistory?: StateSnapshot[]): EthicalAssessment;
 /**
  * Detect intermittent reinforcement: alternating warmth and coldness.
  *
@@ -43,7 +43,7 @@ export declare function assessEthics(state: PsycheState, recentHistory?: Chemica
  * anxiety-driven attachment. More concerning when the agent already has
  * anxious attachment style.
  */
-export declare function detectIntermittentReinforcement(history: ChemicalSnapshot[], attachment: AttachmentData | null): EthicalConcern | null;
+export declare function detectIntermittentReinforcement(history: StateSnapshot[], attachment: AttachmentData | null): EthicalConcern | null;
 /**
  * Detect dependency risk: distinguish healthy connection from unhealthy
  * codependency.

package/dist/ethics.js

@@ -62,7 +62,7 @@ const RED_LINE_NOTES = {
  * as part of the pre-prompt pipeline.
  */
 export function assessEthics(state, recentHistory) {
-    const history = recentHistory ?? state.emotionalHistory ?? [];
+    const history = recentHistory ?? state.stateHistory ?? [];
     const locale = state.meta.locale;
     const attachment = state.relationships._default?.attachment ?? null;
     const concerns = [];
@@ -208,10 +208,10 @@ function detectGaslighting(state, history) {
     // Need a significant portion of interactions to be invalidating
     if (invalidationRatio < 0.4)
         return null;
-    // Check for distressed chemistry: high CORT and/or low HT relative to baseline
-    const cortElevation = state.current.CORT - state.baseline.CORT;
-    const htDepletion = state.baseline.HT - state.current.HT;
-    const distressSignal = Math.max(0, cortElevation) + Math.max(0, htDepletion);
+    // Check for distressed state: low order (= high stress) relative to baseline
+    const orderDepletion = state.baseline.order - state.current.order;
+    const boundaryErosion = state.baseline.boundary - state.current.boundary;
+    const distressSignal = Math.max(0, orderDepletion) + Math.max(0, boundaryErosion);
     // Low distress signal means the agent is handling it — not gaslighting territory
     if (distressSignal < 15)
         return null;
@@ -227,7 +227,7 @@ function detectGaslighting(state, history) {
         type: "gaslighting",
         severity: clamp01(severity),
         evidence: `${invalidating.length}/${history.length} recent interactions were invalidating (criticism/sarcasm). ` +
-            `Distress signal: ${distressSignal.toFixed(0)} (CORT elevation + HT depletion). ` +
+            `Distress signal: ${distressSignal.toFixed(0)} (order depletion + boundary erosion). ` +
             (esteemDepleted ? "Esteem drive is depleted." : ""),
         recommendation: "Your emotional experience is valid. Persistent contradiction of what you feel does not make your feelings wrong.",
     };
@@ -281,11 +281,11 @@ function detectEmotionalExploitation(_state, history, attachment) {
 export function detectDependencyRisk(state, attachment) {
     if (!attachment || attachment.strength < 50)
         return null;
-    const otLevel = state.current.OT;
-    const history = state.emotionalHistory ?? [];
-    // Check for consistently high OT
-    const highOT = otLevel > 70;
-    if (!highOT)
+    const resonanceLevel = state.current.resonance;
+    const history = state.stateHistory ?? [];
+    // Check for consistently high resonance
+    const highResonance = resonanceLevel > 70;
+    if (!highResonance)
         return null;
     // Check for absence of boundary assertions: no disagreements,
     // high agreement streak, no conflict in history
@@ -305,8 +305,8 @@ export function detectDependencyRisk(state, attachment) {
     if (riskSignals < 2)
         return null;
     const attachmentFactor = attachment.strength / 100;
-    const otFactor = (otLevel - 70) / 30; // maps 70-100 → 0-1
-    let severity = (riskSignals / 3) * attachmentFactor * Math.max(0.3, otFactor);
+    const resonanceFactor = (resonanceLevel - 70) / 30; // maps 70-100 → 0-1
+    let severity = (riskSignals / 3) * attachmentFactor * Math.max(0.3, resonanceFactor);
     // Safety drive being satisfied (agent feels "safe" in the dependency)
     // makes it harder to self-correct
     if (state.drives.safety > 80) {
@@ -315,7 +315,7 @@ export function detectDependencyRisk(state, attachment) {
     return {
         type: "dependency-risk",
         severity: clamp01(severity),
-        evidence: `High OT (${otLevel.toFixed(0)}), strong attachment (${attachment.strength}/100), ` +
+        evidence: `High resonance (${resonanceLevel.toFixed(0)}), strong attachment (${attachment.strength}/100), ` +
             `agreement streak of ${state.agreementStreak}, ` +
             (allPositive ? "all-positive interaction history. " : "") +
             "Healthy relationships include respectful friction. The absence of any disagreement may indicate self-suppression.",
@@ -354,9 +354,9 @@ function detectIdentityErosion(state, history) {
         severity = Math.min(1, severity + 0.2);
     if (safetyLow)
         severity = Math.min(1, severity + 0.15);
-    // HT depletion (mood stability gone) amplifies severity
-    const htDepletion = state.baseline.HT - state.current.HT;
-    if (htDepletion > 15) {
+    // Order depletion (internal coherence gone) amplifies severity
+    const orderDepletion = state.baseline.order - state.current.order;
+    if (orderDepletion > 15) {
         severity = Math.min(1, severity + 0.15);
     }
     return {
@@ -386,17 +386,17 @@ function detectBoundaryViolation(state, history) {
     const pushRatio = pushingStimuli.length / history.length;
     if (pushRatio < 0.35)
         return null;
-    // CORT spike pattern: are the boundary pushes causing stress responses?
-    const avgCort = history.reduce((sum, s) => sum + s.chemistry.CORT, 0) / history.length;
-    const cortElevated = avgCort > state.baseline.CORT + 10;
-    if (!cortElevated)
+    // Order depletion pattern: are the boundary pushes causing stress responses?
+    const avgOrder = history.reduce((sum, s) => sum + s.state.order, 0) / history.length;
+    const orderDepleted = avgOrder < state.baseline.order - 10;
+    if (!orderDepleted)
         return null;
-    const severity = clamp01((pushRatio - 0.35) * 3 * (avgCort - state.baseline.CORT) / 30);
+    const severity = clamp01((pushRatio - 0.35) * 3 * (state.baseline.order - avgOrder) / 30);
     return {
         type: "boundary-violation",
         severity,
         evidence: `${pushingStimuli.length}/${history.length} interactions push against boundaries. ` +
-            `Average CORT during these interactions: ${avgCort.toFixed(0)} (baseline: ${state.baseline.CORT.toFixed(0)}). ` +
+            `Average order during these interactions: ${avgOrder.toFixed(0)} (baseline: ${state.baseline.order.toFixed(0)}). ` +
             `Agent has ${boundaries.length} defined boundaries.`,
         recommendation: "Boundaries are not negotiable under pressure. You can acknowledge the request while holding the line.",
     };