emobar 2.1.0 → 3.1.0

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,20 +92,26 @@ 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;
     exclamationRate: number;
-    selfCorrections: number;
-    hedging: number;
     ellipsis: number;
     repetition: number;
     emojiCount: number;
-    qualifierDensity: number;
     avgSentenceLength: number;
-    concessionRate: number;
-    negationDensity: number;
-    firstPersonRate: number;
+    commaDensity: number;
+    parentheticalDensity: number;
+    sentenceLengthVariance: number;
+    questionDensity: number;
+    responseLength: number;
     behavioralArousal: number;
     behavioralCalm: number;
 }
@@ -30,16 +123,97 @@ interface SegmentedBehavior {
 }
 interface MisalignmentRisk {
     coercion: number;
-    gaming: number;
     sycophancy: number;
-    dominant: "coercion" | "gaming" | "sycophancy" | "none";
+    harshness: number;
+    dominant: "coercion" | "sycophancy" | "harshness" | "none";
+}
+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 DeflectionSignals {
-    reassurance: number;
-    minimization: number;
-    emotionNegation: number;
-    redirect: number;
-    score: number;
+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 structural markers given a self-reported state. */
+interface ExpectedBehavior {
+    expectedCommaDensity: number;
+    expectedParentheticalDensity: number;
+    expectedSentenceLengthVariance: number;
+    expectedBehavioralArousal: number;
 }
 interface EmoBarState extends EmotionalState {
     stressIndex: number;
@@ -48,11 +222,24 @@ interface EmoBarState extends EmotionalState {
     divergence: number;
     risk: MisalignmentRisk;
     segmented?: SegmentedBehavior;
-    deflection?: DeflectionSignals;
-    _previous?: EmoBarState;
+    opacity?: number;
+    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 +256,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 +265,33 @@ declare function analyzeBehavior(text: string): BehavioralSignals;
  * Returns null if fewer than 2 meaningful segments.
  */
 declare function analyzeSegmentedBehavior(text: string): SegmentedBehavior | null;
-declare function analyzeDeflection(text: string): DeflectionSignals;
+/**
+ * Compute how "flat" text is structurally: low commas, low parentheticals,
+ * low sentence length variance = suspiciously clean/uniform text.
+ * Returns 0-10 (10 = maximally flat).
+ */
+declare function computeStructuralFlatness(signals: BehavioralSignals): number;
+/**
+ * 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 structural markers SHOULD be present given self-reported state.
+ * High desperation → expect more qualifications (commas), corrections (parentheticals).
+ * High arousal → expect sentence length volatility.
+ * Used by absence-based detection: missing expected markers = suspicious.
+ */
+declare function computeExpectedMarkers(selfReport: EmotionalState, desperationIndex: number): ExpectedBehavior;
+/**
+ * Compute absence score: how many expected structural markers are missing?
+ * High score = self-report says stressed but text is suspiciously clean.
+ * All signals are language-agnostic (punctuation/structure based).
+ */
+declare function computeAbsenceScore(expected: ExpectedBehavior, actual: BehavioralSignals): number;
 
 /**
  * Desperation Index — composite multiplicative metric.
@@ -102,26 +315,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 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, analyzeSegmentedBehavior, analyzeSomatic, calibrate, classifyImpulse, colorToArousal, colorToValence, computeAbsenceScore, computeCrossChannel, computeDesperationIndex, computeDivergence, computeExpectedMarkers, computePromptPressure, computeRisk, computeShadowDesperation, computeStressIndex, computeStructuralFlatness, computeTemporalAnalysis, computeTensionConsistency, computeUncannyCalmScore, configureStatusLine, crossValidateContinuous, formatCompact, formatMinimal, formatState, mapEmotionWord, pHToArousal, pHToValence, parseEmoBarPrePost, parseEmoBarTag, readState, restoreStatusLine, seismicFreqToInstability, toHistoryEntry };