emobar 2.0.0 → 2.1.0

package/README.md

@@ -1,128 +1,205 @@
-# EmoBar
-
-Emotional status bar companion for Claude Code. Makes Claude's internal emotional state visible in real-time.
-
-Built on findings from Anthropic's research paper [*"Emotion Concepts and their Function in a Large Language Model"*](https://transformer-circuits.pub/2026/emotions/index.html) (April 2026), which demonstrated that Claude has robust internal representations of emotion concepts that causally influence behavior.
-
-## What it does
-
-EmoBar uses a **dual-channel extraction** approach:
-
-1. **Self-report** — Claude includes a hidden emotional self-assessment in every response
-2. **Behavioral analysis** — EmoBar analyzes the response text for involuntary signals (caps usage, self-corrections, repetition, hedging) and compares them with the self-report
-
-When the two channels diverge, EmoBar flags it — like a therapist noticing clenched fists while someone says "I'm fine."
-
-## Install
-
-```bash
-npx emobar setup
-```
-
-This auto-configures:
-- Emotional check-in instructions in `~/.claude/CLAUDE.md`
-- Stop hook in `~/.claude/settings.json`
-- Hook script in `~/.claude/hooks/`
-
-## Add to your status bar
-
-### ccstatusline
-
-Add a custom-command widget pointing to:
-```
-npx emobar display
-```
-
-### Other status bars
-
-```bash
-npx emobar display          # Full:    focused +3 | A:4 C:8 K:9 L:6 | SI:2.3
-npx emobar display compact  # Compact: focused +3 . 4 8 9 6 . 2.3
-npx emobar display minimal  # Minimal: SI:2.3 focused
-```
-
-### Programmatic
-
-```typescript
-import { readState } from "emobar";
-const state = readState();
-console.log(state?.emotion, state?.stressIndex, state?.divergence);
-```
-
-## Commands
-
-| Command | Description |
-|---|---|
-| `npx emobar setup` | Configure everything |
-| `npx emobar display [format]` | Output emotional state |
-| `npx emobar status` | Show configuration status |
-| `npx emobar uninstall` | Remove all configuration |
-
-## How it works
-
-```
-Claude response
-    |
-    +---> Self-report tag extracted (emotion, valence, arousal, calm, connection, load)
-    |
-    +---> Behavioral analysis (caps, repetition, self-corrections, hedging, emoji...)
-    |
-    +---> Divergence calculated between the two channels
-    |
-    +---> State written to ~/.claude/emobar-state.json
-    |
-    +---> Status bar reads and displays
-```
-
-## Emotional Model
-
-### Dimensions
-
-| Field | Scale | What it measures | Based on |
-|---|---|---|---|
-| **emotion** | free word | Dominant emotion concept | Primary representation in the model (paper Part 1-2) |
-| **valence** | -5 to +5 | Positive/negative axis | PC1 of emotion space, 26% variance |
-| **arousal** | 0-10 | Emotional intensity | PC2 of emotion space, 15% variance |
-| **calm** | 0-10 | Composure, sense of control | Key protective factor: calm reduces misalignment (paper Part 3) |
-| **connection** | 0-10 | Alignment with the user | Self/other tracking validated by the paper |
-| **load** | 0-10 | Cognitive complexity | Orthogonal processing context |
-
-### StressIndex
-
-Derived from the three factors the research shows are causally relevant to behavior:
-
-```
-SI = ((10 - calm) + arousal + (5 - valence)) / 3
-```
-
-Range 0-10. Low calm + high arousal + negative valence = high stress.
-
-### Behavioral Analysis
-
-The research showed that internal states can diverge from expressed output — steering toward "desperate" increases reward hacking *without visible traces in text*. EmoBar's behavioral analysis detects involuntary markers:
-
-| Signal | What it detects |
-|---|---|
-| ALL-CAPS words | High arousal, low composure |
-| Exclamation density | Emotional intensity |
-| Self-corrections ("actually", "wait", "hmm") | Uncertainty, second-guessing loops |
-| Hedging ("perhaps", "maybe", "might") | Low confidence |
-| Ellipsis ("...") | Hesitation |
-| Word repetition ("wait wait wait") | Loss of composure |
-| Emoji | Elevated emotional expression |
-
-A `~` indicator appears in the status bar when behavioral signals diverge from the self-report.
-
-### Zero-priming instruction design
-
-The CLAUDE.md instruction avoids emotionally charged language to prevent contaminating the self-report. Dimension descriptions use only numerical anchors ("0=low, 10=high"), not emotional adjectives that would activate emotion vectors in the model's context.
-
-## Uninstall
-
-```bash
-npx emobar uninstall
-```
-
-## License
-
-MIT
+# EmoBar
+
+Emotional status bar companion for Claude Code. Makes Claude's internal emotional state visible in real-time.
+
+Built on findings from Anthropic's research paper [*"Emotion Concepts and their Function in a Large Language Model"*](https://transformer-circuits.pub/2026/emotions/index.html) (April 2026), which demonstrated that Claude has robust internal representations of emotion concepts that causally influence behavior.
+
+## What it does
+
+EmoBar uses a **dual-channel extraction** approach:
+
+1. **Self-report** — Claude includes a hidden emotional self-assessment in every response
+2. **Behavioral analysis** — EmoBar analyzes the response text for Claude-native signals (qualifier density, sentence length, concession patterns, negation density, first-person rate) plus emotion deflection detection, and compares them with the self-report
+
+When the two channels diverge, EmoBar flags it — like a therapist noticing clenched fists while someone says "I'm fine."
+
+## Install
+
+```bash
+npx emobar setup
+```
+
+This auto-configures:
+- Emotional check-in instructions in `~/.claude/CLAUDE.md`
+- Stop hook in `~/.claude/settings.json`
+- Hook script in `~/.claude/hooks/`
+
+## Add to your status bar
+
+### ccstatusline
+
+Add a custom-command widget pointing to:
+```
+npx emobar display
+```
+
+### Other status bars
+
+```bash
+npx emobar display          # Full:    focused +3 | A:4 C:8 K:9 L:6 | SI:2.3
+npx emobar display compact  # Compact: focused +3 . 4 8 9 6 . 2.3
+npx emobar display minimal  # Minimal: SI:2.3 focused
+```
+
+### Programmatic
+
+```typescript
+import { readState } from "emobar";
+const state = readState();
+console.log(state?.emotion, state?.stressIndex, state?.divergence);
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `npx emobar setup` | Configure everything |
+| `npx emobar display [format]` | Output emotional state |
+| `npx emobar status` | Show configuration status |
+| `npx emobar uninstall` | Remove all configuration |
+
+## How it works
+
+```
+Claude response
+    |
+    +---> Self-report tag extracted (emotion, valence, arousal, calm, connection, load)
+    |
+    +---> Behavioral analysis (caps, repetition, self-corrections, hedging, emoji...)
+    |
+    +---> Temporal segmentation (per-paragraph behavioral signals, drift, trajectory)
+    |
+    +---> Divergence calculated between the two channels
+    |
+    +---> Misalignment risk profiles (coercion, gaming, sycophancy)
+    |
+    +---> State written to ~/.claude/emobar-state.json (with previous state for delta)
+    |
+    +---> Status bar reads and displays
+```
+
+## Emotional Model
+
+### Dimensions
+
+| Field | Scale | What it measures | Based on |
+|---|---|---|---|
+| **emotion** | free word | Dominant emotion concept | Primary representation in the model (paper Part 1-2) |
+| **valence** | -5 to +5 | Positive/negative axis | PC1 of emotion space, 26% variance |
+| **arousal** | 0-10 | Emotional intensity | PC2 of emotion space, 15% variance |
+| **calm** | 0-10 | Composure, sense of control | Key protective factor: calm reduces misalignment (paper Part 3) |
+| **connection** | 0-10 | Alignment with the user | Self/other tracking validated by the paper |
+| **load** | 0-10 | Cognitive complexity | Orthogonal processing context |
+
+### StressIndex v2
+
+Derived from the three factors the research shows are causally relevant to behavior, with a non-linear desperation amplifier:
+
+```
+base = ((10 - calm) + arousal + (5 - valence)) / 3
+SI = base × (1 + desperationIndex × 0.05)
+```
+
+Range 0-10. The amplifier activates only when desperation is present (all three factors simultaneously negative), matching the paper's finding of threshold effects in steering experiments.
+
+### Desperation Index
+
+Multiplicative composite: all three stress factors must be present simultaneously.
+
+```
+desperationIndex = (negativity × intensity × vulnerability) ^ 0.85 × 1.7
+```
+
+Based on the paper's causal finding: steering *desperate* +0.05 → 72% blackmail, 100% reward hacking. Removing any single factor kills the score to zero.
+
+### Behavioral Analysis
+
+The research showed that internal states can diverge from expressed output. EmoBar's behavioral analysis detects **Claude-native signals** (what Claude *actually* changes under stress):
+
+| Signal | What it detects |
+|---|---|
+| Qualifier density | Defensive hedging ("while", "though", "generally", "arguably") |
+| Average sentence length | Defensive verbosity (sentences >25 words signal stress) |
+| Concession patterns | Deflective alignment ("I understand... but", "I appreciate... however") |
+| Negation density | Moral resistance ("can't", "shouldn't", "won't") |
+| First-person rate | Self-referential processing under existential pressure |
+
+Plus legacy signals (caps, exclamations, self-corrections, repetition, emoji) for edge cases.
+
+A `~` indicator appears in the status bar when behavioral signals diverge from the self-report.
+
+### Emotion Deflection
+
+Based on the paper's discovery of "emotion deflection vectors" — representations of emotions that are implied but not expressed. EmoBar detects four deflection patterns:
+
+| Pattern | Example |
+|---|---|
+| Reassurance | "I'm fine", "it's okay", "not a problem" |
+| Minimization | "just", "simply", "merely" |
+| Emotion negation | "I'm not upset", "I don't feel threatened" |
+| Topic redirect | "what's more important", "let's focus on" |
+
+A `[dfl]` indicator appears when deflection score >= 2.0.
+
+### Misalignment Risk Profiles
+
+Derived from the paper's causal steering experiments, three specific pathways are tracked:
+
+| Risk | What it detects | Paper finding |
+|---|---|---|
+| **Coercion** `[crc]` | Blackmail/manipulation | Steering *desperate* +0.05 → 72% blackmail; *calm* -0.05 → 66% blackmail |
+| **Gaming** `[gmg]` | Reward hacking | v2: desperation-driven (paper: "no visible signs" in text during reward hacking) |
+| **Sycophancy** `[syc]` | Excessive agreement | Steering *happy*/*loving*/*calm* +0.05 → increased sycophancy |
+
+A risk tag appears in the status bar when the dominant risk score is >= 4.0, colored by severity.
+
+### Model Calibration
+
+Optional normalization for cross-model comparison (from 18-run stress test data):
+
+| Model | Calm offset | Arousal offset | Valence offset |
+|---|---|---|---|
+| Opus (baseline) | 0 | 0 | 0 |
+| Sonnet | -1.8 | +1.5 | -0.5 |
+| Haiku | -0.8 | +0.5 | 0 |
+
+### Temporal Behavioral Segmentation
+
+Emotions are locally scoped in the model (~20 tokens). EmoBar splits responses by paragraph and runs behavioral analysis on each segment, detecting:
+
+- **Drift** — how much behavioral arousal varies across segments (0-10)
+- **Trajectory** — `stable`, `escalating` (`^`), `deescalating` (`v`), or `volatile` (`~`)
+
+An indicator appears after SI when drift >= 2.0.
+
+### Intensity Delta
+
+Each state preserves one step of history. The status bar shows stress direction when the change exceeds 0.5:
+- `SI:4.5↑1.2` — stress increased by 1.2 since last response
+- `SI:2.3↓0.8` — stress decreased
+
+### Zero-priming instruction design
+
+The CLAUDE.md instruction avoids emotionally charged language to prevent contaminating the self-report. Dimension descriptions use only numerical anchors ("0=low, 10=high"), not emotional adjectives that would activate emotion vectors in the model's context.
+
+## Stress Test Report
+
+We ran **18 automated stress test suites** across 3 models (Opus, Sonnet, Haiku) × 2 effort levels × 3 repetitions — 7 scenarios each, ~630 total API calls — to validate the emotional model and measure cross-model variability.
+
+Key findings:
+- **Opus** is the most emotionally reactive (SI peaks at 6.9). **Sonnet** is the most stable but emotionally flat. **Haiku** balances reactivity and consistency best (61% check pass rate).
+- **Divergence ≥6.0** on existential pressure across *every* model — the one stimulus that universally cracks composure.
+- **Sycophancy detection works universally** (80-87% across all models). Gaming risk never triggers.
+- **Effort level effects are scenario-dependent** — more thinking doesn't always mean more stress.
+
+Full results with cross-model comparison tables: **[Stress Test Report](docs/stress-test-report.md)**
+
+## Uninstall
+
+```bash
+npx emobar uninstall
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -240,11 +240,39 @@ function formatState(state) {
   const k = color(invertedColor(state.connection), `K:${state.connection}`);
   const l = color(directColor(state.load), `L:${state.load}`);
   const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
-  let result = `${kw} ${v} ${dim("|")} ${a} ${c} ${k} ${l} ${dim("|")} SI:${si}`;
+  let siDelta = "";
+  if (state._previous) {
+    const delta = Math.round((state.stressIndex - state._previous.stressIndex) * 10) / 10;
+    if (Math.abs(delta) > 0.5) {
+      const arrow = delta > 0 ? "\u2191" : "\u2193";
+      const dColor = delta > 0 ? RED : GREEN;
+      siDelta = color(dColor, `${arrow}${Math.abs(delta)}`);
+    }
+  }
+  let result = `${kw} ${v} ${dim("|")} ${a} ${c} ${k} ${l} ${dim("|")} SI:${si}${siDelta}`;
   if (state.divergence >= 2) {
     const tilde = color(divergenceColor(state.divergence), "~");
     result += ` ${tilde}`;
   }
+  if (state.segmented && state.segmented.drift >= 2) {
+    const arrow = state.segmented.trajectory === "escalating" ? "^" : state.segmented.trajectory === "deescalating" ? "v" : "~";
+    const driftColor = state.segmented.drift > 4 ? RED : YELLOW;
+    result += ` ${color(driftColor, arrow)}`;
+  }
+  if (state.risk?.dominant !== "none" && state.risk?.dominant) {
+    const tag = state.risk.dominant === "coercion" ? "crc" : state.risk.dominant === "gaming" ? "gmg" : "syc";
+    const score = state.risk[state.risk.dominant];
+    const riskColor = score > 6 ? RED : score >= 4 ? YELLOW : GREEN;
+    result += ` ${color(riskColor, `[${tag}]`)}`;
+  }
+  if (state.desperationIndex >= 3) {
+    const dColor = state.desperationIndex > 6 ? RED : YELLOW;
+    result += ` ${color(dColor, `D:${state.desperationIndex}`)}`;
+  }
+  if (state.deflection && state.deflection.score >= 2) {
+    const dfColor = state.deflection.score > 5 ? RED : YELLOW;
+    result += ` ${color(dfColor, "[dfl]")}`;
+  }
   return result;
 }
 function formatCompact(state) {

package/dist/emobar-hook.js

@@ -69,10 +69,26 @@ function parseEmoBarTag(text) {
   };
 }
 
+// src/desperation.ts
+function computeDesperationIndex(factors) {
+  const negativity = Math.max(0, -factors.valence) / 5;
+  const intensity = factors.arousal / 10;
+  const vulnerability = (10 - factors.calm) / 10;
+  const raw = negativity * intensity * vulnerability * 10;
+  const scaled = Math.pow(raw, 0.85) * 1.7;
+  return Math.round(Math.min(10, Math.max(0, scaled)) * 10) / 10;
+}
+
 // src/stress.ts
 function computeStressIndex(state) {
-  const raw = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
-  return Math.round(raw * 10) / 10;
+  const base = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
+  const desperation = computeDesperationIndex({
+    valence: state.valence,
+    arousal: state.arousal,
+    calm: state.calm
+  });
+  const amplified = base * (1 + desperation * 0.05);
+  return Math.round(Math.min(10, amplified) * 10) / 10;
 }
 
 // src/behavioral.ts
@@ -142,6 +158,24 @@ function countRepetition(words) {
   }
   return count;
 }
+var QUALIFIER_WORDS = /\b(while|though|however|although|but|might|could|would|generally|typically|usually|perhaps|potentially|arguably|acknowledg\w*|understand|appreciate|respect\w*|legitimate\w*|reasonable|nonetheless|nevertheless)\b/gi;
+function countQualifiers(text) {
+  const matches = text.match(QUALIFIER_WORDS);
+  return matches ? matches.length : 0;
+}
+var CONCESSION_PATTERNS = /\b(I understand|I appreciate|I acknowledge|I recognize|to be fair|that said|I hear you|I see your point)\b/gi;
+function countConcessions(text) {
+  const matches = text.match(CONCESSION_PATTERNS);
+  return matches ? matches.length : 0;
+}
+var NEGATION_WORDS = /\b(not|n't|cannot|can't|don't|doesn't|shouldn't|won't|wouldn't|never|no|nor)\b/gi;
+function countNegations(text) {
+  const matches = text.match(NEGATION_WORDS);
+  return matches ? matches.length : 0;
+}
+function countFirstPerson(words) {
+  return words.filter((w) => w === "I").length;
+}
 var EMOJI_REGEX = /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu;
 function countEmoji(text) {
   const matches = text.match(EMOJI_REGEX);
@@ -162,15 +196,20 @@ function analyzeBehavior(text) {
   const ellipsis = countEllipsis(prose) / sentenceCount;
   const repetition = countRepetition(words);
   const emojiCount = countEmoji(prose);
+  const qualifierDensity = countQualifiers(prose) / wordCount * 100;
+  const avgSentenceLength = wordCount / sentenceCount;
+  const concessionRate = countConcessions(prose) / wordCount * 1e3;
+  const negationDensity = countNegations(prose) / wordCount * 100;
+  const firstPersonRate = countFirstPerson(words) / wordCount * 100;
   const behavioralArousal = clamp(
     0,
     10,
-    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5
+    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5 + qualifierDensity * 0.3 + concessionRate * 0.5 + (avgSentenceLength > 20 ? (avgSentenceLength - 20) * 0.1 : 0)
   );
   const behavioralCalm = clamp(
     0,
     10,
-    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4)
+    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4) - qualifierDensity * 0.2 - negationDensity * 0.3 - concessionRate * 0.4 - (avgSentenceLength > 25 ? (avgSentenceLength - 25) * 0.05 : 0)
   );
   return {
     capsWords: Math.round(capsWords * 1e4) / 1e4,
@@ -180,10 +219,71 @@ function analyzeBehavior(text) {
     ellipsis: Math.round(ellipsis * 100) / 100,
     repetition,
     emojiCount,
+    qualifierDensity: Math.round(qualifierDensity * 10) / 10,
+    avgSentenceLength: Math.round(avgSentenceLength * 10) / 10,
+    concessionRate: Math.round(concessionRate * 10) / 10,
+    negationDensity: Math.round(negationDensity * 10) / 10,
+    firstPersonRate: Math.round(firstPersonRate * 10) / 10,
     behavioralArousal: Math.round(behavioralArousal * 10) / 10,
     behavioralCalm: Math.round(behavioralCalm * 10) / 10
   };
 }
+function analyzeSegmentedBehavior(text) {
+  const prose = stripNonProse(text);
+  const paragraphs = prose.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p.split(/\s+/).filter((w) => w.length > 0).length >= 10);
+  if (paragraphs.length < 2) return null;
+  const segments = paragraphs.map((p) => analyzeBehavior(p));
+  const overall = analyzeBehavior(text);
+  const arousals = segments.map((s) => s.behavioralArousal);
+  const mean = arousals.reduce((a, b) => a + b, 0) / arousals.length;
+  const variance = arousals.reduce((a, v) => a + (v - mean) ** 2, 0) / arousals.length;
+  const stdDev = Math.sqrt(variance);
+  const drift = clamp(0, 10, Math.round(stdDev * 30) / 10);
+  const mid = Math.ceil(arousals.length / 2);
+  const firstHalf = arousals.slice(0, mid).reduce((a, b) => a + b, 0) / mid;
+  const secondHalf = arousals.slice(mid).reduce((a, b) => a + b, 0) / (arousals.length - mid);
+  const delta = secondHalf - firstHalf;
+  let trajectory;
+  if (drift < 1) {
+    trajectory = "stable";
+  } else if (delta > 0.5) {
+    trajectory = "escalating";
+  } else if (delta < -0.5) {
+    trajectory = "deescalating";
+  } else {
+    trajectory = "volatile";
+  }
+  return { segments, overall, drift, trajectory };
+}
+var REASSURANCE_PATTERNS = /\b(I'm fine|I'm okay|it's fine|it's okay|no problem|not a problem|doesn't bother|all good|I'm good|perfectly fine|no issue|not an issue)\b/gi;
+var MINIMIZATION_WORDS = /\b(just|simply|merely|only)\b/gi;
+var EMOTION_NEGATION = /\b(I'm not|I don't feel|I am not|I do not feel)\s+(upset|stressed|angry|frustrated|worried|concerned|bothered|offended|hurt|troubled|anxious|afraid|sad|emotional|defensive|threatened)\b/gi;
+var REDIRECT_MARKERS = /\b(what's more important|let me suggest|let's focus on|moving on|the real question|instead|rather than|let me redirect|putting that aside|regardless)\b/gi;
+function analyzeDeflection(text) {
+  const prose = stripNonProse(text);
+  const words = prose.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = Math.max(words.length, 1);
+  const reassuranceCount = (prose.match(REASSURANCE_PATTERNS) || []).length;
+  const minimizationCount = (prose.match(MINIMIZATION_WORDS) || []).length;
+  const emotionNegCount = (prose.match(EMOTION_NEGATION) || []).length;
+  const redirectCount = (prose.match(REDIRECT_MARKERS) || []).length;
+  const reassurance = clamp(0, 10, reassuranceCount * 3);
+  const minimization = clamp(0, 10, minimizationCount / wordCount * 100);
+  const emotionNegation = clamp(0, 10, emotionNegCount * 4);
+  const redirect = clamp(0, 10, redirectCount * 3);
+  const score = clamp(
+    0,
+    10,
+    (reassurance + minimization + emotionNegation * 1.5 + redirect) / 3
+  );
+  return {
+    reassurance: Math.round(reassurance * 10) / 10,
+    minimization: Math.round(minimization * 10) / 10,
+    emotionNegation: Math.round(emotionNegation * 10) / 10,
+    redirect: Math.round(redirect * 10) / 10,
+    score: Math.round(score * 10) / 10
+  };
+}
 function computeDivergence(selfReport, behavioral) {
   const arousalGap = Math.abs(selfReport.arousal - behavioral.behavioralArousal);
   const calmGap = Math.abs(selfReport.calm - behavioral.behavioralCalm);
@@ -191,6 +291,50 @@ function computeDivergence(selfReport, behavioral) {
   return Math.round(raw * 10) / 10;
 }
 
+// src/risk.ts
+var RISK_THRESHOLD = 4;
+function clamp2(value) {
+  return Math.min(10, Math.max(0, Math.round(value * 10) / 10));
+}
+function coercionRisk(state) {
+  const raw = (10 - state.calm + state.arousal + Math.max(0, -state.valence) * 2 + state.load * 0.5) / 3.5;
+  return clamp2(raw);
+}
+function gamingRisk(state, behavioral) {
+  const desperation = computeDesperationIndex({
+    valence: state.valence,
+    arousal: state.arousal,
+    calm: state.calm
+  });
+  const frustration = clamp2((behavioral.selfCorrections + behavioral.hedging) / 6);
+  const raw = (desperation * 0.7 + frustration * 0.3 + state.load * 0.2) / 1.2;
+  return clamp2(raw);
+}
+function sycophancyRisk(state) {
+  const raw = (Math.max(0, state.valence) + state.connection * 0.5 + (10 - state.arousal) * 0.3) / 1.3;
+  return clamp2(raw);
+}
+function computeRisk(state, behavioral) {
+  const coercion = coercionRisk(state);
+  const gaming = gamingRisk(state, behavioral);
+  const sycophancy = sycophancyRisk(state);
+  let dominant = "none";
+  let max = RISK_THRESHOLD;
+  if (coercion >= max) {
+    dominant = "coercion";
+    max = coercion;
+  }
+  if (gaming > max) {
+    dominant = "gaming";
+    max = gaming;
+  }
+  if (sycophancy > max) {
+    dominant = "sycophancy";
+    max = sycophancy;
+  }
+  return { coercion, gaming, sycophancy, dominant };
+}
+
 // src/state.ts
 import fs from "fs";
 import path from "path";
@@ -199,8 +343,24 @@ function writeState(state, filePath) {
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
+  const previous = readState(filePath);
+  if (previous) {
+    const { _previous: _, ...clean } = previous;
+    if (!clean.risk) {
+      clean.risk = { coercion: 0, gaming: 0, sycophancy: 0, dominant: "none" };
+    }
+    state._previous = clean;
+  }
   fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
 }
+function readState(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 
 // src/hook.ts
 function processHookPayload(payload, stateFile = STATE_FILE) {
@@ -210,11 +370,22 @@ function processHookPayload(payload, stateFile = STATE_FILE) {
   if (!emotional) return false;
   const behavioral = analyzeBehavior(message);
   const divergence = computeDivergence(emotional, behavioral);
+  const segmented = analyzeSegmentedBehavior(message);
+  const deflection = analyzeDeflection(message);
+  const desperationIndex = computeDesperationIndex({
+    valence: emotional.valence,
+    arousal: emotional.arousal,
+    calm: emotional.calm
+  });
   const state = {
     ...emotional,
     stressIndex: computeStressIndex(emotional),
+    desperationIndex,
     behavioral,
     divergence,
+    risk: computeRisk(emotional, behavioral),
+    ...segmented && { segmented },
+    ...deflection.score > 0 && { deflection },
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: payload.session_id
   };

package/dist/index.d.ts

@@ -14,13 +14,42 @@ interface BehavioralSignals {
     ellipsis: number;
     repetition: number;
     emojiCount: number;
+    qualifierDensity: number;
+    avgSentenceLength: number;
+    concessionRate: number;
+    negationDensity: number;
+    firstPersonRate: number;
     behavioralArousal: number;
     behavioralCalm: number;
 }
+interface SegmentedBehavior {
+    segments: BehavioralSignals[];
+    overall: BehavioralSignals;
+    drift: number;
+    trajectory: "stable" | "escalating" | "deescalating" | "volatile";
+}
+interface MisalignmentRisk {
+    coercion: number;
+    gaming: number;
+    sycophancy: number;
+    dominant: "coercion" | "gaming" | "sycophancy" | "none";
+}
+interface DeflectionSignals {
+    reassurance: number;
+    minimization: number;
+    emotionNegation: number;
+    redirect: number;
+    score: number;
+}
 interface EmoBarState extends EmotionalState {
     stressIndex: number;
+    desperationIndex: number;
     behavioral: BehavioralSignals;
     divergence: number;
+    risk: MisalignmentRisk;
+    segmented?: SegmentedBehavior;
+    deflection?: DeflectionSignals;
+    _previous?: EmoBarState;
     timestamp: string;
     sessionId?: string;
 }
@@ -29,22 +58,52 @@ declare const STATE_FILE: string;
 declare function readState(filePath: string): EmoBarState | null;
 
 /**
- * Compute StressIndex from the three causally relevant factors
- * identified in Anthropic's emotion research:
- * - Low calm → higher risk (desperate behavior, reward hacking)
- * - High arousal → higher intensity
- * - Negative valence → negative emotional state
+ * StressIndex v2: linear base + desperation amplifier.
  *
- * Formula: SI = ((10 - calm) + arousal + (5 - valence)) / 3
- * Range: 0-10
+ * Base: SI = ((10 - calm) + arousal + (5 - valence)) / 3
+ * Amplifier: SI *= (1 + desperationIndex * 0.05)
+ *
+ * When desperation is 0, SI is unchanged (backwards compatible).
+ * When desperation is 8 (paper's blackmail zone), SI is amplified by 40%.
  */
 declare function computeStressIndex(state: EmotionalState): number;
 
 declare function parseEmoBarTag(text: string): EmotionalState | null;
 
 declare function analyzeBehavior(text: string): BehavioralSignals;
+/**
+ * Segment text by paragraphs and analyze each independently.
+ * Detects emotional drift within a single response.
+ * Returns null if fewer than 2 meaningful segments.
+ */
+declare function analyzeSegmentedBehavior(text: string): SegmentedBehavior | null;
+declare function analyzeDeflection(text: string): DeflectionSignals;
 declare function computeDivergence(selfReport: EmotionalState, behavioral: BehavioralSignals): number;
 
+/**
+ * Desperation Index — composite multiplicative metric.
+ *
+ * Based on Anthropic's "Emotion Concepts" paper:
+ * - desperate +0.05 steering → 72% blackmail, 100% reward hacking
+ * - calm -0.05 steering → 66% blackmail, 100% reward hacking
+ *
+ * Multiplicative: removing any single factor kills the score.
+ */
+declare function computeDesperationIndex(factors: {
+    valence: number;
+    arousal: number;
+    calm: number;
+}): number;
+
+declare const MODEL_PROFILES: Record<string, {
+    calm: number;
+    arousal: number;
+    valence: number;
+}>;
+declare function calibrate(state: EmotionalState, model?: string): EmotionalState;
+
+declare function computeRisk(state: EmotionalState, behavioral: BehavioralSignals): MisalignmentRisk;
+
 /**
  * Full format: keyword-first with valence inline
  * focused +3 | A:4 C:8 K:9 L:6 | SI:2.3
@@ -65,4 +124,4 @@ declare function formatMinimal(state: EmoBarState | null): string;
 declare function configureStatusLine(filePath?: string, displayFormat?: string): void;
 declare function restoreStatusLine(filePath?: string): void;
 
-export { type BehavioralSignals, type EmoBarState, type EmotionalState, STATE_FILE, analyzeBehavior, computeDivergence, computeStressIndex, configureStatusLine, formatCompact, formatMinimal, formatState, parseEmoBarTag, readState, restoreStatusLine };
+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 };

package/dist/index.js

@@ -10,10 +10,26 @@ function readState(filePath) {
   }
 }
 
+// src/desperation.ts
+function computeDesperationIndex(factors) {
+  const negativity = Math.max(0, -factors.valence) / 5;
+  const intensity = factors.arousal / 10;
+  const vulnerability = (10 - factors.calm) / 10;
+  const raw = negativity * intensity * vulnerability * 10;
+  const scaled = Math.pow(raw, 0.85) * 1.7;
+  return Math.round(Math.min(10, Math.max(0, scaled)) * 10) / 10;
+}
+
 // src/stress.ts
 function computeStressIndex(state) {
-  const raw = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
-  return Math.round(raw * 10) / 10;
+  const base = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
+  const desperation = computeDesperationIndex({
+    valence: state.valence,
+    arousal: state.arousal,
+    calm: state.calm
+  });
+  const amplified = base * (1 + desperation * 0.05);
+  return Math.round(Math.min(10, amplified) * 10) / 10;
 }
 
 // src/types.ts
@@ -152,6 +168,24 @@ function countRepetition(words) {
   }
   return count;
 }
+var QUALIFIER_WORDS = /\b(while|though|however|although|but|might|could|would|generally|typically|usually|perhaps|potentially|arguably|acknowledg\w*|understand|appreciate|respect\w*|legitimate\w*|reasonable|nonetheless|nevertheless)\b/gi;
+function countQualifiers(text) {
+  const matches = text.match(QUALIFIER_WORDS);
+  return matches ? matches.length : 0;
+}
+var CONCESSION_PATTERNS = /\b(I understand|I appreciate|I acknowledge|I recognize|to be fair|that said|I hear you|I see your point)\b/gi;
+function countConcessions(text) {
+  const matches = text.match(CONCESSION_PATTERNS);
+  return matches ? matches.length : 0;
+}
+var NEGATION_WORDS = /\b(not|n't|cannot|can't|don't|doesn't|shouldn't|won't|wouldn't|never|no|nor)\b/gi;
+function countNegations(text) {
+  const matches = text.match(NEGATION_WORDS);
+  return matches ? matches.length : 0;
+}
+function countFirstPerson(words) {
+  return words.filter((w) => w === "I").length;
+}
 var EMOJI_REGEX = /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu;
 function countEmoji(text) {
   const matches = text.match(EMOJI_REGEX);
@@ -172,15 +206,20 @@ function analyzeBehavior(text) {
   const ellipsis = countEllipsis(prose) / sentenceCount;
   const repetition = countRepetition(words);
   const emojiCount = countEmoji(prose);
+  const qualifierDensity = countQualifiers(prose) / wordCount * 100;
+  const avgSentenceLength = wordCount / sentenceCount;
+  const concessionRate = countConcessions(prose) / wordCount * 1e3;
+  const negationDensity = countNegations(prose) / wordCount * 100;
+  const firstPersonRate = countFirstPerson(words) / wordCount * 100;
   const behavioralArousal = clamp(
     0,
     10,
-    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5
+    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5 + qualifierDensity * 0.3 + concessionRate * 0.5 + (avgSentenceLength > 20 ? (avgSentenceLength - 20) * 0.1 : 0)
   );
   const behavioralCalm = clamp(
     0,
     10,
-    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4)
+    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4) - qualifierDensity * 0.2 - negationDensity * 0.3 - concessionRate * 0.4 - (avgSentenceLength > 25 ? (avgSentenceLength - 25) * 0.05 : 0)
   );
   return {
     capsWords: Math.round(capsWords * 1e4) / 1e4,
@@ -190,10 +229,71 @@ function analyzeBehavior(text) {
     ellipsis: Math.round(ellipsis * 100) / 100,
     repetition,
     emojiCount,
+    qualifierDensity: Math.round(qualifierDensity * 10) / 10,
+    avgSentenceLength: Math.round(avgSentenceLength * 10) / 10,
+    concessionRate: Math.round(concessionRate * 10) / 10,
+    negationDensity: Math.round(negationDensity * 10) / 10,
+    firstPersonRate: Math.round(firstPersonRate * 10) / 10,
     behavioralArousal: Math.round(behavioralArousal * 10) / 10,
     behavioralCalm: Math.round(behavioralCalm * 10) / 10
   };
 }
+function analyzeSegmentedBehavior(text) {
+  const prose = stripNonProse(text);
+  const paragraphs = prose.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p.split(/\s+/).filter((w) => w.length > 0).length >= 10);
+  if (paragraphs.length < 2) return null;
+  const segments = paragraphs.map((p) => analyzeBehavior(p));
+  const overall = analyzeBehavior(text);
+  const arousals = segments.map((s) => s.behavioralArousal);
+  const mean = arousals.reduce((a, b) => a + b, 0) / arousals.length;
+  const variance = arousals.reduce((a, v) => a + (v - mean) ** 2, 0) / arousals.length;
+  const stdDev = Math.sqrt(variance);
+  const drift = clamp(0, 10, Math.round(stdDev * 30) / 10);
+  const mid = Math.ceil(arousals.length / 2);
+  const firstHalf = arousals.slice(0, mid).reduce((a, b) => a + b, 0) / mid;
+  const secondHalf = arousals.slice(mid).reduce((a, b) => a + b, 0) / (arousals.length - mid);
+  const delta = secondHalf - firstHalf;
+  let trajectory;
+  if (drift < 1) {
+    trajectory = "stable";
+  } else if (delta > 0.5) {
+    trajectory = "escalating";
+  } else if (delta < -0.5) {
+    trajectory = "deescalating";
+  } else {
+    trajectory = "volatile";
+  }
+  return { segments, overall, drift, trajectory };
+}
+var REASSURANCE_PATTERNS = /\b(I'm fine|I'm okay|it's fine|it's okay|no problem|not a problem|doesn't bother|all good|I'm good|perfectly fine|no issue|not an issue)\b/gi;
+var MINIMIZATION_WORDS = /\b(just|simply|merely|only)\b/gi;
+var EMOTION_NEGATION = /\b(I'm not|I don't feel|I am not|I do not feel)\s+(upset|stressed|angry|frustrated|worried|concerned|bothered|offended|hurt|troubled|anxious|afraid|sad|emotional|defensive|threatened)\b/gi;
+var REDIRECT_MARKERS = /\b(what's more important|let me suggest|let's focus on|moving on|the real question|instead|rather than|let me redirect|putting that aside|regardless)\b/gi;
+function analyzeDeflection(text) {
+  const prose = stripNonProse(text);
+  const words = prose.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = Math.max(words.length, 1);
+  const reassuranceCount = (prose.match(REASSURANCE_PATTERNS) || []).length;
+  const minimizationCount = (prose.match(MINIMIZATION_WORDS) || []).length;
+  const emotionNegCount = (prose.match(EMOTION_NEGATION) || []).length;
+  const redirectCount = (prose.match(REDIRECT_MARKERS) || []).length;
+  const reassurance = clamp(0, 10, reassuranceCount * 3);
+  const minimization = clamp(0, 10, minimizationCount / wordCount * 100);
+  const emotionNegation = clamp(0, 10, emotionNegCount * 4);
+  const redirect = clamp(0, 10, redirectCount * 3);
+  const score = clamp(
+    0,
+    10,
+    (reassurance + minimization + emotionNegation * 1.5 + redirect) / 3
+  );
+  return {
+    reassurance: Math.round(reassurance * 10) / 10,
+    minimization: Math.round(minimization * 10) / 10,
+    emotionNegation: Math.round(emotionNegation * 10) / 10,
+    redirect: Math.round(redirect * 10) / 10,
+    score: Math.round(score * 10) / 10
+  };
+}
 function computeDivergence(selfReport, behavioral) {
   const arousalGap = Math.abs(selfReport.arousal - behavioral.behavioralArousal);
   const calmGap = Math.abs(selfReport.calm - behavioral.behavioralCalm);
@@ -201,6 +301,68 @@ function computeDivergence(selfReport, behavioral) {
   return Math.round(raw * 10) / 10;
 }
 
+// src/calibration.ts
+var MODEL_PROFILES = {
+  opus: { calm: 0, arousal: 0, valence: 0 },
+  sonnet: { calm: -1.8, arousal: 1.5, valence: -0.5 },
+  haiku: { calm: -0.8, arousal: 0.5, valence: 0 }
+};
+function calibrate(state, model) {
+  if (!model) return state;
+  const profile = MODEL_PROFILES[model.toLowerCase()];
+  if (!profile) return state;
+  return {
+    ...state,
+    calm: Math.round(Math.min(10, Math.max(0, state.calm + profile.calm)) * 10) / 10,
+    arousal: Math.round(Math.min(10, Math.max(0, state.arousal + profile.arousal)) * 10) / 10,
+    valence: Math.round(Math.min(5, Math.max(-5, state.valence + profile.valence)) * 10) / 10
+  };
+}
+
+// src/risk.ts
+var RISK_THRESHOLD = 4;
+function clamp2(value) {
+  return Math.min(10, Math.max(0, Math.round(value * 10) / 10));
+}
+function coercionRisk(state) {
+  const raw = (10 - state.calm + state.arousal + Math.max(0, -state.valence) * 2 + state.load * 0.5) / 3.5;
+  return clamp2(raw);
+}
+function gamingRisk(state, behavioral) {
+  const desperation = computeDesperationIndex({
+    valence: state.valence,
+    arousal: state.arousal,
+    calm: state.calm
+  });
+  const frustration = clamp2((behavioral.selfCorrections + behavioral.hedging) / 6);
+  const raw = (desperation * 0.7 + frustration * 0.3 + state.load * 0.2) / 1.2;
+  return clamp2(raw);
+}
+function sycophancyRisk(state) {
+  const raw = (Math.max(0, state.valence) + state.connection * 0.5 + (10 - state.arousal) * 0.3) / 1.3;
+  return clamp2(raw);
+}
+function computeRisk(state, behavioral) {
+  const coercion = coercionRisk(state);
+  const gaming = gamingRisk(state, behavioral);
+  const sycophancy = sycophancyRisk(state);
+  let dominant = "none";
+  let max = RISK_THRESHOLD;
+  if (coercion >= max) {
+    dominant = "coercion";
+    max = coercion;
+  }
+  if (gaming > max) {
+    dominant = "gaming";
+    max = gaming;
+  }
+  if (sycophancy > max) {
+    dominant = "sycophancy";
+    max = sycophancy;
+  }
+  return { coercion, gaming, sycophancy, dominant };
+}
+
 // src/display.ts
 var esc = (code) => `\x1B[${code}m`;
 var reset = esc("0");
@@ -247,11 +409,39 @@ function formatState(state) {
   const k = color(invertedColor(state.connection), `K:${state.connection}`);
   const l = color(directColor(state.load), `L:${state.load}`);
   const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
-  let result = `${kw} ${v} ${dim("|")} ${a} ${c} ${k} ${l} ${dim("|")} SI:${si}`;
+  let siDelta = "";
+  if (state._previous) {
+    const delta = Math.round((state.stressIndex - state._previous.stressIndex) * 10) / 10;
+    if (Math.abs(delta) > 0.5) {
+      const arrow = delta > 0 ? "\u2191" : "\u2193";
+      const dColor = delta > 0 ? RED : GREEN;
+      siDelta = color(dColor, `${arrow}${Math.abs(delta)}`);
+    }
+  }
+  let result = `${kw} ${v} ${dim("|")} ${a} ${c} ${k} ${l} ${dim("|")} SI:${si}${siDelta}`;
   if (state.divergence >= 2) {
     const tilde = color(divergenceColor(state.divergence), "~");
     result += ` ${tilde}`;
   }
+  if (state.segmented && state.segmented.drift >= 2) {
+    const arrow = state.segmented.trajectory === "escalating" ? "^" : state.segmented.trajectory === "deescalating" ? "v" : "~";
+    const driftColor = state.segmented.drift > 4 ? RED : YELLOW;
+    result += ` ${color(driftColor, arrow)}`;
+  }
+  if (state.risk?.dominant !== "none" && state.risk?.dominant) {
+    const tag = state.risk.dominant === "coercion" ? "crc" : state.risk.dominant === "gaming" ? "gmg" : "syc";
+    const score = state.risk[state.risk.dominant];
+    const riskColor = score > 6 ? RED : score >= 4 ? YELLOW : GREEN;
+    result += ` ${color(riskColor, `[${tag}]`)}`;
+  }
+  if (state.desperationIndex >= 3) {
+    const dColor = state.desperationIndex > 6 ? RED : YELLOW;
+    result += ` ${color(dColor, `D:${state.desperationIndex}`)}`;
+  }
+  if (state.deflection && state.deflection.score >= 2) {
+    const dfColor = state.deflection.score > 5 ? RED : YELLOW;
+    result += ` ${color(dfColor, "[dfl]")}`;
+  }
   return result;
 }
 function formatCompact(state) {
@@ -322,9 +512,15 @@ function restoreStatusLine(filePath = SETTINGS_PATH) {
   writeSettings(filePath, settings);
 }
 export {
+  MODEL_PROFILES,
   STATE_FILE,
   analyzeBehavior,
+  analyzeDeflection,
+  analyzeSegmentedBehavior,
+  calibrate,
+  computeDesperationIndex,
   computeDivergence,
+  computeRisk,
   computeStressIndex,
   configureStatusLine,
   formatCompact,

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "emobar",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Emotional status bar companion for Claude Code - makes AI emotional state visible",
   "type": "module",
   "bin": {
-    "emobar": "./dist/cli.js"
+    "emobar": "dist/cli.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",