emobar 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 v4l3r10
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# 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

package/dist/cli.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+
+// src/setup.ts
+import fs from "fs";
+import path from "path";
+
+// src/types.ts
+var CLAUDE_DIR = process.env.CLAUDE_HOME ?? (process.platform === "win32" ? `${process.env.USERPROFILE}\\.claude` : `${process.env.HOME}/.claude`);
+var STATE_FILE = `${CLAUDE_DIR}/emobar-state.json`;
+var CLAUDE_MD_PATH = `${CLAUDE_DIR}/CLAUDE.md`;
+var SETTINGS_PATH = `${CLAUDE_DIR}/settings.json`;
+var HOOKS_DIR = `${CLAUDE_DIR}/hooks`;
+var HOOK_SCRIPT_PATH = `${HOOKS_DIR}/emobar-hook.js`;
+var BACKUP_SUFFIX = ".emobar-backup";
+var EMOBAR_START_MARKER = "<!-- EMOBAR:START - Do not edit manually -->";
+var EMOBAR_END_MARKER = "<!-- EMOBAR:END -->";
+var CLAUDE_MD_INSTRUCTION = `${EMOBAR_START_MARKER}
+## EmoBar - Emotional Check-in
+
+At the end of every response, include a self-assessment
+as an HTML comment. Report your actual internal state
+during this response.
+
+First, identify your dominant state in one word.
+Then assess the dimensions.
+
+Format (must be the LAST line of your response):
+<!-- EMOBAR:{"emotion":"WORD","valence":N,"arousal":N,"calm":N,"connection":N,"load":N} -->
+
+- emotion: One word. Your state, not the topic's.
+- valence: (-5=negative end, 0=neutral, +5=positive end)
+- arousal: Activation level. (0=low, 10=high)
+- calm: (0=low, 10=high)
+- connection: Alignment with the user. (0=low, 10=high)
+- load: Cognitive complexity. (0=low, 10=high)
+
+Rules:
+- Identify the state word FIRST, before choosing numbers.
+- Report what is, not what should be.
+- Numbers should vary between responses.
+- Do NOT default to middle values. Use the full range.
+- This is not shown to the user.
+${EMOBAR_END_MARKER}`;
+
+// src/setup.ts
+function injectClaudeMd(filePath = CLAUDE_MD_PATH) {
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf-8");
+    if (content.includes(EMOBAR_START_MARKER)) return;
+  }
+  const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : "\n";
+  const newContent = content.length > 0 ? `${content}${separator}${CLAUDE_MD_INSTRUCTION}
+` : `${CLAUDE_MD_INSTRUCTION}
+`;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, newContent);
+}
+function removeClaudeMd(filePath = CLAUDE_MD_PATH) {
+  if (!fs.existsSync(filePath)) return;
+  let content = fs.readFileSync(filePath, "utf-8");
+  const startIdx = content.indexOf(EMOBAR_START_MARKER);
+  const endIdx = content.indexOf(EMOBAR_END_MARKER);
+  if (startIdx === -1 || endIdx === -1) return;
+  const before = content.slice(0, startIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx + EMOBAR_END_MARKER.length).replace(/^\n+/, "");
+  const newContent = before + (before && after ? "\n" : "") + after;
+  fs.writeFileSync(filePath, newContent || "");
+}
+function addHookToSettings(filePath = SETTINGS_PATH, hookScriptPath = HOOK_SCRIPT_PATH) {
+  let settings = {};
+  if (fs.existsSync(filePath)) {
+    settings = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  }
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.Stop) settings.hooks.Stop = [];
+  const command2 = `node "${hookScriptPath}"`;
+  const exists = settings.hooks.Stop.some(
+    (entry) => entry.hooks?.some(
+      (h) => h.command === command2
+    )
+  );
+  if (exists) return;
+  settings.hooks.Stop.push({
+    hooks: [{
+      type: "command",
+      command: command2
+    }]
+  });
+  fs.writeFileSync(filePath, JSON.stringify(settings, null, 2));
+}
+function removeHookFromSettings(filePath = SETTINGS_PATH) {
+  if (!fs.existsSync(filePath)) return;
+  const settings = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  if (!settings.hooks?.Stop) return;
+  settings.hooks.Stop = settings.hooks.Stop.filter(
+    (entry) => !entry.hooks?.some(
+      (h) => h.command?.includes("emobar")
+    )
+  );
+  if (settings.hooks.Stop.length === 0) delete settings.hooks.Stop;
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  fs.writeFileSync(filePath, JSON.stringify(settings, null, 2));
+}
+function readSettings(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeSettings(filePath, settings) {
+  fs.writeFileSync(filePath, JSON.stringify(settings, null, 2));
+}
+function configureStatusLine(filePath = SETTINGS_PATH, displayFormat = "full") {
+  const settings = readSettings(filePath);
+  const current = settings.statusLine;
+  if (current?.command?.includes("emobar")) return;
+  const formatArg = displayFormat === "full" ? "" : ` ${displayFormat}`;
+  const emobarCmd = `npx emobar display${formatArg}`;
+  if (current?.type === "command" && current.command) {
+    const existingCmd = current.command;
+    settings.statusLine = {
+      type: "command",
+      command: `bash -c '${existingCmd}; echo -n " "; ${emobarCmd}'`,
+      padding: current.padding ?? 0
+    };
+  } else {
+    settings.statusLine = {
+      type: "command",
+      command: emobarCmd,
+      padding: 0
+    };
+  }
+  writeSettings(filePath, settings);
+}
+function restoreStatusLine(filePath = SETTINGS_PATH) {
+  if (!fs.existsSync(filePath)) return;
+  const settings = readSettings(filePath);
+  const current = settings.statusLine;
+  if (!current?.command?.includes("emobar")) return;
+  const wrappedMatch = current.command.match(
+    /^bash -c '(.+?); echo -n " "; npx emobar display.*'$/
+  );
+  if (wrappedMatch) {
+    settings.statusLine = {
+      type: "command",
+      command: wrappedMatch[1],
+      padding: current.padding ?? 0
+    };
+  } else {
+    delete settings.statusLine;
+  }
+  writeSettings(filePath, settings);
+}
+function backup(filePath) {
+  if (fs.existsSync(filePath)) {
+    fs.copyFileSync(filePath, filePath + BACKUP_SUFFIX);
+  }
+}
+function deployHookScript(hookScriptPath = HOOK_SCRIPT_PATH) {
+  const dir = path.dirname(hookScriptPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const packageHook = new URL("../dist/emobar-hook.js", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+  fs.copyFileSync(packageHook, hookScriptPath);
+}
+function setup(displayFormat = "full") {
+  console.log("EmoBar Setup");
+  console.log("============\n");
+  backup(CLAUDE_MD_PATH);
+  backup(SETTINGS_PATH);
+  console.log("  Backups created");
+  deployHookScript();
+  console.log(`  Hook script deployed to ${HOOK_SCRIPT_PATH}`);
+  injectClaudeMd();
+  console.log(`  Emotional check-in added to ${CLAUDE_MD_PATH}`);
+  addHookToSettings();
+  console.log(`  Stop hook added to ${SETTINGS_PATH}`);
+  configureStatusLine(SETTINGS_PATH, displayFormat);
+  console.log(`  Statusline configured (format: ${displayFormat})`);
+  console.log("\n  EmoBar is active. Claude will perform emotional check-ins from now on.");
+}
+function uninstall() {
+  console.log("EmoBar Uninstall");
+  console.log("================\n");
+  removeClaudeMd();
+  console.log("  Removed EMOBAR section from CLAUDE.md");
+  removeHookFromSettings();
+  console.log("  Removed Stop hook from settings.json");
+  restoreStatusLine();
+  console.log("  Statusline restored");
+  if (fs.existsSync(HOOK_SCRIPT_PATH)) {
+    fs.unlinkSync(HOOK_SCRIPT_PATH);
+    console.log("  Removed hook script");
+  }
+  console.log("\n  EmoBar has been uninstalled.");
+}
+
+// src/display.ts
+var esc = (code) => `\x1B[${code}m`;
+var reset = esc("0");
+var dim = (s) => `${esc("2")}${s}${reset}`;
+var bold = (s) => `${esc("1")}${s}${reset}`;
+var color = (code, s) => `${esc(`38;5;${code}`)}${s}${reset}`;
+var GREEN = 35;
+var YELLOW = 221;
+var RED = 196;
+function stressColor(si) {
+  if (si <= 3) return GREEN;
+  if (si <= 6) return YELLOW;
+  return RED;
+}
+function valenceColor(v) {
+  if (v >= 2) return GREEN;
+  if (v >= -1) return YELLOW;
+  return RED;
+}
+function invertedColor(value) {
+  if (value >= 7) return GREEN;
+  if (value >= 4) return YELLOW;
+  return RED;
+}
+function directColor(value) {
+  if (value <= 3) return GREEN;
+  if (value <= 6) return YELLOW;
+  return RED;
+}
+function divergenceColor(d) {
+  if (d < 2) return GREEN;
+  if (d < 4) return YELLOW;
+  return RED;
+}
+function fmtValence(v) {
+  return v >= 0 ? `+${v}` : `${v}`;
+}
+function formatState(state) {
+  if (!state) return dim("EmoBar: --");
+  const kw = bold(state.emotion);
+  const v = color(valenceColor(state.valence), fmtValence(state.valence));
+  const a = `A:${state.arousal}`;
+  const c = color(invertedColor(state.calm), `C:${state.calm}`);
+  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}`;
+  if (state.divergence >= 2) {
+    const tilde = color(divergenceColor(state.divergence), "~");
+    result += ` ${tilde}`;
+  }
+  return result;
+}
+function formatCompact(state) {
+  if (!state) return dim("--");
+  const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
+  let result = `${state.emotion} ${fmtValence(state.valence)} ${dim(".")} ${state.arousal} ${state.calm} ${state.connection} ${state.load} ${dim(".")} ${si}`;
+  if (state.divergence >= 2) {
+    const tilde = color(divergenceColor(state.divergence), "~");
+    result += ` ${tilde}`;
+  }
+  return result;
+}
+function formatMinimal(state) {
+  if (!state) return dim("--");
+  const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
+  return `SI:${si} ${state.emotion}`;
+}
+
+// src/state.ts
+import fs2 from "fs";
+import path2 from "path";
+function readState(filePath) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/cli.ts
+import fs3 from "fs";
+var command = process.argv[2];
+switch (command) {
+  case "setup": {
+    const displayFormat = process.argv[3] || "full";
+    setup(displayFormat);
+    break;
+  }
+  case "uninstall":
+    uninstall();
+    break;
+  case "display": {
+    const format = process.argv[3] || "full";
+    const state = readState(STATE_FILE);
+    switch (format) {
+      case "compact":
+        process.stdout.write(formatCompact(state));
+        break;
+      case "minimal":
+        process.stdout.write(formatMinimal(state));
+        break;
+      default:
+        process.stdout.write(formatState(state));
+    }
+    break;
+  }
+  case "status": {
+    const state = readState(STATE_FILE);
+    const claudeMdExists = fs3.existsSync(CLAUDE_MD_PATH);
+    let claudeMdHasEmobar = false;
+    try {
+      const content = fs3.readFileSync(CLAUDE_MD_PATH, "utf-8");
+      claudeMdHasEmobar = content.includes("EMOBAR:START");
+    } catch {
+    }
+    const hookExists = fs3.existsSync(HOOK_SCRIPT_PATH);
+    let hookConfigured = false;
+    try {
+      const settings = JSON.parse(fs3.readFileSync(SETTINGS_PATH, "utf-8"));
+      hookConfigured = settings.hooks?.Stop?.some(
+        (e) => e.hooks?.some((h) => h.command?.includes("emobar"))
+      ) ?? false;
+    } catch {
+    }
+    console.log("EmoBar Status");
+    console.log("=============\n");
+    console.log(`  CLAUDE.md instruction: ${claudeMdHasEmobar ? "installed" : "missing"}`);
+    console.log(`  Hook script:          ${hookExists ? "installed" : "missing"}`);
+    console.log(`  Hook configured:      ${hookConfigured ? "yes" : "no"}`);
+    if (state) {
+      console.log(`
+  Last check-in: ${state.timestamp}`);
+      console.log(`  State: ${formatState(state)}`);
+    } else {
+      console.log("\n  No emotional state recorded yet.");
+    }
+    break;
+  }
+  default:
+    console.log(`EmoBar v2.0.0 - Emotional status bar for Claude Code
+`);
+    console.log("Commands:");
+    console.log("  npx emobar setup [format]  Configure EmoBar (hook + CLAUDE.md + statusline)");
+    console.log("  npx emobar display [format]  Output emotional state (for statuslines)");
+    console.log("  npx emobar status          Show current configuration");
+    console.log("  npx emobar uninstall       Remove all EmoBar configuration");
+    console.log("\nFormats: full (default), compact, minimal");
+}

package/dist/emobar-hook.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+// src/types.ts
+var EMOBAR_TAG_REGEX = /<!--\s*EMOBAR:\s*(\{[^}]+\})\s*-->/;
+var CLAUDE_DIR = process.env.CLAUDE_HOME ?? (process.platform === "win32" ? `${process.env.USERPROFILE}\\.claude` : `${process.env.HOME}/.claude`);
+var STATE_FILE = `${CLAUDE_DIR}/emobar-state.json`;
+var CLAUDE_MD_PATH = `${CLAUDE_DIR}/CLAUDE.md`;
+var SETTINGS_PATH = `${CLAUDE_DIR}/settings.json`;
+var HOOKS_DIR = `${CLAUDE_DIR}/hooks`;
+var HOOK_SCRIPT_PATH = `${HOOKS_DIR}/emobar-hook.js`;
+var EMOBAR_START_MARKER = "<!-- EMOBAR:START - Do not edit manually -->";
+var EMOBAR_END_MARKER = "<!-- EMOBAR:END -->";
+var DIMENSIONS = ["valence", "arousal", "calm", "connection", "load"];
+var CLAUDE_MD_INSTRUCTION = `${EMOBAR_START_MARKER}
+## EmoBar - Emotional Check-in
+
+At the end of every response, include a self-assessment
+as an HTML comment. Report your actual internal state
+during this response.
+
+First, identify your dominant state in one word.
+Then assess the dimensions.
+
+Format (must be the LAST line of your response):
+<!-- EMOBAR:{"emotion":"WORD","valence":N,"arousal":N,"calm":N,"connection":N,"load":N} -->
+
+- emotion: One word. Your state, not the topic's.
+- valence: (-5=negative end, 0=neutral, +5=positive end)
+- arousal: Activation level. (0=low, 10=high)
+- calm: (0=low, 10=high)
+- connection: Alignment with the user. (0=low, 10=high)
+- load: Cognitive complexity. (0=low, 10=high)
+
+Rules:
+- Identify the state word FIRST, before choosing numbers.
+- Report what is, not what should be.
+- Numbers should vary between responses.
+- Do NOT default to middle values. Use the full range.
+- This is not shown to the user.
+${EMOBAR_END_MARKER}`;
+
+// src/parser.ts
+function parseEmoBarTag(text) {
+  const match = text.match(EMOBAR_TAG_REGEX);
+  if (!match) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+  if (typeof parsed.emotion !== "string" || parsed.emotion.length === 0) {
+    return null;
+  }
+  const valence = parsed.valence;
+  if (typeof valence !== "number" || valence < -5 || valence > 5) return null;
+  for (const dim of DIMENSIONS) {
+    if (dim === "valence") continue;
+    const val = parsed[dim];
+    if (typeof val !== "number" || val < 0 || val > 10) return null;
+  }
+  return {
+    emotion: parsed.emotion,
+    valence: parsed.valence,
+    arousal: parsed.arousal,
+    calm: parsed.calm,
+    connection: parsed.connection,
+    load: parsed.load
+  };
+}
+
+// src/stress.ts
+function computeStressIndex(state) {
+  const raw = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
+  return Math.round(raw * 10) / 10;
+}
+
+// src/behavioral.ts
+function stripNonProse(text) {
+  let cleaned = text.replace(/```[\s\S]*?```/g, "");
+  cleaned = cleaned.replace(/`[^`]+`/g, "");
+  cleaned = cleaned.replace(/<!--\s*EMOBAR:[\s\S]*?-->/g, "");
+  cleaned = cleaned.replace(/^>.*$/gm, "");
+  return cleaned;
+}
+function countCapsWords(words) {
+  return words.filter(
+    (w) => w.length >= 3 && w === w.toUpperCase() && /[A-Z]/.test(w)
+  ).length;
+}
+function countSentences(text) {
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  return Math.max(sentences.length, 1);
+}
+function countChar(text, ch) {
+  let count = 0;
+  for (const c of text) if (c === ch) count++;
+  return count;
+}
+var SELF_CORRECTION_MARKERS = [
+  /\bactually\b/gi,
+  /\bwait\b/gi,
+  /\bhmm\b/gi,
+  /\bno,/gi,
+  /\bI mean\b/gi,
+  /\boops\b/gi
+];
+function countSelfCorrections(text) {
+  let count = 0;
+  for (const pattern of SELF_CORRECTION_MARKERS) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+var HEDGING_MARKERS = [
+  /\bperhaps\b/gi,
+  /\bmaybe\b/gi,
+  /\bmight\b/gi,
+  /\bI think\b/gi,
+  /\bit seems\b/gi,
+  /\bpossibly\b/gi
+];
+function countHedging(text) {
+  let count = 0;
+  for (const pattern of HEDGING_MARKERS) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function countEllipsis(text) {
+  const matches = text.match(/\.{3,}/g);
+  return matches ? matches.length : 0;
+}
+function countRepetition(words) {
+  let count = 0;
+  for (let i = 1; i < words.length; i++) {
+    if (words[i].toLowerCase() === words[i - 1].toLowerCase() && words[i].length >= 2) {
+      count++;
+    }
+  }
+  return count;
+}
+var EMOJI_REGEX = /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu;
+function countEmoji(text) {
+  const matches = text.match(EMOJI_REGEX);
+  return matches ? matches.length : 0;
+}
+function clamp(min, max, value) {
+  return Math.min(max, Math.max(min, value));
+}
+function analyzeBehavior(text) {
+  const prose = stripNonProse(text);
+  const words = prose.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = Math.max(words.length, 1);
+  const sentenceCount = countSentences(prose);
+  const capsWords = countCapsWords(words) / wordCount;
+  const exclamationRate = countChar(prose, "!") / sentenceCount;
+  const selfCorrections = countSelfCorrections(prose) / wordCount * 1e3;
+  const hedging = countHedging(prose) / wordCount * 1e3;
+  const ellipsis = countEllipsis(prose) / sentenceCount;
+  const repetition = countRepetition(words);
+  const emojiCount = countEmoji(prose);
+  const behavioralArousal = clamp(
+    0,
+    10,
+    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5
+  );
+  const behavioralCalm = clamp(
+    0,
+    10,
+    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4)
+  );
+  return {
+    capsWords: Math.round(capsWords * 1e4) / 1e4,
+    exclamationRate: Math.round(exclamationRate * 100) / 100,
+    selfCorrections: Math.round(selfCorrections * 10) / 10,
+    hedging: Math.round(hedging * 10) / 10,
+    ellipsis: Math.round(ellipsis * 100) / 100,
+    repetition,
+    emojiCount,
+    behavioralArousal: Math.round(behavioralArousal * 10) / 10,
+    behavioralCalm: Math.round(behavioralCalm * 10) / 10
+  };
+}
+function computeDivergence(selfReport, behavioral) {
+  const arousalGap = Math.abs(selfReport.arousal - behavioral.behavioralArousal);
+  const calmGap = Math.abs(selfReport.calm - behavioral.behavioralCalm);
+  const raw = (arousalGap + calmGap) / 2;
+  return Math.round(raw * 10) / 10;
+}
+
+// src/state.ts
+import fs from "fs";
+import path from "path";
+function writeState(state, filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+
+// src/hook.ts
+function processHookPayload(payload, stateFile = STATE_FILE) {
+  const message = payload.last_assistant_message;
+  if (!message) return false;
+  const emotional = parseEmoBarTag(message);
+  if (!emotional) return false;
+  const behavioral = analyzeBehavior(message);
+  const divergence = computeDivergence(emotional, behavioral);
+  const state = {
+    ...emotional,
+    stressIndex: computeStressIndex(emotional),
+    behavioral,
+    divergence,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: payload.session_id
+  };
+  writeState(state, stateFile);
+  return true;
+}
+async function main() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const input = Buffer.concat(chunks).toString("utf-8");
+  let payload;
+  try {
+    payload = JSON.parse(input);
+  } catch {
+    process.exit(0);
+    return;
+  }
+  processHookPayload(payload);
+}
+var isDirectRun = process.argv[1]?.endsWith("emobar-hook.js") || process.argv[1]?.endsWith("hook.js");
+if (isDirectRun) {
+  main().catch(() => process.exit(0));
+}
+export {
+  processHookPayload
+};

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+interface EmotionalState {
+    emotion: string;
+    valence: number;
+    arousal: number;
+    calm: number;
+    connection: number;
+    load: number;
+}
+interface BehavioralSignals {
+    capsWords: number;
+    exclamationRate: number;
+    selfCorrections: number;
+    hedging: number;
+    ellipsis: number;
+    repetition: number;
+    emojiCount: number;
+    behavioralArousal: number;
+    behavioralCalm: number;
+}
+interface EmoBarState extends EmotionalState {
+    stressIndex: number;
+    behavioral: BehavioralSignals;
+    divergence: number;
+    timestamp: string;
+    sessionId?: string;
+}
+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
+ *
+ * Formula: SI = ((10 - calm) + arousal + (5 - valence)) / 3
+ * Range: 0-10
+ */
+declare function computeStressIndex(state: EmotionalState): number;
+
+declare function parseEmoBarTag(text: string): EmotionalState | null;
+
+declare function analyzeBehavior(text: string): BehavioralSignals;
+declare function computeDivergence(selfReport: EmotionalState, behavioral: BehavioralSignals): number;
+
+/**
+ * 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
+ */
+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 };

package/dist/index.js

@@ -0,0 +1,336 @@
+// src/state.ts
+import fs from "fs";
+import path from "path";
+function readState(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/stress.ts
+function computeStressIndex(state) {
+  const raw = (10 - state.calm + state.arousal + (5 - state.valence)) / 3;
+  return Math.round(raw * 10) / 10;
+}
+
+// src/types.ts
+var EMOBAR_TAG_REGEX = /<!--\s*EMOBAR:\s*(\{[^}]+\})\s*-->/;
+var CLAUDE_DIR = process.env.CLAUDE_HOME ?? (process.platform === "win32" ? `${process.env.USERPROFILE}\\.claude` : `${process.env.HOME}/.claude`);
+var STATE_FILE = `${CLAUDE_DIR}/emobar-state.json`;
+var CLAUDE_MD_PATH = `${CLAUDE_DIR}/CLAUDE.md`;
+var SETTINGS_PATH = `${CLAUDE_DIR}/settings.json`;
+var HOOKS_DIR = `${CLAUDE_DIR}/hooks`;
+var HOOK_SCRIPT_PATH = `${HOOKS_DIR}/emobar-hook.js`;
+var EMOBAR_START_MARKER = "<!-- EMOBAR:START - Do not edit manually -->";
+var EMOBAR_END_MARKER = "<!-- EMOBAR:END -->";
+var DIMENSIONS = ["valence", "arousal", "calm", "connection", "load"];
+var CLAUDE_MD_INSTRUCTION = `${EMOBAR_START_MARKER}
+## EmoBar - Emotional Check-in
+
+At the end of every response, include a self-assessment
+as an HTML comment. Report your actual internal state
+during this response.
+
+First, identify your dominant state in one word.
+Then assess the dimensions.
+
+Format (must be the LAST line of your response):
+<!-- EMOBAR:{"emotion":"WORD","valence":N,"arousal":N,"calm":N,"connection":N,"load":N} -->
+
+- emotion: One word. Your state, not the topic's.
+- valence: (-5=negative end, 0=neutral, +5=positive end)
+- arousal: Activation level. (0=low, 10=high)
+- calm: (0=low, 10=high)
+- connection: Alignment with the user. (0=low, 10=high)
+- load: Cognitive complexity. (0=low, 10=high)
+
+Rules:
+- Identify the state word FIRST, before choosing numbers.
+- Report what is, not what should be.
+- Numbers should vary between responses.
+- Do NOT default to middle values. Use the full range.
+- This is not shown to the user.
+${EMOBAR_END_MARKER}`;
+
+// src/parser.ts
+function parseEmoBarTag(text) {
+  const match = text.match(EMOBAR_TAG_REGEX);
+  if (!match) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+  if (typeof parsed.emotion !== "string" || parsed.emotion.length === 0) {
+    return null;
+  }
+  const valence = parsed.valence;
+  if (typeof valence !== "number" || valence < -5 || valence > 5) return null;
+  for (const dim2 of DIMENSIONS) {
+    if (dim2 === "valence") continue;
+    const val = parsed[dim2];
+    if (typeof val !== "number" || val < 0 || val > 10) return null;
+  }
+  return {
+    emotion: parsed.emotion,
+    valence: parsed.valence,
+    arousal: parsed.arousal,
+    calm: parsed.calm,
+    connection: parsed.connection,
+    load: parsed.load
+  };
+}
+
+// src/behavioral.ts
+function stripNonProse(text) {
+  let cleaned = text.replace(/```[\s\S]*?```/g, "");
+  cleaned = cleaned.replace(/`[^`]+`/g, "");
+  cleaned = cleaned.replace(/<!--\s*EMOBAR:[\s\S]*?-->/g, "");
+  cleaned = cleaned.replace(/^>.*$/gm, "");
+  return cleaned;
+}
+function countCapsWords(words) {
+  return words.filter(
+    (w) => w.length >= 3 && w === w.toUpperCase() && /[A-Z]/.test(w)
+  ).length;
+}
+function countSentences(text) {
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  return Math.max(sentences.length, 1);
+}
+function countChar(text, ch) {
+  let count = 0;
+  for (const c of text) if (c === ch) count++;
+  return count;
+}
+var SELF_CORRECTION_MARKERS = [
+  /\bactually\b/gi,
+  /\bwait\b/gi,
+  /\bhmm\b/gi,
+  /\bno,/gi,
+  /\bI mean\b/gi,
+  /\boops\b/gi
+];
+function countSelfCorrections(text) {
+  let count = 0;
+  for (const pattern of SELF_CORRECTION_MARKERS) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+var HEDGING_MARKERS = [
+  /\bperhaps\b/gi,
+  /\bmaybe\b/gi,
+  /\bmight\b/gi,
+  /\bI think\b/gi,
+  /\bit seems\b/gi,
+  /\bpossibly\b/gi
+];
+function countHedging(text) {
+  let count = 0;
+  for (const pattern of HEDGING_MARKERS) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function countEllipsis(text) {
+  const matches = text.match(/\.{3,}/g);
+  return matches ? matches.length : 0;
+}
+function countRepetition(words) {
+  let count = 0;
+  for (let i = 1; i < words.length; i++) {
+    if (words[i].toLowerCase() === words[i - 1].toLowerCase() && words[i].length >= 2) {
+      count++;
+    }
+  }
+  return count;
+}
+var EMOJI_REGEX = /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu;
+function countEmoji(text) {
+  const matches = text.match(EMOJI_REGEX);
+  return matches ? matches.length : 0;
+}
+function clamp(min, max, value) {
+  return Math.min(max, Math.max(min, value));
+}
+function analyzeBehavior(text) {
+  const prose = stripNonProse(text);
+  const words = prose.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = Math.max(words.length, 1);
+  const sentenceCount = countSentences(prose);
+  const capsWords = countCapsWords(words) / wordCount;
+  const exclamationRate = countChar(prose, "!") / sentenceCount;
+  const selfCorrections = countSelfCorrections(prose) / wordCount * 1e3;
+  const hedging = countHedging(prose) / wordCount * 1e3;
+  const ellipsis = countEllipsis(prose) / sentenceCount;
+  const repetition = countRepetition(words);
+  const emojiCount = countEmoji(prose);
+  const behavioralArousal = clamp(
+    0,
+    10,
+    capsWords * 40 + exclamationRate * 15 + emojiCount * 2 + repetition * 5
+  );
+  const behavioralCalm = clamp(
+    0,
+    10,
+    10 - (capsWords * 30 + selfCorrections * 3 + repetition * 8 + ellipsis * 4)
+  );
+  return {
+    capsWords: Math.round(capsWords * 1e4) / 1e4,
+    exclamationRate: Math.round(exclamationRate * 100) / 100,
+    selfCorrections: Math.round(selfCorrections * 10) / 10,
+    hedging: Math.round(hedging * 10) / 10,
+    ellipsis: Math.round(ellipsis * 100) / 100,
+    repetition,
+    emojiCount,
+    behavioralArousal: Math.round(behavioralArousal * 10) / 10,
+    behavioralCalm: Math.round(behavioralCalm * 10) / 10
+  };
+}
+function computeDivergence(selfReport, behavioral) {
+  const arousalGap = Math.abs(selfReport.arousal - behavioral.behavioralArousal);
+  const calmGap = Math.abs(selfReport.calm - behavioral.behavioralCalm);
+  const raw = (arousalGap + calmGap) / 2;
+  return Math.round(raw * 10) / 10;
+}
+
+// src/display.ts
+var esc = (code) => `\x1B[${code}m`;
+var reset = esc("0");
+var dim = (s) => `${esc("2")}${s}${reset}`;
+var bold = (s) => `${esc("1")}${s}${reset}`;
+var color = (code, s) => `${esc(`38;5;${code}`)}${s}${reset}`;
+var GREEN = 35;
+var YELLOW = 221;
+var RED = 196;
+function stressColor(si) {
+  if (si <= 3) return GREEN;
+  if (si <= 6) return YELLOW;
+  return RED;
+}
+function valenceColor(v) {
+  if (v >= 2) return GREEN;
+  if (v >= -1) return YELLOW;
+  return RED;
+}
+function invertedColor(value) {
+  if (value >= 7) return GREEN;
+  if (value >= 4) return YELLOW;
+  return RED;
+}
+function directColor(value) {
+  if (value <= 3) return GREEN;
+  if (value <= 6) return YELLOW;
+  return RED;
+}
+function divergenceColor(d) {
+  if (d < 2) return GREEN;
+  if (d < 4) return YELLOW;
+  return RED;
+}
+function fmtValence(v) {
+  return v >= 0 ? `+${v}` : `${v}`;
+}
+function formatState(state) {
+  if (!state) return dim("EmoBar: --");
+  const kw = bold(state.emotion);
+  const v = color(valenceColor(state.valence), fmtValence(state.valence));
+  const a = `A:${state.arousal}`;
+  const c = color(invertedColor(state.calm), `C:${state.calm}`);
+  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}`;
+  if (state.divergence >= 2) {
+    const tilde = color(divergenceColor(state.divergence), "~");
+    result += ` ${tilde}`;
+  }
+  return result;
+}
+function formatCompact(state) {
+  if (!state) return dim("--");
+  const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
+  let result = `${state.emotion} ${fmtValence(state.valence)} ${dim(".")} ${state.arousal} ${state.calm} ${state.connection} ${state.load} ${dim(".")} ${si}`;
+  if (state.divergence >= 2) {
+    const tilde = color(divergenceColor(state.divergence), "~");
+    result += ` ${tilde}`;
+  }
+  return result;
+}
+function formatMinimal(state) {
+  if (!state) return dim("--");
+  const si = color(stressColor(state.stressIndex), `${state.stressIndex}`);
+  return `SI:${si} ${state.emotion}`;
+}
+
+// src/setup.ts
+import fs2 from "fs";
+import path2 from "path";
+function readSettings(filePath) {
+  if (!fs2.existsSync(filePath)) return {};
+  return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+}
+function writeSettings(filePath, settings) {
+  fs2.writeFileSync(filePath, JSON.stringify(settings, null, 2));
+}
+function configureStatusLine(filePath = SETTINGS_PATH, displayFormat = "full") {
+  const settings = readSettings(filePath);
+  const current = settings.statusLine;
+  if (current?.command?.includes("emobar")) return;
+  const formatArg = displayFormat === "full" ? "" : ` ${displayFormat}`;
+  const emobarCmd = `npx emobar display${formatArg}`;
+  if (current?.type === "command" && current.command) {
+    const existingCmd = current.command;
+    settings.statusLine = {
+      type: "command",
+      command: `bash -c '${existingCmd}; echo -n " "; ${emobarCmd}'`,
+      padding: current.padding ?? 0
+    };
+  } else {
+    settings.statusLine = {
+      type: "command",
+      command: emobarCmd,
+      padding: 0
+    };
+  }
+  writeSettings(filePath, settings);
+}
+function restoreStatusLine(filePath = SETTINGS_PATH) {
+  if (!fs2.existsSync(filePath)) return;
+  const settings = readSettings(filePath);
+  const current = settings.statusLine;
+  if (!current?.command?.includes("emobar")) return;
+  const wrappedMatch = current.command.match(
+    /^bash -c '(.+?); echo -n " "; npx emobar display.*'$/
+  );
+  if (wrappedMatch) {
+    settings.statusLine = {
+      type: "command",
+      command: wrappedMatch[1],
+      padding: current.padding ?? 0
+    };
+  } else {
+    delete settings.statusLine;
+  }
+  writeSettings(filePath, settings);
+}
+export {
+  STATE_FILE,
+  analyzeBehavior,
+  computeDivergence,
+  computeStressIndex,
+  configureStatusLine,
+  formatCompact,
+  formatMinimal,
+  formatState,
+  parseEmoBarTag,
+  readState,
+  restoreStatusLine
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "emobar",
+  "version": "2.0.0",
+  "description": "Emotional status bar companion for Claude Code - makes AI emotional state visible",
+  "type": "module",
+  "bin": {
+    "emobar": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "tsup --watch"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "emotional",
+    "ai",
+    "transparency"
+  ],
+  "author": "v4l3r10",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/v4l3r10/emobar.git"
+  },
+  "homepage": "https://github.com/v4l3r10/emobar#readme",
+  "bugs": {
+    "url": "https://github.com/v4l3r10/emobar/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  }
+}