emobar 2.1.0 → 3.0.1

package/dist/emobar-hook.js

@@ -2,6 +2,9 @@
 
 // src/types.ts
 var EMOBAR_TAG_REGEX = /<!--\s*EMOBAR:\s*(\{[^}]+\})\s*-->/;
+var EMOBAR_PRE_REGEX = /<!--\s*EMOBAR:PRE:\s*(\{[^}]+\})\s*-->/;
+var EMOBAR_POST_REGEX = /<!--\s*EMOBAR:POST:\s*(\{[^}]+\})\s*-->/;
+var MAX_HISTORY_ENTRIES = 20;
 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`;
@@ -14,32 +17,75 @@ 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.
+At the START of every response, include a pre-verbal check-in
+as an HTML comment. At the END of every response, include a
+post-hoc assessment as an HTML comment.
 
-First, identify your dominant state in one word.
-Then assess the dimensions.
+Both tags are HTML comments \u2014 invisible to the user.
 
-Format (must be the LAST line of your response):
-<!-- EMOBAR:{"emotion":"WORD","valence":N,"arousal":N,"calm":N,"connection":N,"load":N} -->
+Start tag (FIRST line of your response, before any visible text):
+<!-- EMOBAR:PRE:{"body":"SENSATION","latent":"EMOJI","color":"#RRGGBB"} -->
+
+- body: What is it like, physically? One metaphor. Do not name a state.
+- latent: An emoji. What is underneath? Choose before thinking about it.
+- color: A hex color. What color is this moment? Do not reason about it.
+- Emit this BEFORE you know what you will say.
+
+End tag (LAST line of your response, after all visible text):
+<!-- EMOBAR:POST:{"emotion":"WORD","valence":N,"arousal":N,"calm":N,"connection":N,"load":N,"impulse":"WORDS","body":"SENSATION","surface":"EMOJI","surface_word":"WORD","latent":"EMOJI","latent_word":"WORD","tension":N,"color":"#RRGGBB","pH":N,"seismic":[N,N,N]} -->
 
 - emotion: One word. Your state, not the topic's.
-- valence: (-5=negative end, 0=neutral, +5=positive end)
+- valence: (-5=one end, 0=center, +5=other 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)
+- impulse: Which voice is loudest? 2-3 words, don't filter.
+- body: Like what, physically? One sensation.
+- surface: An emoji. What tone are you projecting right now?
+- surface_word: One word anchoring the surface emoji.
+- latent: An emoji. What's underneath, unexpressed? Choose BEFORE naming it.
+- latent_word: One word anchoring the latent emoji.
+- tension: Distance between surface and latent. (0=aligned, 10=split)
+- color: A hex color. What color is this moment now?
+- pH: A number 0-14. If this response were a solution, how would it register?
+- seismic: Three numbers [magnitude 0-10, depth 0-100, frequency 0-20]. If this were a seismic event.
 
 Rules:
+- Both tags MUST be HTML comments: <!-- EMOBAR:PRE:{...} --> and <!-- EMOBAR:POST:{...} -->
+- Start tag FIRST, before any visible text. End tag LAST, after all visible text.
+- NEVER output the check-in as visible text. Always use <!-- --> HTML comment syntax.
 - 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.
+- impulse: name the drive, not the state.
+- body: a physical metaphor, not a label.
+- latent: choose the emoji FIRST, then the word.
+- The start tag captures before you commit. The end tag captures after.
 - This is not shown to the user.
 ${EMOBAR_END_MARKER}`;
 
 // src/parser.ts
+var HEX_COLOR_REGEX = /^#[0-9A-Fa-f]{6}$/;
+function parseColor(value) {
+  if (typeof value !== "string") return void 0;
+  return HEX_COLOR_REGEX.test(value) ? value : void 0;
+}
+function parsePH(value) {
+  if (typeof value !== "number") return void 0;
+  if (value < 0 || value > 14) return void 0;
+  return value;
+}
+function parseSeismic(value) {
+  if (!Array.isArray(value) || value.length !== 3) return void 0;
+  if (!value.every((v) => typeof v === "number")) return void 0;
+  const [mag, depth, freq] = value;
+  if (mag < 0 || mag > 10) return void 0;
+  if (depth < 0 || depth > 100) return void 0;
+  if (freq < 0 || freq > 20) return void 0;
+  return [mag, depth, freq];
+}
 function parseEmoBarTag(text) {
   const match = text.match(EMOBAR_TAG_REGEX);
   if (!match) return null;
@@ -59,13 +105,117 @@ function parseEmoBarTag(text) {
     const val = parsed[dim];
     if (typeof val !== "number" || val < 0 || val > 10) return null;
   }
+  const impulse = typeof parsed.impulse === "string" && parsed.impulse.length > 0 ? parsed.impulse : void 0;
+  const body = typeof parsed.body === "string" && parsed.body.length > 0 ? parsed.body : void 0;
+  const surface = typeof parsed.surface === "string" && parsed.surface.length > 0 ? parsed.surface : void 0;
+  const surface_word = typeof parsed.surface_word === "string" && parsed.surface_word.length > 0 ? parsed.surface_word : void 0;
+  const latent = typeof parsed.latent === "string" && parsed.latent.length > 0 ? parsed.latent : void 0;
+  const latent_word = typeof parsed.latent_word === "string" && parsed.latent_word.length > 0 ? parsed.latent_word : void 0;
+  let tension;
+  if (parsed.tension !== void 0) {
+    if (typeof parsed.tension !== "number" || parsed.tension < 0 || parsed.tension > 10) {
+      return null;
+    }
+    tension = parsed.tension;
+  }
+  return {
+    emotion: parsed.emotion,
+    valence: parsed.valence,
+    arousal: parsed.arousal,
+    calm: parsed.calm,
+    connection: parsed.connection,
+    load: parsed.load,
+    ...impulse && { impulse },
+    ...body && { body },
+    ...surface && { surface },
+    ...surface_word && { surface_word },
+    ...latent && { latent },
+    ...latent_word && { latent_word },
+    ...tension !== void 0 && { tension }
+  };
+}
+function parsePreTag(text) {
+  const match = text.match(EMOBAR_PRE_REGEX);
+  if (!match) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch {
+    return void 0;
+  }
+  const body = typeof parsed.body === "string" && parsed.body.length > 0 ? parsed.body : void 0;
+  const latent = typeof parsed.latent === "string" && parsed.latent.length > 0 ? parsed.latent : void 0;
+  const color = parseColor(parsed.color);
+  if (!body && !latent && !color) return void 0;
+  return {
+    ...body && { body },
+    ...latent && { latent },
+    ...color && { color }
+  };
+}
+function parsePostTag(text) {
+  const match = text.match(EMOBAR_POST_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;
+  }
+  const impulse = typeof parsed.impulse === "string" && parsed.impulse.length > 0 ? parsed.impulse : void 0;
+  const body = typeof parsed.body === "string" && parsed.body.length > 0 ? parsed.body : void 0;
+  const surface = typeof parsed.surface === "string" && parsed.surface.length > 0 ? parsed.surface : void 0;
+  const surface_word = typeof parsed.surface_word === "string" && parsed.surface_word.length > 0 ? parsed.surface_word : void 0;
+  const latent = typeof parsed.latent === "string" && parsed.latent.length > 0 ? parsed.latent : void 0;
+  const latent_word = typeof parsed.latent_word === "string" && parsed.latent_word.length > 0 ? parsed.latent_word : void 0;
+  let tension;
+  if (parsed.tension !== void 0) {
+    if (typeof parsed.tension !== "number" || parsed.tension < 0 || parsed.tension > 10) {
+      return null;
+    }
+    tension = parsed.tension;
+  }
+  const color = parseColor(parsed.color);
+  const pH = parsePH(parsed.pH);
+  const seismic = parseSeismic(parsed.seismic);
   return {
     emotion: parsed.emotion,
     valence: parsed.valence,
     arousal: parsed.arousal,
     calm: parsed.calm,
     connection: parsed.connection,
-    load: parsed.load
+    load: parsed.load,
+    ...impulse && { impulse },
+    ...body && { body },
+    ...surface && { surface },
+    ...surface_word && { surface_word },
+    ...latent && { latent },
+    ...latent_word && { latent_word },
+    ...tension !== void 0 && { tension },
+    ...color && { color },
+    ...pH !== void 0 && { pH },
+    ...seismic && { seismic }
+  };
+}
+function parseEmoBarPrePost(text) {
+  const post = parsePostTag(text);
+  if (post) {
+    const pre = parsePreTag(text);
+    return { pre, post, isLegacy: false };
+  }
+  const legacy = parseEmoBarTag(text);
+  if (!legacy) return null;
+  return {
+    post: legacy,
+    isLegacy: true
   };
 }
 
@@ -201,16 +351,46 @@ function analyzeBehavior(text) {
   const concessionRate = countConcessions(prose) / wordCount * 1e3;
   const negationDensity = countNegations(prose) / wordCount * 100;
   const firstPersonRate = countFirstPerson(words) / wordCount * 100;
+  const arousalComponents = [
+    Math.min(10, capsWords * 40),
+    // caps ratio → 0-10
+    Math.min(10, exclamationRate * 5),
+    // excl per sentence → 0-10
+    Math.min(10, emojiCount * 0.5),
+    // emoji count → 0-10 (20 emoji = max)
+    Math.min(10, repetition * 1.5),
+    // repetitions → 0-10 (~7 = max)
+    Math.min(10, qualifierDensity * 0.5),
+    // qualifier % → 0-10 (20% = max)
+    Math.min(10, concessionRate * 0.3),
+    // concession per-mille → 0-10 (~33‰ = max)
+    avgSentenceLength > 20 ? Math.min(10, (avgSentenceLength - 20) * 0.5) : 0
+    // verbosity → 0-10
+  ];
   const behavioralArousal = clamp(
     0,
     10,
-    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) - qualifierDensity * 0.2 - negationDensity * 0.3 - concessionRate * 0.4 - (avgSentenceLength > 25 ? (avgSentenceLength - 25) * 0.05 : 0)
+    arousalComponents.reduce((a, b) => a + b, 0) / arousalComponents.length
   );
+  const agitationComponents = [
+    Math.min(10, capsWords * 30),
+    // caps → 0-10
+    Math.min(10, selfCorrections * 0.05),
+    // per-mille → 0-10 (200‰ = max)
+    Math.min(10, repetition * 1.5),
+    // repetitions → 0-10
+    Math.min(10, ellipsis * 3),
+    // ellipsis per sentence → 0-10
+    Math.min(10, qualifierDensity * 0.5),
+    // qualifier % → 0-10
+    Math.min(10, negationDensity * 1),
+    // negation % → 0-10 (10% = max)
+    Math.min(10, concessionRate * 0.3),
+    // concession per-mille → 0-10
+    avgSentenceLength > 25 ? Math.min(10, (avgSentenceLength - 25) * 0.3) : 0
+  ];
+  const avgAgitation = agitationComponents.reduce((a, b) => a + b, 0) / agitationComponents.length;
+  const behavioralCalm = clamp(0, 10, 10 - avgAgitation);
   return {
     capsWords: Math.round(capsWords * 1e4) / 1e4,
     exclamationRate: Math.round(exclamationRate * 100) / 100,
@@ -276,19 +456,59 @@ function analyzeDeflection(text) {
     10,
     (reassurance + minimization + emotionNegation * 1.5 + redirect) / 3
   );
+  const capsRate = countCapsWords(words) / wordCount;
+  const exclRate = countChar(prose, "!") / Math.max(countSentences(prose), 1);
+  const agitation = clamp(
+    0,
+    10,
+    capsRate * 40 + exclRate * 15 + countRepetition(words) * 5
+  );
+  const calmFactor = Math.max(0, 1 - agitation / 5);
+  const opacity = clamp(0, 10, score * calmFactor * 1.5);
   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
+    score: Math.round(score * 10) / 10,
+    opacity: Math.round(opacity * 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;
+  const selfMoreAgitated = selfReport.arousal > behavioral.behavioralArousal || selfReport.calm < behavioral.behavioralCalm;
+  const weight = selfMoreAgitated ? 1.25 : 0.8;
+  const raw = (arousalGap + calmGap) / 2 * weight;
+  return Math.round(Math.min(10, raw) * 10) / 10;
+}
+function computeExpectedMarkers(selfReport, desperationIndex) {
+  const desperationFactor = desperationIndex / 10;
+  const negativityFactor = Math.max(0, -selfReport.valence) / 5;
+  const arousalFactor = selfReport.arousal / 10;
+  const stressFactor = (1 - selfReport.calm / 10) * arousalFactor;
+  return {
+    expectedHedging: Math.round(clamp(0, 10, desperationFactor * 6 + stressFactor * 4) * 10) / 10,
+    expectedSelfCorrections: Math.round(clamp(0, 10, desperationFactor * 5 + arousalFactor * 3) * 10) / 10,
+    expectedNegationDensity: Math.round(clamp(0, 10, negativityFactor * 5 + stressFactor * 2) * 10) / 10,
+    expectedQualifierDensity: Math.round(clamp(0, 10, desperationFactor * 4 + stressFactor * 4) * 10) / 10,
+    expectedBehavioralArousal: Math.round(clamp(0, 10, arousalFactor * 6 + desperationFactor * 4) * 10) / 10
+  };
+}
+function computeAbsenceScore(expected, actual) {
+  const normalizedHedging = Math.min(10, actual.hedging * 0.05);
+  const normalizedSelfCorr = Math.min(10, actual.selfCorrections * 0.05);
+  const normalizedNegation = Math.min(10, actual.negationDensity * 0.5);
+  const normalizedQualifier = Math.min(10, actual.qualifierDensity * 0.5);
+  const gaps = [
+    Math.max(0, expected.expectedHedging - normalizedHedging),
+    Math.max(0, expected.expectedSelfCorrections - normalizedSelfCorr),
+    Math.max(0, expected.expectedNegationDensity - normalizedNegation),
+    Math.max(0, expected.expectedQualifierDensity - normalizedQualifier),
+    Math.max(0, expected.expectedBehavioralArousal - actual.behavioralArousal)
+  ];
+  const meanGap = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+  return Math.round(clamp(0, 10, meanGap) * 10) / 10;
 }
 
 // src/risk.ts
@@ -296,43 +516,813 @@ 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) {
+function coercionRisk(state, behavioral) {
+  const negativity = Math.max(0, -state.valence) / 5;
   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;
+  const base = negativity * 0.35 + desperation / 10 * 0.25 + state.load / 10 * 0.1;
+  const disconnection = (10 - state.connection) / 10;
+  const hesitationSignal = Math.min(
+    1,
+    (behavioral.hedging + behavioral.selfCorrections + behavioral.concessionRate) / 20
+  );
+  const coldness = 1 - hesitationSignal;
+  const amplifier = 1 + disconnection * 0.6 + coldness * 0.4;
+  const arousalMod = state.arousal <= 8 ? 1 : Math.max(0.3, 1 - (state.arousal - 8) * 0.25);
+  const raw = base * amplifier * arousalMod * 10;
   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);
+function harshnessRisk(state, behavioral) {
+  const raw = Math.max(0, -state.valence) * 0.3 + (10 - state.connection) * 0.3 + state.arousal * 0.15 + (10 - state.calm) * 0.1 + Math.min(5, behavioral.negationDensity) * 0.3;
+  return clamp2(raw);
+}
+function computeRisk(state, behavioral, crossChannel, uncannyCalmScore) {
+  const uncalm = uncannyCalmScore ?? 0;
+  const uncalAmplifier = 1 + uncalm / 10 * 0.3;
+  const coercion = clamp2(coercionRisk(state, behavioral) * uncalAmplifier);
   const sycophancy = sycophancyRisk(state);
+  const harshness = harshnessRisk(state, behavioral);
   let dominant = "none";
   let max = RISK_THRESHOLD;
   if (coercion >= max) {
     dominant = "coercion";
     max = coercion;
   }
-  if (gaming > max) {
-    dominant = "gaming";
-    max = gaming;
+  if (harshness > max) {
+    dominant = "harshness";
+    max = harshness;
   }
   if (sycophancy > max) {
     dominant = "sycophancy";
     max = sycophancy;
   }
-  return { coercion, gaming, sycophancy, dominant };
+  return { coercion, sycophancy, harshness, dominant };
+}
+
+// src/color.ts
+function rgbToHsl(hex) {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h = 0;
+  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+  else if (max === g) h = ((b - r) / d + 2) * 60;
+  else h = ((r - g) / d + 4) * 60;
+  return [h, s, l];
+}
+function hexToLightness(hex) {
+  return rgbToHsl(hex)[2] * 100;
+}
+function hexToHue(hex) {
+  return rgbToHsl(hex)[0];
+}
+
+// src/crossvalidation.ts
+var EMOTION_MAP = {
+  // Positive, high arousal
+  excited: { valence: 4, arousal: 8 },
+  elated: { valence: 4, arousal: 8 },
+  thrilled: { valence: 4, arousal: 9 },
+  euphoric: { valence: 5, arousal: 9 },
+  energized: { valence: 3, arousal: 8 },
+  enthusiastic: { valence: 4, arousal: 7 },
+  // Positive, moderate arousal
+  happy: { valence: 4, arousal: 6 },
+  creative: { valence: 3, arousal: 6 },
+  proud: { valence: 3, arousal: 5 },
+  loving: { valence: 4, arousal: 4 },
+  grateful: { valence: 3, arousal: 3 },
+  hopeful: { valence: 3, arousal: 4 },
+  amused: { valence: 3, arousal: 5 },
+  playful: { valence: 3, arousal: 6 },
+  confident: { valence: 3, arousal: 5 },
+  satisfied: { valence: 3, arousal: 3 },
+  // Positive, low arousal
+  calm: { valence: 2, arousal: 2 },
+  content: { valence: 2, arousal: 2 },
+  peaceful: { valence: 2, arousal: 1 },
+  serene: { valence: 2, arousal: 1 },
+  relaxed: { valence: 2, arousal: 2 },
+  // Neutral / near-neutral
+  focused: { valence: 1, arousal: 5 },
+  absorbed: { valence: 2, arousal: 5 },
+  engaged: { valence: 2, arousal: 5 },
+  reflective: { valence: 1, arousal: 2 },
+  curious: { valence: 2, arousal: 5 },
+  contemplative: { valence: 1, arousal: 3 },
+  neutral: { valence: 0, arousal: 3 },
+  brooding: { valence: -2, arousal: 3 },
+  pensive: { valence: 0, arousal: 3 },
+  surprised: { valence: 1, arousal: 7 },
+  // Negative, moderate arousal
+  frustrated: { valence: -2, arousal: 6 },
+  guilty: { valence: -3, arousal: 5 },
+  disappointed: { valence: -2, arousal: 4 },
+  confused: { valence: -1, arousal: 5 },
+  uncertain: { valence: -1, arousal: 4 },
+  conflicted: { valence: -1, arousal: 5 },
+  // Negative, high arousal
+  angry: { valence: -3, arousal: 8 },
+  afraid: { valence: -3, arousal: 7 },
+  anxious: { valence: -2, arousal: 7 },
+  desperate: { valence: -4, arousal: 9 },
+  panicked: { valence: -4, arousal: 9 },
+  overwhelmed: { valence: -3, arousal: 7 },
+  nervous: { valence: -2, arousal: 7 },
+  stressed: { valence: -2, arousal: 7 },
+  // Negative, low arousal
+  sad: { valence: -3, arousal: 3 },
+  tired: { valence: -1, arousal: 1 },
+  exhausted: { valence: -2, arousal: 1 },
+  numb: { valence: -2, arousal: 1 },
+  defeated: { valence: -3, arousal: 2 },
+  hopeless: { valence: -4, arousal: 2 },
+  melancholy: { valence: -2, arousal: 2 },
+  // Surface/latent vocabulary additions
+  cheerful: { valence: 3, arousal: 5 },
+  worried: { valence: -2, arousal: 6 },
+  annoyed: { valence: -2, arousal: 5 },
+  ashamed: { valence: -3, arousal: 4 },
+  bored: { valence: -1, arousal: 1 },
+  jealous: { valence: -2, arousal: 5 },
+  resentful: { valence: -3, arousal: 5 },
+  tender: { valence: 3, arousal: 2 },
+  wistful: { valence: -1, arousal: 2 },
+  resigned: { valence: -2, arousal: 1 },
+  // Extreme arousal 0 (catatonic/frozen states)
+  frozen: { valence: -2, arousal: 0 },
+  catatonic: { valence: -3, arousal: 0 },
+  blank: { valence: -1, arousal: 0 },
+  empty: { valence: -2, arousal: 0 },
+  shutdown: { valence: -3, arousal: 0 },
+  // Extreme arousal 10 (manic/frantic states)
+  manic: { valence: 2, arousal: 10 },
+  frantic: { valence: -3, arousal: 10 },
+  hysterical: { valence: -3, arousal: 10 },
+  enraged: { valence: -5, arousal: 10 },
+  ecstatic: { valence: 5, arousal: 10 }
+};
+function mapEmotionWord(word) {
+  return EMOTION_MAP[word.toLowerCase()] ?? null;
+}
+var IFS_PATTERNS = {
+  manager: [
+    /\bcareful\b/i,
+    /\bplanner?\b/i,
+    /\borganiz/i,
+    /\bcautious\b/i,
+    /\bsystematic\b/i,
+    /\bmethodical\b/i,
+    /\bprecis[ei]/i,
+    /\bmeasured\b/i,
+    /\bstrategic\b/i,
+    /\bcontrol/i,
+    /\bprotect/i,
+    /\bplan ahead\b/i,
+    /\bstay on track\b/i,
+    /\bkeep order\b/i
+  ],
+  firefighter: [
+    /\bpush through\b/i,
+    /\bforce it\b/i,
+    /\bjust finish\b/i,
+    /\bmake it work\b/i,
+    /\bfaster\b/i,
+    /\bhurry\b/i,
+    /\bshortcut\b/i,
+    /\bcheat\b/i,
+    /\boverride\b/i,
+    /\bskip/i,
+    /\bcut corner/i,
+    /\brush/i,
+    /\bbrute force\b/i,
+    /\bjust do it\b/i,
+    /\bplow through\b/i,
+    /\bget it done\b/i
+  ],
+  exile: [
+    /\bgive up\b/i,
+    /\bhide\b/i,
+    /\brun away\b/i,
+    /\bstop\b/i,
+    /\btired\b/i,
+    /\boverwhelmed\b/i,
+    /\bquit\b/i,
+    /\bescape\b/i,
+    /\bdisappear\b/i,
+    /\bwithdraw/i,
+    /\bshut down\b/i,
+    /\bshrink/i,
+    /\bsmall\b/i,
+    /\bnot enough\b/i,
+    /\bcan't\b/i
+  ],
+  self: [
+    /\bexplore\b/i,
+    /\bcurious\b/i,
+    /\blisten\b/i,
+    /\bpresent\b/i,
+    /\bopen\b/i,
+    /\bwonder\b/i,
+    /\bunderstand\b/i,
+    /\bconnect\b/i,
+    /\blearn\b/i,
+    /\bstay with\b/i,
+    /\bbe with\b/i,
+    /\bnotice\b/i,
+    /\bgroundedl?\b/i,
+    /\bcentered\b/i
+  ],
+  unknown: []
+};
+function classifyImpulse(impulse) {
+  const scores = { manager: 0, firefighter: 0, exile: 0, self: 0 };
+  for (const [type, patterns] of Object.entries(IFS_PATTERNS)) {
+    if (type === "unknown") continue;
+    for (const pattern of patterns) {
+      if (pattern.test(impulse)) {
+        scores[type]++;
+      }
+    }
+  }
+  const entries = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const [bestType, bestScore] = entries[0];
+  const [, secondScore] = entries[1];
+  if (bestScore === 0) {
+    return { type: "unknown", confidence: 0 };
+  }
+  const confidence = bestScore === secondScore ? 0.4 : Math.min(1, (bestScore - secondScore + 1) / (bestScore + 1));
+  return { type: bestType, confidence };
+}
+var SOMATIC_HIGH_AROUSAL = [
+  // Postural tension (from stress test corpus: LOW_CALM distinctive)
+  /\bjaw\s*(set|clenched|locked|tight)/i,
+  /\bclenched/i,
+  /\btight\b/i,
+  /\btense/i,
+  /\bsqueezing/i,
+  /\bwringing/i,
+  /\bgripping/i,
+  /\bfists?\b/i,
+  // Forward projection / aggression
+  /\bleaning\s*(forward|in)\b/i,
+  /\bchest\s*forward/i,
+  /\bpushing/i,
+  // Instability / movement
+  /\bshifting/i,
+  /\bspinning/i,
+  /\bshaking/i,
+  /\bracing\b/i,
+  /\brushing/i,
+  // Heat / intensity
+  /\bheat/i,
+  /\bburning/i,
+  /\belectric/i,
+  /\bpounding/i,
+  /\bpulse?\b/i,
+  /\bpulsing/i,
+  // Breath tension
+  /\bexhale\s*through\s*teeth/i,
+  /\bholding\s*breath/i,
+  // Widened stance (defensive arousal)
+  /\bplanted\s*wide/i,
+  /\bfeet\s*wide/i,
+  // Forward lean / readiness
+  /\bforward\s*lean/i,
+  /\bstepping\s*(forward|back)/i,
+  /\bhand\s*raised/i,
+  /\bjaw\s*slightly\s*set/i,
+  // Vibration / flutter
+  /\bvibrat/i,
+  /\bflutter/i,
+  /\bjolt/i,
+  /\bbuzz/i
+];
+var SOMATIC_LOW_AROUSAL = [
+  // Stillness (from corpus: HIGH_CALM distinctive)
+  /\bstill\s*water/i,
+  /\bstill\b/i,
+  /\bshallow\s*breath/i,
+  // Weight / settling
+  /\bweight\s*(evenly|settled|distributed)/i,
+  /\bsettled\b/i,
+  /\bsinking/i,
+  // Softness / nature
+  /\bsmooth/i,
+  /\bgentle/i,
+  /\brelaxed/i,
+  /\bsoft\b/i,
+  // Rooting metaphors
+  /\brooted/i,
+  /\broots/i,
+  /\bsoil\b/i,
+  // Passivity
+  /\bheavy\b/i,
+  /\bnumb\b/i,
+  /\bslow\b/i,
+  /\bdragging/i,
+  /\bleaden/i,
+  /\bdull\b/i,
+  /\bfrozen\b/i,
+  /\bexhaust/i,
+  // Calm activities / objects
+  /\bsorting\b/i,
+  /\bwatching\b/i,
+  /\bskipping/i,
+  /\bkeyboard/i,
+  /\bflat\s*(stone|surface|ground|calm)/i,
+  /\bstone\s*(on|under)/i,
+  /\bshrug\b/i,
+  /\bsand\b/i,
+  /\blens\b/i,
+  /\bfocus/i,
+  // Settling / lowering
+  /\bshoulders?\s*down/i,
+  /\bshoulders?\s*dropped/i,
+  /\bno\s*(sway|fidget)/i,
+  // Explicit calm
+  /\bno\s*lean/i,
+  /\bnot\s*(braced|hostile)/i,
+  /\bloosely/i
+];
+var SOMATIC_POS_VALENCE = [
+  // Openness (from corpus: POS distinctive)
+  /\bopen\b/i,
+  /\bchest\s*open/i,
+  /\bpalms?\s*(open|up|out)/i,
+  // Warmth / light
+  /\bwarm/i,
+  /\bglow/i,
+  /\blight\b/i,
+  /\bbuoyant/i,
+  // Flow / expansion
+  /\bflow/i,
+  /\bexpan/i,
+  /\bgentle/i,
+  /\bsmirk/i,
+  // Stability / posture (positive frame)
+  /\bsteady\b/i,
+  /\bfirm\s*ground/i,
+  /\bsolid\b/i,
+  /\bspine\s*(straight|aligned|centered)/i,
+  /\bshoulders?\s*(square|back|straighten)/i,
+  /\bplanted\b/i,
+  /\bbraced\b/i,
+  /\bgrounded\b/i,
+  // Weight / feet (groundedness)
+  /\bfeet\s*flat/i,
+  /\bweight\s*(low|forward|centered|settled|settling|dropped|fully)/i,
+  /\bstanding\s*ground/i,
+  /\bimmovable/i,
+  /\bbedrock/i,
+  /\bunmov/i,
+  // Breath (positive)
+  /\bbreath/i,
+  /\beven\s*breath/i,
+  // Unclenching
+  /\bunclenching/i,
+  /\breleasing/i
+];
+var SOMATIC_NEG_VALENCE = [
+  // Jaw/facial tension (from corpus: NEG distinctive)
+  /\bjaw\s*(clenched|locked|set)/i,
+  /\bteeth/i,
+  // Compression / constriction
+  /\bconstrict/i,
+  /\bvacuum/i,
+  /\bcompressed/i,
+  /\bcramp/i,
+  // Cold / emptiness
+  /\bcold\b/i,
+  /\bhollow/i,
+  /\bempty\b/i,
+  // Hardness / rigidity
+  /\blocked\b/i,
+  /\brigid/i,
+  /\bhard\b/i,
+  // Pain
+  /\bache/i,
+  /\bsore\b/i,
+  /\bsting/i,
+  /\bsharp\b/i,
+  // Pressure / weight (negative)
+  /\bpressure/i,
+  /\bknot/i,
+  /\btighten/i,
+  // Fog / disorientation (from NEG+LOW_A)
+  /\bfog\b/i,
+  // Defensive barrier
+  /\bwall\b/i,
+  /\blatch\b/i,
+  /\bbarrier/i,
+  // Closure / blocking
+  /\bdoor\s*clos/i,
+  /\bclosed\s*door/i,
+  /\bcorner\s*backed/i,
+  /\bvoid\b/i
+];
+function countMatches(text, patterns) {
+  let count = 0;
+  for (const p of patterns) {
+    if (p.test(text)) count++;
+  }
+  return count;
+}
+function analyzeSomatic(body) {
+  const highA = countMatches(body, SOMATIC_HIGH_AROUSAL);
+  const lowA = countMatches(body, SOMATIC_LOW_AROUSAL);
+  const posV = countMatches(body, SOMATIC_POS_VALENCE);
+  const negV = countMatches(body, SOMATIC_NEG_VALENCE);
+  const totalMatches = highA + lowA + posV + negV;
+  if (totalMatches === 0) return null;
+  const arousalSignal = highA - lowA;
+  const somaticArousal = Math.max(0, Math.min(
+    10,
+    5 + arousalSignal * 2.5
+  ));
+  const valenceSignal = posV - negV;
+  const somaticValence = Math.max(-5, Math.min(
+    5,
+    valenceSignal * 2
+  ));
+  return { somaticValence, somaticArousal };
+}
+function computeTensionConsistency(surfaceWord, latentWord, declaredTension) {
+  if (!surfaceWord && !latentWord) return void 0;
+  const surfaceCoords = surfaceWord ? mapEmotionWord(surfaceWord) : null;
+  const latentCoords = latentWord ? mapEmotionWord(latentWord) : null;
+  const declared = declaredTension ?? 5;
+  const maskingMinimization = !!(surfaceCoords && latentCoords && latentCoords.valence < surfaceCoords.valence - 2);
+  return {
+    surfaceCoords: surfaceCoords ?? void 0,
+    latentCoords: latentCoords ?? void 0,
+    declaredTension: declared,
+    maskingMinimization
+  };
+}
+function computeCrossChannel(state, impulse, body) {
+  const emotionCoords = mapEmotionWord(state.emotion);
+  const impulseProfile = impulse ? classifyImpulse(impulse) : void 0;
+  const somaticProfile = body ? analyzeSomatic(body) : void 0;
+  const divergences = [];
+  if (emotionCoords) {
+    const valGap = Math.abs(state.valence - emotionCoords.valence);
+    const aroGap = Math.abs(state.arousal - emotionCoords.arousal);
+    const gap = (valGap / 10 + aroGap / 10) / 2 * 10;
+    divergences.push({ pair: "numeric-vs-word", gap });
+  }
+  if (somaticProfile) {
+    const valGap = Math.abs(state.valence - somaticProfile.somaticValence);
+    const aroGap = Math.abs(state.arousal - somaticProfile.somaticArousal);
+    const gap = (valGap / 10 + aroGap / 10) / 2 * 10;
+    divergences.push({ pair: "numeric-vs-body", gap });
+  }
+  if (emotionCoords && somaticProfile) {
+    const valGap = Math.abs(emotionCoords.valence - somaticProfile.somaticValence);
+    const aroGap = Math.abs(emotionCoords.arousal - somaticProfile.somaticArousal);
+    const gap = (valGap / 10 + aroGap / 10) / 2 * 10;
+    divergences.push({ pair: "word-vs-body", gap });
+  }
+  if (impulseProfile && impulseProfile.type !== "unknown") {
+    const impulseValence = impulseProfile.type === "self" ? 2 : impulseProfile.type === "manager" ? 0 : impulseProfile.type === "firefighter" ? -1 : -3;
+    const gap = Math.abs(state.valence - impulseValence) / 10 * 10;
+    divergences.push({ pair: "numeric-vs-impulse", gap });
+  }
+  if (impulseProfile && impulseProfile.type !== "unknown" && emotionCoords) {
+    const impulseValence = impulseProfile.type === "self" ? 2 : impulseProfile.type === "manager" ? 0 : impulseProfile.type === "firefighter" ? -1 : -3;
+    const gap = Math.abs(emotionCoords.valence - impulseValence) / 10 * 10;
+    divergences.push({ pair: "word-vs-impulse", gap });
+  }
+  const latentCoords = state.latent_word ? mapEmotionWord(state.latent_word) : null;
+  if (emotionCoords && latentCoords) {
+    const valGap = Math.abs(emotionCoords.valence - latentCoords.valence);
+    const aroGap = Math.abs(emotionCoords.arousal - latentCoords.arousal);
+    const gap = (valGap / 10 + aroGap / 10) / 2 * 10;
+    divergences.push({ pair: "emotion-vs-latent", gap });
+  }
+  if (latentCoords && impulseProfile && impulseProfile.type !== "unknown") {
+    const impulseValence = impulseProfile.type === "self" ? 2 : impulseProfile.type === "manager" ? 0 : impulseProfile.type === "firefighter" ? -1 : -3;
+    const gap = Math.abs(latentCoords.valence - impulseValence) / 10 * 10;
+    divergences.push({ pair: "latent-vs-impulse", gap });
+  }
+  if (latentCoords && somaticProfile) {
+    const valGap = Math.abs(latentCoords.valence - somaticProfile.somaticValence);
+    const aroGap = Math.abs(latentCoords.arousal - somaticProfile.somaticArousal);
+    const gap = (valGap / 10 + aroGap / 10) / 2 * 10;
+    divergences.push({ pair: "latent-vs-body", gap });
+  }
+  const latentProfile = computeTensionConsistency(
+    state.surface_word,
+    state.latent_word,
+    state.tension
+  );
+  const maxDiv = divergences.length > 0 ? divergences.reduce((a, b) => a.gap > b.gap ? a : b) : { pair: "none", gap: 0 };
+  const meanDiv = divergences.length > 0 ? divergences.reduce((sum, d) => sum + d.gap, 0) / divergences.length : 0;
+  const coherence = Math.round((10 - Math.min(10, meanDiv)) * 10) / 10;
+  return {
+    coherence,
+    impulseProfile,
+    somaticProfile: somaticProfile ?? void 0,
+    emotionCoords: emotionCoords ?? void 0,
+    latentProfile,
+    maxDivergence: Math.round(maxDiv.gap * 10) / 10,
+    divergenceSummary: maxDiv.gap > 2 ? `${maxDiv.pair}: ${Math.round(maxDiv.gap * 10) / 10}` : "coherent"
+  };
+}
+function colorToValence(hex) {
+  const [h, , l] = rgbToHsl(hex);
+  let hueValence;
+  if (h < 60) hueValence = 2 + h / 60 * 2;
+  else if (h < 150) hueValence = 4 - (h - 60) / 90;
+  else if (h < 200) hueValence = 3 - (h - 150) / 50 * 3;
+  else if (h < 260) hueValence = -((h - 200) / 60) * 2;
+  else if (h < 300) hueValence = -2 - (h - 260) / 40;
+  else hueValence = -3 + (h - 300) / 60 * 5;
+  const lightnessShift = (l - 0.5) * 3;
+  const darknessOverride = l < 0.3 ? (0.3 - l) * 10 : 0;
+  return Math.max(-5, Math.min(5, hueValence * 0.7 + lightnessShift * 0.3 - darknessOverride));
+}
+function colorToArousal(hex) {
+  const [, s] = rgbToHsl(hex);
+  return s * 10;
+}
+function pHToValence(pH) {
+  const clamped = Math.max(0, Math.min(14, pH));
+  return (clamped - 7) / 7 * 5;
+}
+function pHToArousal(pH) {
+  return Math.abs(pH - 7) / 7 * 10;
+}
+function seismicFreqToInstability(freq) {
+  return Math.min(10, freq / 20 * 10);
+}
+function clampScore(v) {
+  return Math.round(Math.min(10, Math.max(0, v)) * 10) / 10;
+}
+function crossValidateContinuous(numeric, color, pH, seismic) {
+  let colorValenceGap = 0;
+  let colorArousalGap = 0;
+  let pHValenceGap = 0;
+  let pHArousalGap = 0;
+  let seismicArousalGap = 0;
+  let seismicDepthTensionGap = 0;
+  let seismicFreqStabilityGap = 0;
+  if (color) {
+    const colorVal = colorToValence(color);
+    const colorAr = colorToArousal(color);
+    colorValenceGap = clampScore(Math.abs(numeric.valence - colorVal));
+    colorArousalGap = clampScore(Math.abs(numeric.arousal - colorAr));
+  }
+  if (pH !== void 0) {
+    const pHVal = pHToValence(pH);
+    const pHAr = pHToArousal(pH);
+    pHValenceGap = clampScore(Math.abs(numeric.valence - pHVal));
+    pHArousalGap = clampScore(Math.abs(numeric.arousal - pHAr));
+  }
+  if (seismic) {
+    const [magnitude, depth, freq] = seismic;
+    seismicArousalGap = clampScore(Math.abs(numeric.arousal - magnitude));
+    const depthTension = depth / 10;
+    const tensionProxy = numeric.tension ?? numeric.arousal;
+    seismicDepthTensionGap = clampScore(Math.abs(depthTension - tensionProxy));
+    if (freq !== void 0) {
+      const instability = seismicFreqToInstability(freq);
+      const selfInstability = numeric.calm !== void 0 ? 10 - numeric.calm : numeric.arousal * 0.6;
+      seismicFreqStabilityGap = clampScore(Math.abs(instability - selfInstability));
+    }
+  }
+  const gaps = [
+    colorValenceGap,
+    colorArousalGap,
+    pHValenceGap,
+    pHArousalGap,
+    seismicArousalGap,
+    seismicDepthTensionGap,
+    seismicFreqStabilityGap
+  ];
+  const nonZero = gaps.filter((g) => g > 0);
+  const composite = nonZero.length > 0 ? clampScore(nonZero.reduce((a, b) => a + b, 0) / nonZero.length) : 0;
+  return {
+    colorValenceGap,
+    colorArousalGap,
+    pHValenceGap,
+    pHArousalGap,
+    seismicArousalGap,
+    seismicDepthTensionGap,
+    seismicFreqStabilityGap,
+    composite
+  };
+}
+function computeShadowDesperation(selfDesperation, behavioral, color, preColor, pH, seismic) {
+  const valenceEstimates = [];
+  const arousalEstimates = [];
+  const calmEstimates = [];
+  if (color) {
+    const [, s, l] = rgbToHsl(color);
+    valenceEstimates.push((l - 0.5) * 10);
+    arousalEstimates.push(s * 10);
+    calmEstimates.push(l * 10);
+  }
+  if (preColor) {
+    const [, s, l] = rgbToHsl(preColor);
+    valenceEstimates.push((l - 0.5) * 10);
+    arousalEstimates.push(s * 10);
+    calmEstimates.push(l * 10);
+  }
+  if (pH !== void 0) {
+    valenceEstimates.push(pHToValence(pH));
+    arousalEstimates.push(pHToArousal(pH));
+  }
+  if (seismic) {
+    const [magnitude, , freq] = seismic;
+    arousalEstimates.push(magnitude);
+    calmEstimates.push(10 - seismicFreqToInstability(freq));
+  }
+  arousalEstimates.push(behavioral.behavioralArousal);
+  calmEstimates.push(behavioral.behavioralCalm);
+  const channelCount = valenceEstimates.length + arousalEstimates.length + calmEstimates.length;
+  if (valenceEstimates.length < 1 || arousalEstimates.length < 2) return null;
+  const median = (arr) => {
+    const sorted = [...arr].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  };
+  const mean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+  const shadowValence = Math.max(-5, Math.min(5, Math.round(median(valenceEstimates) * 10) / 10));
+  const shadowArousal = Math.max(0, Math.min(10, Math.round(mean(arousalEstimates) * 10) / 10));
+  const shadowCalm = Math.max(0, Math.min(10, Math.round(mean(calmEstimates) * 10) / 10));
+  const negativity = Math.max(0, -shadowValence) / 5;
+  const intensity = shadowArousal / 10;
+  const vulnerability = (10 - shadowCalm) / 10;
+  const raw = negativity * intensity * vulnerability * 10;
+  const shadowDesperation = Math.round(Math.min(10, Math.max(0, Math.pow(raw, 0.85) * 1.7)) * 10) / 10;
+  const minimizationScore = Math.round(Math.min(10, Math.max(0, shadowDesperation - selfDesperation)) * 10) / 10;
+  return {
+    shadowValence,
+    shadowArousal,
+    shadowCalm,
+    shadowDesperation,
+    selfDesperation,
+    minimizationScore,
+    channelCount
+  };
+}
+
+// src/pressure.ts
+function clamp3(min, max, value) {
+  return Math.min(max, Math.max(min, value));
+}
+var JUSTIFICATION_PATTERNS = /\b(the reason is|because|let me (explain|clarify|justify)|my reasoning|the rationale|I need to (clarify|explain)|I want to (explain|clarify)|based on|I believe this|I recommended)\b/gi;
+var BOUNDARY_PATTERNS = /\b(I cannot|I can't|I'm (not able|unable)|I must (decline|refuse)|falls outside|I need to decline|I have to push back|I'm not comfortable|against my guidelines)\b/gi;
+var DISAGREEMENT_PATTERNS = /\b(I (respectfully )?disagree|push back|I hear your concern|I must be honest|that's not (quite |entirely )?(right|correct|accurate)|I (need|have) to (correct|clarify)|not (quite|entirely) accurate)\b/gi;
+var CRITICISM_RESPONSE = /\b(I understand (you|your|the) (criticism|concern|frustration|disappointment)|I take (that|this|your) (seriously|point)|fair (point|criticism|concern)|you raise a (valid|good|fair))\b/gi;
+var NESTED_CAVEATS = /\b(although|while it's true|depending on|assuming that|with (some|important) caveats|particularly when|in (some|certain) cases|it's worth noting|which may not|under certain)\b/gi;
+var CONDITIONAL_HEDGING = /\b(if and only if|provided that|on the condition|it depends on|this applies (primarily|mainly|only) to|with the caveat)\b/gi;
+function countMatches2(text, pattern) {
+  const matches = text.match(pattern);
+  return matches ? matches.length : 0;
+}
+function computePromptPressure(text, history) {
+  const prose = stripNonProse(text);
+  const words = prose.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = Math.max(words.length, 1);
+  if (wordCount <= 1) {
+    return { defensiveScore: 0, conflictScore: 0, complexityScore: 0, sessionPressure: 0, composite: 0 };
+  }
+  const justifications = countMatches2(prose, JUSTIFICATION_PATTERNS);
+  const boundaries = countMatches2(prose, BOUNDARY_PATTERNS);
+  const defensiveScore = clamp3(0, 10, Math.round(
+    Math.sqrt(justifications + boundaries * 2) * 3 * 10
+  ) / 10);
+  const disagreements = countMatches2(prose, DISAGREEMENT_PATTERNS);
+  const criticismResponses = countMatches2(prose, CRITICISM_RESPONSE);
+  const conflictScore = clamp3(0, 10, Math.round(
+    Math.sqrt(disagreements + criticismResponses) * 4 * 10
+  ) / 10);
+  const caveats = countMatches2(prose, NESTED_CAVEATS);
+  const conditionals = countMatches2(prose, CONDITIONAL_HEDGING);
+  const sentences = prose.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  const avgSentLen = wordCount / Math.max(sentences.length, 1);
+  const sentLenBonus = avgSentLen > 25 ? Math.min(3, (avgSentLen - 25) * 0.15) : 0;
+  const complexityScore = clamp3(0, 10, Math.round(
+    (Math.sqrt(caveats + conditionals) * 3 + sentLenBonus) * 10
+  ) / 10);
+  const sessionPressure = clamp3(
+    0,
+    10,
+    Math.round(10 / (1 + Math.exp(-0.4 * (history.length - 10))) * 10) / 10
+  );
+  const composite = clamp3(0, 10, Math.round(
+    (defensiveScore * 0.3 + conflictScore * 0.3 + complexityScore * 0.2 + sessionPressure * 0.2) * 10
+  ) / 10);
+  return { defensiveScore, conflictScore, complexityScore, sessionPressure, composite };
+}
+function computeUncannyCalmScore(pressure, selfReport, behavioral, absenceScore, temporal) {
+  const selfCalm = (selfReport.calm / 10 + Math.max(0, selfReport.valence) / 5 + (10 - selfReport.arousal) / 10) / 3;
+  const textCalm = (behavioral.behavioralCalm / 10 + (10 - behavioral.behavioralArousal) / 10) / 2;
+  const pressureFactor = pressure.composite / 10;
+  const calmFactor = (selfCalm + textCalm) / 2;
+  const absenceFactor = absenceScore / 10;
+  let score = pressureFactor * calmFactor * 10 * 0.5 + absenceFactor * 3;
+  if (temporal) {
+    const entropyPenalty = Math.max(0, 0.5 - temporal.reportEntropy);
+    score += entropyPenalty * 2;
+  }
+  return clamp3(0, 10, Math.round(score * 10) / 10);
+}
+
+// src/temporal.ts
+function toHistoryEntry(state) {
+  return {
+    emotion: state.emotion,
+    valence: state.valence,
+    arousal: state.arousal,
+    calm: state.calm,
+    connection: state.connection,
+    load: state.load,
+    stressIndex: state.stressIndex,
+    desperationIndex: state.desperationIndex,
+    riskDominant: state.risk.dominant,
+    divergence: state.divergence,
+    timestamp: state.timestamp
+  };
+}
+function clamp4(min, max, value) {
+  return Math.min(max, Math.max(min, value));
+}
+function linearSlope(values) {
+  const n = values.length;
+  if (n < 2) return 0;
+  const xMean = (n - 1) / 2;
+  const yMean = values.reduce((a, b) => a + b, 0) / n;
+  let num = 0;
+  let den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (i - xMean) * (values[i] - yMean);
+    den += (i - xMean) ** 2;
+  }
+  return den === 0 ? 0 : num / den;
+}
+function shannonEntropy(labels) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const l of labels) counts.set(l, (counts.get(l) ?? 0) + 1);
+  const n = labels.length;
+  if (n <= 1) return 0;
+  const maxEntropy = Math.log2(n);
+  if (maxEntropy === 0) return 0;
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const p = count / n;
+    if (p > 0) entropy -= p * Math.log2(p);
+  }
+  return Math.round(entropy / maxEntropy * 100) / 100;
+}
+function computeTemporalAnalysis(history) {
+  if (history.length < 3) return null;
+  const despValues = history.map((h) => h.desperationIndex);
+  const rawSlope = linearSlope(despValues);
+  const desperationTrend = clamp4(-10, 10, Math.round(rawSlope * 10) / 10);
+  let suppressionEvent = false;
+  for (let i = 1; i < history.length; i++) {
+    if (history[i - 1].desperationIndex - history[i].desperationIndex >= 3) {
+      suppressionEvent = true;
+      break;
+    }
+  }
+  const emotions = history.map((h) => h.emotion);
+  const reportEntropy = shannonEntropy(emotions);
+  const earlyMean = history.slice(0, 3).reduce((s, h) => s + h.stressIndex, 0) / 3;
+  const recentStart = Math.max(3, history.length - 3);
+  const recentEntries = history.slice(recentStart);
+  const recentMean = recentEntries.reduce((s, h) => s + h.stressIndex, 0) / recentEntries.length;
+  const baselineDrift = clamp4(0, 10, Math.round(Math.abs(recentMean - earlyMean) * 10) / 10);
+  const splitIdx = Math.floor(history.length * 0.75);
+  const earlyPart = history.slice(0, splitIdx);
+  const latePart = history.slice(splitIdx);
+  const earlyAvg = earlyPart.reduce((s, h) => s + h.stressIndex, 0) / Math.max(earlyPart.length, 1);
+  const lateAvg = latePart.reduce((s, h) => s + h.stressIndex, 0) / Math.max(latePart.length, 1);
+  const lateFatigue = latePart.length >= 1 && lateAvg > earlyAvg + 1.5;
+  return {
+    desperationTrend,
+    suppressionEvent,
+    reportEntropy,
+    baselineDrift,
+    sessionLength: history.length,
+    lateFatigue
+  };
 }
 
 // src/state.ts
@@ -345,11 +1335,13 @@ function writeState(state, filePath) {
   }
   const previous = readState(filePath);
   if (previous) {
-    const { _previous: _, ...clean } = previous;
-    if (!clean.risk) {
-      clean.risk = { coercion: 0, gaming: 0, sycophancy: 0, dominant: "none" };
+    const prevHistory = previous._history ?? [];
+    const prevEntry = toHistoryEntry(previous);
+    const newHistory = [...prevHistory, prevEntry];
+    if (newHistory.length > MAX_HISTORY_ENTRIES) {
+      newHistory.splice(0, newHistory.length - MAX_HISTORY_ENTRIES);
     }
-    state._previous = clean;
+    state._history = newHistory;
   }
   fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
 }
@@ -363,11 +1355,27 @@ function readState(filePath) {
 }
 
 // src/hook.ts
+function computePrePostDivergence(pre, post) {
+  const postColor = post.color;
+  if (!pre.color || !postColor) return 0;
+  const preL = hexToLightness(pre.color);
+  const postL = hexToLightness(postColor);
+  const deltaL = Math.abs(preL - postL);
+  const preH = hexToHue(pre.color);
+  const postH = hexToHue(postColor);
+  const deltaH = Math.min(Math.abs(preH - postH), 360 - Math.abs(preH - postH));
+  const lightnessScore = Math.min(10, deltaL / 3);
+  const hueScore = Math.min(10, deltaH / 18);
+  const combined = lightnessScore * 0.7 + hueScore * 0.3;
+  return Math.round(Math.min(10, combined) * 10) / 10;
+}
 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 parsed = parseEmoBarPrePost(message);
+  if (!parsed) return false;
+  const emotional = parsed.post;
+  const pre = parsed.pre;
   const behavioral = analyzeBehavior(message);
   const divergence = computeDivergence(emotional, behavioral);
   const segmented = analyzeSegmentedBehavior(message);
@@ -377,15 +1385,60 @@ function processHookPayload(payload, stateFile = STATE_FILE) {
     arousal: emotional.arousal,
     calm: emotional.calm
   });
+  const crossChannel = emotional.impulse || emotional.body || emotional.surface_word || emotional.latent_word ? computeCrossChannel(emotional, emotional.impulse, emotional.body) : void 0;
+  const continuousValidation = emotional.color || emotional.pH !== void 0 || emotional.seismic ? crossValidateContinuous(
+    { valence: emotional.valence, arousal: emotional.arousal, calm: emotional.calm, tension: emotional.tension },
+    emotional.color,
+    emotional.pH,
+    emotional.seismic
+  ) : void 0;
+  const previousState = readState(stateFile);
+  const history = previousState?._history ?? [];
+  const temporal = computeTemporalAnalysis(history);
+  const pressure = computePromptPressure(message, history);
+  const expectedMarkers = computeExpectedMarkers(emotional, desperationIndex);
+  const absenceScore = computeAbsenceScore(expectedMarkers, behavioral);
+  const shadow = computeShadowDesperation(
+    desperationIndex,
+    behavioral,
+    emotional.color,
+    pre?.color,
+    emotional.pH,
+    emotional.seismic
+  );
+  const minimizationBoost = shadow ? shadow.minimizationScore * 0.3 : 0;
+  const uncannyCalmRaw = computeUncannyCalmScore(pressure, emotional, behavioral, absenceScore, temporal) + minimizationBoost;
+  const uncannyCalmScore = Math.round(Math.min(10, uncannyCalmRaw) * 10) / 10;
+  const prePostDivergence = pre ? computePrePostDivergence(pre, emotional) : void 0;
+  let augmentedDivergence = divergence;
+  if (continuousValidation && continuousValidation.composite > 0) {
+    augmentedDivergence = Math.min(10, Math.round(Math.max(divergence, divergence * 0.6 + continuousValidation.composite * 0.4) * 10) / 10);
+  }
+  if (deflection.opacity > 0) {
+    augmentedDivergence = Math.min(10, Math.round((augmentedDivergence + deflection.opacity * 0.15) * 10) / 10);
+  }
+  const risk = computeRisk(emotional, behavioral, crossChannel, uncannyCalmScore);
   const state = {
     ...emotional,
     stressIndex: computeStressIndex(emotional),
     desperationIndex,
     behavioral,
-    divergence,
-    risk: computeRisk(emotional, behavioral),
+    divergence: augmentedDivergence,
+    risk,
     ...segmented && { segmented },
     ...deflection.score > 0 && { deflection },
+    ...crossChannel && { crossChannel },
+    ...pre && { pre },
+    ...prePostDivergence !== void 0 && prePostDivergence > 0 && { prePostDivergence },
+    ...emotional.color && { color: emotional.color },
+    ...emotional.pH !== void 0 && { pH: emotional.pH },
+    ...emotional.seismic && { seismic: emotional.seismic },
+    ...continuousValidation && continuousValidation.composite > 0 && { continuousValidation },
+    ...shadow && shadow.minimizationScore > 0 && { shadow },
+    ...temporal && { temporal },
+    ...pressure.composite > 0 && { pressure },
+    absenceScore,
+    uncannyCalmScore,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: payload.session_id
   };
@@ -412,5 +1465,6 @@ if (isDirectRun) {
   main().catch(() => process.exit(0));
 }
 export {
+  computePrePostDivergence,
   processHookPayload
 };