psyche-ai 10.2.3 → 11.2.0

package/dist/core.js

@@ -9,20 +9,21 @@
 // Auto-learning: processInput auto-evaluates the previous turn's
 // outcome using the new user message as the outcome signal.
 //
-// Orchestrates: chemistry, classify, prompt, profiles, guards, learning
+// Orchestrates: self-state, classify, prompt, profiles, guards, learning
 // ============================================================
-import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT, DEFAULT_SUBJECT_RESIDUE, DEFAULT_DYADIC_FIELD, MODE_PROFILES } from "./types.js";
+import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT, DEFAULT_SUBJECT_RESIDUE, DEFAULT_DYADIC_FIELD } from "./types.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.js";
 import { classifyStimulus, BuiltInClassifier, buildLLMClassifierPrompt, parseLLMClassification } from "./classify.js";
+import { perceive } from "./perceive.js";
 import { buildCompactContext, buildProtocolContext } from "./prompt.js";
 import { getSensitivity, getBaseline, getDefaultSelfModel, traitsToBaseline } from "./profiles.js";
 import { isStimulusType } from "./guards.js";
 import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, compressSession, summarizeTurnSemantic, } from "./psyche-file.js";
-import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
+import { detectExistentialThreat, deriveDriveSatisfaction, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
 import { checkForUpdate, getPackageVersion } from "./update.js";
 import { DiagnosticCollector, generateReport, formatLogEntry, submitFeedback } from "./diagnostics.js";
-import { evaluateOutcome, computeContextHash, updateLearnedVector, predictChemistry, recordPrediction, } from "./learning.js";
+import { evaluateOutcome, computeContextHash, updateLearnedVector, predictState, recordPrediction, } from "./learning.js";
 import { computeCircadianModulation, computeHomeostaticPressure, computeEnergyDepletion, computeEnergyRecovery } from "./circadian.js";
 import { runReflectiveTurnPhases } from "./input-turn.js";
 import { applyRelationalTurn, applySessionBridge, applyWritebackSignals, createWritebackCalibrations, evaluateWritebackCalibrations } from "./relation-dynamics.js";
@@ -60,22 +61,25 @@ const RELATIONSHIP_DELTAS = {
 function applyRepairLag(previous, next, baseline, stimulus) {
     if (!REPAIRING_STIMULI.has(stimulus))
         return next;
-    const stressLoad = Math.max(0, previous.CORT - baseline.CORT);
+    // Low order = high stress (inverse of old CORT). Stress = baseline.order - previous.order.
+    const stressLoad = Math.max(0, baseline.order - previous.order);
     if (stressLoad < 15)
         return next;
     // High stress slows emotional recovery so apology/praise doesn't instantly
-    // snap chemistry back to baseline.
+    // snap state back to baseline.
     const repairFactor = Math.max(0.35, 1 - stressLoad / 50);
     const adjusted = { ...next };
-    for (const key of ["DA", "HT", "OT", "END"]) {
+    // For flow, resonance, boundary: positive deltas (recovery) are damped
+    for (const key of ["flow", "resonance", "boundary"]) {
         const delta = next[key] - previous[key];
         if (delta > 0) {
             adjusted[key] = clamp(previous[key] + delta * repairFactor);
         }
     }
-    const cortDelta = next.CORT - previous.CORT;
-    if (cortDelta < 0) {
-        adjusted.CORT = clamp(previous.CORT + cortDelta * repairFactor);
+    // For order: recovery means order increasing (stress reducing)
+    const orderDelta = next.order - previous.order;
+    if (orderDelta > 0) {
+        adjusted.order = clamp(previous.order + orderDelta * repairFactor);
     }
     return adjusted;
 }
@@ -144,7 +148,7 @@ export class PsycheEngine {
             locale: config.locale ?? "zh",
             stripUpdateTags: config.stripUpdateTags ?? true,
             emotionalContagionRate: config.emotionalContagionRate ?? 0.2,
-            maxChemicalDelta: config.maxChemicalDelta ?? 25,
+            maxDimensionDelta: config.maxDimensionDelta ?? 25,
             compactMode: config.compactMode ?? true,
             mode: config.mode ?? "natural",
             personalityIntensity: config.personalityIntensity ?? 0.7,
@@ -189,7 +193,7 @@ export class PsycheEngine {
                 loaded.version = 7;
             }
             // Migrate v7 → v8: P8 Barrett construction + P10 processing depth + P11 memory consolidation
-            // No data changes needed — ChemicalSnapshot new fields are optional (backward compatible)
+            // No data changes needed — StateSnapshot new fields are optional (backward compatible)
             if (loaded.version < 8) {
                 loaded.version = 8;
             }
@@ -245,7 +249,7 @@ export class PsycheEngine {
             // Record prediction accuracy
             state = {
                 ...state,
-                learning: recordPrediction(state.learning, this.pendingPrediction.predictedChemistry, state.current, this.pendingPrediction.appliedStimulus),
+                learning: recordPrediction(state.learning, this.pendingPrediction.predictedState, state.current, this.pendingPrediction.appliedStimulus),
             };
             // Update learned vectors based on outcome
             if (this.pendingPrediction.appliedStimulus) {
@@ -262,15 +266,15 @@ export class PsycheEngine {
         const now = new Date();
         const minutesElapsed = (now.getTime() - new Date(state.updatedAt).getTime()) / 60000;
         if (minutesElapsed >= 1) {
-            // Decay drives first — needs build up over time
-            const decayedDrives = decayDrives(state.drives, minutesElapsed);
-            // Compute effective baseline from drives (unsatisfied drives shift baseline)
-            const effectiveBaseline = computeEffectiveBaseline(state.baseline, decayedDrives, state.traitDrift);
+            // Compute effective baseline from current 4D position (drives are derived, not stored)
+            const effectiveBaseline = computeEffectiveBaseline(state.baseline, state.current, state.traitDrift);
             // P12: Apply circadian rhythm modulation to effective baseline
             const circadianBaseline = computeCircadianModulation(now, effectiveBaseline);
+            // Derive drives from current position for state persistence
+            const drives = deriveDriveSatisfaction(state.current, state.baseline);
             state = {
                 ...state,
-                drives: decayedDrives,
+                drives,
                 current: applyDecay(state.current, circadianBaseline, minutesElapsed, state.traitDrift?.decayRateModifiers),
                 updatedAt: now.toISOString(),
             };
@@ -285,36 +289,38 @@ export class PsycheEngine {
         // Apply homeostatic pressure (fatigue from extended sessions)
         const sessionMinutes = (now.getTime() - new Date(state.sessionStartedAt).getTime()) / 60000;
         const pressure = computeHomeostaticPressure(sessionMinutes);
-        if (pressure.cortAccumulation > 0 || pressure.daDepletion > 0 || pressure.neDepletion > 0) {
+        if (pressure.orderDepletion > 0 || pressure.flowDepletion > 0 || pressure.boundaryStiffening > 0) {
             state = {
                 ...state,
                 current: {
                     ...state.current,
-                    CORT: clamp(state.current.CORT + pressure.cortAccumulation * 0.1),
-                    DA: clamp(state.current.DA - pressure.daDepletion * 0.1),
-                    NE: clamp(state.current.NE - pressure.neDepletion * 0.1),
+                    order: clamp(state.current.order - pressure.orderDepletion * 0.1),
+                    flow: clamp(state.current.flow - pressure.flowDepletion * 0.1),
+                    boundary: clamp(state.current.boundary + pressure.boundaryStiffening * 0.1),
                 },
             };
         }
         // v9: Energy budget recovery during absence + depletion per turn
-        const isExtravert = state.baseline.DA >= 55;
+        const isExtravert = state.baseline.flow >= 55;
         const currentBudgets = state.energyBudgets ?? { ...DEFAULT_ENERGY_BUDGETS };
         let energyBudgets = minutesElapsed >= 5
             ? computeEnergyRecovery(currentBudgets, minutesElapsed, isExtravert)
             : { ...currentBudgets };
-        // Classify user stimulus and apply chemistry
+        // ── Perceive ─────────────────────────────────────────────
+        // One act. Text enters the self, chemistry changes, appraisal
+        // forms. There is no "classify then feel" — perception is atomic.
         let appliedStimulus = null;
+        let perceptionAppraisal;
         if (text.length > 0) {
-            // Check for existential threats → direct survival drive hit
+            // Existential threats → direct survival drive hit (pre-perception)
             const survivalHit = detectExistentialThreat(text);
             let drives = state.drives;
             if (survivalHit < 0) {
                 drives = { ...drives, survival: Math.max(0, drives.survival + survivalHit) };
             }
-            const recentStimuli = (state.emotionalHistory ?? []).slice(-3).map(s => s.stimulus);
-            // v9.1: Use pluggable classifier
+            const recentStimuli = (state.stateHistory ?? []).slice(-3).map(s => s.stimulus);
+            // Pluggable classifier + LLM fallback (raw signal for perception)
             let classifications = await Promise.resolve(this.classifier.classify(text, { recentStimuli, locale: this.cfg.locale }));
-            // v9.1: LLM fallback when confidence is low
             if (this.llmClassifier &&
                 (!classifications[0] || classifications[0].confidence < this.cfg.llmClassifierThreshold)) {
                 try {
@@ -325,40 +331,45 @@ export class PsycheEngine {
                         classifications = [llmResult, ...classifications];
                     }
                 }
-                catch {
-                    // LLM call failed — continue with built-in result
-                }
+                catch { /* continue with built-in */ }
             }
-            const primary = classifications[0];
-            const primaryConfidence = primary?.confidence ?? 0;
-            let current = state.current;
-            if (primary && primary.confidence >= 0.5) {
-                appliedStimulus = primary.type;
-                const preStimulus = current;
-                // Feed drives from stimulus, then apply stimulus with drive-modified sensitivity
-                drives = feedDrives(drives, primary.type);
-                const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), drives, primary.type, state.traitDrift);
-                // v9.2: Confidence modulates intensity — a 0.95 life-or-death dilemma
-                // hits ~1.7x harder than a 0.55 mild disagreement.
-                // Maps [0.5, 1.0] → [0.6, 1.2] via linear interpolation.
-                const confidenceIntensity = 0.6 + (primary.confidence - 0.5) * 1.2;
-                const modeProfile = MODE_PROFILES[this.cfg.mode];
-                const modeMultiplier = modeProfile.chemistryMultiplier;
-                const effectiveMaxDelta = modeProfile.maxChemicalDelta ?? this.cfg.maxChemicalDelta;
-                // v9: Habituation — count recent same-type stimuli in this session
-                const recentSameCount = (state.emotionalHistory ?? [])
-                    .filter(s => s.stimulus === primary.type).length + 1; // +1 for current
-                current = applyStimulus(current, primary.type, effectiveSensitivity * this.cfg.personalityIntensity * modeMultiplier * confidenceIntensity, effectiveMaxDelta, NOOP_LOGGER, recentSameCount);
-                current = applyRepairLag(preStimulus, current, state.baseline, primary.type);
+            // Resolve relationship trust
+            const userId = opts?.userId ?? "__default__";
+            const trust = state.relationships?.[userId]?.trust;
+            // Perceive: text + self → chemistry + appraisal + annotation
+            const perception = perceive(text, {
+                current: state.current,
+                baseline: state.baseline,
+                sensitivity: state.sensitivity ?? 1.0,
+                personalityIntensity: this.cfg.personalityIntensity,
+                mode: this.cfg.mode,
+                maxDimensionDelta: this.cfg.maxDimensionDelta,
+                drives,
+                previousAppraisal: state.subjectResidue?.axes,
+                trust,
+                recentStimuli,
+                traitDrift: state.traitDrift,
+                stateHistory: state.stateHistory,
+                locale: this.cfg.locale,
+                rawClassifications: classifications,
+            });
+            appliedStimulus = perception.dominantStimulus;
+            perceptionAppraisal = perception.appraisal;
+            // Chemistry is already changed inside perceive(). Apply repair lag.
+            let current = perception.state;
+            if (appliedStimulus) {
+                current = applyRepairLag(state.current, current, state.baseline, appliedStimulus);
             }
+            // Derive drives from updated position
+            drives = deriveDriveSatisfaction(current, state.baseline);
             state = { ...state, drives, current };
             if (appliedStimulus) {
                 state = applyRelationshipDrift(state, appliedStimulus, opts?.userId);
             }
             this.lastStimulusAssessment = {
-                stimulus: primary?.type ?? null,
-                confidence: primaryConfidence,
-                overrideWindow: primaryConfidence >= 0.78 ? "narrow" : primaryConfidence >= 0.62 ? "balanced" : "wide",
+                stimulus: appliedStimulus,
+                confidence: perception.confidence,
+                overrideWindow: perception.confidence >= 0.78 ? "narrow" : perception.confidence >= 0.62 ? "balanced" : "wide",
             };
         }
         else {
@@ -368,29 +379,31 @@ export class PsycheEngine {
                 overrideWindow: "wide",
             };
         }
-        // v9: Deplete energy budgets from this interaction turn
+        // Deplete energy budgets
         energyBudgets = computeEnergyDepletion(energyBudgets, appliedStimulus, isExtravert);
         state = { ...state, energyBudgets };
+        // Relational turn uses pre-computed appraisal from perception
         const relationalTurn = applyRelationalTurn(state, text, {
             mode: this.cfg.mode,
             now: now.toISOString(),
             stimulus: appliedStimulus,
             userId: opts?.userId,
+            preComputedAppraisal: perceptionAppraisal,
         });
         state = relationalTurn.state;
         const appraisalAxes = relationalTurn.appraisalAxes;
-        // Conversation warmth: sustained interaction → gentle DA/OT rise, CORT drop
+        // Conversation warmth: sustained interaction → gentle flow/resonance rise, order stabilization
         // Simulates the natural "warm glow" of being in continuous conversation
-        const turnsSoFar = (state.emotionalHistory ?? []).length;
+        const turnsSoFar = (state.stateHistory ?? []).length;
         if (minutesElapsed < 5 && turnsSoFar > 0) {
             const warmth = Math.min(3, 1 + turnsSoFar * 0.2);
             state = {
                 ...state,
                 current: {
                     ...state.current,
-                    DA: clamp(state.current.DA + warmth),
-                    OT: clamp(state.current.OT + warmth),
-                    CORT: clamp(state.current.CORT - 1),
+                    flow: clamp(state.current.flow + warmth),
+                    resonance: clamp(state.current.resonance + warmth),
+                    order: clamp(state.current.order + 1),
                 },
             };
         }
@@ -424,10 +437,10 @@ export class PsycheEngine {
         // ── Generate prediction for next turn's auto-learning ────
         if (appliedStimulus) {
             const ctxHash = computeContextHash(state, opts?.userId);
-            const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), state.drives, appliedStimulus, state.traitDrift);
-            const predicted = predictChemistry(preInteractionState.current, appliedStimulus, state.learning, ctxHash, effectiveSensitivity, this.cfg.maxChemicalDelta);
+            const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), state.current, state.baseline, appliedStimulus, state.traitDrift);
+            const predicted = predictState(preInteractionState.current, appliedStimulus, state.learning, ctxHash, effectiveSensitivity, this.cfg.maxDimensionDelta);
             this.pendingPrediction = {
-                predictedChemistry: predicted,
+                predictedState: predicted,
                 preInteractionState,
                 appliedStimulus,
                 contextHash: ctxHash,
@@ -552,16 +565,16 @@ export class PsycheEngine {
                 const RELEASE_TYPES = new Set([
                     "vulnerability", "intimacy", "validation",
                 ]);
-                if (RELEASE_TYPES.has(selfPrimary.type) && state.current.CORT > 60) {
-                    const stressExcess = (state.current.CORT - 60) / 40; // 0 at CORT=60, 1 at CORT=100
-                    const recoveryMagnitude = 3 + stressExcess * 5; // 3–8 point CORT drop
+                if (RELEASE_TYPES.has(selfPrimary.type) && state.current.order < 40) {
+                    const stressExcess = (40 - state.current.order) / 40; // 0 at order=40, 1 at order=0
+                    const recoveryMagnitude = 3 + stressExcess * 5; // 3–8 point recovery
                     state = {
                         ...state,
                         current: {
                             ...state.current,
-                            CORT: clamp(state.current.CORT - recoveryMagnitude),
-                            END: clamp(state.current.END + recoveryMagnitude * 0.6),
-                            HT: clamp(state.current.HT + recoveryMagnitude * 0.3),
+                            order: clamp(state.current.order + recoveryMagnitude),
+                            resonance: clamp(state.current.resonance + recoveryMagnitude * 0.6),
+                            boundary: clamp(state.current.boundary + recoveryMagnitude * 0.3),
                         },
                     };
                 }
@@ -575,20 +588,18 @@ export class PsycheEngine {
         if (text.includes("<psyche_update>")) {
             const parseResult = parsePsycheUpdate(text, NOOP_LOGGER);
             if (parseResult) {
-                state = mergeUpdates(state, parseResult.state, this.cfg.maxChemicalDelta, opts?.userId);
+                state = mergeUpdates(state, parseResult.state, this.cfg.maxDimensionDelta, opts?.userId);
                 stateChanged = true;
                 // LLM-assisted classification: if algorithm didn't apply a stimulus
                 // but LLM classified one, retroactively apply chemistry + drives
                 const overrideAllowed = this.lastStimulusAssessment?.overrideWindow !== "narrow";
                 if (parseResult.llmStimulus && (!this._lastAlgorithmApplied || overrideAllowed)) {
+                    const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), state.current, state.baseline, parseResult.llmStimulus, state.traitDrift);
+                    const newCurrent = applyStimulus(state.current, parseResult.llmStimulus, effectiveSensitivity * (overrideAllowed && this._lastAlgorithmApplied ? 0.8 : 1), this.cfg.maxDimensionDelta, NOOP_LOGGER);
                     state = {
                         ...state,
-                        drives: feedDrives(state.drives, parseResult.llmStimulus),
-                    };
-                    const effectiveSensitivity = computeEffectiveSensitivity((state.sensitivity ?? 1.0), state.drives, parseResult.llmStimulus, state.traitDrift);
-                    state = {
-                        ...state,
-                        current: applyStimulus(state.current, parseResult.llmStimulus, effectiveSensitivity * (overrideAllowed && this._lastAlgorithmApplied ? 0.8 : 1), this.cfg.maxChemicalDelta, NOOP_LOGGER),
+                        current: newCurrent,
+                        drives: deriveDriveSatisfaction(newCurrent, state.baseline),
                     };
                 }
                 if (parseResult.signals && parseResult.signals.length > 0) {
@@ -653,7 +664,7 @@ export class PsycheEngine {
         // Record prediction
         state = {
             ...state,
-            learning: recordPrediction(state.learning, pending.predictedChemistry, state.current, pending.appliedStimulus),
+            learning: recordPrediction(state.learning, pending.predictedState, state.current, pending.appliedStimulus),
         };
         // Update learned vectors
         let learningUpdated = false;
@@ -687,7 +698,7 @@ export class PsycheEngine {
         return cached;
     }
     /**
-     * End the current session: compress emotionalHistory into a rich summary
+     * End the current session: compress stateHistory into a rich summary
      * stored in relationship.memory[], then preserve only core/recent context.
      * Auto-generates diagnostic report and persists to log.
      *
@@ -715,7 +726,7 @@ export class PsycheEngine {
                 submitFeedback(report, this.feedbackUrl).catch(() => { });
             }
         }
-        if ((state.emotionalHistory ?? []).length >= 2) {
+        if ((state.stateHistory ?? []).length >= 2) {
             state = compressSession(state, opts?.userId);
         }
         // Reset session tracking for homeostatic pressure
@@ -784,7 +795,7 @@ export class PsycheEngine {
             relationships: { _default: { ...DEFAULT_RELATIONSHIP } },
             empathyLog: null,
             selfModel,
-            emotionalHistory: [],
+            stateHistory: [],
             agreementStreak: 0,
             lastDisagreement: null,
             learning: { ...DEFAULT_LEARNING_STATE },
@@ -828,7 +839,7 @@ export class PsycheEngine {
             current: { ...baseline },
             baseline,
             drives: { ...DEFAULT_DRIVES },
-            emotionalHistory: [],
+            stateHistory: [],
             agreementStreak: 0,
             lastDisagreement: null,
             empathyLog: null,
@@ -863,16 +874,16 @@ export class PsycheEngine {
         const state = this.ensureInitialized();
         const locale = state.meta.locale ?? "zh";
         const emotion = describeEmotionalState(state.current, locale);
-        const { DA, CORT } = state.current;
+        const { flow, order } = state.current;
         // Emoji based on dominant state
         let emoji = "\u{1F610}";
-        if (DA > 70 && CORT < 40)
+        if (flow > 70 && order > 60)
             emoji = "\u{1F60A}";
-        else if (DA > 60)
+        else if (flow > 60)
             emoji = "\u{1F642}";
-        else if (CORT > 60)
+        else if (order < 40)
             emoji = "\u{1F630}";
-        else if (DA < 35)
+        else if (flow < 35)
             emoji = "\u{1F614}";
         // Check for hungry drives
         const hungryDrives = Object.entries(state.drives)
@@ -881,6 +892,6 @@ export class PsycheEngine {
         const driveWarning = hungryDrives.length > 0
             ? ` | \u26A0\uFE0F${hungryDrives.join(",")}`
             : "";
-        return `${emoji} ${emotion} | DA:${Math.round(DA)} CORT:${Math.round(CORT)}${driveWarning}`;
+        return `${emoji} ${emotion} | flow:${Math.round(flow)} order:${Math.round(order)}${driveWarning}`;
     }
 }

package/dist/custom-profile.d.ts

@@ -1,12 +1,12 @@
-import type { ChemicalState, MBTIType, StimulusType, SelfModel, InnateDrives } from "./types.js";
+import type { SelfState, MBTIType, StimulusType, SelfModel, InnateDrives } from "./types.js";
 /** Configuration for creating a custom personality profile */
 export interface CustomProfileConfig {
     /** Unique name for the profile, e.g. "cheerful-assistant", "stoic-mentor" */
     name: string;
     /** Optional description of the personality */
     description?: string;
-    /** Override specific chemicals; rest inherited from baseMBTI */
-    baseline?: Partial<ChemicalState>;
+    /** Override specific dimensions; rest inherited from baseMBTI */
+    baseline?: Partial<SelfState>;
     /** Which MBTI to use as starting point (default: "INFJ") */
     baseMBTI?: MBTIType;
     /** Override specific stimulus sensitivities (0.1-3.0) */
@@ -30,7 +30,7 @@ export interface ResolvedProfile {
     name: string;
     description: string;
     baseMBTI: MBTIType;
-    baseline: ChemicalState;
+    baseline: SelfState;
     sensitivityMap: Record<StimulusType, number>;
     temperament: {
         expressiveness: number;
@@ -61,10 +61,10 @@ export declare const PRESET_PROFILES: {
         description: string;
         baseMBTI: MBTIType;
         baseline: {
-            DA: number;
-            END: number;
-            HT: number;
-            CORT: number;
+            order: number;
+            flow: number;
+            boundary: number;
+            resonance: number;
         };
         temperament: {
             expressiveness: number;
@@ -87,10 +87,10 @@ export declare const PRESET_PROFILES: {
         description: string;
         baseMBTI: MBTIType;
         baseline: {
-            HT: number;
-            CORT: number;
-            DA: number;
-            NE: number;
+            order: number;
+            flow: number;
+            boundary: number;
+            resonance: number;
         };
         sensitivity: Partial<Record<StimulusType, number>>;
         temperament: {
@@ -110,10 +110,10 @@ export declare const PRESET_PROFILES: {
         description: string;
         baseMBTI: MBTIType;
         baseline: {
-            OT: number;
-            HT: number;
-            END: number;
-            CORT: number;
+            order: number;
+            flow: number;
+            boundary: number;
+            resonance: number;
         };
         sensitivity: Partial<Record<StimulusType, number>>;
         temperament: {
@@ -136,10 +136,10 @@ export declare const PRESET_PROFILES: {
         description: string;
         baseMBTI: MBTIType;
         baseline: {
-            NE: number;
-            DA: number;
-            HT: number;
-            OT: number;
+            order: number;
+            flow: number;
+            boundary: number;
+            resonance: number;
         };
         sensitivity: Partial<Record<StimulusType, number>>;
         temperament: {

package/dist/custom-profile.js

@@ -4,7 +4,7 @@
 // Allows creating fully customized personality profiles that
 // start from an MBTI base and override specific parameters.
 // ============================================================
-import { CHEMICAL_KEYS, DEFAULT_DRIVES, DRIVE_KEYS } from "./types.js";
+import { DIMENSION_KEYS, DEFAULT_DRIVES, DRIVE_KEYS } from "./types.js";
 import { getBaseline, getDefaultSelfModel, getSensitivity } from "./profiles.js";
 import { isMBTIType, isStimulusType } from "./guards.js";
 // ── Stimulus type list for iteration ────────────────────────
@@ -14,7 +14,7 @@ const ALL_STIMULUS_TYPES = [
     "sarcasm", "authority", "validation", "boredom", "vulnerability",
 ];
 // ── Clamping helpers ────────────────────────────────────────
-function clampChemical(v) {
+function clampDimension(v) {
     return Math.max(0, Math.min(100, v));
 }
 function clampSensitivity(v) {
@@ -48,12 +48,12 @@ export function createCustomProfile(config) {
     const baseSensitivity = getSensitivity(baseMBTI);
     const baseSelfModel = getDefaultSelfModel(baseMBTI);
     const baseTemperament = defaultTemperamentFromMBTI(baseMBTI);
-    // Merge baseline: start from MBTI, override specific chemicals
+    // Merge baseline: start from MBTI, override specific dimensions
     const baseline = { ...baseBaseline };
     if (config.baseline) {
-        for (const key of CHEMICAL_KEYS) {
+        for (const key of DIMENSION_KEYS) {
             if (config.baseline[key] !== undefined) {
-                baseline[key] = clampChemical(config.baseline[key]);
+                baseline[key] = clampDimension(config.baseline[key]);
             }
         }
     }
@@ -127,7 +127,7 @@ export function validateProfileConfig(config) {
             errors.push("baseMBTI must be a valid MBTI type (e.g. INFJ, ENTP)");
         }
     }
-    // baseline: optional partial ChemicalState
+    // baseline: optional partial SelfState
     if (obj.baseline !== undefined) {
         if (typeof obj.baseline !== "object" || obj.baseline === null || Array.isArray(obj.baseline)) {
             errors.push("baseline must be an object");
@@ -135,8 +135,8 @@ export function validateProfileConfig(config) {
         else {
             const bl = obj.baseline;
             for (const key of Object.keys(bl)) {
-                if (!CHEMICAL_KEYS.includes(key)) {
-                    errors.push(`baseline.${key} is not a valid chemical key (valid: ${CHEMICAL_KEYS.join(", ")})`);
+                if (!DIMENSION_KEYS.includes(key)) {
+                    errors.push(`baseline.${key} is not a valid dimension key (valid: ${DIMENSION_KEYS.join(", ")})`);
                 }
                 else if (typeof bl[key] !== "number" || !isFinite(bl[key])) {
                     errors.push(`baseline.${key} must be a finite number`);
@@ -240,7 +240,7 @@ export const PRESET_PROFILES = {
         name: "cheerful",
         description: "Sunny, warm personality with high energy and emotional stability",
         baseMBTI: "ENFP",
-        baseline: { DA: 80, END: 75, HT: 65, CORT: 20 },
+        baseline: { order: 65, flow: 80, boundary: 50, resonance: 75 },
         temperament: {
             expressiveness: 0.9,
             volatility: 0.2,
@@ -258,7 +258,7 @@ export const PRESET_PROFILES = {
         name: "stoic",
         description: "Calm, measured personality with emotional restraint and deep resilience",
         baseMBTI: "INTJ",
-        baseline: { HT: 75, CORT: 25, DA: 45, NE: 40 },
+        baseline: { order: 75, flow: 45, boundary: 72, resonance: 35 },
         sensitivity: {
             praise: 0.3,
             criticism: 0.4,
@@ -285,7 +285,7 @@ export const PRESET_PROFILES = {
         name: "empathetic",
         description: "Deeply attuned to others' emotions, strong bonding instinct",
         baseMBTI: "INFJ",
-        baseline: { OT: 80, HT: 60, END: 60, CORT: 30 },
+        baseline: { order: 60, flow: 55, boundary: 45, resonance: 80 },
         sensitivity: {
             intimacy: 2.5,
             vulnerability: 2.8,
@@ -310,7 +310,7 @@ export const PRESET_PROFILES = {
         name: "analytical",
         description: "Sharp, focused personality driven by intellectual curiosity",
         baseMBTI: "INTP",
-        baseline: { NE: 75, DA: 60, HT: 60, OT: 30 },
+        baseline: { order: 60, flow: 75, boundary: 68, resonance: 30 },
         sensitivity: {
             intellectual: 2.5,
             surprise: 2.0,

package/dist/decision-bias.d.ts

@@ -17,13 +17,13 @@ export interface AttentionWeights {
 /**
  * Compute a decision bias vector from the current psyche state.
  *
- * Each bias dimension is a weighted combination of relevant chemical
- * levels and drive states, normalized to [0, 1] where 0.5 is neutral.
+ * Each bias dimension is a weighted combination of relevant self-state
+ * dimensions and drive states, normalized to [0, 1] where 0.5 is neutral.
  */
 export declare function computeDecisionBias(state: PsycheState): DecisionBiasVector;
 /**
  * Compute attention weights that prioritize different conversation content
- * based on current chemical state.
+ * based on current self-state dimensions.
  *
  * Returns normalized weights (sum to ~1) for each content category.
  * Higher weight = higher priority for that type of content.
@@ -38,15 +38,14 @@ export declare function computeAttentionWeights(state: PsycheState): AttentionWe
  *
  * Exploration is driven by:
  *   - High curiosity drive satisfaction (energy to explore)
- *   - High DA (reward anticipation)
- *   - High NE (novelty-seeking)
- *   - Low CORT (not stressed)
+ *   - High flow (exchange/novelty-seeking)
+ *   - High order (coherent enough to venture out)
  *   - High safety (secure enough to take risks)
  *
  * Exploitation is driven by:
- *   - High CORT / anxiety
+ *   - Low order (disorder/stress)
  *   - Low safety drive satisfaction
- *   - Low DA (no reward motivation)
+ *   - Low flow (no exchange motivation)
  */
 export declare function computeExploreExploit(state: PsycheState): number;
 /**