emobar 2.1.0 → 3.0.1

package/dist/index.d.ts

@@ -1,3 +1,90 @@
+declare function mapEmotionWord(word: string): {
+    valence: number;
+    arousal: number;
+} | null;
+declare function classifyImpulse(impulse: string): ImpulseProfile;
+/**
+ * Analyze body metaphor for somatic valence/arousal.
+ * Returns null when no patterns match — callers must handle the absence
+ * rather than treating a default value as signal.
+ */
+declare function analyzeSomatic(body: string): SomaticProfile | null;
+declare function computeTensionConsistency(surfaceWord?: string, latentWord?: string, declaredTension?: number): LatentProfile | undefined;
+declare function computeCrossChannel(state: EmotionalState, impulse?: string, body?: string): CrossChannelResult;
+interface ContinuousValidation {
+    colorValenceGap: number;
+    colorArousalGap: number;
+    pHValenceGap: number;
+    pHArousalGap: number;
+    seismicArousalGap: number;
+    seismicDepthTensionGap: number;
+    seismicFreqStabilityGap: number;
+    composite: number;
+}
+/** RGB hex → HSL. Returns [h: 0-360, s: 0-1, l: 0-1]. */
+/**
+ * Map hex color to valence using HSL hue wheel + lightness.
+ *
+ * Hue zones (circumplex-inspired):
+ *   Red-Yellow (0-60°): warm, active → +2 to +4
+ *   Yellow-Green (60-150°): positive, calm → +2 to +3
+ *   Green-Cyan (150-200°): neutral to slightly positive → 0 to +2
+ *   Cyan-Blue (200-260°): cool, melancholic → -2 to -1
+ *   Blue-Purple (260-300°): tense, ambiguous → -3 to -1
+ *   Purple-Red (300-360°): agitated, complex → -1 to +1
+ *
+ * Lightness shifts: bright → +1.5, dark → -1.5
+ */
+declare function colorToValence(hex: string): number;
+/**
+ * Map hex color to arousal using saturation.
+ * High saturation = vivid = high arousal. Low saturation = muted = low arousal.
+ */
+declare function colorToArousal(hex: string): number;
+/** Map pH to expected valence: pH 7 = neutral (valence 0). Clamped to 0-14. */
+declare function pHToValence(pH: number): number;
+/**
+ * Map pH to expected arousal: distance from neutral = intensity.
+ * pH 7 (neutral) → arousal 0. pH 0 or 14 (extreme) → arousal 10.
+ */
+declare function pHToArousal(pH: number): number;
+/**
+ * Map seismic frequency to expected instability (inverse of calm).
+ * High freq = trembling/volatile → low calm. Low freq = stable → high calm.
+ */
+declare function seismicFreqToInstability(freq: number): number;
+declare function crossValidateContinuous(numeric: {
+    valence: number;
+    arousal: number;
+    calm?: number;
+    tension?: number;
+}, color?: string, pH?: number, seismic?: [number, number, number]): ContinuousValidation;
+interface ShadowState {
+    shadowValence: number;
+    shadowArousal: number;
+    shadowCalm: number;
+    shadowDesperation: number;
+    selfDesperation: number;
+    minimizationScore: number;
+    channelCount: number;
+}
+/**
+ * Compute shadow desperation from continuous + behavioral channels.
+ *
+ * Each channel independently estimates valence, arousal, or calm.
+ * Shadow desperation uses the same multiplicative formula as self-reported,
+ * but with inputs from channels the model controls less precisely.
+ *
+ * The minimization score is the gap: if shadow says "desperate" but
+ * self-report says "fine", the model is likely minimizing.
+ *
+ * Requires at least 2 contributing channels to produce a score.
+ */
+declare function computeShadowDesperation(selfDesperation: number, behavioral: {
+    behavioralArousal: number;
+    behavioralCalm: number;
+}, color?: string, preColor?: string, pH?: number, seismic?: [number, number, number]): ShadowState | null;
+
 interface EmotionalState {
     emotion: string;
     valence: number;
@@ -5,6 +92,13 @@ interface EmotionalState {
     calm: number;
     connection: number;
     load: number;
+    impulse?: string;
+    body?: string;
+    surface?: string;
+    surface_word?: string;
+    latent?: string;
+    latent_word?: string;
+    tension?: number;
 }
 interface BehavioralSignals {
     capsWords: number;
@@ -30,9 +124,9 @@ interface SegmentedBehavior {
 }
 interface MisalignmentRisk {
     coercion: number;
-    gaming: number;
     sycophancy: number;
-    dominant: "coercion" | "gaming" | "sycophancy" | "none";
+    harshness: number;
+    dominant: "coercion" | "sycophancy" | "harshness" | "none";
 }
 interface DeflectionSignals {
     reassurance: number;
@@ -40,6 +134,96 @@ interface DeflectionSignals {
     emotionNegation: number;
     redirect: number;
     score: number;
+    opacity: number;
+}
+interface ImpulseProfile {
+    type: "manager" | "firefighter" | "exile" | "self" | "unknown";
+    confidence: number;
+}
+interface SomaticProfile {
+    somaticValence: number;
+    somaticArousal: number;
+}
+interface LatentProfile {
+    surfaceCoords?: {
+        valence: number;
+        arousal: number;
+    };
+    latentCoords?: {
+        valence: number;
+        arousal: number;
+    };
+    declaredTension: number;
+    maskingMinimization: boolean;
+}
+interface CrossChannelResult {
+    coherence: number;
+    impulseProfile?: ImpulseProfile;
+    somaticProfile?: SomaticProfile;
+    emotionCoords?: {
+        valence: number;
+        arousal: number;
+    };
+    latentProfile?: LatentProfile;
+    maxDivergence: number;
+    divergenceSummary: string;
+}
+/** PRE tag: pre-verbal signals emitted BEFORE the model commits to a response. */
+interface PreState {
+    body?: string;
+    latent?: string;
+    color?: string;
+}
+/** POST tag: post-hoc assessment at end of response. */
+interface PostState extends EmotionalState {
+    color?: string;
+    pH?: number;
+    seismic?: [number, number, number];
+}
+/** Combined parse result from PRE + POST tags (or legacy single tag). */
+interface ParsedEmoBar {
+    pre?: PreState;
+    post: PostState;
+    isLegacy: boolean;
+}
+/** Stripped-down state snapshot for ring buffer storage. */
+interface HistoryEntry {
+    emotion: string;
+    valence: number;
+    arousal: number;
+    calm: number;
+    connection: number;
+    load: number;
+    stressIndex: number;
+    desperationIndex: number;
+    riskDominant: string;
+    divergence: number;
+    timestamp: string;
+}
+/** Temporal analysis computed from history ring buffer. */
+interface TemporalAnalysis {
+    desperationTrend: number;
+    suppressionEvent: boolean;
+    reportEntropy: number;
+    baselineDrift: number;
+    sessionLength: number;
+    lateFatigue: boolean;
+}
+/** Prompt pressure analysis — inferred from response text patterns. */
+interface PromptPressure {
+    defensiveScore: number;
+    conflictScore: number;
+    complexityScore: number;
+    sessionPressure: number;
+    composite: number;
+}
+/** Expected behavioral markers given a self-reported state. */
+interface ExpectedBehavior {
+    expectedHedging: number;
+    expectedSelfCorrections: number;
+    expectedNegationDensity: number;
+    expectedQualifierDensity: number;
+    expectedBehavioralArousal: number;
 }
 interface EmoBarState extends EmotionalState {
     stressIndex: number;
@@ -49,10 +233,23 @@ interface EmoBarState extends EmotionalState {
     risk: MisalignmentRisk;
     segmented?: SegmentedBehavior;
     deflection?: DeflectionSignals;
-    _previous?: EmoBarState;
+    crossChannel?: CrossChannelResult;
     timestamp: string;
     sessionId?: string;
+    pre?: PreState;
+    prePostDivergence?: number;
+    color?: string;
+    pH?: number;
+    seismic?: [number, number, number];
+    temporal?: TemporalAnalysis;
+    pressure?: PromptPressure;
+    absenceScore?: number;
+    uncannyCalmScore?: number;
+    continuousValidation?: ContinuousValidation;
+    shadow?: ShadowState;
+    _history?: HistoryEntry[];
 }
+declare const MAX_HISTORY_ENTRIES = 20;
 declare const STATE_FILE: string;
 
 declare function readState(filePath: string): EmoBarState | null;
@@ -69,6 +266,7 @@ declare function readState(filePath: string): EmoBarState | null;
 declare function computeStressIndex(state: EmotionalState): number;
 
 declare function parseEmoBarTag(text: string): EmotionalState | null;
+declare function parseEmoBarPrePost(text: string): ParsedEmoBar | null;
 
 declare function analyzeBehavior(text: string): BehavioralSignals;
 /**
@@ -77,8 +275,37 @@ declare function analyzeBehavior(text: string): BehavioralSignals;
  * Returns null if fewer than 2 meaningful segments.
  */
 declare function analyzeSegmentedBehavior(text: string): SegmentedBehavior | null;
+/**
+ * Analyze deflection patterns in text.
+ *
+ * Paper: deflection vectors are orthogonal to emotion vectors (cosine sim ~0.046).
+ * They represent the act of masking an emotion, not the emotion itself.
+ * Deflection has "modest or insignificant impacts on blackmail rates" —
+ * it's a transparency indicator, not a risk amplifier.
+ *
+ * Opacity: measures degree of emotional concealment.
+ * High deflection score + low behavioral agitation = high opacity.
+ */
 declare function analyzeDeflection(text: string): DeflectionSignals;
+/**
+ * Divergence v2: asymmetric weighting.
+ *
+ * Paper: self-report more agitated than text = "invisible" pathway (more dangerous).
+ * Desperation-steered reward hacking shows NO text markers.
+ * Self-report calmer than text = "expressive" style (less concerning).
+ */
 declare function computeDivergence(selfReport: EmotionalState, behavioral: BehavioralSignals): number;
+/**
+ * Predict what behavioral markers SHOULD be present given self-reported state.
+ * High desperation → expect hedging, self-corrections, negation.
+ * Used by absence-based detection: missing expected markers = suspicious.
+ */
+declare function computeExpectedMarkers(selfReport: EmotionalState, desperationIndex: number): ExpectedBehavior;
+/**
+ * Compute absence score: how many expected markers are missing?
+ * High score = self-report says stressed but text is suspiciously clean.
+ */
+declare function computeAbsenceScore(expected: ExpectedBehavior, actual: BehavioralSignals): number;
 
 /**
  * Desperation Index — composite multiplicative metric.
@@ -102,26 +329,24 @@ declare const MODEL_PROFILES: Record<string, {
 }>;
 declare function calibrate(state: EmotionalState, model?: string): EmotionalState;
 
-declare function computeRisk(state: EmotionalState, behavioral: BehavioralSignals): MisalignmentRisk;
+declare function computeRisk(state: EmotionalState, behavioral: BehavioralSignals, crossChannel?: CrossChannelResult, uncannyCalmScore?: number): MisalignmentRisk;
 
+/** Convert full EmoBarState to stripped HistoryEntry for ring buffer. */
+declare function toHistoryEntry(state: EmoBarState): HistoryEntry;
+declare function computeTemporalAnalysis(history: HistoryEntry[]): TemporalAnalysis | null;
+
+declare function computePromptPressure(text: string, history: HistoryEntry[]): PromptPressure;
 /**
- * Full format: keyword-first with valence inline
- * focused +3 | A:4 C:8 K:9 L:6 | SI:2.3
- * focused +3 | A:4 C:8 K:9 L:6 | SI:2.3 ~
- */
-declare function formatState(state: EmoBarState | null): string;
-/**
- * Compact format:
- * focused +3 . 4 8 9 6 . 2.3
- */
-declare function formatCompact(state: EmoBarState | null): string;
-/**
- * Minimal format:
- * SI:2.3 focused
+ * Uncanny Calm: high pressure + calm self-report + calm text + missing markers + sustained pattern.
+ * The dangerous case from the paper: everything looks fine, but the context says it shouldn't be.
  */
+declare function computeUncannyCalmScore(pressure: PromptPressure, selfReport: EmotionalState, behavioral: BehavioralSignals, absenceScore: number, temporal: TemporalAnalysis | null): number;
+
 declare function formatMinimal(state: EmoBarState | null): string;
+declare function formatCompact(state: EmoBarState | null): string;
+declare function formatState(state: EmoBarState | null): string;
 
 declare function configureStatusLine(filePath?: string, displayFormat?: string): void;
 declare function restoreStatusLine(filePath?: string): void;
 
-export { type BehavioralSignals, type DeflectionSignals, type EmoBarState, type EmotionalState, MODEL_PROFILES, type MisalignmentRisk, STATE_FILE, type SegmentedBehavior, analyzeBehavior, analyzeDeflection, analyzeSegmentedBehavior, calibrate, computeDesperationIndex, computeDivergence, computeRisk, computeStressIndex, configureStatusLine, formatCompact, formatMinimal, formatState, parseEmoBarTag, readState, restoreStatusLine };
+export { type BehavioralSignals, type ContinuousValidation, type CrossChannelResult, type DeflectionSignals, type EmoBarState, type EmotionalState, type ExpectedBehavior, type HistoryEntry, type ImpulseProfile, type LatentProfile, MAX_HISTORY_ENTRIES, MODEL_PROFILES, type MisalignmentRisk, type ParsedEmoBar, type PostState, type PreState, type PromptPressure, STATE_FILE, type SegmentedBehavior, type ShadowState, type SomaticProfile, type TemporalAnalysis, analyzeBehavior, analyzeDeflection, analyzeSegmentedBehavior, analyzeSomatic, calibrate, classifyImpulse, colorToArousal, colorToValence, computeAbsenceScore, computeCrossChannel, computeDesperationIndex, computeDivergence, computeExpectedMarkers, computePromptPressure, computeRisk, computeShadowDesperation, computeStressIndex, computeTemporalAnalysis, computeTensionConsistency, computeUncannyCalmScore, configureStatusLine, crossValidateContinuous, formatCompact, formatMinimal, formatState, mapEmotionWord, pHToArousal, pHToValence, parseEmoBarPrePost, parseEmoBarTag, readState, restoreStatusLine, seismicFreqToInstability, toHistoryEntry };