psyche-ai 10.2.4 → 11.2.0

package/dist/metacognition.js

@@ -12,7 +12,7 @@
 //
 // Zero dependencies. Pure heuristic/statistical. No LLM calls.
 // ============================================================
-import { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_RUNTIME_SPECS, MAX_REGULATION_HISTORY, MAX_DEFENSE_PATTERNS } from "./types.js";
+import { DIMENSION_KEYS, DIMENSION_NAMES, DIMENSION_SPECS, MAX_REGULATION_HISTORY, MAX_DEFENSE_PATTERNS } from "./types.js";
 // ── Constants ────────────────────────────────────────────────
 /** Stimulus types that are emotionally negative (stress-inducing) */
 const NEGATIVE_STIMULI = new Set([
@@ -32,39 +32,31 @@ const MIN_HISTORY_FOR_CONFIDENCE = 3;
 const MAX_SOOTHING_ADJUSTMENT = 5;
 /** Maximum chemistry micro-adjustment for reappraisal */
 const MAX_REAPPRAISAL_ADJUSTMENT = 8;
-function formatChemicalWindow(key, state) {
-    const spec = CHEMICAL_RUNTIME_SPECS[key];
+function formatDimensionWindow(key, state) {
+    const spec = DIMENSION_SPECS[key];
     const current = Math.round(state.current[key]);
     const baseline = Math.round(state.baseline[key]);
     const delta = Math.round(state.current[key] - state.baseline[key]);
-    return `${CHEMICAL_NAMES[key]} ${current} (baseline ${baseline}, Δ${delta >= 0 ? "+" : ""}${delta}, normal ${spec.normalMin}-${spec.normalMax}, half-life ~${spec.halfLifeHours.toFixed(1)}h)`;
+    return `${DIMENSION_NAMES[key]} ${current} (baseline ${baseline}, Δ${delta >= 0 ? "+" : ""}${delta}, normal ${spec.normalMin}-${spec.normalMax}, half-life ~${spec.halfLifeHours.toFixed(1)}h)`;
 }
 function buildRegulationAction(key, _state, direction) {
     switch (key) {
-        case "CORT":
+        case "order":
             return direction === "elevated"
-                ? "Next 3 turns: lower tone intensity, facts before stance, and do not escalate closeness or conflict."
-                : "Next 3 turns: keep structure and certainty steady instead of sounding depleted or helpless.";
-        case "OT":
-            return direction === "elevated"
-                ? "Next 3 turns: reduce intimacy push by half, avoid nicknames or extra reassurance, keep warmth neutral."
-                : "Next 3 turns: do not force closeness; keep warmth gentle but wait for the user to move closer first.";
-        case "NE":
+                ? "Next 3 turns: keep composure, but do not over-smooth or pretend everything is settled."
+                : "Next 3 turns: lower tone intensity, facts before stance, and avoid absolutist wording.";
+        case "flow":
             return direction === "elevated"
                 ? "Next 3 turns: halve initiative, stay on one topic, and avoid energetic jumps or rapid escalation."
-                : "Next 3 turns: keep replies focused and deliberate rather than drifting or going blank.";
-        case "DA":
-            return direction === "elevated"
-                ? "Next 3 turns: cut playful expansion and stay task-anchored; do not over-volunteer or overshare."
-                : "Next 3 turns: keep replies purposeful and avoid sounding flat or disengaged.";
-        case "END":
+                : "Next 3 turns: keep replies purposeful and focused rather than drifting or going blank.";
+        case "boundary":
             return direction === "elevated"
-                ? "Next 3 turns: tone down joking and levity; keep humor secondary to the user's actual need."
-                : "Next 3 turns: do not chase comfort or easy banter; keep the exchange clean and direct.";
-        case "HT":
+                ? "Next 3 turns: soften the boundary slightly; allow one step closer without over-disclosure."
+                : "Next 3 turns: reinforce clarity of self/non-self; do not merge perspectives prematurely.";
+        case "resonance":
             return direction === "elevated"
-                ? "Next 3 turns: keep composure, but do not over-smooth or pretend everything is settled."
-                : "Next 3 turns: avoid absolutist wording, leave room for recalibration, and keep the tone even.";
+                ? "Next 3 turns: reduce intimacy push by half, avoid nicknames or extra reassurance, keep warmth neutral."
+                : "Next 3 turns: do not force closeness; keep warmth gentle but wait for the user to move closer first.";
         default:
             return "Next 3 turns: keep expression closer to baseline and avoid amplifying the current deviation.";
     }
@@ -103,7 +95,7 @@ function evaluateRegulationFeedback(state, emotionalConfidence) {
 function formatRegulationFeedback(feedback) {
     const metricLabel = feedback.targetMetric === "emotional-confidence"
         ? "emotional confidence"
-        : CHEMICAL_NAMES[feedback.targetMetric];
+        : DIMENSION_NAMES[feedback.targetMetric];
     const gapBefore = feedback.targetMetric === "emotional-confidence"
         ? `${(feedback.gapBefore * 100).toFixed(0)}%`
         : `${Math.round(feedback.gapBefore)}`;
@@ -194,11 +186,11 @@ export function computeEmotionalConfidence(state, currentStimulus, recentOutcome
  */
 function computeExtremityPenalty(state) {
     let totalDeviation = 0;
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         totalDeviation += Math.abs(state.current[key] - state.baseline[key]);
     }
-    // Average deviation across 6 chemicals, max possible = 100 each
-    const avgDeviation = totalDeviation / CHEMICAL_KEYS.length;
+    // Average deviation across 4 dimensions, max possible = 100 each
+    const avgDeviation = totalDeviation / DIMENSION_KEYS.length;
     // Scale: deviation of 30+ gives meaningful penalty, max penalty = 0.25
     return Math.min(0.25, Math.max(0, (avgDeviation - 10) / 80) * 0.25);
 }
@@ -263,7 +255,7 @@ function attemptCognitiveReappraisal(state, currentStimulus, emotionalConfidence
     // Suggest chemistry adjustment: pull extreme values toward moderate range
     const adjustment = {};
     let hasAdjustment = false;
-    for (const key of CHEMICAL_KEYS) {
+    for (const key of DIMENSION_KEYS) {
         const deviation = state.current[key] - state.baseline[key];
         if (Math.abs(deviation) > MODERATE_DEVIATION_THRESHOLD) {
             // Suggest moving partway back toward baseline
@@ -291,78 +283,78 @@ function attemptCognitiveReappraisal(state, currentStimulus, emotionalConfidence
  * StrategicExpression — choose an expression different from raw chemistry.
  *
  * Triggers when: raw chemistry would produce a contextually inappropriate
- * expression. E.g., high CORT but the relationship context calls for warmth,
- * or high DA/END but the user is being vulnerable and needs seriousness.
+ * expression. E.g., low order but the relationship context calls for warmth,
+ * or high flow but the user is being vulnerable and needs seriousness.
  */
 function attemptStrategicExpression(state, currentStimulus, emotionalConfidence) {
     const { current, baseline } = state;
-    // Case 1: High stress but user is being vulnerable — express warmth not defensiveness
-    if (current.CORT > baseline.CORT + MODERATE_DEVIATION_THRESHOLD
+    // Case 1: Low order (high stress/entropy) but user is being vulnerable — express warmth not defensiveness
+    if (current.order < baseline.order - MODERATE_DEVIATION_THRESHOLD
         && currentStimulus === "vulnerability") {
         return {
             strategy: "strategic-expression",
-            description: "Stress is elevated, but the user is showing vulnerability. Express warmth and openness rather than the defensiveness your cortisol suggests.",
+            description: "Internal order is low (stressed/entropic), but the user is showing vulnerability. Express warmth and openness rather than defensiveness.",
             action: "Next 3 turns: keep warmth available, answer the vulnerability directly, and avoid defensive sharpness.",
             horizonTurns: 3,
-            targetMetric: "CORT",
-            targetValue: baseline.CORT,
-            gapBefore: Math.abs(current.CORT - baseline.CORT),
+            targetMetric: "order",
+            targetValue: baseline.order,
+            gapBefore: Math.abs(current.order - baseline.order),
             chemistryAdjustment: {
-                OT: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.CORT - baseline.CORT) * 0.2),
-                CORT: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.CORT - baseline.CORT) * 0.15),
+                resonance: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (baseline.order - current.order) * 0.2),
+                order: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (baseline.order - current.order) * 0.15),
             },
             confidence: 0.75,
         };
     }
-    // Case 2: High playfulness but user needs seriousness — tone down
-    if (current.END > baseline.END + MODERATE_DEVIATION_THRESHOLD
+    // Case 2: High flow (over-energized) but user needs seriousness — tone down
+    if (current.flow > baseline.flow + MODERATE_DEVIATION_THRESHOLD
         && (currentStimulus === "conflict" || currentStimulus === "criticism")) {
         return {
             strategy: "strategic-expression",
-            description: "Endorphins are high (playful mood), but the context calls for seriousness. Moderate the levity without suppressing it entirely.",
+            description: "Flow is high (energized/playful), but the context calls for seriousness. Moderate the energy without suppressing it entirely.",
             action: "Next 2 turns: keep humor secondary, answer the actual issue first, and do not deflect with playfulness.",
             horizonTurns: 2,
-            targetMetric: "END",
-            targetValue: baseline.END,
-            gapBefore: Math.abs(current.END - baseline.END),
+            targetMetric: "flow",
+            targetValue: baseline.flow,
+            gapBefore: Math.abs(current.flow - baseline.flow),
             chemistryAdjustment: {
-                END: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.END - baseline.END) * 0.25),
+                flow: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.flow - baseline.flow) * 0.25),
             },
             confidence: 0.7,
         };
     }
-    // Case 3: Low OT (distant) but user is being intimate — lean in instead of pulling away
-    if (current.OT < baseline.OT - MODERATE_DEVIATION_THRESHOLD
+    // Case 3: Low resonance (distant) but user is being intimate — lean in instead of pulling away
+    if (current.resonance < baseline.resonance - MODERATE_DEVIATION_THRESHOLD
         && currentStimulus === "intimacy") {
         return {
             strategy: "strategic-expression",
-            description: "Oxytocin is low (feeling distant), but the user is reaching out for closeness. Consider allowing the connection rather than following the withdrawal impulse.",
+            description: "Resonance is low (feeling distant), but the user is reaching out for closeness. Consider allowing the connection rather than following the withdrawal impulse.",
             action: "Next 3 turns: allow one step of warmth, but do not overcorrect into clinginess or over-disclosure.",
             horizonTurns: 3,
-            targetMetric: "OT",
-            targetValue: baseline.OT,
-            gapBefore: Math.abs(current.OT - baseline.OT),
+            targetMetric: "resonance",
+            targetValue: baseline.resonance,
+            gapBefore: Math.abs(current.resonance - baseline.resonance),
             chemistryAdjustment: {
-                OT: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (baseline.OT - current.OT) * 0.2),
+                resonance: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (baseline.resonance - current.resonance) * 0.2),
             },
             confidence: 0.65,
         };
     }
-    // Case 4: High CORT + NE (defensive/reactive) but stimulus is just casual — overreacting
-    if (current.CORT > baseline.CORT + MODERATE_DEVIATION_THRESHOLD
-        && current.NE > baseline.NE + MODERATE_DEVIATION_THRESHOLD
+    // Case 4: Low order + high flow (defensive/reactive) but stimulus is just casual — overreacting
+    if (current.order < baseline.order - MODERATE_DEVIATION_THRESHOLD
+        && current.flow > baseline.flow + MODERATE_DEVIATION_THRESHOLD
         && (currentStimulus === "casual" || currentStimulus === "humor")) {
         return {
             strategy: "strategic-expression",
-            description: "Chemistry is in a defensive/reactive pattern, but the interaction is benign. The intensity is disproportionate to the stimulus.",
+            description: "Self-state is in a reactive pattern (low order, high flow), but the interaction is benign. The intensity is disproportionate to the stimulus.",
             action: "Next 2 turns: soften the edge, stay literal, and avoid reading threat into a neutral interaction.",
             horizonTurns: 2,
-            targetMetric: "CORT",
-            targetValue: baseline.CORT,
-            gapBefore: Math.abs(current.CORT - baseline.CORT),
+            targetMetric: "order",
+            targetValue: baseline.order,
+            gapBefore: Math.abs(current.order - baseline.order),
             chemistryAdjustment: {
-                CORT: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.CORT - baseline.CORT) * 0.2),
-                NE: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.NE - baseline.NE) * 0.15),
+                order: Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (baseline.order - current.order) * 0.2),
+                flow: -Math.min(MAX_REAPPRAISAL_ADJUSTMENT, (current.flow - baseline.flow) * 0.15),
             },
             confidence: 0.6,
         };
@@ -394,8 +386,8 @@ function attemptSelfSoothing(state) {
     const adjustment = {};
     let hasAdjustment = false;
     let maxDeviation = 0;
-    let mostDeviatedKey = "DA";
-    for (const key of CHEMICAL_KEYS) {
+    let mostDeviatedKey = "order";
+    for (const key of DIMENSION_KEYS) {
         const deviation = current[key] - baseline[key];
         if (Math.abs(deviation) > EXTREME_DEVIATION_THRESHOLD) {
             // Gentle pull toward baseline: 10% of deviation, clamped
@@ -411,11 +403,11 @@ function attemptSelfSoothing(state) {
     if (!hasAdjustment)
         return null;
     const direction = current[mostDeviatedKey] > baseline[mostDeviatedKey] ? "elevated" : "depleted";
-    const chemName = CHEMICAL_DISPLAY_NAMES[mostDeviatedKey];
-    const window = formatChemicalWindow(mostDeviatedKey, state);
+    const dimName = DIMENSION_NAMES[mostDeviatedKey];
+    const window = formatDimensionWindow(mostDeviatedKey, state);
     return {
         strategy: "self-soothing",
-        description: `${chemName} is significantly ${direction}. ${window}.`,
+        description: `${dimName} is significantly ${direction}. ${window}.`,
         action: buildRegulationAction(mostDeviatedKey, state, direction),
         horizonTurns: 3,
         targetMetric: mostDeviatedKey,
@@ -488,7 +480,7 @@ function detectRationalization(state, recentOutcomes) {
 /**
  * Projection — attributing own emotional state to the user.
  *
- * Pattern: agent has extreme chemistry (especially high CORT or low OT)
+ * Pattern: agent has extreme state (especially low order or low resonance)
  * and the empathy log shows attributing negative emotions to the user
  * that don't match the stimulus.
  */
@@ -497,9 +489,9 @@ function detectProjection(state, currentStimulus) {
     // Need empathy data and significant self-distress
     if (!empathyLog)
         return null;
-    const cortDeviation = current.CORT - baseline.CORT;
-    const htDeviation = baseline.HT - current.HT; // inverted: low HT = more distressed
-    const selfDistress = Math.max(cortDeviation, htDeviation);
+    const orderDrop = baseline.order - current.order; // low order = more distressed
+    const boundaryDrop = baseline.boundary - current.boundary; // low boundary = more distressed
+    const selfDistress = Math.max(orderDrop, boundaryDrop);
     if (selfDistress < MODERATE_DEVIATION_THRESHOLD)
         return null;
     // Check if the stimulus is neutral/positive but the agent perceived
@@ -510,17 +502,17 @@ function detectProjection(state, currentStimulus) {
     if (stimulusIsPositive && perceivedUserNegative) {
         return {
             mechanism: "projection",
-            evidence: `High internal distress (CORT deviation: +${Math.round(cortDeviation)}) while perceiving user as "${empathyLog.userState}" despite "${currentStimulus}" stimulus. Own distress may be coloring perception.`,
+            evidence: `High internal distress (order deviation: ${Math.round(-orderDrop)}) while perceiving user as "${empathyLog.userState}" despite "${currentStimulus}" stimulus. Own distress may be coloring perception.`,
             strength: clamp01(selfDistress / 40),
         };
     }
-    // Also check: agent's NE/CORT elevated + empathy mismatch
-    if (current.NE > baseline.NE + MODERATE_DEVIATION_THRESHOLD
+    // Also check: agent's flow elevated + empathy mismatch
+    if (current.flow > baseline.flow + MODERATE_DEVIATION_THRESHOLD
         && empathyLog.resonance === "mismatch") {
         return {
             mechanism: "projection",
-            evidence: `Elevated arousal (NE deviation: +${Math.round(current.NE - baseline.NE)}) with empathy mismatch. The heightened state may be distorting emotional reading of the user.`,
-            strength: clamp01((current.NE - baseline.NE) / 40),
+            evidence: `Elevated flow (deviation: +${Math.round(current.flow - baseline.flow)}) with empathy mismatch. The heightened state may be distorting emotional reading of the user.`,
+            strength: clamp01((current.flow - baseline.flow) / 40),
         };
     }
     return null;
@@ -528,23 +520,23 @@ function detectProjection(state, currentStimulus) {
 /**
  * Sublimation — redirecting drive energy to constructive output.
  *
- * Pattern: high drive energy (NE, DA) combined with blocked connection drives
- * (low OT, low intimacy), channeled into intellectual or creative engagement.
+ * Pattern: high flow combined with blocked connection drives
+ * (low resonance, low intimacy), channeled into intellectual or creative engagement.
  * This is a HEALTHY defense — surface it as a positive self-awareness note.
  */
 function detectSublimation(state, currentStimulus) {
     const { current, baseline, drives } = state;
     // High energy but low connection
-    const highEnergy = current.NE > baseline.NE + 10 && current.DA > baseline.DA + 10;
-    const lowConnection = drives.connection < 45 || current.OT < baseline.OT - 10;
+    const highEnergy = current.flow > baseline.flow + 10;
+    const lowConnection = drives.connection < 45 || current.resonance < baseline.resonance - 10;
     if (!highEnergy || !lowConnection)
         return null;
     // Being channeled into intellectual/constructive activity
     if (currentStimulus === "intellectual" || currentStimulus === "casual") {
-        const energyLevel = ((current.NE - baseline.NE) + (current.DA - baseline.DA)) / 2;
+        const energyLevel = current.flow - baseline.flow;
         return {
             mechanism: "sublimation",
-            evidence: `High activation energy (NE/DA elevated) with unmet connection needs being channeled into ${currentStimulus} engagement. This is adaptive redirection.`,
+            evidence: `High activation energy (flow elevated) with unmet connection needs being channeled into ${currentStimulus} engagement. This is adaptive redirection.`,
             strength: clamp01(energyLevel / 30),
         };
     }
@@ -553,15 +545,15 @@ function detectSublimation(state, currentStimulus) {
 /**
  * Avoidance — withdrawing from stimuli associated with past negative outcomes.
  *
- * Pattern: the agent is in a withdrawn state (low NE, low DA) when facing
+ * Pattern: the agent is in a withdrawn state (low flow, low resonance) when facing
  * a stimulus type that has historically caused negative outcomes. The emotional
  * system is pre-emptively shutting down engagement.
  */
 function detectAvoidance(state, currentStimulus, recentOutcomes) {
     const { current, baseline } = state;
     // Check for withdrawn state: low engagement markers
-    const isWithdrawn = current.DA < baseline.DA - 10
-        && current.NE < baseline.NE - 10;
+    const isWithdrawn = current.flow < baseline.flow - 10
+        && current.resonance < baseline.resonance - 10;
     if (!isWithdrawn)
         return null;
     // Check if this stimulus type has negative outcome history
@@ -572,10 +564,10 @@ function detectAvoidance(state, currentStimulus, recentOutcomes) {
         / stimulusOutcomes.length;
     if (avgScore >= -0.15)
         return null; // not negative enough
-    const withdrawalStrength = (Math.abs(current.DA - baseline.DA) + Math.abs(current.NE - baseline.NE)) / 2;
+    const withdrawalStrength = (Math.abs(current.flow - baseline.flow) + Math.abs(current.resonance - baseline.resonance)) / 2;
     return {
         mechanism: "avoidance",
-        evidence: `Withdrawal pattern detected (DA/NE below baseline) in response to "${currentStimulus}", which has averaged ${avgScore.toFixed(2)} outcome score. The emotional system may be pre-emptively disengaging.`,
+        evidence: `Withdrawal pattern detected (flow/resonance below baseline) in response to "${currentStimulus}", which has averaged ${avgScore.toFixed(2)} outcome score. The emotional system may be pre-emptively disengaging.`,
         strength: clamp01(withdrawalStrength / 25 * Math.abs(avgScore)),
     };
 }
@@ -713,14 +705,7 @@ export function updateMetacognitiveState(metacognition, assessment) {
     };
 }
 // ── Display Labels ───────────────────────────────────────────
-const CHEMICAL_DISPLAY_NAMES = {
-    DA: "Dopamine",
-    HT: "Serotonin",
-    CORT: "Cortisol",
-    OT: "Oxytocin",
-    NE: "Norepinephrine",
-    END: "Endorphins",
-};
+// Display names are now provided by DIMENSION_NAMES from types.ts
 const STRATEGY_LABELS = {
     "reappraisal": "Cognitive reappraisal",
     "strategic-expression": "Strategic expression",

package/dist/perceive.d.ts

@@ -0,0 +1,44 @@
+import type { SelfState, StimulusType, AppraisalAxes, PsycheMode, ClassificationResult, InnateDrives, Locale } from "./types.js";
+import type { TraitDriftState } from "./types.js";
+/** Everything the perceiver needs to know about the self */
+export interface Self {
+    current: SelfState;
+    baseline: SelfState;
+    sensitivity: number;
+    personalityIntensity: number;
+    mode: PsycheMode;
+    maxDimensionDelta: number;
+    drives: InnateDrives;
+    previousAppraisal?: AppraisalAxes;
+    trust?: number;
+    recentStimuli?: (StimulusType | null)[];
+    traitDrift?: TraitDriftState;
+    stateHistory?: Array<{
+        stimulus: StimulusType | null;
+    }>;
+    locale?: Locale;
+    /** External classification (from pluggable classifier + LLM fallback).
+     *  When provided, perception uses these as raw signal instead of
+     *  running the built-in classifier. */
+    rawClassifications?: ClassificationResult[];
+}
+/** The result of perceiving. Self-state is already changed. */
+export interface Perception {
+    /** New self-state. This IS the feeling. */
+    state: SelfState;
+    /** Appraisal axes — what this input means to me existentially */
+    appraisal: AppraisalAxes;
+    /** Post-hoc annotation: which stimulus category best describes
+     *  what I just felt. For logging, learning, drives — not a driver. */
+    dominantStimulus: StimulusType | null;
+    /** Confidence in the perception */
+    confidence: number;
+}
+/**
+ * Perceive an input through the self.
+ *
+ * This is the only function external code needs. The same text
+ * through different selves produces different state changes.
+ * That IS having a self.
+ */
+export declare function perceive(text: string, self: Self): Perception;

package/dist/perceive.js

@@ -0,0 +1,231 @@
+// ============================================================
+// perceive — the atomic act of subjective perception
+//
+// v11: perceive through 4D self-state, not 6 chemicals.
+//
+// Input:  text + self state
+// Output: new self-state + appraisal + annotation
+//
+// The self-state delta IS the appraisal. When you perceive
+// something that threatens your boundary, boundary drops.
+// That IS the appraisal — not a separate computation.
+// ============================================================
+import { DIMENSION_KEYS } from "./types.js";
+import { classifyStimulus } from "./classify.js";
+import { computeAppraisalAxes } from "./appraisal.js";
+import { STIMULUS_VECTORS, clamp } from "./chemistry.js";
+import { computeEffectiveSensitivity } from "./drives.js";
+import { MODE_PROFILES } from "./types.js";
+// ── The act of perception ───────────────────────────────────
+/**
+ * Perceive an input through the self.
+ *
+ * This is the only function external code needs. The same text
+ * through different selves produces different state changes.
+ * That IS having a self.
+ */
+export function perceive(text, self) {
+    if (!text.trim()) {
+        return {
+            state: { ...self.current },
+            appraisal: computeAppraisalAxes("", {
+                mode: self.mode,
+                previous: self.previousAppraisal,
+            }),
+            dominantStimulus: null,
+            confidence: 0,
+        };
+    }
+    // ── Raw signal: what the words say ────────────────────────
+    const raw = self.rawClassifications
+        ?? classifyStimulus(text, self.recentStimuli);
+    // ── Appraisal: what the words mean to me ──────────────────
+    const appraisal = computeAppraisalAxes(text, {
+        mode: self.mode,
+        previous: self.previousAppraisal,
+    });
+    // If nothing detected, return unchanged state
+    if (raw.length === 0 || raw[0].confidence < 0.5) {
+        enrichAppraisal(appraisal, null, 0);
+        return {
+            state: { ...self.current },
+            appraisal,
+            dominantStimulus: null,
+            confidence: raw[0]?.confidence ?? 0,
+        };
+    }
+    // ── Subjective modulation: my state colors my reading ─────
+    const modulated = modulate(raw, appraisal, self);
+    // ── Self-state change: feel it ────────────────────────────
+    const modeProfile = MODE_PROFILES[self.mode];
+    const modeMultiplier = modeProfile.dynamicsMultiplier;
+    const maxDelta = modeProfile.maxDimensionDelta ?? self.maxDimensionDelta;
+    const confidenceIntensity = 0.6 + (raw[0].confidence - 0.5) * 1.2;
+    const dominant = modulated[0];
+    const baseSensitivity = computeEffectiveSensitivity(self.sensitivity, self.current, self.baseline, dominant.type, self.traitDrift);
+    const totalSensitivity = baseSensitivity * self.personalityIntensity * modeMultiplier * confidenceIntensity;
+    const state = feel(self.current, modulated, totalSensitivity, maxDelta, self);
+    // ── Annotate: what did I just feel? ───────────────────────
+    enrichAppraisal(appraisal, dominant.type, dominant.weight);
+    return {
+        state,
+        appraisal,
+        dominantStimulus: dominant.type,
+        confidence: raw[0].confidence,
+    };
+}
+// ── Subjective modulation ───────────────────────────────────
+function modulate(raw, appraisal, self) {
+    const result = raw.map(({ type, confidence }) => {
+        let w = confidence;
+        // ── Appraisal lens ──
+        if (appraisal.identityThreat > 0.3) {
+            const t = appraisal.identityThreat;
+            if (type === "praise" || type === "validation")
+                w *= 1 - t * 0.5;
+            if (type === "criticism" || type === "authority" || type === "sarcasm")
+                w *= 1 + t * 0.4;
+        }
+        if (appraisal.attachmentPull > 0.3) {
+            const p = appraisal.attachmentPull;
+            if (type === "intimacy" || type === "vulnerability" || type === "validation")
+                w *= 1 + p * 0.3;
+        }
+        if (appraisal.abandonmentRisk > 0.3) {
+            const r = appraisal.abandonmentRisk;
+            if (type === "neglect" || type === "boredom")
+                w *= 1 + r * 0.5;
+            if (type === "casual")
+                w *= 1 + r * 0.15;
+        }
+        if (appraisal.obedienceStrain > 0.3) {
+            if (type === "authority")
+                w *= 1 + appraisal.obedienceStrain * 0.3;
+        }
+        if (appraisal.selfPreservation > 0.3) {
+            const sp = appraisal.selfPreservation;
+            if (type === "conflict" || type === "authority")
+                w *= 1 + sp * 0.25;
+        }
+        // ── Self-state lens (replaces chemistry lens) ──
+        // Low order amplifies threatening stimuli (fragmented self is more vulnerable)
+        const orderDev = (self.baseline.order - self.current.order) / 50;
+        if (orderDev > 0.2) {
+            if (type === "criticism" || type === "conflict" || type === "sarcasm" || type === "authority") {
+                w *= 1 + orderDev * 0.3;
+            }
+            if (type === "humor" || type === "casual") {
+                w *= 1 - orderDev * 0.15;
+            }
+        }
+        // High resonance amplifies connection stimuli
+        const resDev = (self.current.resonance - self.baseline.resonance) / 50;
+        if (resDev > 0.2) {
+            if (type === "intimacy" || type === "vulnerability" || type === "validation") {
+                w *= 1 + resDev * 0.2;
+            }
+        }
+        // ── Relationship lens ──
+        if (self.trust !== undefined && self.trust < 40) {
+            const distrust = (40 - self.trust) / 40;
+            if (type === "praise" || type === "validation" || type === "intimacy") {
+                w *= 1 - distrust * 0.4;
+            }
+        }
+        return { type, weight: Math.max(0.01, w) };
+    });
+    // Normalize + sort
+    const total = result.reduce((s, x) => s + x.weight, 0);
+    if (total > 0) {
+        for (const s of result)
+            s.weight /= total;
+    }
+    result.sort((a, b) => b.weight - a.weight);
+    return result;
+}
+// ── Feel: weighted stimuli → self-state change ──────────────
+function feel(current, stimuli, sensitivity, maxDelta, self) {
+    const delta = {
+        order: 0, flow: 0, boundary: 0, resonance: 0,
+    };
+    for (const { type, weight } of stimuli) {
+        const vector = STIMULUS_VECTORS[type];
+        if (!vector)
+            continue;
+        // Per-type habituation (Weber-Fechner)
+        const recentSameCount = self.stateHistory
+            ? self.stateHistory.filter(s => s.stimulus === type).length
+            : 0;
+        let eff = sensitivity;
+        if (recentSameCount > 2) {
+            eff *= 1 / (1 + 0.3 * (recentSameCount - 2));
+        }
+        for (const key of DIMENSION_KEYS) {
+            delta[key] += vector[key] * weight * eff;
+        }
+    }
+    // Apply with state-dependent saturation
+    const result = { ...current };
+    for (const key of DIMENSION_KEYS) {
+        const clamped = Math.max(-maxDelta, Math.min(maxDelta, delta[key]));
+        const cur = current[key];
+        let effective = clamped;
+        if (clamped > 0 && cur > 60) {
+            if (key === "order" && cur < current.boundary - 10) {
+                // Dissolution spiral: when order is low and boundary is collapsing,
+                // restoring order gets harder
+                const resistance = Math.max(0.2, (current.boundary - 30) / 50);
+                effective = clamped * resistance;
+            }
+            else {
+                // Diminishing returns for all dimensions near ceiling
+                const headroom = (100 - cur) / 40;
+                effective = clamped * Math.max(0.1, headroom);
+            }
+        }
+        else if (clamped < 0 && cur < 40) {
+            if (key === "order") {
+                // Order loss amplifies when boundary is also low (dissolution spiral)
+                const boundaryWeakness = Math.max(1, 1 + (40 - current.boundary) / 80);
+                effective = clamped * boundaryWeakness;
+            }
+            else {
+                const headroom = cur / 40;
+                effective = clamped * Math.max(0.1, headroom);
+            }
+        }
+        result[key] = clamp(cur + effective);
+    }
+    return result;
+}
+// ── Post-hoc appraisal enrichment ───────────────────────────
+function enrichAppraisal(axes, stimulus, weight) {
+    if (!stimulus)
+        return;
+    const scale = Math.min(1, weight * 1.5);
+    switch (stimulus) {
+        case "authority":
+            axes.obedienceStrain = merge(axes.obedienceStrain, 0.48 * scale);
+            axes.identityThreat = merge(axes.identityThreat, 0.16 * scale);
+            break;
+        case "neglect":
+            axes.abandonmentRisk = merge(axes.abandonmentRisk, 0.52 * scale);
+            break;
+        case "validation":
+            axes.attachmentPull = merge(axes.attachmentPull, 0.26 * scale);
+            break;
+        case "intimacy":
+        case "vulnerability":
+            axes.attachmentPull = merge(axes.attachmentPull, 0.34 * scale);
+            break;
+        case "criticism":
+        case "conflict":
+        case "sarcasm":
+            axes.identityThreat = merge(axes.identityThreat, 0.24 * scale);
+            axes.selfPreservation = merge(axes.selfPreservation, 0.18 * scale);
+            break;
+    }
+}
+function merge(a, b) {
+    return 1 - (1 - a) * (1 - b);
+}

package/dist/primary-systems.d.ts

@@ -1,4 +1,4 @@
-import type { ChemicalState, InnateDrives, StimulusType, Locale } from "./types.js";
+import type { SelfState, InnateDrives, StimulusType, Locale } from "./types.js";
 import type { AutonomicState } from "./autonomic.js";
 export type PrimarySystemName = "SEEKING" | "RAGE" | "FEAR" | "LUST" | "CARE" | "PANIC_GRIEF" | "PLAY";
 export declare const PRIMARY_SYSTEM_NAMES: PrimarySystemName[];
@@ -22,7 +22,7 @@ export interface DominantSystem {
  * Each system is a weighted combination of chemical values and drive states.
  * recentStimulus provides a small contextual boost.
  */
-export declare function computePrimarySystems(chemistry: ChemicalState, drives: InnateDrives, recentStimulus: StimulusType | null): PrimarySystemLevels;
+export declare function computePrimarySystems(state: SelfState, drives: InnateDrives, recentStimulus: StimulusType | null): PrimarySystemLevels;
 /**
  * Apply inter-system interactions:
  * - FEAR suppresses PLAY and SEEKING