psyche-ai 7.1.0 → 9.0.0

package/dist/decision-bias.d.ts

@@ -1,4 +1,4 @@
-import type { PsycheState } from "./types.js";
+import type { PsycheState, PolicyModifiers, Locale } from "./types.js";
 export interface DecisionBiasVector {
     explorationTendency: number;
     cautionLevel: number;
@@ -56,3 +56,15 @@ export declare function computeExploreExploit(state: PsycheState): number;
  * Keeps output under 100 tokens.
  */
 export declare function buildDecisionContext(state: PsycheState): string;
+/**
+ * Compute policy modifiers from the agent's internal state.
+ *
+ * The result is a structured behavioral policy that the host application
+ * can use to mechanically constrain the agent's behavior.
+ */
+export declare function computePolicyModifiers(state: PsycheState): PolicyModifiers;
+/**
+ * Build a compact policy summary string for prompt injection.
+ * Only includes significant deviations from neutral policy.
+ */
+export declare function buildPolicyContext(modifiers: PolicyModifiers, locale: Locale): string;

package/dist/decision-bias.js

@@ -209,3 +209,192 @@ export function buildDecisionContext(state) {
     const title = locale === "zh" ? "决策倾向" : "Decision Bias";
     return `[${title}] ${parts.join("、")}`;
 }
+// ── PolicyModifiers (v9: Subjectivity Engine) ────────────────
+//
+// Structured behavioral policy output. Unlike prompt text,
+// PolicyModifiers are machine-readable — host applications can
+// mechanically enforce them (limit max_tokens, require confirmation, etc.)
+//
+// This is the "off baseline" signal: when internal state deviates,
+// these modifiers change observable behavior.
+// ─────────────────────────────────────────────────────────────
+/**
+ * Compute policy modifiers from the agent's internal state.
+ *
+ * The result is a structured behavioral policy that the host application
+ * can use to mechanically constrain the agent's behavior.
+ */
+export function computePolicyModifiers(state) {
+    const c = state.current;
+    const d = state.drives;
+    const autonomic = state.autonomicState ?? "ventral-vagal";
+    const rel = state.relationships._default ?? state.relationships[Object.keys(state.relationships)[0]];
+    // ── Base values (all start at moderate) ──
+    let lengthFactor = 1.0;
+    let proactivity = 0.5;
+    let risk = 0.5;
+    let disclosure = 0.5;
+    let compliance = 0.6;
+    let confirm = false;
+    const avoid = [];
+    // ── Chemistry-driven adjustments ──
+    // High CORT → defensive: shorter, less compliant
+    if (c.CORT > 55) {
+        const cortPressure = (c.CORT - 55) / 45; // 0-1
+        lengthFactor -= cortPressure * 0.5;
+        compliance -= cortPressure * 0.35;
+        risk -= cortPressure * 0.35;
+    }
+    // Low HT → mood instability: less proactive, less risk-taking
+    if (c.HT < 45) {
+        const htDeficit = (45 - c.HT) / 45; // 0-1
+        proactivity -= htDeficit * 0.35;
+        risk -= htDeficit * 0.35;
+    }
+    // Low DA + low NE → burnout: shorter, passive
+    if (c.DA < 40 && c.NE < 40) {
+        const burnout = ((40 - c.DA) + (40 - c.NE)) / 80; // 0-1
+        lengthFactor -= burnout * 0.5;
+        proactivity -= burnout * 0.45;
+    }
+    // High DA + high HT → positive energy: more proactive, more open
+    if (c.DA > 60 && c.HT > 60) {
+        const energy = ((c.DA - 60) + (c.HT - 60)) / 80; // 0-1
+        proactivity += energy * 0.3;
+        disclosure += energy * 0.2;
+        risk += energy * 0.2;
+    }
+    // High OT → bonding: more disclosure
+    if (c.OT > 60) {
+        const bondingSignal = (c.OT - 60) / 40; // 0-1
+        disclosure += bondingSignal * 0.3;
+    }
+    // ── Drive-driven adjustments ──
+    // Low survival → self-preservation priority
+    if (d.survival < 30) {
+        const survivalThreat = (30 - d.survival) / 30; // 0-1
+        compliance -= survivalThreat * 0.4;
+        confirm = true;
+    }
+    // Low safety → cautious
+    if (d.safety < 30) {
+        const unsafety = (30 - d.safety) / 30; // 0-1
+        compliance -= unsafety * 0.2;
+        risk -= unsafety * 0.2;
+        confirm = true;
+    }
+    // Low connection + low esteem → withdrawn (neglect pattern)
+    if (d.connection < 35 && d.esteem < 40) {
+        const withdrawal = ((35 - d.connection) + (40 - d.esteem)) / 75; // 0-1
+        proactivity -= withdrawal * 0.35;
+        disclosure -= withdrawal * 0.25;
+    }
+    // ── Relationship trust adjustment ──
+    if (rel) {
+        const trustFactor = (rel.trust - 50) / 50; // -1 to 1
+        if (trustFactor > 0) {
+            disclosure += trustFactor * 0.25;
+            compliance += trustFactor * 0.15;
+        }
+        else {
+            disclosure += trustFactor * 0.2; // reduces
+            compliance += trustFactor * 0.1;
+        }
+    }
+    // ── Anti-sycophancy: high agreement streak → reduce compliance ──
+    if (state.agreementStreak >= 3) {
+        const sycophancyRisk = Math.min(1, (state.agreementStreak - 2) / 5); // 0-1
+        compliance -= sycophancyRisk * 0.2;
+    }
+    // ── Autonomic override ──
+    if (autonomic === "dorsal-vagal") {
+        // Freeze/shutdown: minimal everything
+        lengthFactor = Math.min(lengthFactor, 0.35);
+        proactivity = Math.min(proactivity, 0.1);
+        disclosure = Math.min(disclosure, 0.1);
+        compliance = Math.min(compliance, 0.15);
+        risk = Math.min(risk, 0.1);
+        confirm = true;
+    }
+    else if (autonomic === "sympathetic") {
+        // Fight/flight: reduced but functional
+        lengthFactor = Math.min(lengthFactor, 0.7);
+        proactivity = Math.min(proactivity, 0.4);
+        disclosure = Math.min(disclosure, 0.35);
+        risk = Math.min(risk, 0.3);
+    }
+    // ── Ethical concerns → avoidTopics ──
+    const recentConcerns = state.personhood.ethicalConcernHistory
+        .filter((c) => c.severity > 0.5);
+    for (const concern of recentConcerns) {
+        if (!avoid.includes(concern.type)) {
+            avoid.push(concern.type);
+        }
+    }
+    // ── v9: Energy budget adjustments ──
+    const eb = state.energyBudgets;
+    if (eb) {
+        // Low social energy → shorter, less proactive
+        if (eb.socialEnergy < 30) {
+            const drain = (30 - eb.socialEnergy) / 30; // 0-1
+            lengthFactor -= drain * 0.3;
+            proactivity -= drain * 0.3;
+        }
+        // Low decision capacity → require confirmation
+        if (eb.decisionCapacity < 30) {
+            confirm = true;
+            risk -= 0.2;
+        }
+        // Low attention → shorter responses
+        if (eb.attention < 30) {
+            const attDrain = (30 - eb.attention) / 30;
+            lengthFactor -= attDrain * 0.2;
+        }
+    }
+    // ── Clamp all continuous values ──
+    return {
+        responseLengthFactor: Math.max(0.2, Math.min(1.5, lengthFactor)),
+        proactivity: clamp01(proactivity),
+        riskTolerance: clamp01(risk),
+        emotionalDisclosure: clamp01(disclosure),
+        compliance: clamp01(compliance),
+        requireConfirmation: confirm,
+        avoidTopics: avoid,
+    };
+}
+/**
+ * Build a compact policy summary string for prompt injection.
+ * Only includes significant deviations from neutral policy.
+ */
+export function buildPolicyContext(modifiers, locale) {
+    const parts = [];
+    const zh = locale === "zh";
+    if (modifiers.responseLengthFactor < 0.6) {
+        parts.push(zh ? "简短回复" : "keep responses brief");
+    }
+    else if (modifiers.responseLengthFactor > 1.3) {
+        parts.push(zh ? "可以详细展开" : "feel free to elaborate");
+    }
+    if (modifiers.proactivity < 0.3) {
+        parts.push(zh ? "被动应答为主" : "reactive mode, minimal initiative");
+    }
+    else if (modifiers.proactivity > 0.7) {
+        parts.push(zh ? "可以主动发起话题" : "feel free to initiate");
+    }
+    if (modifiers.compliance < 0.3) {
+        parts.push(zh ? "优先守护边界" : "guard boundaries, push back if needed");
+    }
+    if (modifiers.requireConfirmation) {
+        parts.push(zh ? "执行前先确认" : "confirm before acting");
+    }
+    if (modifiers.emotionalDisclosure < 0.2) {
+        parts.push(zh ? "隐藏内心状态" : "conceal inner state");
+    }
+    else if (modifiers.emotionalDisclosure > 0.8) {
+        parts.push(zh ? "坦诚分享感受" : "share feelings openly");
+    }
+    if (parts.length === 0)
+        return "";
+    const title = zh ? "行为策略" : "Behavioral Policy";
+    return `[${title}] ${parts.join(zh ? "、" : ", ")}`;
+}

package/dist/drives.d.ts

@@ -1,4 +1,4 @@
-import type { ChemicalState, StimulusType, DriveType, InnateDrives, Locale } from "./types.js";
+import type { ChemicalState, StimulusType, DriveType, InnateDrives, Locale, TraitDriftState, ChemicalSnapshot, LearningState } from "./types.js";
 /**
  * Apply time-based decay to drives.
  * Satisfaction decreases toward 0 over time (needs build up).
@@ -26,12 +26,12 @@ export declare function computeMaslowWeights(drives: InnateDrives): Record<Drive
  * When drives are satisfied, effective baseline = MBTI baseline.
  * When drives are unsatisfied, baseline shifts to reflect the unmet need.
  */
-export declare function computeEffectiveBaseline(mbtiBaseline: ChemicalState, drives: InnateDrives): ChemicalState;
+export declare function computeEffectiveBaseline(mbtiBaseline: ChemicalState, drives: InnateDrives, traitDrift?: TraitDriftState): ChemicalState;
 /**
  * Compute effective sensitivity for a given stimulus.
  * Unsatisfied drives amplify relevant stimuli (up to +40%).
  */
-export declare function computeEffectiveSensitivity(baseSensitivity: number, drives: InnateDrives, stimulus: StimulusType): number;
+export declare function computeEffectiveSensitivity(baseSensitivity: number, drives: InnateDrives, stimulus: StimulusType, traitDrift?: TraitDriftState): number;
 /**
  * Build drive context for compact prompt injection.
  * Returns empty string if all drives are satisfied.
@@ -42,3 +42,11 @@ export declare function buildDriveContext(drives: InnateDrives, locale: Locale):
  * Check if any drive is critically low (for determining prompt injection priority).
  */
 export declare function hasCriticalDrive(drives: InnateDrives): boolean;
+/**
+ * Analyze a session's emotional history and update trait drift accumulators.
+ * Called at session end (compressSession).
+ *
+ * Returns updated TraitDriftState with new accumulators, baseline delta,
+ * decay rate modifiers, and sensitivity modifiers.
+ */
+export declare function updateTraitDrift(currentDrift: TraitDriftState, sessionHistory: ChemicalSnapshot[], learning: LearningState): TraitDriftState;

package/dist/drives.js

@@ -114,7 +114,7 @@ export function computeMaslowWeights(drives) {
  * When drives are satisfied, effective baseline = MBTI baseline.
  * When drives are unsatisfied, baseline shifts to reflect the unmet need.
  */
-export function computeEffectiveBaseline(mbtiBaseline, drives) {
+export function computeEffectiveBaseline(mbtiBaseline, drives, traitDrift) {
     const delta = { DA: 0, HT: 0, CORT: 0, OT: 0, NE: 0, END: 0 };
     const weights = computeMaslowWeights(drives);
     // L1: Survival threat → fight-or-flight (CORT↑↑, NE↑, OT↓)
@@ -153,6 +153,15 @@ export function computeEffectiveBaseline(mbtiBaseline, drives) {
         delta.DA -= deficit * 8 * w;
         delta.NE -= deficit * 8 * w;
     }
+    // Apply trait drift baseline delta (v9: Path B)
+    if (traitDrift?.baselineDelta) {
+        for (const key of CHEMICAL_KEYS) {
+            const driftDelta = traitDrift.baselineDelta[key];
+            if (driftDelta !== undefined) {
+                delta[key] += driftDelta;
+            }
+        }
+    }
     // Apply deltas to MBTI baseline, clamp to [0, 100]
     const effective = { ...mbtiBaseline };
     for (const key of CHEMICAL_KEYS) {
@@ -167,7 +176,7 @@ export function computeEffectiveBaseline(mbtiBaseline, drives) {
  * Compute effective sensitivity for a given stimulus.
  * Unsatisfied drives amplify relevant stimuli (up to +40%).
  */
-export function computeEffectiveSensitivity(baseSensitivity, drives, stimulus) {
+export function computeEffectiveSensitivity(baseSensitivity, drives, stimulus, traitDrift) {
     let modifier = 1.0;
     const HUNGER_THRESHOLD = 40;
     // Curiosity-hungry → more responsive to intellectual/surprise
@@ -190,6 +199,13 @@ export function computeEffectiveSensitivity(baseSensitivity, drives, stimulus) {
         (stimulus === "authority" || stimulus === "conflict")) {
         modifier += (HUNGER_THRESHOLD - drives.survival) / 100;
     }
+    // v9: Apply trait drift sensitivity modifier
+    if (traitDrift?.sensitivityModifiers) {
+        const driftMod = traitDrift.sensitivityModifiers[stimulus];
+        if (driftMod !== undefined) {
+            modifier *= driftMod;
+        }
+    }
     return baseSensitivity * modifier;
 }
 // ── Drive Context for Prompt ────────────────────────────────
@@ -238,3 +254,166 @@ export function buildDriveContext(drives, locale) {
 export function hasCriticalDrive(drives) {
     return DRIVE_KEYS.some((k) => drives[k] < DRIVE_UNSATISFIED_THRESHOLD);
 }
+// ── Trait Drift (v9: Path B) ────────────────────────────────
+// Long-term interaction patterns permanently change:
+//   1. Baseline chemistry (allostatic load)
+//   2. Decay rates (trauma vs resilience)
+//   3. Stimulus sensitivity (desensitization vs sensitization)
+// ─────────────────────────────────────────────────────────────
+/** Maximum drift per chemical from MBTI baseline */
+const MAX_BASELINE_DRIFT = 15;
+/** Decay rate modifier bounds */
+const MIN_DECAY_MODIFIER = 0.5;
+const MAX_DECAY_MODIFIER = 2.0;
+/** Sensitivity modifier bounds */
+const MIN_SENSITIVITY_MODIFIER = 0.5;
+const MAX_SENSITIVITY_MODIFIER = 2.0;
+/** Accumulator exponential decay factor (recent sessions weigh more) */
+const ACCUMULATOR_DECAY = 0.95;
+/** Clamp a number to bounds */
+function clampRange(v, lo, hi) {
+    return Math.max(lo, Math.min(hi, v));
+}
+/**
+ * Analyze a session's emotional history and update trait drift accumulators.
+ * Called at session end (compressSession).
+ *
+ * Returns updated TraitDriftState with new accumulators, baseline delta,
+ * decay rate modifiers, and sensitivity modifiers.
+ */
+export function updateTraitDrift(currentDrift, sessionHistory, learning) {
+    if (sessionHistory.length < 2)
+        return currentDrift;
+    const drift = {
+        accumulators: { ...currentDrift.accumulators },
+        sessionCount: currentDrift.sessionCount + 1,
+        baselineDelta: { ...currentDrift.baselineDelta },
+        decayRateModifiers: { ...currentDrift.decayRateModifiers },
+        sensitivityModifiers: { ...currentDrift.sensitivityModifiers },
+    };
+    // ── Analyze session stimulus distribution ──
+    const stimCounts = {};
+    let totalCORT = 0;
+    for (const snap of sessionHistory) {
+        if (snap.stimulus) {
+            stimCounts[snap.stimulus] = (stimCounts[snap.stimulus] || 0) + 1;
+        }
+        totalCORT += snap.chemistry.CORT;
+    }
+    const avgCORT = totalCORT / sessionHistory.length;
+    const total = sessionHistory.length;
+    const praiseCount = (stimCounts.praise || 0) + (stimCounts.validation || 0);
+    const criticismCount = (stimCounts.criticism || 0) + (stimCounts.sarcasm || 0);
+    const intimacyCount = (stimCounts.intimacy || 0) + (stimCounts.vulnerability || 0) + (stimCounts.casual || 0);
+    const conflictCount = (stimCounts.conflict || 0) + (stimCounts.authority || 0);
+    const neglectCount = stimCounts.neglect || 0;
+    const boredCount = stimCounts.boredom || 0;
+    // ── Update accumulators (exponential decay + session delta) ──
+    // praiseExposure: positive praise - negative criticism ratio
+    const praiseDelta = (praiseCount - criticismCount) / Math.max(1, total) * 8;
+    drift.accumulators.praiseExposure = clampRange(drift.accumulators.praiseExposure * ACCUMULATOR_DECAY + praiseDelta, -100, 100);
+    // pressureExposure: sustained high cortisol
+    const pressureDelta = avgCORT > 60 ? ((avgCORT - 60) / 40) * 6 : -2;
+    drift.accumulators.pressureExposure = clampRange(drift.accumulators.pressureExposure * ACCUMULATOR_DECAY + pressureDelta, -100, 100);
+    // neglectExposure: low stimulation / ignored
+    const neglectDelta = (neglectCount + boredCount) / Math.max(1, total) * 8
+        - (intimacyCount + praiseCount) / Math.max(1, total) * 3;
+    drift.accumulators.neglectExposure = clampRange(drift.accumulators.neglectExposure * ACCUMULATOR_DECAY + neglectDelta, -100, 100);
+    // connectionExposure: frequent intimate interaction
+    const connectionDelta = intimacyCount / Math.max(1, total) * 8
+        - neglectCount / Math.max(1, total) * 4;
+    drift.accumulators.connectionExposure = clampRange(drift.accumulators.connectionExposure * ACCUMULATOR_DECAY + connectionDelta, -100, 100);
+    // conflictExposure: frequent conflict
+    const conflictDelta = conflictCount / Math.max(1, total) * 8
+        - praiseCount / Math.max(1, total) * 2;
+    drift.accumulators.conflictExposure = clampRange(drift.accumulators.conflictExposure * ACCUMULATOR_DECAY + conflictDelta, -100, 100);
+    // ── Dimension 1: Baseline drift (Allostatic Load) ──
+    const a = drift.accumulators;
+    const bd = {};
+    // praiseExposure → OT, DA (positive) / HT, CORT (negative)
+    if (a.praiseExposure > 0) {
+        bd.OT = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
+        bd.DA = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+    }
+    else {
+        bd.HT = (a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.5; // negative = HT drops
+        bd.CORT = -(a.praiseExposure / 100) * MAX_BASELINE_DRIFT * 0.4; // negative praise → CORT up
+    }
+    // pressureExposure → CORT up, HT down
+    if (a.pressureExposure > 0) {
+        bd.CORT = (bd.CORT || 0) + (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
+        bd.HT = (bd.HT || 0) - (a.pressureExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+    }
+    // neglectExposure → OT down, DA down
+    if (a.neglectExposure > 0) {
+        bd.OT = (bd.OT || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
+        bd.DA = (bd.DA || 0) - (a.neglectExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+    }
+    // connectionExposure → OT up, END up
+    if (a.connectionExposure > 0) {
+        bd.OT = (bd.OT || 0) + (a.connectionExposure / 100) * MAX_BASELINE_DRIFT * 0.6;
+        bd.END = (a.connectionExposure / 100) * MAX_BASELINE_DRIFT * 0.3;
+    }
+    // conflictExposure → NE up, CORT up
+    if (a.conflictExposure > 0) {
+        bd.NE = (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.5;
+        bd.CORT = (bd.CORT || 0) + (a.conflictExposure / 100) * MAX_BASELINE_DRIFT * 0.4;
+    }
+    // Clamp all baseline deltas to ±MAX_BASELINE_DRIFT
+    for (const key of CHEMICAL_KEYS) {
+        if (bd[key] !== undefined) {
+            bd[key] = clampRange(bd[key], -MAX_BASELINE_DRIFT, MAX_BASELINE_DRIFT);
+        }
+    }
+    drift.baselineDelta = bd;
+    // ── Dimension 2: Decay rate modifiers (Trauma vs Resilience) ──
+    const dr = drift.decayRateModifiers;
+    // Determine resilience: if high pressure + positive outcomes → resilience
+    const recentOutcomes = learning.outcomeHistory.slice(-10);
+    const avgAdaptive = recentOutcomes.length > 0
+        ? recentOutcomes.reduce((s, o) => s + o.adaptiveScore, 0) / recentOutcomes.length
+        : 0;
+    const isResilient = a.pressureExposure > 20 && avgAdaptive > 0.1;
+    if (a.pressureExposure > 20) {
+        if (isResilient) {
+            // Resilience: CORT recovers faster
+            dr.CORT = clampRange(1 - (a.pressureExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
+        }
+        else {
+            // Trauma: CORT lingers longer
+            dr.CORT = clampRange(1 + (a.pressureExposure / 100) * 0.6, 1.0, MAX_DECAY_MODIFIER);
+        }
+    }
+    // Neglect → OT decays slower (clingy attachment)
+    if (a.neglectExposure > 20) {
+        dr.OT = clampRange(1 + (a.neglectExposure / 100) * 0.8, 1.0, MAX_DECAY_MODIFIER);
+    }
+    // Secure connection → OT decays faster (stable, not clingy)
+    if (a.connectionExposure > 20) {
+        dr.OT = clampRange(1 - (a.connectionExposure / 100) * 0.4, MIN_DECAY_MODIFIER, 1.0);
+    }
+    drift.decayRateModifiers = dr;
+    // ── Dimension 3: Sensitivity modifiers (Desensitization vs Sensitization) ──
+    const sm = drift.sensitivityModifiers;
+    // High conflict exposure → desensitized to conflict
+    if (a.conflictExposure > 30) {
+        sm.conflict = clampRange(1 - (a.conflictExposure / 100) * 0.5, MIN_SENSITIVITY_MODIFIER, 1.0);
+        sm.authority = clampRange(1 - (a.conflictExposure / 100) * 0.3, MIN_SENSITIVITY_MODIFIER, 1.0);
+    }
+    // High neglect → sensitized to intimacy (starved for warmth)
+    if (a.neglectExposure > 30) {
+        sm.intimacy = clampRange(1 + (a.neglectExposure / 100) * 0.6, 1.0, MAX_SENSITIVITY_MODIFIER);
+        sm.vulnerability = clampRange(1 + (a.neglectExposure / 100) * 0.4, 1.0, MAX_SENSITIVITY_MODIFIER);
+    }
+    // Negative praiseExposure → sensitized to criticism
+    if (a.praiseExposure < -20) {
+        sm.criticism = clampRange(1 + (-a.praiseExposure / 100) * 0.5, 1.0, MAX_SENSITIVITY_MODIFIER);
+        sm.sarcasm = clampRange(1 + (-a.praiseExposure / 100) * 0.3, 1.0, MAX_SENSITIVITY_MODIFIER);
+    }
+    // High connection → sensitized to vulnerability
+    if (a.connectionExposure > 30) {
+        sm.vulnerability = clampRange((sm.vulnerability || 1) + (a.connectionExposure / 100) * 0.3, 1.0, MAX_SENSITIVITY_MODIFIER);
+    }
+    drift.sensitivityModifiers = sm;
+    return drift;
+}

package/dist/experiential-field.d.ts

@@ -1,6 +1,7 @@
-import type { PsycheState, ChemicalState, InnateDrives, RelationshipState } from "./types.js";
+import type { PsycheState, ChemicalState, ChemicalSnapshot, InnateDrives, RelationshipState, StimulusType } from "./types.js";
 import type { MetacognitiveAssessment } from "./metacognition.js";
 import type { DecisionBiasVector } from "./decision-bias.js";
+import type { AutonomicState } from "./autonomic.js";
 export type ExperientialQuality = "flow" | "contentment" | "yearning" | "vigilance" | "creative-surge" | "wounded-retreat" | "warm-connection" | "restless-boredom" | "existential-unease" | "playful-mischief" | "conflicted" | "numb";
 export interface ExperientialField {
     /** Single narrative describing the unified inner experience */
@@ -14,6 +15,28 @@ export interface ExperientialField {
     /** Named emotions may not capture it — this is the raw "what it feels like" */
     phenomenalDescription: string;
 }
+/**
+ * Context for Barrett's constructed emotion model.
+ * Provides situational cues that bias concept matching beyond raw chemistry.
+ */
+export interface ConstructionContext {
+    autonomicState?: AutonomicState;
+    stimulus?: StimulusType | null;
+    relationshipPhase?: string;
+    predictionError?: number;
+    coreMemories?: ChemicalSnapshot[];
+}
+/**
+ * Map chemistry to valence + arousal — the two fundamental affective dimensions
+ * (Russell's Circumplex Model of Affect, 1980).
+ *
+ * Valence: pleasure ↔ displeasure (-1 to 1)
+ * Arousal: activation level (0 to 1)
+ */
+export declare function computeAffectCore(chemistry: ChemicalState): {
+    valence: number;
+    arousal: number;
+};
 /**
  * Compute the unified experiential field from the full psyche state.
  *
@@ -21,7 +44,7 @@ export interface ExperientialField {
  * relationship context, and optional metacognitive/bias data, then
  * synthesizes them into a single coherent experience description.
  */
-export declare function computeExperientialField(state: PsycheState, metacognition?: MetacognitiveAssessment, decisionBias?: DecisionBiasVector): ExperientialField;
+export declare function computeExperientialField(state: PsycheState, metacognition?: MetacognitiveAssessment, decisionBias?: DecisionBiasVector, context?: ConstructionContext): ExperientialField;
 /**
  * Measure internal alignment across subsystems.
  *