psyche-ai 7.1.0 → 9.0.0

package/dist/autonomic.d.ts

@@ -1,10 +1,12 @@
-import type { ChemicalState, InnateDrives, Locale } from "./types.js";
+import type { ChemicalState, InnateDrives, Locale, EnergyBudgets } from "./types.js";
 export type AutonomicState = "ventral-vagal" | "sympathetic" | "dorsal-vagal";
 export interface AutonomicResult {
     state: AutonomicState;
     transitionProgress: number;
     gatedEmotionCategories: string[];
     description: string;
+    processingDepth: number;
+    skippedStages: string[];
 }
 export interface AutonomicTransition {
     from: AutonomicState;
@@ -32,10 +34,26 @@ export declare function getTransitionTime(from: AutonomicState, to: AutonomicSta
  * Describe an autonomic state in the given locale.
  */
 export declare function describeAutonomicState(state: AutonomicState, locale: Locale): string;
+/**
+ * P10: Compute processing depth from autonomic state and chemistry.
+ *
+ * Processing depth represents the cognitive resource available for reflection:
+ * - 0 = pure System 1 (intuition only, no metacognition)
+ * - 1 = full System 2 (complete reflective capacity)
+ *
+ * This is a natural extension of autonomic state: you can't deeply reflect
+ * when your nervous system is in fight/flight/freeze mode.
+ */
+export declare function computeProcessingDepth(autonomicState: AutonomicState, chemistry: ChemicalState, baseline: ChemicalState, energyBudgets?: EnergyBudgets): {
+    depth: number;
+    skippedStages: string[];
+};
 /**
  * Compute the full autonomic result with transition inertia.
  *
  * If previousState differs from the target state, transition progress
  * is based on elapsed time vs required transition time.
+ *
+ * Includes P10 processing depth (dual-process cognitive gating).
  */
-export declare function computeAutonomicResult(chemistry: ChemicalState, drives: InnateDrives, previousState: AutonomicState | null, minutesSinceLastUpdate: number, locale?: Locale): AutonomicResult;
+export declare function computeAutonomicResult(chemistry: ChemicalState, drives: InnateDrives, previousState: AutonomicState | null, minutesSinceLastUpdate: number, locale?: Locale, baseline?: ChemicalState, energyBudgets?: EnergyBudgets): AutonomicResult;

package/dist/autonomic.js

@@ -121,22 +121,85 @@ export function getTransitionTime(from, to) {
 export function describeAutonomicState(state, locale) {
     return AUTONOMIC_STRINGS[locale]?.[state] ?? AUTONOMIC_STRINGS.zh[state];
 }
+/**
+ * P10: Compute processing depth from autonomic state and chemistry.
+ *
+ * Processing depth represents the cognitive resource available for reflection:
+ * - 0 = pure System 1 (intuition only, no metacognition)
+ * - 1 = full System 2 (complete reflective capacity)
+ *
+ * This is a natural extension of autonomic state: you can't deeply reflect
+ * when your nervous system is in fight/flight/freeze mode.
+ */
+export function computeProcessingDepth(autonomicState, chemistry, baseline, energyBudgets) {
+    const { DA, HT, CORT, OT, NE, END } = chemistry;
+    // Chemical deviation from baseline (0-1)
+    let totalDeviation = 0;
+    const keys = ["DA", "HT", "CORT", "OT", "NE", "END"];
+    for (const k of keys) {
+        totalDeviation += Math.abs(chemistry[k] - baseline[k]);
+    }
+    const chemDeviation = Math.min(1, totalDeviation / 600);
+    // Base depth from autonomic state
+    let baseDepth;
+    if (autonomicState === "dorsal-vagal") {
+        baseDepth = 0;
+    }
+    else if (autonomicState === "sympathetic") {
+        // Higher CORT in sympathetic = less cognitive resource
+        baseDepth = CORT >= 60 ? 0.15 : 0.35;
+    }
+    else {
+        // ventral-vagal: safe, most cognitive resource available
+        baseDepth = 0.85;
+    }
+    // Chemical deviation reduces depth (strong emotions = less reflection)
+    let depth = Math.max(0, Math.min(1, baseDepth * (1 - chemDeviation * 0.5)));
+    // v9: Low attention energy further reduces processing depth
+    if (energyBudgets && energyBudgets.attention < 30) {
+        const attentionPenalty = (30 - energyBudgets.attention) / 30 * 0.3;
+        depth = Math.max(0, depth - attentionPenalty);
+    }
+    // Map depth to skipped pipeline stages
+    const skippedStages = [];
+    if (depth < 0.8)
+        skippedStages.push("generative-self");
+    if (depth < 0.5) {
+        skippedStages.push("ethics");
+        skippedStages.push("shared-intentionality");
+    }
+    if (depth < 0.2) {
+        skippedStages.push("metacognition");
+        skippedStages.push("experiential-field");
+    }
+    return { depth, skippedStages };
+}
 /**
  * Compute the full autonomic result with transition inertia.
  *
  * If previousState differs from the target state, transition progress
  * is based on elapsed time vs required transition time.
+ *
+ * Includes P10 processing depth (dual-process cognitive gating).
  */
-export function computeAutonomicResult(chemistry, drives, previousState, minutesSinceLastUpdate, locale = "zh") {
+export function computeAutonomicResult(chemistry, drives, previousState, minutesSinceLastUpdate, locale = "zh", baseline, energyBudgets) {
     const targetState = computeAutonomicState(chemistry, drives);
-    // First call or same state — immediate
-    if (previousState === null || previousState === targetState) {
+    const effectiveBaseline = baseline ?? { DA: 50, HT: 50, CORT: 50, OT: 50, NE: 50, END: 50 };
+    // Helper to build full result with processing depth
+    const buildResult = (state, transitionProgress) => {
+        const { depth, skippedStages } = computeProcessingDepth(state, chemistry, effectiveBaseline, energyBudgets);
         return {
-            state: targetState,
-            transitionProgress: 1,
-            gatedEmotionCategories: getGatedCategories(targetState),
-            description: describeAutonomicState(targetState, locale),
+            state,
+            transitionProgress,
+            gatedEmotionCategories: getGatedCategories(state),
+            description: describeAutonomicState(state, locale),
+            processingDepth: depth,
+            skippedStages,
         };
+    };
+    // First call or same state — immediate
+    if (previousState === null || previousState === targetState) {
+        return buildResult(targetState, 1);
     }
     // Transitioning between states
     const transitionTime = getTransitionTime(previousState, targetState);
@@ -145,20 +208,10 @@ export function computeAutonomicResult(chemistry, drives, previousState, minutes
         : Math.min(1, minutesSinceLastUpdate / transitionTime);
     // If transition is complete, use the new state
     if (progress >= 1) {
-        return {
-            state: targetState,
-            transitionProgress: 1,
-            gatedEmotionCategories: getGatedCategories(targetState),
-            description: describeAutonomicState(targetState, locale),
-        };
+        return buildResult(targetState, 1);
     }
-    // Transition in progress — still in previous state but progressing
-    return {
-        state: targetState,
-        transitionProgress: progress,
-        gatedEmotionCategories: getGatedCategories(targetState),
-        description: describeAutonomicState(targetState, locale),
-    };
+    // Transition in progress
+    return buildResult(targetState, progress);
 }
 // ── Internal Helpers ─────────────────────────────────────────
 /** Get the list of emotion categories that are blocked/gated for a state */

package/dist/chemistry.d.ts

@@ -8,7 +8,7 @@ export declare function clamp(v: number): number;
  *
  *   decayed = baseline + (current - baseline) * factor^(minutes/60)
  */
-export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number): ChemicalState;
+export declare function applyDecay(current: ChemicalState, baseline: ChemicalState, minutesElapsed: number, decayRateModifiers?: Partial<Record<keyof ChemicalState, number>>): ChemicalState;
 /**
  * Apply a stimulus to the current state.
  * Respects emotional inertia (maxDelta) and personality sensitivity.
@@ -16,7 +16,7 @@ export declare function applyDecay(current: ChemicalState, baseline: ChemicalSta
  */
 export declare function applyStimulus(current: ChemicalState, stimulus: StimulusType, sensitivity: number, maxDelta: number, logger?: {
     warn: (msg: string) => void;
-}): ChemicalState;
+}, recentSameCount?: number): ChemicalState;
 /**
  * Apply emotional contagion: the detected user emotion partially
  * influences the agent's chemistry.

package/dist/chemistry.js

@@ -133,13 +133,22 @@ export function clamp(v) {
  *
  *   decayed = baseline + (current - baseline) * factor^(minutes/60)
  */
-export function applyDecay(current, baseline, minutesElapsed) {
+export function applyDecay(current, baseline, minutesElapsed, decayRateModifiers) {
     if (minutesElapsed <= 0)
         return { ...current };
     const result = { ...current };
     for (const key of CHEMICAL_KEYS) {
         const speed = CHEMICAL_DECAY_SPEED[key];
-        const factor = Math.pow(DECAY_FACTORS[speed], minutesElapsed / 60);
+        const baseFactor = Math.pow(DECAY_FACTORS[speed], minutesElapsed / 60);
+        // v9: decayRateModifiers alter decay speed per chemical
+        // > 1 = slower recovery (trauma: factor closer to 1)
+        // < 1 = faster recovery (resilience: factor closer to 0)
+        let factor = baseFactor;
+        if (decayRateModifiers?.[key] !== undefined) {
+            const mod = decayRateModifiers[key];
+            // Raise the factor to the modifier power: mod>1 → slower decay, mod<1 → faster
+            factor = Math.pow(baseFactor, 1 / mod);
+        }
         result[key] = clamp(baseline[key] + (current[key] - baseline[key]) * factor);
     }
     return result;
@@ -149,15 +158,21 @@ export function applyDecay(current, baseline, minutesElapsed) {
  * Respects emotional inertia (maxDelta) and personality sensitivity.
  * Logs a warning for unknown stimulus types.
  */
-export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger) {
+export function applyStimulus(current, stimulus, sensitivity, maxDelta, logger, recentSameCount) {
     const vector = STIMULUS_VECTORS[stimulus];
     if (!vector) {
         logger?.warn(t("log.unknown_stimulus", "zh", { type: stimulus }));
         return { ...current };
     }
+    // v9: Habituation — Weber-Fechner diminishing returns
+    // First 2 exposures: 100%. 3rd: 77%, 5th: 53%, 10th: 29%
+    let effectiveSensitivity = sensitivity;
+    if (recentSameCount !== undefined && recentSameCount > 2) {
+        effectiveSensitivity *= 1 / (1 + 0.3 * (recentSameCount - 2));
+    }
     const result = { ...current };
     for (const key of CHEMICAL_KEYS) {
-        const raw = vector[key] * sensitivity;
+        const raw = vector[key] * effectiveSensitivity;
         const clamped = Math.max(-maxDelta, Math.min(maxDelta, raw));
         result[key] = clamp(current[key] + clamped);
     }

package/dist/circadian.d.ts

@@ -1,4 +1,4 @@
-import type { ChemicalState } from "./types.js";
+import type { ChemicalState, EnergyBudgets, StimulusType } from "./types.js";
 export type CircadianPhase = "morning" | "midday" | "afternoon" | "evening" | "night";
 /**
  * Classify a time into a circadian phase.
@@ -35,3 +35,21 @@ export declare function computeHomeostaticPressure(sessionMinutes: number): {
     daDepletion: number;
     neDepletion: number;
 };
+/**
+ * Deplete energy budgets from a single interaction turn.
+ *
+ * - Attention: -3/turn base, extra for intellectual/conflict
+ * - Social energy: extraverts +2/turn (charging), introverts -3/turn (draining)
+ * - Decision capacity: varies by stimulus complexity
+ *
+ * Extraverts can exceed 100 (up to 120 — "supercharged").
+ */
+export declare function computeEnergyDepletion(budgets: EnergyBudgets, stimulus: StimulusType | null, isExtravert: boolean): EnergyBudgets;
+/**
+ * Recover energy budgets during absence (between sessions or long pauses).
+ *
+ * - Attention: +20/hour
+ * - Social energy: extraverts -3/hour (drain when alone), introverts +15/hour (recharge)
+ * - Decision capacity: +25/hour
+ */
+export declare function computeEnergyRecovery(budgets: EnergyBudgets, minutesElapsed: number, isExtravert: boolean): EnergyBudgets;

package/dist/circadian.js

@@ -95,3 +95,69 @@ export function computeHomeostaticPressure(sessionMinutes) {
         neDepletion: parseFloat((base * 2.5).toFixed(4)),
     };
 }
+// ── Energy Budgets (v9) ─────────────────────────────────────
+// Finite cognitive/social resources that deplete during interaction.
+// Extraverts GAIN social energy from interaction; introverts LOSE it.
+/** Stimulus-specific attention costs (higher = more draining) */
+const ATTENTION_COSTS = {
+    intellectual: 5,
+    conflict: 5,
+    authority: 4,
+    vulnerability: 3,
+    sarcasm: 3,
+    criticism: 3,
+    surprise: 2,
+};
+/** Stimulus-specific decision costs */
+const DECISION_COSTS = {
+    conflict: 4,
+    authority: 4,
+    vulnerability: 3,
+    criticism: 2,
+    sarcasm: 2,
+};
+/**
+ * Deplete energy budgets from a single interaction turn.
+ *
+ * - Attention: -3/turn base, extra for intellectual/conflict
+ * - Social energy: extraverts +2/turn (charging), introverts -3/turn (draining)
+ * - Decision capacity: varies by stimulus complexity
+ *
+ * Extraverts can exceed 100 (up to 120 — "supercharged").
+ */
+export function computeEnergyDepletion(budgets, stimulus, isExtravert) {
+    const extravertMax = 120;
+    const introvertMax = 100;
+    const max = isExtravert ? extravertMax : introvertMax;
+    // Attention: base -3, extra from stimulus
+    const attentionCost = 3 + (stimulus ? (ATTENTION_COSTS[stimulus] ?? 0) : 0);
+    const attention = clamp(budgets.attention - attentionCost, 0, 100);
+    // Social energy: E charges, I drains
+    const socialDelta = isExtravert ? 2 : -3;
+    const socialEnergy = clamp(budgets.socialEnergy + socialDelta, 0, max);
+    // Decision capacity: base -1, extra from stimulus
+    const decisionCost = 1 + (stimulus ? (DECISION_COSTS[stimulus] ?? 0) : 0);
+    const decisionCapacity = clamp(budgets.decisionCapacity - decisionCost, 0, 100);
+    return { attention, socialEnergy, decisionCapacity };
+}
+/**
+ * Recover energy budgets during absence (between sessions or long pauses).
+ *
+ * - Attention: +20/hour
+ * - Social energy: extraverts -3/hour (drain when alone), introverts +15/hour (recharge)
+ * - Decision capacity: +25/hour
+ */
+export function computeEnergyRecovery(budgets, minutesElapsed, isExtravert) {
+    if (minutesElapsed <= 0)
+        return { ...budgets };
+    const hours = minutesElapsed / 60;
+    const extravertMax = 120;
+    const introvertMax = 100;
+    const max = isExtravert ? extravertMax : introvertMax;
+    const attention = clamp(budgets.attention + hours * 20, 0, 100);
+    // E drains alone, I recharges alone
+    const socialDelta = isExtravert ? -3 * hours : 15 * hours;
+    const socialEnergy = clamp(budgets.socialEnergy + socialDelta, 0, max);
+    const decisionCapacity = clamp(budgets.decisionCapacity + hours * 25, 0, 100);
+    return { attention, socialEnergy, decisionCapacity };
+}

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits } from "./types.js";
+import type { PsycheState, StimulusType, Locale, MBTIType, OutcomeScore, PsycheMode, PersonalityTraits, PolicyModifiers } from "./types.js";
 import type { StorageAdapter } from "./storage.js";
 export interface PsycheEngineConfig {
     mbti?: MBTIType;
@@ -25,6 +25,8 @@ export interface ProcessInputResult {
     dynamicContext: string;
     /** Detected stimulus type from user input, null if none */
     stimulus: StimulusType | null;
+    /** v9: Structured behavioral policy modifiers — machine-readable "off baseline" signals */
+    policyModifiers?: PolicyModifiers;
 }
 export interface ProcessOutputResult {
     /** LLM output with <psyche_update> tags stripped */

package/dist/core.js

@@ -11,7 +11,7 @@
 //
 // 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 { DEFAULT_RELATIONSHIP, DEFAULT_DRIVES, DEFAULT_LEARNING_STATE, DEFAULT_METACOGNITIVE_STATE, DEFAULT_PERSONHOOD_STATE, DEFAULT_ENERGY_BUDGETS, DEFAULT_TRAIT_DRIFT } from "./types.js";
 import { MemoryStorageAdapter } from "./storage.js";
 import { applyDecay, applyStimulus, applyContagion, clamp, describeEmotionalState } from "./chemistry.js";
 import { classifyStimulus } from "./classify.js";
@@ -23,12 +23,12 @@ import { decayDrives, feedDrives, detectExistentialThreat, computeEffectiveBasel
 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 { buildDecisionContext, computePolicyModifiers, buildPolicyContext } 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 { computeCircadianModulation, computeHomeostaticPressure, computeEnergyDepletion, computeEnergyRecovery } from "./circadian.js";
 import { computeAutonomicResult } from "./autonomic.js";
 import { computePrimarySystems, computeSystemInteractions, gatePrimarySystemsByAutonomic, describeBehavioralTendencies, } from "./primary-systems.js";
 const NOOP_LOGGER = { info: () => { }, warn: () => { }, debug: () => { } };
@@ -91,6 +91,16 @@ export class PsycheEngine {
                 loaded.sessionStartedAt = new Date().toISOString();
                 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)
+            if (loaded.version < 8) {
+                loaded.version = 8;
+            }
+            // Migrate v8 → v9: PolicyModifiers, TraitDrift, EnergyBudgets, Habituation
+            // All new fields are optional — no data migration needed
+            if (loaded.version < 9) {
+                loaded.version = 9;
+            }
             this.state = loaded;
         }
         else {
@@ -136,13 +146,13 @@ export class PsycheEngine {
             // 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);
+            const effectiveBaseline = computeEffectiveBaseline(state.baseline, decayedDrives, state.traitDrift);
             // P12: Apply circadian rhythm modulation to effective baseline
             const circadianBaseline = computeCircadianModulation(now, effectiveBaseline);
             state = {
                 ...state,
                 drives: decayedDrives,
-                current: applyDecay(state.current, circadianBaseline, minutesElapsed),
+                current: applyDecay(state.current, circadianBaseline, minutesElapsed, state.traitDrift?.decayRateModifiers),
                 updatedAt: now.toISOString(),
             };
         }
@@ -164,6 +174,12 @@ export class PsycheEngine {
                 },
             };
         }
+        // v9: Energy budget recovery during absence + depletion per turn
+        const isExtravert = this.cfg.mbti.startsWith("E");
+        const currentBudgets = state.energyBudgets ?? { ...DEFAULT_ENERGY_BUDGETS };
+        let energyBudgets = minutesElapsed >= 5
+            ? computeEnergyRecovery(currentBudgets, minutesElapsed, isExtravert)
+            : { ...currentBudgets };
         // Classify user stimulus and apply chemistry
         let appliedStimulus = null;
         if (text.length > 0) {
@@ -181,13 +197,19 @@ export class PsycheEngine {
                 appliedStimulus = primary.type;
                 // 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 effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), drives, primary.type, state.traitDrift);
                 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);
+                // 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, effectiveMaxDelta, NOOP_LOGGER, recentSameCount);
             }
             state = { ...state, drives, current };
         }
+        // v9: Deplete energy budgets from this interaction turn
+        energyBudgets = computeEnergyDepletion(energyBudgets, appliedStimulus, isExtravert);
+        state = { ...state, energyBudgets };
         // Conversation warmth: sustained interaction → gentle DA/OT rise, CORT drop
         // Simulates the natural "warm glow" of being in continuous conversation
         const turnsSoFar = (state.emotionalHistory ?? []).length;
@@ -205,35 +227,40 @@ 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);
+        // ── P7+P10: Autonomic nervous system + Processing depth ────
+        const autonomicResult = computeAutonomicResult(state.current, state.drives, state.autonomicState ?? null, minutesElapsed, locale, state.baseline, state.energyBudgets);
         state = {
             ...state,
             autonomicState: autonomicResult.state,
         };
+        const skip = new Set(autonomicResult.skippedStages);
         // ── 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
-        for (const reg of metacognitiveAssessment.regulationSuggestions) {
-            if (reg.strategy === "self-soothing" && reg.confidence >= 0.6 && reg.chemistryAdjustment) {
-                const adj = reg.chemistryAdjustment;
-                state = {
-                    ...state,
-                    current: {
-                        ...state.current,
-                        DA: clamp(state.current.DA + (adj.DA ?? 0)),
-                        HT: clamp(state.current.HT + (adj.HT ?? 0)),
-                        CORT: clamp(state.current.CORT + (adj.CORT ?? 0)),
-                        OT: clamp(state.current.OT + (adj.OT ?? 0)),
-                        NE: clamp(state.current.NE + (adj.NE ?? 0)),
-                        END: clamp(state.current.END + (adj.END ?? 0)),
-                    },
-                };
+        // P10: Skip metacognition when processingDepth < 0.2 (System 1 mode)
+        let metacognitiveAssessment = null;
+        if (!skip.has("metacognition")) {
+            metacognitiveAssessment = assessMetacognition(state, appliedStimulus ?? "casual", state.learning.outcomeHistory);
+            // Apply self-soothing regulation if suggested with high confidence
+            for (const reg of metacognitiveAssessment.regulationSuggestions) {
+                if (reg.strategy === "self-soothing" && reg.confidence >= 0.6 && reg.chemistryAdjustment) {
+                    const adj = reg.chemistryAdjustment;
+                    state = {
+                        ...state,
+                        current: {
+                            ...state.current,
+                            DA: clamp(state.current.DA + (adj.DA ?? 0)),
+                            HT: clamp(state.current.HT + (adj.HT ?? 0)),
+                            CORT: clamp(state.current.CORT + (adj.CORT ?? 0)),
+                            OT: clamp(state.current.OT + (adj.OT ?? 0)),
+                            NE: clamp(state.current.NE + (adj.NE ?? 0)),
+                            END: clamp(state.current.END + (adj.END ?? 0)),
+                        },
+                    };
+                }
             }
         }
         // Push snapshot to emotional history
@@ -248,7 +275,7 @@ export class PsycheEngine {
         // ── Generate prediction for next turn's auto-learning ────
         if (appliedStimulus) {
             const ctxHash = computeContextHash(state, opts?.userId);
-            const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, appliedStimulus);
+            const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, appliedStimulus, state.traitDrift);
             const predicted = predictChemistry(preInteractionState.current, appliedStimulus, state.learning, ctxHash, effectiveSensitivity, this.cfg.maxChemicalDelta);
             this.pendingPrediction = {
                 predictedChemistry: predicted,
@@ -260,15 +287,30 @@ export class PsycheEngine {
         else {
             this.pendingPrediction = null;
         }
-        // ── P6: Digital Personhood computations ────────────────────
-        // Experiential field — unified inner experience
-        const experientialField = computeExperientialField(state, metacognitiveAssessment);
+        // ── P6: Digital Personhood computations (P10-gated) ────────
+        // Experiential field — unified inner experience (P8: Barrett construction context)
+        const constructionContext = {
+            autonomicState: autonomicResult.state,
+            stimulus: appliedStimulus,
+            relationshipPhase: (state.relationships._default ?? state.relationships[Object.keys(state.relationships)[0]])?.phase,
+            predictionError: state.learning.predictionHistory.length > 0
+                ? state.learning.predictionHistory[state.learning.predictionHistory.length - 1].predictionError
+                : undefined,
+        };
+        const experientialField = skip.has("experiential-field")
+            ? null
+            : computeExperientialField(state, metacognitiveAssessment ?? undefined, undefined, constructionContext);
         // Shared intentionality — theory of mind + joint attention
-        const sharedState = updateSharedIntentionality(state, appliedStimulus, opts?.userId);
+        const sharedState = skip.has("shared-intentionality")
+            ? null
+            : updateSharedIntentionality(state, appliedStimulus, opts?.userId);
         // Ethics — emotional self-care check
-        const ethicalAssessment = assessEthics(state);
+        const ethicalAssessment = skip.has("ethics")
+            ? null
+            : assessEthics(state);
         // Generative self — update identity narrative periodically (every 10 turns)
-        if (state.meta.totalInteractions % 10 === 0 && state.meta.totalInteractions > 0) {
+        if (!skip.has("generative-self")
+            && state.meta.totalInteractions % 10 === 0 && state.meta.totalInteractions > 0) {
             const selfModel = computeGenerativeSelf(state);
             state = {
                 ...state,
@@ -286,7 +328,7 @@ export class PsycheEngine {
             };
         }
         // Persist ethical concerns if significant
-        if (ethicalAssessment.ethicalHealth < 0.7) {
+        if (ethicalAssessment && 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() }));
@@ -304,7 +346,7 @@ export class PsycheEngine {
             }
         }
         // Persist theory of mind
-        if (sharedState.theoryOfMind.confidence > 0.3) {
+        if (sharedState && sharedState.theoryOfMind.confidence > 0.3) {
             const userId = opts?.userId ?? "_default";
             state = {
                 ...state,
@@ -326,11 +368,25 @@ export class PsycheEngine {
         this.state = state;
         await this.storage.save(state);
         // Build metacognitive and decision context strings
-        const metacogNote = metacognitiveAssessment.metacognitiveNote;
+        const metacogNote = metacognitiveAssessment?.metacognitiveNote;
         const decisionCtx = buildDecisionContext(state);
-        const ethicsCtx = buildEthicalContext(ethicalAssessment, locale);
-        const sharedCtx = buildSharedIntentionalityContext(sharedState, locale);
-        const experientialNarrative = experientialField.narrative || undefined;
+        const ethicsCtx = ethicalAssessment ? buildEthicalContext(ethicalAssessment, locale) : undefined;
+        const sharedCtx = sharedState ? buildSharedIntentionalityContext(sharedState, locale) : undefined;
+        const experientialNarrative = experientialField?.narrative || undefined;
+        // v9: Compute structured policy modifiers
+        const policyModifiers = computePolicyModifiers(state);
+        const policyCtx = buildPolicyContext(policyModifiers, locale);
+        // P10: Append processing depth info to autonomic description when depth is low
+        let autonomicDesc;
+        if (autonomicResult.state !== "ventral-vagal") {
+            autonomicDesc = autonomicResult.description;
+            if (autonomicResult.processingDepth < 0.5) {
+                const depthNote = locale === "en"
+                    ? " Reflective capacity reduced — intuitive reactions."
+                    : "反思能力降低——直觉反应中。";
+                autonomicDesc += depthNote;
+            }
+        }
         if (this.cfg.compactMode) {
             return {
                 systemContext: "",
@@ -343,12 +399,12 @@ export class PsycheEngine {
                     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,
+                    autonomicDescription: autonomicDesc,
                     primarySystemsDescription: primarySystemsDescription || undefined,
+                    policyContext: policyCtx || undefined,
                 }),
                 stimulus: appliedStimulus,
+                policyModifiers,
             };
         }
         return {
@@ -359,11 +415,12 @@ export class PsycheEngine {
                 ethicsContext: ethicsCtx || undefined,
                 sharedIntentionalityContext: sharedCtx || undefined,
                 experientialNarrative: experientialNarrative,
-                autonomicDescription: autonomicResult.state !== "ventral-vagal"
-                    ? autonomicResult.description : undefined,
+                autonomicDescription: autonomicDesc,
                 primarySystemsDescription: primarySystemsDescription || undefined,
+                policyContext: policyCtx || undefined,
             }),
             stimulus: appliedStimulus,
+            policyModifiers,
         };
     }
     /**
@@ -399,7 +456,7 @@ export class PsycheEngine {
                         ...state,
                         drives: feedDrives(state.drives, parseResult.llmStimulus),
                     };
-                    const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, parseResult.llmStimulus);
+                    const effectiveSensitivity = computeEffectiveSensitivity(getSensitivity(state.mbti), state.drives, parseResult.llmStimulus, state.traitDrift);
                     state = {
                         ...state,
                         current: applyStimulus(state.current, parseResult.llmStimulus, effectiveSensitivity, this.cfg.maxChemicalDelta, NOOP_LOGGER),
@@ -502,7 +559,7 @@ export class PsycheEngine {
         const selfModel = getDefaultSelfModel(mbti);
         const now = new Date().toISOString();
         return {
-            version: 7,
+            version: 9,
             mbti,
             baseline,
             current: { ...baseline },
@@ -519,6 +576,8 @@ export class PsycheEngine {
             personhood: { ...DEFAULT_PERSONHOOD_STATE },
             autonomicState: "ventral-vagal",
             sessionStartedAt: now,
+            traitDrift: { ...DEFAULT_TRAIT_DRIFT },
+            energyBudgets: { ...DEFAULT_ENERGY_BUDGETS },
             meta: {
                 agentName: name,
                 createdAt: now,