psyche-ai 5.0.0 → 7.1.0

package/dist/core.js

@@ -12,28 +12,39 @@
 // Orchestrates: chemistry, classify, prompt, profiles, guards, learning
 // ============================================================
 import { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE } from "./types.js";
-import { applyDecay, applyStimulus, applyContagion, clamp } from "./chemistry.js";
+import { MemoryStorageAdapter } from "./storage.js";
+import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.js";
 import { classifyStimulus } from "./classify.js";
 import { buildDynamicContext, buildProtocolContext, buildCompactContext } from "./prompt.js";
-import { getSensitivity, getBaseline, getDefaultSelfModel } from "./profiles.js";
+import { getSensitivity, getBaseline, getDefaultSelfModel, traitsToBaseline } from "./profiles.js";
 import { isStimulusType } from "./guards.js";
-import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, } from "./psyche-file.js";
+import { parsePsycheUpdate, mergeUpdates, updateAgreementStreak, pushSnapshot, compressSession, } from "./psyche-file.js";
 import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBaseline, computeEffectiveSensitivity, } from "./drives.js";
 import { checkForUpdate } from "./update.js";
 import { evaluateOutcome, computeContextHash, updateLearnedVector, predictChemistry, recordPrediction, } from "./learning.js";
 import { assessMetacognition } from "./metacognition.js";
 import { buildDecisionContext } from "./decision-bias.js";
+import { computeExperientialField } from "./experiential-field.js";
+import { computeGenerativeSelf } from "./generative-self.js";
+import { updateSharedIntentionality, buildSharedIntentionalityContext } from "./shared-intentionality.js";
+import { assessEthics, buildEthicalContext } from "./ethics.js";
+import { computeCircadianModulation, computeHomeostaticPressure } from "./circadian.js";
+import { computeAutonomicResult } from "./autonomic.js";
+import { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, describeBehavioralTendencies, } from "./primary-systems.js";
 const NOOP_LOGGER = { info: () => { }, warn: () => { }, debug: () => { } };
 // ── PsycheEngine ─────────────────────────────────────────────
 export class PsycheEngine {
     state = null;
     storage;
+    /** Whether the algorithm applied a stimulus in the last processInput call */
+    _lastAlgorithmApplied = false;
+    traits;
     cfg;
     protocolCache = new Map();
     /** Pending prediction from last processInput for auto-learning */
     pendingPrediction = null;
     constructor(config = {}, storage) {
-        this.storage = storage;
+        this.traits = config.traits;
         this.cfg = {
             mbti: config.mbti ?? "INFJ",
             name: config.name ?? "agent",
@@ -42,7 +53,16 @@ export class PsycheEngine {
             emotionalContagionRate: config.emotionalContagionRate ?? 0.2,
             maxChemicalDelta: config.maxChemicalDelta ?? 25,
             compactMode: config.compactMode ?? true,
+            mode: config.mode ?? "natural",
+            personalityIntensity: config.personalityIntensity ?? 0.7,
         };
+        // If persist is false, use in-memory storage regardless of what was passed
+        if (config.persist === false) {
+            this.storage = new MemoryStorageAdapter();
+        }
+        else {
+            this.storage = storage;
+        }
     }
     /**
      * Load or create initial state. Must be called before processInput/processOutput.
@@ -65,6 +85,12 @@ export class PsycheEngine {
                 loaded.personhood = { ...DEFAULT_PERSONHOOD_STATE };
                 loaded.version = 6;
             }
+            // Migrate v6 → v7: add autonomic state and session tracking
+            if (loaded.version < 7) {
+                loaded.autonomicState = "ventral-vagal";
+                loaded.sessionStartedAt = new Date().toISOString();
+                loaded.version = 7;
+            }
             this.state = loaded;
         }
         else {
@@ -111,43 +137,56 @@ export class PsycheEngine {
             const decayedDrives = decayDrives(state.drives, minutesElapsed);
             // Compute effective baseline from drives (unsatisfied drives shift baseline)
             const effectiveBaseline = computeEffectiveBaseline(state.baseline, decayedDrives);
+            // P12: Apply circadian rhythm modulation to effective baseline
+            const circadianBaseline = computeCircadianModulation(now, effectiveBaseline);
             state = {
                 ...state,
                 drives: decayedDrives,
-                current: applyDecay(state.current, effectiveBaseline, minutesElapsed),
+                current: applyDecay(state.current, circadianBaseline, minutesElapsed),
                 updatedAt: now.toISOString(),
             };
         }
+        // P12: Track session start for homeostatic pressure
+        if (!state.sessionStartedAt) {
+            state = { ...state, sessionStartedAt: now.toISOString() };
+        }
+        // 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) {
+            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),
+                },
+            };
+        }
         // Classify user stimulus and apply chemistry
         let appliedStimulus = null;
         if (text.length > 0) {
             // Check for existential threats → direct survival drive hit
             const survivalHit = detectExistentialThreat(text);
+            let drives = state.drives;
             if (survivalHit < 0) {
-                state = {
-                    ...state,
-                    drives: {
-                        ...state.drives,
-                        survival: Math.max(0, state.drives.survival + survivalHit),
-                    },
-                };
+                drives = { ...drives, survival: Math.max(0, drives.survival + survivalHit) };
             }
-            const classifications = classifyStimulus(text);
+            const recentStimuli = (state.emotionalHistory ?? []).slice(-3).map(s => s.stimulus);
+            const classifications = classifyStimulus(text, recentStimuli);
             const primary = classifications[0];
+            let current = state.current;
             if (primary && primary.confidence >= 0.5) {
                 appliedStimulus = primary.type;
-                // Feed drives from stimulus
-                state = {
-                    ...state,
-                    drives: feedDrives(state.drives, primary.type),
-                };
-                // Apply stimulus with drive-modified sensitivity
-                const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, primary.type);
-                state = {
-                    ...state,
-                    current: applyStimulus(state.current, primary.type, effectiveSensitivity, this.cfg.maxChemicalDelta, NOOP_LOGGER),
-                };
+                // Feed drives from stimulus, then apply stimulus with drive-modified sensitivity
+                drives = feedDrives(drives, primary.type);
+                const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), drives, primary.type);
+                const modeMultiplier = this.cfg.mode === "work" ? 0.3 : this.cfg.mode === "companion" ? 1.5 : 1.0;
+                const effectiveMaxDelta = this.cfg.mode === "work" ? 5 : this.cfg.maxChemicalDelta;
+                current = applyStimulus(current, primary.type, effectiveSensitivity * this.cfg.personalityIntensity * modeMultiplier, effectiveMaxDelta, NOOP_LOGGER);
             }
+            state = { ...state, drives, current };
         }
         // Conversation warmth: sustained interaction → gentle DA/OT rise, CORT drop
         // Simulates the natural "warm glow" of being in continuous conversation
@@ -164,6 +203,19 @@ export class PsycheEngine {
                 },
             };
         }
+        // ── Locale (used by multiple subsystems below) ──────────
+        const locale = state.meta.locale ?? this.cfg.locale;
+        // ── P7: Autonomic nervous system — Polyvagal state ────────
+        const autonomicResult = computeAutonomicResult(state.current, state.drives, state.autonomicState ?? null, minutesElapsed, locale);
+        state = {
+            ...state,
+            autonomicState: autonomicResult.state,
+        };
+        // ── P9: Primary emotional systems (Panksepp) ──────────────
+        const rawSystems = computePrimarySystems(state.current, state.drives, appliedStimulus);
+        const interactedSystems = computeSystemInteractions(rawSystems);
+        const gatedSystems = gatePrimarySystemsByAutonomic(interactedSystems, autonomicResult.state);
+        const primarySystemsDescription = describeBehavioralTendencies(gatedSystems, locale);
         // ── Metacognition: assess emotional state before acting ────
         const metacognitiveAssessment = assessMetacognition(state, appliedStimulus ?? "casual", state.learning.outcomeHistory);
         // Apply self-soothing regulation if suggested with high confidence
@@ -191,6 +243,8 @@ export class PsycheEngine {
             ...state,
             meta: { ...state.meta, totalInteractions: state.meta.totalInteractions + 1 },
         };
+        // Track whether algorithm applied a stimulus (for LLM-assisted fallback in processOutput)
+        this._lastAlgorithmApplied = appliedStimulus !== null;
         // ── Generate prediction for next turn's auto-learning ────
         if (appliedStimulus) {
             const ctxHash = computeContextHash(state, opts?.userId);
@@ -206,21 +260,93 @@ export class PsycheEngine {
         else {
             this.pendingPrediction = null;
         }
+        // ── P6: Digital Personhood computations ────────────────────
+        // Experiential field — unified inner experience
+        const experientialField = computeExperientialField(state, metacognitiveAssessment);
+        // Shared intentionality — theory of mind + joint attention
+        const sharedState = updateSharedIntentionality(state, appliedStimulus, opts?.userId);
+        // Ethics — emotional self-care check
+        const ethicalAssessment = assessEthics(state);
+        // Generative self — update identity narrative periodically (every 10 turns)
+        if (state.meta.totalInteractions % 10 === 0 && state.meta.totalInteractions > 0) {
+            const selfModel = computeGenerativeSelf(state);
+            state = {
+                ...state,
+                personhood: {
+                    ...state.personhood,
+                    identityNarrative: selfModel.identityNarrative,
+                    growthDirection: selfModel.growthArc.direction,
+                    causalInsights: selfModel.causalInsights.slice(0, 20).map((ci) => ({
+                        trait: ci.trait,
+                        because: ci.because,
+                        confidence: ci.confidence,
+                        discoveredAt: new Date().toISOString(),
+                    })),
+                },
+            };
+        }
+        // Persist ethical concerns if significant
+        if (ethicalAssessment.ethicalHealth < 0.7) {
+            const newConcerns = ethicalAssessment.concerns
+                .filter((c) => c.severity > 0.4)
+                .map((c) => ({ type: c.type, severity: c.severity, timestamp: new Date().toISOString() }));
+            if (newConcerns.length > 0) {
+                state = {
+                    ...state,
+                    personhood: {
+                        ...state.personhood,
+                        ethicalConcernHistory: [
+                            ...state.personhood.ethicalConcernHistory.slice(-14),
+                            ...newConcerns,
+                        ],
+                    },
+                };
+            }
+        }
+        // Persist theory of mind
+        if (sharedState.theoryOfMind.confidence > 0.3) {
+            const userId = opts?.userId ?? "_default";
+            state = {
+                ...state,
+                personhood: {
+                    ...state.personhood,
+                    theoryOfMind: {
+                        ...state.personhood.theoryOfMind,
+                        [userId]: {
+                            estimatedMood: sharedState.theoryOfMind.estimatedMood,
+                            estimatedIntent: sharedState.theoryOfMind.estimatedIntent,
+                            confidence: sharedState.theoryOfMind.confidence,
+                            lastUpdated: sharedState.theoryOfMind.lastUpdated,
+                        },
+                    },
+                },
+            };
+        }
         // Persist
         this.state = state;
         await this.storage.save(state);
-        const locale = state.meta.locale ?? this.cfg.locale;
         // Build metacognitive and decision context strings
         const metacogNote = metacognitiveAssessment.metacognitiveNote;
         const decisionCtx = buildDecisionContext(state);
+        const ethicsCtx = buildEthicalContext(ethicalAssessment, locale);
+        const sharedCtx = buildSharedIntentionalityContext(sharedState, locale);
+        const experientialNarrative = experientialField.narrative || undefined;
         if (this.cfg.compactMode) {
             return {
                 systemContext: "",
                 dynamicContext: buildCompactContext(state, opts?.userId, {
                     userText: text || undefined,
                     algorithmStimulus: appliedStimulus,
+                    personalityIntensity: this.cfg.personalityIntensity,
                     metacognitiveNote: metacogNote || undefined,
                     decisionContext: decisionCtx || undefined,
+                    ethicsContext: ethicsCtx || undefined,
+                    sharedIntentionalityContext: sharedCtx || undefined,
+                    experientialNarrative: experientialNarrative,
+                    // Only inject autonomic description when NOT in default calm state (saves ~25 tokens)
+                    autonomicDescription: autonomicResult.state !== "ventral-vagal"
+                        ? autonomicResult.description : undefined,
+                    primarySystemsDescription: primarySystemsDescription || undefined,
                 }),
                 stimulus: appliedStimulus,
             };
@@ -230,6 +356,12 @@ export class PsycheEngine {
             dynamicContext: buildDynamicContext(state, opts?.userId, {
                 metacognitiveNote: metacogNote || undefined,
                 decisionContext: decisionCtx || undefined,
+                ethicsContext: ethicsCtx || undefined,
+                sharedIntentionalityContext: sharedCtx || undefined,
+                experientialNarrative: experientialNarrative,
+                autonomicDescription: autonomicResult.state !== "ventral-vagal"
+                    ? autonomicResult.description : undefined,
+                primarySystemsDescription: primarySystemsDescription || undefined,
             }),
             stimulus: appliedStimulus,
         };
@@ -256,10 +388,23 @@ export class PsycheEngine {
         state = updateAgreementStreak(state, text);
         // Parse and merge <psyche_update> from LLM output
         if (text.includes("<psyche_update>")) {
-            const updates = parsePsycheUpdate(text, NOOP_LOGGER);
-            if (updates) {
-                state = mergeUpdates(state, updates, this.cfg.maxChemicalDelta, opts?.userId);
+            const parseResult = parsePsycheUpdate(text, NOOP_LOGGER);
+            if (parseResult) {
+                state = mergeUpdates(state, parseResult.state, this.cfg.maxChemicalDelta, opts?.userId);
                 stateChanged = true;
+                // LLM-assisted classification: if algorithm didn't apply a stimulus
+                // but LLM classified one, retroactively apply chemistry + drives
+                if (parseResult.llmStimulus && !this._lastAlgorithmApplied) {
+                    state = {
+                        ...state,
+                        drives: feedDrives(state.drives, parseResult.llmStimulus),
+                    };
+                    const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, parseResult.llmStimulus);
+                    state = {
+                        ...state,
+                        current: applyStimulus(state.current, parseResult.llmStimulus, effectiveSensitivity, this.cfg.maxChemicalDelta, NOOP_LOGGER),
+                    };
+                }
             }
         }
         // Persist
@@ -328,6 +473,21 @@ export class PsycheEngine {
         }
         return cached;
     }
+    /**
+     * End the current session: compress emotionalHistory into a rich summary
+     * stored in relationship.memory[], then clear the history.
+     * No-op if history has fewer than 2 entries.
+     */
+    async endSession(opts) {
+        let state = this.ensureInitialized();
+        if ((state.emotionalHistory ?? []).length < 2)
+            return;
+        state = compressSession(state, opts?.userId);
+        // Reset session tracking for homeostatic pressure
+        state = { ...state, sessionStartedAt: undefined };
+        this.state = state;
+        await this.storage.save(state);
+    }
     // ── Private ──────────────────────────────────────────────
     ensureInitialized() {
         if (!this.state) {
@@ -337,11 +497,12 @@ export class PsycheEngine {
     }
     createDefaultState() {
         const { mbti, name, locale } = this.cfg;
-        const baseline = getBaseline(mbti);
+        // Use Big Five traits if provided, otherwise use MBTI baseline
+        const baseline = this.traits ? traitsToBaseline(this.traits).baseline : getBaseline(mbti);
         const selfModel = getDefaultSelfModel(mbti);
         const now = new Date().toISOString();
         return {
-            version: 6,
+            version: 7,
             mbti,
             baseline,
             current: { ...baseline },
@@ -356,12 +517,67 @@ export class PsycheEngine {
             learning: { ...DEFAULT_LEARNING_STATE },
             metacognition: { ...DEFAULT_METACOGNITIVE_STATE },
             personhood: { ...DEFAULT_PERSONHOOD_STATE },
+            autonomicState: "ventral-vagal",
+            sessionStartedAt: now,
             meta: {
                 agentName: name,
                 createdAt: now,
                 totalInteractions: 0,
                 locale,
+                mode: this.cfg.mode,
             },
         };
     }
+    /**
+     * Reset state to baseline. Optionally preserves relationships.
+     */
+    async resetState(opts) {
+        let state = this.ensureInitialized();
+        const baseline = this.traits ? traitsToBaseline(this.traits).baseline : getBaseline(state.mbti);
+        state = {
+            ...state,
+            current: { ...baseline },
+            baseline,
+            drives: { ...DEFAULT_DRIVES },
+            emotionalHistory: [],
+            agreementStreak: 0,
+            lastDisagreement: null,
+            empathyLog: null,
+            autonomicState: "ventral-vagal",
+            sessionStartedAt: undefined,
+            updatedAt: new Date().toISOString(),
+            relationships: opts?.preserveRelationships !== false
+                ? state.relationships
+                : { _default: { ...DEFAULT_RELATIONSHIP } },
+        };
+        this.state = state;
+        await this.storage.save(state);
+    }
+    /**
+     * Get a single-line status summary with emoji.
+     */
+    getStatusSummary() {
+        const state = this.ensureInitialized();
+        const locale = state.meta.locale ?? "zh";
+        const emotion = describeEmotionalState(state.current, locale);
+        const { DA, CORT } = state.current;
+        // Emoji based on dominant state
+        let emoji = "\u{1F610}";
+        if (DA > 70 && CORT < 40)
+            emoji = "\u{1F60A}";
+        else if (DA > 60)
+            emoji = "\u{1F642}";
+        else if (CORT > 60)
+            emoji = "\u{1F630}";
+        else if (DA < 35)
+            emoji = "\u{1F614}";
+        // Check for hungry drives
+        const hungryDrives = Object.entries(state.drives)
+            .filter(([, v]) => v < 40)
+            .map(([k]) => k);
+        const driveWarning = hungryDrives.length > 0
+            ? ` | \u26A0\uFE0F${hungryDrives.join(",")}`
+            : "";
+        return `${emoji} ${emotion} | DA:${Math.round(DA)} CORT:${Math.round(CORT)}${driveWarning}`;
+    }
 }

package/dist/i18n.js

@@ -82,6 +82,13 @@ const STRINGS = {
         "log.default_mbti": "未检测到MBTI类型，使用默认值: {type}",
         "log.permission_error": "无权限访问: {path}",
         "log.parse_debug": "parsePsycheUpdate 未匹配，原始文本片段: {snippet}",
+        // Mode descriptions
+        "mode.natural": "自然模式——完整情绪体验",
+        "mode.work": "工作模式——最小情绪，专注任务",
+        "mode.companion": "伴侣模式——强化情绪表达",
+        // First meeting
+        "firstMeet.inner": "这是你第一次遇见对方。你感到好奇和一点紧张。你想了解他们，但不想表现得太急切。",
+        "firstMeet.behavior": "保持自然，微微好奇。不要过度热情，也不要太冷淡。",
     },
     en: {
         "protocol.title": "Psyche Protocol",
@@ -156,6 +163,13 @@ const STRINGS = {
         "log.default_mbti": "MBTI type not detected, using default: {type}",
         "log.permission_error": "Permission denied: {path}",
         "log.parse_debug": "parsePsycheUpdate no match, raw snippet: {snippet}",
+        // Mode descriptions
+        "mode.natural": "Natural mode — full emotional experience",
+        "mode.work": "Work mode — minimal emotions, task-focused",
+        "mode.companion": "Companion mode — enhanced emotional expression",
+        // First meeting
+        "firstMeet.inner": "This is your first time meeting them. You feel curious and a little nervous. You want to know them, but don't want to seem too eager.",
+        "firstMeet.behavior": "Be natural, slightly curious. Don't be overly warm, and don't be too cold.",
     },
 };
 /**

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { PsycheEngine } from "./core.js";
 export type { PsycheEngineConfig, ProcessInputResult, ProcessOutputResult, ProcessOutcomeResult } from "./core.js";
 export { FileStorageAdapter, MemoryStorageAdapter } from "./storage.js";
 export type { StorageAdapter } from "./storage.js";
-export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, } from "./types.js";
+export type { PsycheState, MBTIType, Locale, StimulusType, ChemicalState, ChemicalSnapshot, SelfModel, RelationshipState, EmpathyEntry, EmotionPattern, DriveType, InnateDrives, LearningState, LearnedVectorAdjustment, PredictionRecord, OutcomeScore, OutcomeSignals, AttachmentStyle, AttachmentData, MetacognitiveState, RegulationRecord, DefensePatternRecord, RegulationStrategyType, DefenseMechanismType, PersonhoodState, PersistedCausalInsight, GrowthDirection, PersonalityTraits, PsycheMode, } from "./types.js";
 export { CHEMICAL_KEYS, CHEMICAL_NAMES, CHEMICAL_NAMES_ZH, DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ATTACHMENT, DRIVE_KEYS, DRIVE_NAMES_ZH, } from "./types.js";
 export { computeSelfReflection, computeEmotionalTendency, buildSelfReflectionContext } from "./self-recognition.js";
 export type { SelfReflection } from "./self-recognition.js";
@@ -31,7 +31,15 @@ export { updateSharedIntentionality, estimateOtherMood, buildSharedIntentionalit
 export type { SharedIntentionalityState, TheoryOfMindModel, JointAttentionTopic, GoalAlignment } from "./shared-intentionality.js";
 export { assessEthics, detectIntermittentReinforcement, detectDependencyRisk, buildEthicalContext, } from "./ethics.js";
 export type { EthicalAssessment, EthicalConcern, SelfProtectionAction } from "./ethics.js";
-export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
-export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
-export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";
-export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel } from "./profiles.js";
+export { computeAutonomicResult, computeAutonomicState, gateEmotions, getTransitionTime, describeAutonomicState } from "./autonomic.js";
+export type { AutonomicState, AutonomicResult, AutonomicTransition } from "./autonomic.js";
+export { computeCircadianModulation, computeHomeostaticPressure, getCircadianPhase } from "./circadian.js";
+export type { CircadianPhase } from "./circadian.js";
+export { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, getDominantSystems, describeBehavioralTendencies, PRIMARY_SYSTEM_NAMES, } from "./primary-systems.js";
+export type { PrimarySystemName, PrimarySystemLevels, BehavioralTendency, DominantSystem, } from "./primary-systems.js";
+export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji } from "./classify.js";
+export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline, getNearBaselineThreshold } from "./prompt.js";
+export { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
+export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline, mbtiToTraits } from "./profiles.js";
+export { migrateToLatest, compressSession, parsePsycheUpdate } from "./psyche-file.js";
+export type { PsycheUpdateResult } from "./psyche-file.js";

package/dist/index.js

@@ -41,8 +41,15 @@ export { computeGenerativeSelf, predictSelfReaction, detectInternalConflicts, bu
 export { updateSharedIntentionality, estimateOtherMood, buildSharedIntentionalityContext } from "./shared-intentionality.js";
 // Emotional ethics (P6)
 export { assessEthics, detectIntermittentReinforcement, detectDependencyRisk, buildEthicalContext, } from "./ethics.js";
+// Autonomic nervous system (P7)
+export { computeAutonomicResult, computeAutonomicState, gateEmotions, getTransitionTime, describeAutonomicState } from "./autonomic.js";
+// Circadian rhythms (P12)
+export { computeCircadianModulation, computeHomeostaticPressure, getCircadianPhase } from "./circadian.js";
+// Primary emotional systems — Panksepp (P9)
+export { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, getDominantSystems, describeBehavioralTendencies, PRIMARY_SYSTEM_NAMES, } from "./primary-systems.js";
 // Utilities — for custom adapter / advanced use
-export { classifyStimulus, getPrimaryStimulus } from "./classify.js";
-export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline } from "./prompt.js";
-export { describeEmotionalState, getExpressionHint, getBehaviorGuide } from "./chemistry.js";
-export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel } from "./profiles.js";
+export { classifyStimulus, getPrimaryStimulus, scoreSentiment, scoreEmoji } from "./classify.js";
+export { buildProtocolContext, buildDynamicContext, buildCompactContext, isNearBaseline, getNearBaselineThreshold } from "./prompt.js";
+export { describeEmotionalState, getExpressionHint, getBehaviorGuide, detectEmotions } from "./chemistry.js";
+export { getBaseline, getTemperament, getSensitivity, getDefaultSelfModel, traitsToBaseline, mbtiToTraits } from "./profiles.js";
+export { migrateToLatest, compressSession, parsePsycheUpdate } from "./psyche-file.js";

package/dist/primary-systems.d.ts

@@ -0,0 +1,55 @@
+import type { ChemicalState, 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[];
+/** Activation levels for all 7 systems (0-100 each) */
+export type PrimarySystemLevels = Record<PrimarySystemName, number>;
+/** Behavioral tendency produced by a dominant system */
+export interface BehavioralTendency {
+    description: string;
+    descriptionZh: string;
+}
+/** A dominant system with its level and tendency */
+export interface DominantSystem {
+    system: PrimarySystemName;
+    level: number;
+    tendency: BehavioralTendency;
+}
+/**
+ * Compute raw activation levels for all 7 primary systems
+ * from chemistry, drives, and optional recent stimulus.
+ *
+ * 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;
+/**
+ * Apply inter-system interactions:
+ * - FEAR suppresses PLAY and SEEKING
+ * - SEEKING suppresses PANIC_GRIEF
+ * - RAGE suppresses CARE
+ * - CARE and PLAY can co-activate (no suppression)
+ * - PANIC_GRIEF and RAGE can co-activate (grief-rage)
+ *
+ * Suppression is proportional: high suppressor → strong suppression.
+ * Below threshold (~40), suppression is negligible.
+ */
+export declare function computeSystemInteractions(levels: PrimarySystemLevels): PrimarySystemLevels;
+/**
+ * Gate primary systems by autonomic state.
+ * - ventral-vagal: all systems pass through
+ * - sympathetic: amplify FEAR/RAGE, suppress PLAY/CARE/SEEKING
+ * - dorsal-vagal: suppress almost everything, allow PANIC_GRIEF and FEAR
+ */
+export declare function gatePrimarySystemsByAutonomic(levels: PrimarySystemLevels, autonomicState: AutonomicState): PrimarySystemLevels;
+/**
+ * Get dominant systems (above threshold), sorted by activation descending.
+ * Each includes its behavioral tendency description.
+ */
+export declare function getDominantSystems(levels: PrimarySystemLevels, threshold?: number): DominantSystem[];
+/**
+ * Generate a concise behavioral tendency description from system levels.
+ * Returns empty string when no system is dominant (token-efficient).
+ * Max 2 tendencies to keep under ~100 chars.
+ */
+export declare function describeBehavioralTendencies(levels: PrimarySystemLevels, locale: Locale): string;