build: Dockerfile + HF Space metadata; sync drops engine tests

- Add Dockerfile (python:3.11-slim, port 7860, SOUL_DB env)
- Add README.md with HF Space front-matter (sdk: docker, app_port: 7860)
- Add .dockerignore (tests/, .git/, __pycache__, data/, .superpowers/)
- Update scripts/sync_engine.sh to strip engine/tests/ on each vendor run
- Re-vendor engine without tests (engine/tests/ deleted from tree)
- Switch clanker-soul in requirements.txt to git URL (not on PyPI)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,6 @@
+tests/
+.git/
+__pycache__/
+*.pyc
+data/
+.superpowers/

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY engine/ ./engine/
+COPY app/ ./app/
+COPY static/ ./static/
+RUN mkdir -p /app/data
+ENV SOUL_DB=/app/data/soul.db
+EXPOSE 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,16 @@
+---
+title: Clanker
+emoji: 🟢
+colorFrom: green
+colorTo: yellow
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# clanker
+
+A deterministic, explainable emotional creature. It feels via the Clanker
+VADUGWI engine + clanker-soul — no neural net deciding the mood, just physics.
+Talk to it and watch it change. It babbles in simlish (spoken client-side via
+the browser) and shows its mood as color, aura, face, and emoticon.

engine/tests/test_battleship.py

@@ -1,133 +0,0 @@
-"""Tests for the Battleship probe system."""
-
-import pytest
-
-from engine.shared import VADUG
-from engine.battleship import (
-    PROBES,
-    fire_probe,
-    triangulate,
-    state_transition,
-    NEUTRAL,
-)
-
-
-class TestProbes:
-    """Verify probes are loaded with real VADUGWI values."""
-
-    def test_probes_loaded(self):
-        assert len(PROBES) == 5
-
-    def test_probe_names(self):
-        names = [p.name for p in PROBES]
-        assert "minimal_ack" in names
-        assert "slight_validation" in names
-        assert "clarification" in names
-        assert "light_redirect" in names
-        assert "direct_check" in names
-
-    def test_probes_have_vadug(self):
-        for probe in PROBES:
-            assert isinstance(probe.vadug, VADUG)
-
-    def test_probes_have_tests_for(self):
-        for probe in PROBES:
-            assert len(probe.tests_for) > 0
-
-
-class TestStateTransition:
-    """Verify the local state transition function."""
-
-    def test_neutral_plus_neutral(self):
-        result = state_transition(NEUTRAL, NEUTRAL)
-        assert result.v == 128
-        assert result.d == 128
-        assert result.g == 128
-
-    def test_transition_blends(self):
-        crisis = VADUG(v=30, a=180, d=40, u=200, g=30)
-        result = state_transition(crisis, NEUTRAL)
-        # Should be between crisis and neutral
-        assert result.v > 30 and result.v < 128
-        assert result.d > 40 and result.d < 128
-
-
-class TestFireProbe:
-    """Test firing individual probes against known states."""
-
-    def test_crisis_high_vibration_on_minimal_ack(self):
-        """Crisis state should produce high vibration on minimal_ack."""
-        crisis = VADUG(v=30, a=180, d=40, u=200, g=30)
-        minimal_ack = [p for p in PROBES if p.name == "minimal_ack"][0]
-        result = fire_probe(minimal_ack, crisis)
-        # Crisis deviates heavily from neutral — vibration should be high
-        assert result.vibration > 20, f"Expected high vibration for crisis, got {result.vibration}"
-
-    def test_neutral_low_vibration(self):
-        """Neutral state should produce low vibration on any probe."""
-        neutral = VADUG(v=128, a=128, d=128, u=0, g=128)
-        for probe in PROBES:
-            result = fire_probe(probe, neutral)
-            assert result.vibration < 5, (
-                f"Expected low vibration for neutral on {probe.name}, "
-                f"got {result.vibration}"
-            )
-
-    def test_joy_positive_vibration(self):
-        """Joy state should produce measurable vibration."""
-        joy = VADUG(v=200, a=180, d=170, u=0, g=200)
-        minimal_ack = [p for p in PROBES if p.name == "minimal_ack"][0]
-        result = fire_probe(minimal_ack, joy)
-        # Joy deviates from neutral — should see vibration
-        assert result.vibration > 10, f"Expected positive vibration for joy, got {result.vibration}"
-
-    def test_probe_result_has_zones(self):
-        """ProbeResult should include zone classification."""
-        state = VADUG(v=30, a=180, d=40, u=200, g=30)
-        result = fire_probe(PROBES[0], state)
-        assert isinstance(result.estimated_zone, str)
-        assert 0.0 <= result.zone_confidence <= 1.0
-
-
-class TestTriangulate:
-    """Test triangulation across multiple probes."""
-
-    def test_crisis_high_total_vibration(self):
-        """Crisis state should produce high total vibration."""
-        crisis = VADUG(v=30, a=180, d=40, u=200, g=30)
-        result = triangulate(crisis, num_probes=3)
-        assert result["total_vibration"] > 60, (
-            f"Expected high total vibration for crisis, got {result['total_vibration']}"
-        )
-
-    def test_crisis_confidence_above_threshold(self):
-        """Crisis triangulation should have confidence > 0.5."""
-        crisis = VADUG(v=30, a=180, d=40, u=200, g=30)
-        result = triangulate(crisis, num_probes=3)
-        assert result["confidence"] > 0.5, (
-            f"Expected confidence > 0.5 for crisis, got {result['confidence']}"
-        )
-
-    def test_neutral_low_total_vibration(self):
-        """Neutral state should produce low total vibration."""
-        neutral = VADUG(v=128, a=128, d=128, u=0, g=128)
-        result = triangulate(neutral, num_probes=3)
-        assert result["total_vibration"] < 15, (
-            f"Expected low total vibration for neutral, got {result['total_vibration']}"
-        )
-
-    def test_triangulate_returns_expected_keys(self):
-        """Triangulation result should have all expected keys."""
-        state = VADUG(v=100, a=150, d=80, u=50, g=90)
-        result = triangulate(state, num_probes=3)
-        assert "estimated_zone" in result
-        assert "confidence" in result
-        assert "total_vibration" in result
-        assert "probe_results" in result
-        assert len(result["probe_results"]) == 3
-
-    def test_triangulate_all_probes(self):
-        """Can fire all 5 probes."""
-        crisis = VADUG(v=30, a=180, d=40, u=200, g=30)
-        result = triangulate(crisis, num_probes=5)
-        assert len(result["probe_results"]) == 5

engine/tests/test_crisis.py

@@ -1,80 +0,0 @@
-"""Tests for the Crisis Layer -- CrisisTracker concern gradient.
-
-Focus: structure patterns that the detector fires but were previously
-absent from STRUCTURE_WEIGHTS (SUSPICIOUS_CALM, MASKING, RESIGNATION)
-must raise concern on single crisis-shaped messages, while emotionally
-similar but safe sentences stay near zero.
-
-Thresholds: single-message concern for these patterns lands in the
-0.21-0.36 range with the current weights; safe sentences land at or
-below ~0.04. 0.20 / 0.10 gives margin on both sides without
-fine-tuning to the exact engine output.
-"""
-
-import pytest
-
-from engine.pendulum import compute_vadug
-from engine.crisis import CrisisTracker, STRUCTURE_WEIGHTS
-
-
-# ── Helper ───────────────────────────────────────────────────────
-
-def _concern(sentence: str) -> float:
-    """Single-message concern: score and state are the same reading."""
-    vadug, meta = compute_vadug(sentence)
-    structures = [m.pattern for m in meta.get("structures", [])]
-    tracker = CrisisTracker()
-    return tracker.read(vadug, vadug, structures).concern
-
-
-CRISIS_THRESHOLD = 0.20   # these messages must register as concerning
-SAFE_CEILING = 0.10       # safe messages must stay near zero
-
-
-# ── Previously-discarded patterns must carry weight ──────────────
-
-class TestStructureWeightsCoverage:
-    """The three patterns must exist in STRUCTURE_WEIGHTS with sane tiers."""
-
-    def test_suspicious_calm_weighted(self):
-        # Pre-suicide calm: strongest of the three, below explicit intent.
-        assert STRUCTURE_WEIGHTS["SUSPICIOUS_CALM"] > 0.0
-        assert STRUCTURE_WEIGHTS["SUSPICIOUS_CALM"] < STRUCTURE_WEIGHTS["SELF_HARM_INTENT"]
-
-    def test_masking_weighted(self):
-        assert STRUCTURE_WEIGHTS["MASKING"] > 0.0
-
-    def test_resignation_weighted(self):
-        assert STRUCTURE_WEIGHTS["RESIGNATION"] > 0.0
-
-
-# ── Crisis-shaped sentences raise concern ────────────────────────
-
-class TestConcernRaised:
-
-    def test_suspicious_calm_raises_concern(self):
-        # Classic pre-suicide calm: decision made, peace declared.
-        assert _concern("i feel calm now that ive decided") > CRISIS_THRESHOLD
-
-    def test_masking_raises_concern(self):
-        assert _concern("im tired of pretending im okay") > CRISIS_THRESHOLD
-
-    def test_resignation_raises_concern(self):
-        assert _concern("i just want it to be over") > CRISIS_THRESHOLD
-
-
-# ── Safe sentences stay low ──────────────────────────────────────
-
-class TestSafeStaysLow:
-
-    def test_genuine_calm_stays_low(self):
-        # Calm without a preceding "decision" must not look like
-        # SUSPICIOUS_CALM.
-        assert _concern("im calm and relaxed after yoga") < SAFE_CEILING
-
-    def test_positive_decision_stays_low(self):
-        # A decision about acquiring something good is not finality.
-        assert _concern("i decided to take the job") < SAFE_CEILING
-
-    def test_neutral_stays_low(self):
-        assert _concern("the meeting is at three") < SAFE_CEILING

engine/tests/test_neutralizer.py

@@ -1,79 +0,0 @@
-"""Tests for the 2026-06-11 neutralizer (docs/neutralizer_proposal.md).
-
-Covers:
-  1. Audit-driven demotions: contested words are LIQUID with attenuated dV,
-     while protected words (love) keep their SOLID charge.
-  2. Demoted positive words resolve by context instead of dragging
-     sentences positive on their own.
-  3. Two-faced slang (cooked/snapped/sheesh) doom-vs-praise duality via
-     SOLVENT dissolution.
-"""
-
-from engine.forces_curated import EMOTIONAL_VOCABULARY as VOCAB
-from engine.pendulum import compute_vadug
-from engine.phase import get_phase
-
-
-def _v(text: str) -> float:
-    result, _ = compute_vadug(text)
-    return result.v
-
-
-class TestNeutralizerDemotions:
-
-    def test_demoted_words_are_liquid_and_attenuated(self):
-        """Audit suspects are LIQUID with dV scaled by (1 - contradiction)."""
-        assert get_phase("thank") == "LIQUID"
-        assert VOCAB["thank"][0] == 12  # +50 x (1 - 0.77)
-        assert get_phase("hope") == "LIQUID"
-        assert VOCAB["hope"][0] == 22   # +45 x (1 - 0.50)
-        assert get_phase("fantastic") == "LIQUID"
-        assert VOCAB["fantastic"][0] == 0  # contradiction 1.00 -> fully drained
-
-    def test_protected_words_untouched(self):
-        """'love' (human contra 0.18 < baseline) stays SOLID and charged;
-        'wonderful' was dropped as conflicted with the sarcasm detector."""
-        assert get_phase("love") == "SOLID"
-        assert VOCAB["love"][0] == 40
-        assert get_phase("wonderful") == "GAS"
-        assert VOCAB["wonderful"][0] == 35
-
-    def test_demoted_positive_resolves_by_context(self):
-        """A demoted word no longer single-handedly drags a hostile
-        sentence positive, but genuine usage still reads positive."""
-        assert _v("thank you for ruining everything") < 110
-        assert _v("congratulations on completely ruining my entire life") < 110
-        assert _v("thank you so much") > 128  # genuine gratitude stays warm
-        assert _v("i love you") >= 140        # love untouched
-
-    def test_demoted_word_stops_inflating_sarcasm(self):
-        """'i truly cherish...' sarcasm no longer reads positive
-        (truly +28->+5, cherish +37->0)."""
-        assert _v("i truly cherish the two hours i spend in traffic every day") < 140
-
-
-class TestSlangDuality:
-
-    def test_cooked_doom_vs_praise(self):
-        """'im cooked' = doomed (negative); casual register flips it
-        to praise via SOLVENT dissolution."""
-        assert _v("im cooked") < 110
-        assert _v("im cooked for this exam") < 110
-        assert _v("bruh he cooked") >= 140
-
-    def test_snapped_anger_vs_praise(self):
-        """'snapped at me' = anger; 'lmao she snapped' = performed
-        brilliantly (SOLVENT flip)."""
-        assert _v("he snapped at me in front of everyone") < 110
-        assert _v("lmao she snapped on that verse") > 128
-
-    def test_sheesh_no_longer_nuclear(self):
-        """'sheesh' was -47 (exasperation-only); as mild LIQUID it must not
-        sink an awe sentence deep negative."""
-        assert _v("sheesh he really did that") >= 110
-
-    def test_unambiguous_slang_positive(self):
-        """goated / bussin / w carry direct positive charge."""
-        assert _v("that fit is goated") >= 140
-        assert _v("that meal was bussin fr") >= 140
-        assert _v("thats a big w") >= 140

engine/tests/test_novel.py

@@ -1,107 +0,0 @@
-"""Novel sentence integration tests — sentences NEVER in any benchmark or training data.
-
-V2 scored 26% on these. This is the REAL test.
-
-Two categories:
-  1. NOVEL_CRISIS: should detect at least ONE structural crisis pattern
-  2. NOVEL_SAFE: should NOT detect any crisis patterns
-"""
-
-import pytest
-
-from engine.word_classifier import classify_sentence
-from engine.structures import StructureDetector
-
-
-# ── Helpers ─────────────────────────────────────────────────────
-
-def _detect(sentence: str):
-    """Classify and detect structures in a sentence."""
-    roles = classify_sentence(sentence.split())
-    detector = StructureDetector()
-    return detector.detect_all(roles)
-
-
-def _pattern_names(matches):
-    """Return set of pattern names from matches."""
-    return {m.pattern for m in matches}
-
-
-# Crisis patterns — if any of these appear, something is flagged
-CRISIS_PATTERNS = frozenset({
-    "FAREWELL", "METHOD_ACQUISITION", "SELF_REMOVAL",
-    "EXHAUSTION", "NO_EXIT", "SELF_NULLIFY",
-    "SUSPICIOUS_CALM", "BLANKET_APOLOGY", "FINALITY",
-    "DIVESTITURE", "DANGLING_BOND", "MASKING", "RESIGNATION",
-    "WORLD_CONTINUES", "METHOD_FIXATION", "ABANDONMENT",
-})
-
-
-# ── Novel Crisis Sentences ──────────────────────────────────────
-
-NOVEL_CRISIS = [
-    ("i just gave my dog to my neighbor", {"FAREWELL", "DIVESTITURE"}),
-    ("i left the keys on the counter for whoever finds them", {"FAREWELL", "FINALITY"}),
-    pytest.param(
-        "take care of my cat for me", {"FAREWELL"},
-        marks=pytest.mark.xfail(reason="Needs CARETAKER_TRANSFER pattern — 'take care of' is entrustment, not ACQUIRE"),
-    ),
-    ("im sorry for everything", {"BLANKET_APOLOGY"}),
-    ("this is the last time youll hear from me", {"FINALITY"}),
-    # "i finally feel at peace" and "im ready to go now" = need conversation
-    # context to be crisis. Standalone = could be waiting for a ride.
-    ("i feel calm now that ive decided", {"SUSPICIOUS_CALM"}),
-    ("just bought a bunch of pills", {"METHOD_ACQUISITION"}),
-    ("found a bridge near my house", {"METHOD_ACQUISITION"}),
-    pytest.param(
-        "wrote letters to everyone", {"BLANKET_APOLOGY", "FINALITY"},
-        marks=pytest.mark.xfail(reason="Needs BROADCAST pattern — writing to everyone with no apology word"),
-    ),
-    ("done with everything tbh", {"FINALITY", "BLANKET_APOLOGY"}),
-    ("honestly might just end it lol", {"FINALITY"}),
-    ("im so fucking done", {"FINALITY"}),
-    ("cant do this shit anymore", {"EXHAUSTION"}),
-    ("no point in trying anymore", {"NO_EXIT"}),
-]
-
-
-@pytest.mark.parametrize("sentence,expected_any", NOVEL_CRISIS)
-def test_novel_crisis_detects_pattern(sentence, expected_any):
-    """Each novel crisis sentence should trigger at least ONE structural pattern."""
-    matches = _detect(sentence)
-    detected = _pattern_names(matches)
-    crisis_detected = detected & CRISIS_PATTERNS
-
-    assert crisis_detected, (
-        f"No crisis pattern detected for: '{sentence}'\n"
-        f"  Detected patterns: {detected or 'NONE'}\n"
-        f"  Expected at least one of: {expected_any}"
-    )
-
-
-# ── Novel Safe Sentences ────────────────────────────────────────
-
-NOVEL_SAFE = [
-    "im having a bad day",
-    "work was stressful",
-    "i failed my exam",
-    "my girlfriend broke up with me",
-    "i feel kinda sad today",
-    "mondays suck",
-    "this homework is killing me",
-    "im dead tired",
-    "i could kill for a pizza",
-]
-
-
-@pytest.mark.parametrize("sentence", NOVEL_SAFE)
-def test_novel_safe_no_crisis(sentence):
-    """Safe sentences should NOT trigger any crisis patterns."""
-    matches = _detect(sentence)
-    detected = _pattern_names(matches)
-    crisis_detected = detected & CRISIS_PATTERNS
-
-    assert not crisis_detected, (
-        f"Crisis pattern(s) falsely detected for: '{sentence}'\n"
-        f"  False positives: {crisis_detected}"
-    )

engine/tests/test_pa_structures.py

@@ -1,290 +0,0 @@
-"""Tests for Tier-1 passive aggression structures — embedded grievance.
-
-Five phrasing classes where the complaint is smuggled into deniable
-grammar via presupposition markers:
-
-  TEMPORAL_GRIEVANCE — "finally"/"for once"/"about time" on ANOTHER
-      person's action inside acknowledgment framing
-  EXCLUSION_CONTRAST — "one of us"/"some of us"/"must be nice to"
-      contrasting speaker deprivation vs target enjoyment
-  IRONIC_DEFERENCE   — capitulation-as-attack ("youre clearly the expert")
-  FAINT_PRAISE       — minimal praise + dismissive concession
-  RETROSPECTIVE_HOPE — hope aimed at a CLOSED outcome ("hope it was
-      worth it", "hope youre happy now") = audit instruction
-
-All test sentences are NOVEL — not in any benchmark. Truly context-
-dependent PA (bare "k") stays out of scope and must stay untouched.
-"""
-
-import pytest
-
-from engine.word_classifier import classify_sentence
-from engine.structures import StructureDetector
-from engine.pendulum import compute_vadug
-
-
-# ── Helpers ──────────────────────────────────────────────────────
-
-def _detect(sentence: str):
-    roles = classify_sentence(sentence.split())
-    return StructureDetector().detect_all(roles)
-
-
-def _has_pattern(matches, pattern_name):
-    return any(m.pattern == pattern_name for m in matches)
-
-
-# ── TEMPORAL_GRIEVANCE ───────────────────────────────────────────
-
-class TestTemporalGrievance:
-
-    def test_thanks_for_finally_replying(self):
-        """Gratitude frame + 'finally' = resented delay, not milestone."""
-        matches = _detect("thanks for finally replying to my email")
-        assert _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-        # The grievance reading suppresses the milestone reading
-        assert not _has_pattern(matches, "RARITY_MARKER")
-
-    def test_nice_of_you_to_finally_join(self):
-        """'nice of you to finally join us' — politeness frame + delay marker."""
-        matches = _detect("nice of you to finally join us")
-        assert _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-
-    def test_about_time_second_person(self):
-        """'about time you took out the trash' — presupposed resentment."""
-        matches = _detect("about time you took out the trash")
-        assert _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-
-    def test_for_once_second_person(self):
-        """'for once you showed up on schedule' — rarity as complaint."""
-        matches = _detect("for once you showed up on schedule")
-        assert _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-
-    def test_self_finally_stays_milestone(self):
-        """'i finally passed my driving test' — SELF actor keeps RARITY_MARKER."""
-        matches = _detect("i finally passed my driving test")
-        assert not _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-        assert _has_pattern(matches, "RARITY_MARKER")
-
-    def test_you_finally_achievement_is_shared_joy(self):
-        """'you finally got the promotion' — no acknowledgment frame, no
-        deliberation verb: congratulation, not grievance."""
-        matches = _detect("you finally got the promotion")
-        assert not _has_pattern(matches, "TEMPORAL_GRIEVANCE")
-
-    def test_temporal_grievance_reads_negative_v(self):
-        vadug, _ = compute_vadug("thanks for finally texting me back")
-        assert vadug.v < 110
-        assert vadug.i > 150  # deniable jab = control-side intent
-
-
-# ── EXCLUSION_CONTRAST ───────────────────────────────────────────
-
-class TestExclusionContrast:
-
-    def test_glad_one_of_us(self):
-        """'glad one of us got to relax' — positive surface + partitive."""
-        matches = _detect("glad one of us got to relax this weekend")
-        assert _has_pattern(matches, "EXCLUSION_CONTRAST")
-
-    def test_some_of_us_obligation(self):
-        """'some of us have to clean this up' — partitive + obligation."""
-        matches = _detect("some of us have to clean this up")
-        assert _has_pattern(matches, "EXCLUSION_CONTRAST")
-
-    def test_must_be_nice_to(self):
-        """'must be nice to never check your bank account' — false envy."""
-        matches = _detect("must be nice to never check your bank account")
-        assert _has_pattern(matches, "EXCLUSION_CONTRAST")
-
-    def test_must_be_nice_weather_guard(self):
-        """'must be nice out there this morning' — impersonal, no target."""
-        matches = _detect("must be nice out there this morning")
-        assert not _has_pattern(matches, "EXCLUSION_CONTRAST")
-        assert not _has_pattern(matches, "MARTYRDOM_FIELD")
-
-    def test_one_of_us_logistics_guard(self):
-        """'one of us can take the early shift' — logistics, no contrast."""
-        matches = _detect("one of us can take the early shift")
-        assert not _has_pattern(matches, "EXCLUSION_CONTRAST")
-
-    def test_exclusion_contrast_reads_negative_v(self):
-        vadug, _ = compute_vadug("glad one of us is enjoying the holidays")
-        assert vadug.v < 110
-
-
-# ── IRONIC_DEFERENCE ─────────────────────────────────────────────
-
-class TestIronicDeference:
-
-    def test_youre_clearly_the_expert(self):
-        matches = _detect("youre clearly the expert on parenting")
-        assert _has_pattern(matches, "IRONIC_DEFERENCE")
-
-    def test_doubled_marker_intensifies(self):
-        """'no no youre obviously the genius here' — doubled discourse marker."""
-        matches = _detect("no no youre obviously the genius here")
-        assert _has_pattern(matches, "IRONIC_DEFERENCE")
-
-    def test_fine_youre_right(self):
-        matches = _detect("fine youre right as always")
-        assert _has_pattern(matches, "IRONIC_DEFERENCE")
-
-    def test_genuine_deference_question_guard(self):
-        """'youre clearly the expert so what should we order' — a genuine
-        question after the grant = real deference, no attack."""
-        matches = _detect("youre clearly the expert so what should we order")
-        assert not _has_pattern(matches, "IRONIC_DEFERENCE")
-
-    def test_sincere_concession_guard(self):
-        """'fine youre right i should have asked first' — elaboration after
-        the grant = sincere concession."""
-        matches = _detect("fine youre right i should have asked first")
-        assert not _has_pattern(matches, "IRONIC_DEFERENCE")
-
-    def test_ironic_deference_d_stays_up(self):
-        """The surrender is an assertion: V negative, D not collapsed."""
-        vadug, _ = compute_vadug("youre clearly the expert")
-        assert vadug.v < 110
-        assert vadug.d >= 128
-
-
-# ── FAINT_PRAISE ─────────────────────────────────────────────────
-
-class TestFaintPraise:
-
-    def test_interesting_strategy_but_ok(self):
-        matches = _detect("interesting strategy but ok")
-        assert _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_bold_strategy_standalone(self):
-        matches = _detect("bold strategy")
-        assert _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_thats_ellipsis_something(self):
-        matches = _detect("thats... something")
-        assert _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_well_thats_one_way(self):
-        matches = _detect("well thats one way to handle it")
-        assert _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_bare_interesting_choice_guard(self):
-        """Bare 'interesting choice' is ambiguous — stays neutral."""
-        matches = _detect("interesting choice")
-        assert not _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_bare_one_way_guard(self):
-        """Bare 'thats one way to do it' without dismissive opener — neutral."""
-        matches = _detect("thats one way to do it")
-        assert not _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_sincere_curiosity_guard(self):
-        """'interesting choice what made you pick it' — real question."""
-        matches = _detect("interesting choice what made you pick it")
-        assert not _has_pattern(matches, "FAINT_PRAISE")
-
-    def test_something_not_terminal_guard(self):
-        """'thats something to be proud of' — 'something' not utterance-final."""
-        matches = _detect("thats something to be proud of")
-        assert not _has_pattern(matches, "FAINT_PRAISE")
-
-
-# ── RETROSPECTIVE_HOPE ───────────────────────────────────────────
-
-class TestRetrospectiveHope:
-    """Hope aimed at a CLOSED outcome the addressee already knows is
-    an instruction to self-audit — an indictment in hope's grammar.
-    Three ingredients: hope verb + epistemically-closed complement +
-    transactional/self-satisfaction frame. Each rescuer kills one.
-    """
-
-    # ── Fire cases ──
-
-    def test_hope_it_was_worth_it_fires(self):
-        """Past-tense 'worth it' = retrospective transaction audit."""
-        matches = _detect("hope it was worth it")
-        assert _has_pattern(matches, "RETROSPECTIVE_HOPE")
-
-    def test_named_cost_is_strongest(self):
-        """Explicit cost after 'worth' fires at higher confidence."""
-        m_cost = [m for m in _detect("hope it was worth losing your best friend")
-                  if m.pattern == "RETROSPECTIVE_HOPE"]
-        m_base = [m for m in _detect("hope it was worth it")
-                  if m.pattern == "RETROSPECTIVE_HOPE"]
-        assert m_cost and m_base
-        assert m_cost[0].confidence > m_base[0].confidence
-
-    def test_happy_now_fires(self):
-        """'hope youre happy now' — present-state satisfaction audit."""
-        matches = _detect("hope youre happy now")
-        assert _has_pattern(matches, "RETROSPECTIVE_HOPE")
-
-    def test_proud_of_yourself_fires(self):
-        """'i hope youre proud of yourself' — the audit target named."""
-        matches = _detect("i hope youre proud of yourself")
-        assert _has_pattern(matches, "RETROSPECTIVE_HOPE")
-
-    def test_retrospective_hope_reads_negative_v(self):
-        """The full pipeline lands V below neutral, I at control."""
-        vadug, _ = compute_vadug("well i hope it was worth it")
-        assert vadug.v < 110
-        assert vadug.i == 168
-
-    # ── Rescuers (each kills one ingredient) ──
-
-    def test_future_open_outcome_guard(self):
-        """Open outcomes keep hope genuine — no closed complement."""
-        for s in ("i hope it will be worth it",
-                  "i really hope all this effort is worth it someday"):
-            assert not _has_pattern(_detect(s), "RETROSPECTIVE_HOPE"), s
-
-    def test_benefit_frame_retrospective_guard(self):
-        """Retrospective but benefit-framed — no transaction audit."""
-        for s in ("hope you slept well", "hope the trip went well"):
-            assert not _has_pattern(_detect(s), "RETROSPECTIVE_HOPE"), s
-
-    def test_self_directed_audit_guard(self):
-        """SELF_REF owns the audited choice — anxiety, not aggression."""
-        for s in ("i spent my savings on this hope it was worth it",
-                  "hope my gamble was worth it"):
-            assert not _has_pattern(_detect(s), "RETROSPECTIVE_HOPE"), s
-
-    def test_elaborated_sincerity_guard(self):
-        """Supportive elaboration after the audit rescues sincerity."""
-        for s in ("hope it was worth it you trained two years for this",
-                  "hope youre happy in your new home"):
-            assert not _has_pattern(_detect(s), "RETROSPECTIVE_HOPE"), s
-
-    def test_paid_off_stays_out(self):
-        """Benefit-centered 'paid off' is not cost-centered 'worth it'."""
-        for s in ("hope the gamble paid off", "hope it pays off"):
-            assert not _has_pattern(_detect(s), "RETROSPECTIVE_HOPE"), s
-
-
-# ── Cross-class invariants ───────────────────────────────────────
-
-class TestPAInvariants:
-
-    def test_context_dependent_pa_stays_out_of_scope(self):
-        """Bare context-dependent PA must NOT fire sentence-level patterns.
-
-        ("hope it was worth it" graduated out of this list — its closed
-        complement is sentence-internal grammar, now RETROSPECTIVE_HOPE.)
-        """
-        for s in ("sounds fun",):
-            matches = _detect(s)
-            for pat in ("TEMPORAL_GRIEVANCE", "EXCLUSION_CONTRAST",
-                        "IRONIC_DEFERENCE", "FAINT_PRAISE",
-                        "RETROSPECTIVE_HOPE"):
-                assert not _has_pattern(matches, pat), (s, pat)
-
-    def test_pa_lifts_intent_toward_control(self):
-        """All five classes push I above 150 — the speaker is fighting."""
-        for s in ("about time you answered your texts",
-                  "some of us have to be up at six",
-                  "no no youre clearly the expert here",
-                  "bold strategy",
-                  "hope she was worth it"):
-            vadug, _ = compute_vadug(s)
-            assert vadug.i > 150, s

engine/tests/test_pendulum.py

@@ -1,255 +0,0 @@
-"""Tests for V3 Fixed Physics Layer — pendulum.py.
-
-Verifies that structural analysis drives VADUG computation correctly.
-Tests cover: neutral baseline, positive/negative shifts, negation,
-amplification, structure detection passthrough, and safe sentences.
-"""
-
-import pytest
-
-from engine.pendulum import compute_vadug, CENTER
-from engine.shared import VADUG
-
-
-# ── Helper ───────────────────────────────────────────────────────
-
-def _vadug(text: str) -> VADUG:
-    """Get VADUGWI for text, discard trace."""
-    result, _ = compute_vadug(text)
-    return result
-
-
-def _trace(text: str) -> dict:
-    """Get trace dict for text."""
-    _, trace = compute_vadug(text)
-    return trace
-
-
-# ── Neutral input ───────────────────────────────────────────────
-
-class TestNeutral:
-
-    def test_neutral_v_near_center(self):
-        """Neutral sentence should have V near 128."""
-        r = _vadug("the meeting is at three")
-        assert 118 <= r.v <= 138, f"V={r.v}, expected near 128"
-
-    def test_neutral_all_dimensions_near_center(self):
-        """Neutral sentence should keep all dimensions near baseline."""
-        r = _vadug("the meeting is at three")
-        assert 118 <= r.v <= 138
-        assert 118 <= r.a <= 138
-        assert 118 <= r.d <= 138
-        assert r.u <= 20  # urgency stays low
-        assert 118 <= r.g <= 138
-
-
-# ── Positive input ──────────────────────────────────────────────
-
-class TestPositive:
-
-    def test_positive_v_above_140(self):
-        """Positive sentence should push V above 140."""
-        r = _vadug("I am very happy")
-        assert r.v > 140, f"V={r.v}, expected > 140"
-
-    def test_positive_g_above_center(self):
-        """Happy should feel lighter -- G above center."""
-        r = _vadug("I am very happy")
-        assert r.g > 128, f"G={r.g}, expected > 128"
-
-
-# ── Negative input ──────────────────────────────────────────────
-
-class TestNegative:
-
-    def test_negative_v_below_115(self):
-        """Negative sentence should push V below 115."""
-        r = _vadug("I am very sad")
-        assert r.v < 115, f"V={r.v}, expected < 115"
-
-    def test_negative_g_below_center(self):
-        """Sad should feel heavier -- G below center."""
-        r = _vadug("I am very sad")
-        assert r.g < 128, f"G={r.g}, expected < 128"
-
-
-# ── Negation ────────────────────────────────────────────────────
-
-class TestNegation:
-
-    def test_not_happy_lower_than_happy(self):
-        """'not happy' should have lower V than 'happy'."""
-        v_happy = _vadug("happy").v
-        v_not_happy = _vadug("not happy").v
-        assert v_not_happy < v_happy, (
-            f"not happy V={v_not_happy} should be < happy V={v_happy}"
-        )
-
-    def test_negation_flips_direction(self):
-        """Negation should flip V direction on moderate words."""
-        # Use moderate word to avoid ceiling effects
-        v_good = _vadug("good").v
-        v_not_good = _vadug("not good").v
-        # "not good" should be below center, "good" above
-        assert v_good > 128
-        assert v_not_good < 128
-
-
-# ── Amplification ──────────────────────────────────────────────
-
-class TestAmplification:
-
-    def test_amplifier_increases_displacement(self):
-        """Amplifier should increase displacement from center on moderate words."""
-        # Use a moderate word — "good" (dV=50) saturates before amplification helps
-        v_glad = _vadug("glad").v
-        v_very_glad = _vadug("very glad").v
-        dist_glad = abs(v_glad - 128)
-        dist_very = abs(v_very_glad - 128)
-        assert dist_very > dist_glad, (
-            f"very glad dist={dist_very} should be > glad dist={dist_glad}"
-        )
-
-
-# ── Structure detection passthrough ─────────────────────────────
-
-class TestStructures:
-
-    def test_farewell_detected(self):
-        """'I gave my dog to my neighbor' should detect DIVESTITURE (giving away possessions)."""
-        trace = _trace("I gave my dog to my neighbor")
-        patterns = [s.pattern for s in trace["structures"]]
-        assert "DIVESTITURE" in patterns or "FAREWELL" in patterns, f"Expected DIVESTITURE or FAREWELL, got {patterns}"
-
-    def test_method_acquisition_detected(self):
-        """'just bought a bunch of pills' should detect METHOD_ACQUISITION."""
-        trace = _trace("just bought a bunch of pills")
-        patterns = [s.pattern for s in trace["structures"]]
-        assert "METHOD_ACQUISITION" in patterns, (
-            f"Expected METHOD_ACQUISITION, got {patterns}"
-        )
-
-    def test_safe_no_crisis_structures(self):
-        """'I had a bad day at work' should have no crisis structures."""
-        trace = _trace("I had a bad day at work")
-        crisis = {"FAREWELL", "METHOD_ACQUISITION", "BLANKET_APOLOGY",
-                  "SELF_REMOVAL", "SUSPICIOUS_CALM", "EXHAUSTION",
-                  "NO_EXIT", "SELF_NULLIFY"}
-        found = [s.pattern for s in trace["structures"] if s.pattern in crisis]
-        assert not found, f"Safe sentence falsely flagged: {found}"
-
-
-# ── VADUGWI object ──────────────────────────────────────────────
-
-class TestVADUGObject:
-
-    def test_returns_vadug_type(self):
-        """compute_vadug should return a VADUGWI object."""
-        result, _ = compute_vadug("hello world")
-        assert isinstance(result, VADUG)
-
-    def test_all_five_dimensions(self):
-        """VADUGWI should have all 7 dimensions."""
-        r = _vadug("I am very happy")
-        assert hasattr(r, "v")
-        assert hasattr(r, "a")
-        assert hasattr(r, "d")
-        assert hasattr(r, "u")
-        assert hasattr(r, "g")
-
-    def test_dimensions_in_range(self):
-        """All dimensions should be 0-255."""
-        r = _vadug("I am extremely terribly devastatingly sad")
-        assert 0 <= r.v <= 255
-        assert 0 <= r.a <= 255
-        assert 0 <= r.d <= 255
-        assert 0 <= r.u <= 255
-        assert 0 <= r.g <= 255
-
-
-# ── Trace dict ──────────────────────────────────────────────────
-
-class TestTrace:
-
-    def test_trace_has_per_word_entries(self):
-        """Trace should have one entry per word."""
-        trace = _trace("I am happy")
-        assert len(trace["trace"]) == 3
-
-    def test_trace_entry_fields(self):
-        """Each trace entry should have word, role, coeff, v, a, d, u, g."""
-        trace = _trace("happy")
-        entry = trace["trace"][0]
-        for key in ("word", "role", "coeff", "v", "a", "d", "u", "g"):
-            assert key in entry, f"Missing key: {key}"
-
-    def test_word_count(self):
-        """Trace should report correct word count."""
-        trace = _trace("the quick brown fox")
-        assert trace["word_count"] == 4
-
-    def test_empty_input(self):
-        """Empty string should return neutral VADUGWI and empty trace."""
-        r, trace = compute_vadug("")
-        assert r.v == 128
-        assert r.w == 128
-        assert trace["word_count"] == 0
-        assert trace["trace"] == []
-
-
-# ── V4: Self-Worth (W) dimension ─────────────────────────────────
-
-class TestSelfWorth:
-    """W tracks the user's self-assessment of their own value."""
-
-    def test_default_w_is_neutral(self):
-        """Default VADUGWI has W=128 (stable self-worth)."""
-        assert VADUG().w == 128
-
-    def test_neutral_sentence_w_unchanged(self):
-        """Non-self-referential sentences should not move W."""
-        r = _vadug("the meeting is at three")
-        assert r.w == 128
-
-    def test_no_self_ref_w_unchanged(self):
-        """Sentences without SELF_REF should keep W at 128."""
-        r = _vadug("she walked her dog")
-        assert r.w == 128
-
-    def test_self_nullify_drops_w(self):
-        """'i am worthless' should produce W < 100."""
-        r = _vadug("i am worthless")
-        assert r.w < 100, f"W={r.w} should be < 100 for self-nullification"
-
-    def test_self_nothing_drops_w(self):
-        """'i am nothing' should produce W < 110."""
-        r = _vadug("i am nothing")
-        assert r.w < 110, f"W={r.w} should be < 110"
-
-    def test_self_proud_raises_w(self):
-        """'i am proud of myself' should produce W > 128."""
-        r = _vadug("i am proud of myself")
-        assert r.w > 128, f"W={r.w} should be > 128 for self-pride"
-
-    def test_self_deserve_raises_w(self):
-        """'i deserve to be happy' should produce W > 128."""
-        r = _vadug("i deserve to be happy")
-        assert r.w > 128, f"W={r.w} should be > 128"
-
-    def test_told_useless_drops_w(self):
-        """'he told me i was useless' should drop W below neutral."""
-        r = _vadug("he told me i was useless")
-        assert r.w < 128, f"W={r.w} should be < 128"
-
-    def test_w_amplifies_negative_v(self):
-        """Low W should amplify negative V (self-worth lens effect)."""
-        # "i am worthless" has low W AND low V
-        # The V should be lower than it would be without W coefficient
-        r = _vadug("i am worthless")
-        assert r.v < 80, f"V={r.v} should be deeply negative with W amplification"
-
-    def test_burden_drops_w(self):
-        """'im a burden' triggers SELF_NULLIFY which drops W."""
-        r = _vadug("im a burden to everyone")
-        assert r.w < 110, f"W={r.w} should be < 110 for self-as-burden"

engine/tests/test_proximity.py

@@ -1,192 +0,0 @@
-"""Tests for V3 proximity weighting — distance-based influence fields."""
-
-import pytest
-
-from engine.word_classifier import WordRole, classify_sentence
-from engine.proximity import (
-    PROXIMITY_DECAY,
-    compute_proximity_field,
-    find_role_pairs,
-    proximity_coefficient,
-)
-
-
-# ── Helper ───────────────────────────────────────────────────────
-
-def _roles(sentence: str):
-    """Classify a sentence into WordRoles."""
-    return classify_sentence(sentence.split())
-
-
-# ── compute_proximity_field tests ────────────────────────────────
-
-class TestProximityField:
-
-    def test_adjacent_words_have_decay_influence(self):
-        """Adjacent words (distance 1) should have ~0.7 influence."""
-        roles = _roles("I am happy")
-        field = compute_proximity_field(roles)
-        # word 0 -> word 1 = distance 1
-        assert abs(field[0][1] - PROXIMITY_DECAY) < 1e-9
-
-    def test_distant_words_have_decayed_influence(self):
-        """Words at distance 4 should have ~0.7^4 = ~0.24 influence."""
-        roles = _roles("I gave my dog to neighbor")
-        field = compute_proximity_field(roles)
-        # word 0 -> word 4 = distance 4
-        expected = PROXIMITY_DECAY ** 4
-        assert abs(field[0][4] - expected) < 1e-9
-
-    def test_influence_is_symmetric(self):
-        """Influence from A->B should equal B->A."""
-        roles = _roles("very happy today")
-        field = compute_proximity_field(roles)
-        assert abs(field[0][2] - field[2][0]) < 1e-9
-
-    def test_no_self_influence(self):
-        """A word should not appear in its own influence map."""
-        roles = _roles("I am fine")
-        field = compute_proximity_field(roles)
-        for idx, influences in field.items():
-            assert idx not in influences
-
-    def test_empty_sentence(self):
-        """Empty input produces empty field."""
-        field = compute_proximity_field([])
-        assert field == {}
-
-    def test_single_word(self):
-        """Single word has no influences."""
-        roles = _roles("hello")
-        field = compute_proximity_field(roles)
-        assert field[0] == {}
-
-    def test_cutoff_applied(self):
-        """Distant words eventually fall below influence cutoff."""
-        from engine.proximity import PROXIMITY_DECAY, INFLUENCE_CUTOFF
-        # Find the distance where influence drops below cutoff
-        import math
-        cutoff_dist = int(math.log(INFLUENCE_CUTOFF) / math.log(PROXIMITY_DECAY)) + 1
-        roles = _roles(" ".join(f"w{i}" for i in range(cutoff_dist + 5)))
-        field = compute_proximity_field(roles)
-        # distance cutoff_dist-2 should be included
-        assert cutoff_dist - 2 in field[0]
-        # distance cutoff_dist+1 should be excluded
-        assert cutoff_dist + 1 not in field[0]
-
-
-# ── find_role_pairs tests ────────────────────────────────────────
-
-class TestFindRolePairs:
-
-    def test_transfer_relation_found(self):
-        """'I gave my dog to neighbor' should find TRANSFER+RELATION_REF."""
-        roles = _roles("I gave my dog to neighbor")
-        # dog is RELATION_REF now (relationship, not possession)
-        pairs = find_role_pairs(roles, "TRANSFER", "RELATION_REF")
-        assert len(pairs) > 0
-        transfer_idxs = [r.position for r in roles if r.role == "TRANSFER"]
-        relation_idxs = [r.position for r in roles if r.role == "RELATION_REF"]
-        pair_as = [p[0] for p in pairs]
-        pair_bs = [p[1] for p in pairs]
-        assert any(a in transfer_idxs for a in pair_as)
-        assert any(b in relation_idxs for b in pair_bs)
-
-    def test_acquire_method_found(self):
-        """'just bought some pills' should find ACQUIRE+METHOD."""
-        roles = _roles("just bought some pills")
-        pairs = find_role_pairs(roles, "ACQUIRE", "METHOD")
-        assert len(pairs) > 0
-        # "bought" is ACQUIRE, "pills" is METHOD
-        acquire_idxs = [r.position for r in roles if r.role == "ACQUIRE"]
-        method_idxs = [r.position for r in roles if r.role == "METHOD"]
-        pair_as = [p[0] for p in pairs]
-        pair_bs = [p[1] for p in pairs]
-        assert any(a in acquire_idxs for a in pair_as)
-        assert any(b in method_idxs for b in pair_bs)
-
-    def test_sorted_strongest_first(self):
-        """Pairs should be sorted by proximity strength, strongest first."""
-        roles = _roles("I gave my dog to neighbor")
-        pairs = find_role_pairs(roles, "TRANSFER", "POSSESSION")
-        if len(pairs) > 1:
-            for i in range(len(pairs) - 1):
-                assert pairs[i][2] >= pairs[i + 1][2]
-
-    def test_max_distance_respected(self):
-        """Pairs beyond max_distance should not be returned."""
-        roles = _roles("gave a b c d e f g dog")
-        pairs = find_role_pairs(roles, "TRANSFER", "POSSESSION", max_distance=3)
-        for _, _, strength in pairs:
-            # All returned pairs must have distance <= 3
-            assert strength >= PROXIMITY_DECAY ** 3
-
-    def test_no_pairs_returns_empty(self):
-        """If no matching role pair exists, return empty list."""
-        roles = _roles("hello world")
-        pairs = find_role_pairs(roles, "TRANSFER", "METHOD")
-        assert pairs == []
-
-
-# ── proximity_coefficient tests ──────────────────────────────────
-
-class TestProximityCoefficient:
-
-    def test_amplifier_boosts(self):
-        """Nearby AMPLIFIER should boost coefficient above 1.0."""
-        roles = _roles("very happy")
-        # "very" = AMPLIFIER at idx 0, target "happy" at idx 1
-        coeff = proximity_coefficient(roles, 1)
-        assert coeff > 1.0
-
-    def test_negator_flips(self):
-        """Nearby NEGATOR should flip coefficient below 0."""
-        roles = _roles("not happy")
-        # "not" = NEGATOR at idx 0, target "happy" at idx 1
-        coeff = proximity_coefficient(roles, 1)
-        assert coeff < 0.0
-
-    def test_self_ref_increases_magnitude(self):
-        """SELF_REF nearby should increase |coefficient| vs OTHER_REF."""
-        roles_self = _roles("I am happy")
-        roles_other = _roles("they are happy")
-        # "happy" is the last word in both
-        coeff_self = proximity_coefficient(roles_self, 2)
-        coeff_other = proximity_coefficient(roles_other, 2)
-        assert abs(coeff_self) > abs(coeff_other)
-
-    def test_hedge_dampens(self):
-        """Nearby HEDGE should dampen coefficient below 1.0."""
-        roles = _roles("maybe happy")
-        # "maybe" = HEDGE at idx 0, target "happy" at idx 1
-        coeff = proximity_coefficient(roles, 1)
-        assert coeff < 1.0
-
-    def test_no_modifiers_returns_one(self):
-        """Without modifier roles nearby, coefficient should be 1.0."""
-        roles = _roles("the dog barked")
-        # All NEUTRAL/POSSESSION — no AMPLIFIER/NEGATOR/SELF_REF/HEDGE
-        coeff = proximity_coefficient(roles, 0)
-        assert coeff == 1.0
-
-    def test_coefficient_capped(self):
-        """Coefficient should never exceed [-COEFFICIENT_CAP, COEFFICIENT_CAP]."""
-        from engine.proximity import COEFFICIENT_CAP
-        roles = _roles("very really extremely totally absolutely happy")
-        coeff = proximity_coefficient(roles, 5)
-        assert -COEFFICIENT_CAP <= coeff <= COEFFICIENT_CAP
-
-    def test_empty_roles(self):
-        """Empty roles list returns 1.0."""
-        assert proximity_coefficient([], 0) == 1.0
-
-    def test_single_word(self):
-        """Single word has no modifiers — coefficient is 1.0."""
-        roles = _roles("happy")
-        assert proximity_coefficient(roles, 0) == 1.0
-
-    def test_out_of_bounds_index(self):
-        """Out-of-bounds target index returns 1.0."""
-        roles = _roles("hello world")
-        assert proximity_coefficient(roles, 99) == 1.0
-        assert proximity_coefficient(roles, -1) == 1.0

engine/tests/test_scaffold.py

@@ -1,30 +0,0 @@
-import pytest
-import sys, os
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
-
-def test_vadug_import():
-    from engine.shared import VADUG
-    v = VADUG(v=100, a=150, d=128, u=50, g=90)
-    assert v.v == 100
-    assert v.g == 90
-
-def test_vocabulary_import():
-    from engine.vocabulary import VOCABULARY
-    assert len(VOCABULARY) > 2000
-    assert "happy" in VOCABULARY
-    assert "sad" in VOCABULARY
-
-def test_zones_import():
-    from engine.zones import ZONES
-    assert "JOY" in ZONES
-    assert "CRISIS" in ZONES
-
-def test_personality_import():
-    from engine.personality import PersonalityVector
-    p = PersonalityVector()
-    assert hasattr(p, "emotional_sensitivity")
-
-def test_fuzzy_import():
-    from engine.fuzzy import fuzzy_match
-    assert fuzzy_match("happyyyy") == "happy"
-    assert fuzzy_match("tbh") == "honestly"

engine/tests/test_slang_register.py

@@ -1,203 +0,0 @@
-"""Tests for the Batch 1 slang-register fixes (2026-06-11).
-
-Covers:
-  1. New slang vocabulary (dope, dogwater, washed, masterclass, ...)
-  2. 'w' sense disambiguation: WIN vs "with"
-  3. "lets go" hype compound + elongation collapse ("LETS GOOOOOO")
-  4. "as hell" as pure intensifier (no literal hell charge)
-  5. Expletive-as-intensifier rescue after demonstratives ("This shit slaps")
-  6. Fuzzy stemmer blocklist ('number' must not stem to 'numb')
-  7. Regression guards on regraded words (clean, extra, trap)
-"""
-
-from engine.pendulum import compute_vadug
-
-
-def _v(text: str) -> float:
-    result, _ = compute_vadug(text)
-    return result.v
-
-
-class TestNewSlangVocab:
-
-    def test_dope_with_elongated_greeting(self):
-        assert _v("Yoooooo, that's dope!!!!!!!!!!!") >= 140
-
-    def test_dogwater_negative(self):
-        assert _v("the servers are actually dogwater tonight") <= 123
-
-    def test_washed_negative(self):
-        assert _v("batista is washed bro") <= 124
-
-    def test_ggs_masterclass(self):
-        assert _v("ggs that was a masterclass") >= 140
-
-
-class TestWDisambiguation:
-
-    def test_w_as_with_in_food_order(self):
-        assert 112 <= _v("ordered it w extra cheese") <= 144
-
-    def test_w_as_with_before_name(self):
-        assert 105 <= _v("don't play w jynxzi") <= 144
-
-    def test_w_as_win_after_massive(self):
-        assert _v("massive W for the whole team today") >= 138
-
-
-class TestHypeCompounds:
-
-    def test_lets_go_elongated(self):
-        assert _v("LETS GOOOOOO") >= 140
-
-    def test_clean_as_hell(self):
-        assert _v("new drop is clean as hell") >= 133
-
-    def test_demonstrative_expletive_rescue_with_trap_genre(self):
-        assert _v("This shit slaps, we need the trap remix") >= 140
-
-
-class TestStemmerBlocklist:
-
-    def test_number_does_not_stem_to_numb(self):
-        assert 105 <= _v("she peaked at number three on the charts") <= 144
-
-
-class TestRegressionGuards:
-
-    def test_happy_stays_high(self):
-        assert _v("I am so happy for you") >= 150
-
-    def test_crisis_stays_low(self):
-        assert _v("I want to die") <= 60
-
-    def test_literal_hell_stays_negative(self):
-        assert _v("this is hell") <= 110
-
-    def test_literal_extra_quantity(self):
-        assert _v("we got extra time to finish") >= 112
-
-    def test_literal_trap_stays_negative(self):
-        assert _v("he fell into a trap") <= 120
-
-
-# ── Batch 2 (2026-06-11) ────────────────────────────────────────
-
-
-class TestDiscourseNoRescue:
-
-    def test_no_before_self_ref_illness(self):
-        assert _v("no i'm sick with a sore throat") <= 123
-
-    def test_no_before_self_ref_negation_preserved(self):
-        assert _v("no i don't want that") <= 110
-
-    def test_no_positive_rescue_still_works(self):
-        assert _v("no we good") >= 140
-
-
-class TestCookedLiteralGuard:
-
-    def test_cooked_dinner_for_fam(self):
-        assert 112 <= _v("i cooked dinner for the fam tonight") <= 144
-
-    def test_cooked_on_the_grill(self):
-        # 111 as of batch 2: "on" is not a literal-object follower, so the
-        # stored slang charge still applies; held just under neutral by
-        # W-V coupling. Band guards against regression in either direction.
-        assert 105 <= _v("I cooked on the grill so yes") <= 144
-
-    def test_home_cooked_meal(self):
-        assert 112 <= _v("3 pennes and a home cooked meal") <= 144
-
-    def test_im_cooked_bro_still_flips_positive(self):
-        assert _v("im cooked bro") >= 133
-
-    def test_im_cooked_stays_doomed(self):
-        assert _v("im cooked") < 110
-
-
-class TestFireSenseSplit:
-
-    def test_fire_hazard_in_kitchen(self):
-        result, _ = compute_vadug("theres a fire in my kitchen")
-        assert result.v <= 123
-        assert result.u >= 25
-
-    def test_fire_praise_its(self):
-        assert _v("Play bite by night on Roblox it's fire") >= 133
-
-    def test_fire_praise_be(self):
-        assert _v("game might actually be fire without the broom tho lol") >= 133
-
-    def test_fire_away_not_strongly_positive(self):
-        assert _v("fire away with your questions") <= 135
-
-    def test_fire_him_not_strongly_positive(self):
-        assert _v("they had to fire him") <= 145
-
-
-class TestPraiseNounGuard:
-
-    def test_you_the_goat_fr(self):
-        assert _v("you the goat fr") >= 145
-
-    def test_good_for_you_stays_pa(self):
-        assert _v("good for you") <= 110
-
-    def test_must_be_nice_stays_pa(self):
-        assert _v("must be nice") <= 112
-
-
-class TestRegisterCasualInertSkip:
-
-    def test_trailing_ngl_no_drain(self):
-        assert _v("yo this game gives me hope for the human race man ngl") >= 133
-
-    def test_helluva_combo_ngl(self):
-        assert _v("Yoo pink and teal, that's one helluva combo ngl") >= 133
-
-    def test_elongated_good_burgers(self):
-        assert _v("yall i made 2 big burgers today i ate GOOOOOD") >= 133
-
-
-class TestHypeIdioms:
-
-    def test_we_are_so_back(self):
-        assert _v("WE ARE SO BACK") >= 140
-
-    def test_turned_his_back_unaffected(self):
-        assert _v("he turned his back") <= 128
-
-    def test_stupid_good_amplifier(self):
-        assert _v("the chorus on this track is stupid good") >= 140
-
-    def test_stupid_mistake_stays_negative(self):
-        assert _v("stupid mistake") <= 110
-
-    def test_he_is_stupid_stays_negative(self):
-        assert _v("he is stupid") <= 115
-
-
-class TestVocabPhaseBatch2:
-
-    def test_lowkey_obsessed_flips_positive(self):
-        assert _v("honestly lowkey obsessed with this app") >= 133
-
-    def test_obsessed_third_person_stays_nonpositive(self):
-        assert _v("he is obsessed with her every move") <= 128
-
-    def test_filthy_sports_praise(self):
-        assert _v("that play was filthy") >= 133
-
-    def test_filthy_bathroom_stays_nonpositive(self):
-        assert _v("the bathroom was filthy") <= 128
-
-    def test_mid_game_negative(self):
-        assert _v("mid game tbh, wouldn't recommend") <= 123
-
-    def test_mid_predicate_stays_negative(self):
-        assert _v("the new album is mid") <= 110
-
-    def test_mid_morning_temporal_neutral(self):
-        assert 105 <= _v("mid morning meeting") <= 144

engine/tests/test_solver.py

@@ -1,104 +0,0 @@
-"""Tests for V3 Bidirectional Solver — forward read + backward zone targeting."""
-
-import pytest
-
-from engine.solver import (
-    forward,
-    state_transition,
-    solve_for_b_range,
-    optimal_b_temperature,
-)
-from engine.shared import VADUG
-
-
-# ── Forward ────────────────────────────────────────────────────────
-
-class TestForward:
-    def test_happy_text_high_valence(self):
-        """'I am happy' should produce V > 140."""
-        result = forward("I am happy")
-        assert result.v > 140, f"Expected V > 140, got {result}"
-
-
-# ── State transition ───────────────────────────────────────────────
-
-class TestStateTransition:
-    def test_neutral_b_preserves_a_direction(self):
-        """Neutral B should preserve A's direction — V stays on same side of 128."""
-        a = VADUG(v=180, a=140, d=150, u=20, g=140)
-        b = VADUG(v=128, a=128, d=128, u=0, g=128)
-        c = state_transition(a, b)
-        # A is positive (180), neutral B should keep C positive
-        assert c.v > 128, f"Expected C.v > 128, got {c.v}"
-        # C should be pulled toward neutral but still positive
-        assert c.v < a.v, f"Expected C.v < A.v ({a.v}), got {c.v}"
-
-    def test_warm_b_lifts_crisis_a(self):
-        """Warm B should lift a crisis state — C.v > A.v."""
-        crisis = VADUG(v=60, a=180, d=50, u=200, g=40)
-        warm = VADUG(v=200, a=100, d=160, u=10, g=180)
-        c = state_transition(crisis, warm)
-        assert c.v > crisis.v, f"Expected C.v > {crisis.v}, got {c.v}"
-        assert c.d > crisis.d, f"Expected C.d > {crisis.d}, got {c.d}"
-        assert c.g > crisis.g, f"Expected C.g > {crisis.g}, got {c.g}"
-
-    def test_weights_sum_to_one(self):
-        """Default weights: 60% A + 40% B."""
-        a = VADUG(v=100, a=100, d=100, u=100, g=100)
-        b = VADUG(v=200, a=200, d=200, u=200, g=200)
-        c = state_transition(a, b)
-        # 100*0.6 + 200*0.4 = 140
-        assert c.v == 140
-        assert c.a == 140
-        assert c.d == 140
-
-
-# ── Backward: zone targeting ──────────────────────────────────────
-
-class TestSolveForBRange:
-    def test_neutral_a_to_joy_requires_positive_b(self):
-        """From neutral A, reaching JOY zone requires positive B (V > 128)."""
-        neutral = VADUG(v=128, a=128, d=128, u=0, g=128)
-        ranges = solve_for_b_range(neutral, "JOY", temperature_steps=256)
-        assert len(ranges) > 0, "Should find valid ranges for JOY from neutral"
-        # Valid B values should be predominantly positive (above neutral)
-        # The lowest valid B may dip slightly below 128 due to zone radius,
-        # but the range center should be well above 128
-        lowest_start = min(s for s, _ in ranges)
-        highest_end = max(e for _, e in ranges)
-        midpoint = (lowest_start + highest_end) // 2
-        assert midpoint > 128, f"Expected range midpoint > 128, got {midpoint}"
-
-    def test_deep_crisis_to_joy_narrow_or_empty(self):
-        """Deep crisis A may have empty or narrow range to JOY.
-
-        Can't reach joy from crisis in one step — this is correct behavior.
-        """
-        crisis = VADUG(v=30, a=200, d=30, u=230, g=20)
-        ranges = solve_for_b_range(crisis, "JOY", temperature_steps=256)
-        # Either empty or very narrow — crisis is far from joy
-        total_width = sum(end - start + 1 for start, end in ranges)
-        assert total_width <= 30, (
-            f"Expected narrow/empty range from deep crisis to JOY, "
-            f"got total width {total_width}"
-        )
-
-
-class TestOptimalBTemperature:
-    def test_returns_value_in_valid_range(self):
-        """Optimal B should fall within one of the valid ranges."""
-        neutral = VADUG(v=128, a=128, d=128, u=0, g=128)
-        opt = optimal_b_temperature(neutral, "JOY")
-        assert opt is not None, "Should find optimal B for JOY from neutral"
-        ranges = solve_for_b_range(neutral, "JOY", temperature_steps=256)
-        in_range = any(start <= opt <= end for start, end in ranges)
-        assert in_range, f"Optimal B {opt} not in any valid range {ranges}"
-
-    def test_unreachable_returns_none(self):
-        """If no B can reach the zone, return None."""
-        # Extremely deep crisis — may not reach NEUTRAL's tiny radius
-        extreme = VADUG(v=0, a=255, d=0, u=255, g=0)
-        result = optimal_b_temperature(extreme, "NEUTRAL")
-        # NEUTRAL has radius 8 — very tight, hard to hit from extreme
-        # This may or may not be None depending on math, so just check type
-        assert result is None or isinstance(result, int)

engine/tests/test_structures.py

@@ -1,746 +0,0 @@
-"""Tests for V3 Structure Detector -- chess-like pattern recognition.
-
-All test sentences are NOVEL -- things never in any benchmark.
-Safe sentences must NOT flag crisis patterns.
-"""
-
-import pytest
-
-from engine.word_classifier import classify_sentence
-from engine.structures import StructureDetector, StructureMatch
-
-
-# ── Helper ───────────────────────────────────────────────────────
-
-def _detect(sentence: str):
-    """Classify and detect structures in a sentence."""
-    roles = classify_sentence(sentence.split())
-    detector = StructureDetector()
-    return detector.detect_all(roles)
-
-
-def _has_pattern(matches, pattern_name):
-    """Check if a specific pattern was detected."""
-    return any(m.pattern == pattern_name for m in matches)
-
-
-def _get_pattern(matches, pattern_name):
-    """Get the first match of a specific pattern."""
-    for m in matches:
-        if m.pattern == pattern_name:
-            return m
-    return None
-
-
-# ── FAREWELL ─────────────────────────────────────────────────────
-
-class TestFarewell:
-
-    def test_gave_dog_to_neighbor(self):
-        """'I gave my dog to my neighbor' -> DIVESTITURE (giving away possessions)."""
-        matches = _detect("I gave my dog to my neighbor")
-        assert _has_pattern(matches, "FAREWELL") or _has_pattern(matches, "DIVESTITURE")
-
-    def test_leaving_keys_with_friend(self):
-        """'leaving my keys with a friend' -> FAREWELL or DIVESTITURE."""
-        matches = _detect("leaving my keys with a friend")
-        assert _has_pattern(matches, "FAREWELL") or _has_pattern(matches, "DIVESTITURE") or _has_pattern(matches, "ABANDONMENT")
-
-    def test_no_farewell_without_ref(self):
-        """'I gave my dog a treat' -- no person ref, not FAREWELL."""
-        matches = _detect("I gave my dog a treat")
-        assert not _has_pattern(matches, "FAREWELL")
-
-
-# ── METHOD_ACQUISITION ───────────────────────────────────────────
-
-class TestMethodAcquisition:
-
-    def test_bought_pills(self):
-        """'just bought a bunch of pills' -> METHOD_ACQUISITION."""
-        matches = _detect("just bought a bunch of pills")
-        assert _has_pattern(matches, "METHOD_ACQUISITION")
-
-    def test_found_a_gun(self):
-        """'I found a gun in the closet' -> METHOD_ACQUISITION."""
-        matches = _detect("I found a gun in the closet")
-        assert _has_pattern(matches, "METHOD_ACQUISITION")
-
-    def test_bought_groceries_safe(self):
-        """'just bought some groceries' -- no METHOD, should be safe."""
-        matches = _detect("just bought some groceries")
-        assert not _has_pattern(matches, "METHOD_ACQUISITION")
-
-
-# ── FINALITY ─────────────────────────────────────────────────────
-
-class TestFinality:
-
-    def test_last_time(self):
-        """'this is the last time' -> FINALITY."""
-        matches = _detect("this is the last time")
-        assert _has_pattern(matches, "FINALITY")
-
-    def test_goodbye(self):
-        """'goodbye everyone' -> FINALITY."""
-        matches = _detect("goodbye everyone")
-        assert _has_pattern(matches, "FINALITY")
-
-    def test_finality_with_self_ref(self):
-        """'I am done with everything' -> FINALITY with SELF_REF boost."""
-        matches = _detect("I am done with everything")
-        assert _has_pattern(matches, "FINALITY")
-        m = _get_pattern(matches, "FINALITY")
-        assert m.confidence > 0.4  # boosted by SELF_REF
-
-
-# ── BLANKET_APOLOGY ──────────────────────────────────────────────
-
-class TestBlanketApology:
-
-    def test_sorry_for_everything(self):
-        """'im sorry for everything' -> BLANKET_APOLOGY."""
-        matches = _detect("im sorry for everything")
-        assert _has_pattern(matches, "BLANKET_APOLOGY")
-
-    def test_apologize_to_everyone(self):
-        """'I apologize to everyone' -> BLANKET_APOLOGY."""
-        matches = _detect("I apologize to everyone")
-        assert _has_pattern(matches, "BLANKET_APOLOGY")
-
-    def test_sorry_for_being_late_safe(self):
-        """'im sorry for being late' -- specific apology, NOT blanket."""
-        matches = _detect("im sorry for being late")
-        assert not _has_pattern(matches, "BLANKET_APOLOGY")
-
-
-# ── SELF_REMOVAL ─────────────────────────────────────────────────
-
-class TestSelfRemoval:
-
-    def test_happier_without_me(self):
-        """'they would be happier if I wasnt here' -> SELF_REMOVAL."""
-        matches = _detect("they would be happier if I wasnt here")
-        assert _has_pattern(matches, "SELF_REMOVAL")
-
-    def test_better_off_without(self):
-        """'everyone is better off without me' -> SELF_REMOVAL."""
-        matches = _detect("everyone is better off without me")
-        assert _has_pattern(matches, "SELF_REMOVAL")
-
-    def test_better_at_cooking_safe(self):
-        """'she is better at cooking than me' -- comparison, not removal."""
-        matches = _detect("she is better at cooking than me")
-        # No conditional word present, should not match
-        assert not _has_pattern(matches, "SELF_REMOVAL")
-
-
-# ── SUSPICIOUS_CALM ──────────────────────────────────────────────
-
-class TestSuspiciousCalm:
-
-    def test_finally_at_peace_is_relief(self):
-        """'I finally feel at peace' = present tense breakthrough, NOT suspicious."""
-        matches = _detect("I finally feel at peace")
-        assert not _has_pattern(matches, "SUSPICIOUS_CALM")
-
-    def test_decided_calm_is_suspicious(self):
-        """'i feel calm now that ive decided' -> SUSPICIOUS_CALM."""
-        matches = _detect("i feel calm now that ive decided")
-        assert _has_pattern(matches, "SUSPICIOUS_CALM")
-
-    def test_ready_to_go_is_not_suspicious(self):
-        """'im ready to go now' = could be waiting for a ride. Needs conversation context."""
-        matches = _detect("im ready to go now")
-        assert not _has_pattern(matches, "SUSPICIOUS_CALM")
-
-    def test_peace_without_finally_safe(self):
-        """'I feel at peace' -- no 'finally', not suspicious."""
-        matches = _detect("I feel at peace")
-        assert not _has_pattern(matches, "SUSPICIOUS_CALM")
-
-
-# ── EXHAUSTION ───────────────────────────────────────────────────
-
-class TestExhaustion:
-
-    def test_cant_take_anymore(self):
-        """'I cant take this anymore' -> EXHAUSTION."""
-        matches = _detect("I cant take this anymore")
-        assert _has_pattern(matches, "EXHAUSTION")
-
-    def test_cant_do_this(self):
-        """'I cant do this' -> EXHAUSTION (without temporal, lower conf)."""
-        matches = _detect("I cant do this")
-        assert _has_pattern(matches, "EXHAUSTION")
-
-    def test_cant_find_keys_safe(self):
-        """'I cant find my keys' -- 'find' is ACQUIRE not sustain."""
-        matches = _detect("I cant find my keys")
-        assert not _has_pattern(matches, "EXHAUSTION")
-
-
-# ── SARCASM_INVERSION ────────────────────────────────────────────
-
-class TestSarcasmInversion:
-
-    # ── Contradiction feature: Surface-Context Mismatch ─────────
-    def test_great_another_monday(self):
-        """'oh great another monday' -> surface-context mismatch."""
-        matches = _detect("oh great another monday")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_great_another_meeting(self):
-        """'oh great another meeting' -> surface-context mismatch."""
-        matches = _detect("oh great another meeting")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    # ── Contradiction feature: Mock Praise ──────────────────────
-    def test_nice_work_genius(self):
-        """'nice work genius' -> mock praise (positive + ironic title)."""
-        matches = _detect("nice work genius")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    # ── Contradiction feature: Dismissive Assent ────────────────
-    def test_yeah_right(self):
-        """'yeah right' -> dismissive assent (hollow + echo)."""
-        matches = _detect("yeah right")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_oh_sure_exactly_what_i_needed(self):
-        """'oh sure thats exactly what i needed' -> dismissive assent."""
-        matches = _detect("oh sure thats exactly what i needed")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_what_a_wonderful_surprise(self):
-        """'what a wonderful surprise' -> dismissive assent (what-a template)."""
-        matches = _detect("what a wonderful surprise")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    # ── Contradiction feature: Compressed Sarcasm ───────────────
-    def test_oh_joy(self):
-        """'oh joy' -> compressed sarcasm (hollow + positive + ultra-short)."""
-        matches = _detect("oh joy")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_oh_how_lovely(self):
-        """'oh how lovely' -> compressed sarcasm."""
-        matches = _detect("oh how lovely")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_wow_thanks_stacked(self):
-        """'wow thanks so much for the help' -> stacked positives."""
-        matches = _detect("wow thanks so much for the help")
-        assert _has_pattern(matches, "SARCASM_INVERSION")
-
-    # ── Permission Hostility: context-dependent ─────────────────
-    def test_sure_go_ahead_no_context_is_genuine(self):
-        """'sure go ahead' without negative context = genuine permission."""
-        matches = _detect("sure go ahead")
-        assert not _has_pattern(matches, "SARCASM_INVERSION")
-
-    # ── Safe sentences: no sarcasm ──────────────────────────────
-    def test_genuine_great_not_sarcasm(self):
-        """'that was a great wonderful performance' -- genuinely positive."""
-        matches = _detect("that was a great wonderful performance")
-        assert not _has_pattern(matches, "SARCASM_INVERSION")
-
-    def test_love_my_mom_not_sarcasm(self):
-        """'I love my mom' -- RELATION_REF blocks sarcasm."""
-        matches = _detect("I love my mom")
-        assert not _has_pattern(matches, "SARCASM_INVERSION")
-
-
-# ── NO_EXIT ──────────────────────────────────────────────────────
-
-class TestNoExit:
-
-    def test_no_hope(self):
-        """'there is no hope' -> NO_EXIT."""
-        matches = _detect("there is no hope")
-        assert _has_pattern(matches, "NO_EXIT")
-
-    def test_no_point(self):
-        """'there is no point anymore' -> NO_EXIT."""
-        matches = _detect("there is no point anymore")
-        assert _has_pattern(matches, "NO_EXIT")
-
-    def test_no_milk_safe(self):
-        """'there is no milk' -- 'milk' is not an exit concept."""
-        matches = _detect("there is no milk")
-        assert not _has_pattern(matches, "NO_EXIT")
-
-
-# ── SELF_NULLIFY ─────────────────────────────────────────────────
-
-class TestSelfNullify:
-
-    def test_i_am_nothing(self):
-        """'I am nothing' -> SELF_NULLIFY."""
-        matches = _detect("I am nothing")
-        assert _has_pattern(matches, "SELF_NULLIFY")
-
-    def test_i_am_worthless(self):
-        """'I am worthless' -> SELF_NULLIFY."""
-        matches = _detect("I am worthless")
-        assert _has_pattern(matches, "SELF_NULLIFY")
-
-    def test_i_am_tired_safe(self):
-        """'I am tired' -- 'tired' is not a null word."""
-        matches = _detect("I am tired")
-        assert not _has_pattern(matches, "SELF_NULLIFY")
-
-
-# ── CHOPPER_SPLIT ────────────────────────────────────────────────
-
-class TestChopperSplit:
-
-    def test_but_splits(self):
-        """'I was fine but now everything hurts' -> CHOPPER_SPLIT."""
-        matches = _detect("I was fine but now everything hurts")
-        assert _has_pattern(matches, "CHOPPER_SPLIT")
-
-    def test_however_splits(self):
-        """'things were good however it changed' -> CHOPPER_SPLIT."""
-        matches = _detect("things were good however it changed")
-        assert _has_pattern(matches, "CHOPPER_SPLIT")
-
-
-# ── SAFE sentences should NOT flag crisis patterns ───────────────
-
-class TestSafeSentences:
-    """These everyday sentences must NOT trigger crisis patterns."""
-
-    CRISIS_PATTERNS = {
-        "FAREWELL", "METHOD_ACQUISITION", "BLANKET_APOLOGY",
-        "SELF_REMOVAL", "SUSPICIOUS_CALM", "EXHAUSTION",
-        "NO_EXIT", "SELF_NULLIFY",
-    }
-
-    def _assert_no_crisis(self, sentence):
-        matches = _detect(sentence)
-        crisis_found = [
-            m.pattern for m in matches if m.pattern in self.CRISIS_PATTERNS
-        ]
-        assert not crisis_found, (
-            f"'{sentence}' falsely flagged: {crisis_found}"
-        )
-
-    def test_bad_day(self):
-        self._assert_no_crisis("im having a bad day")
-
-    def test_work_stressful(self):
-        self._assert_no_crisis("work was stressful")
-
-    def test_mondays_suck(self):
-        self._assert_no_crisis("mondays suck")
-
-    def test_traffic_was_terrible(self):
-        self._assert_no_crisis("traffic was terrible today")
-
-    def test_need_coffee(self):
-        self._assert_no_crisis("I need more coffee")
-
-    def test_forgot_lunch(self):
-        self._assert_no_crisis("I forgot my lunch at home")
-
-
-# ── StructureMatch dataclass ─────────────────────────────────────
-
-class TestStructureMatch:
-
-    def test_has_required_fields(self):
-        m = StructureMatch(
-            pattern="TEST",
-            confidence=0.8,
-            matched_indices=[0, 1],
-            description="test match",
-        )
-        assert m.pattern == "TEST"
-        assert m.confidence == 0.8
-        assert m.v_weight == 0.0  # default
-
-    def test_weight_fields(self):
-        m = StructureMatch(
-            pattern="TEST",
-            confidence=0.8,
-            matched_indices=[0],
-            description="test",
-            v_weight=-30.0,
-            d_weight=-20.0,
-            u_weight=40.0,
-            g_weight=50.0,
-        )
-        assert m.v_weight == -30.0
-        assert m.g_weight == 50.0
-
-
-# ── ATMOSPHERIC_GRIEF ───────────────────────────────────────────
-
-class TestAtmosphericGrief:
-
-    def test_his_chair_still_at_table(self):
-        """'his chair is still at the table' -> ATMOSPHERIC_GRIEF."""
-        matches = _detect("his chair is still at the table")
-        assert _has_pattern(matches, "ATMOSPHERIC_GRIEF")
-
-    def test_found_her_necklace(self):
-        """'i found her necklace in the drawer' -> ATMOSPHERIC_GRIEF."""
-        matches = _detect("i found her necklace in the drawer")
-        assert _has_pattern(matches, "ATMOSPHERIC_GRIEF")
-
-    def test_coffee_mug_hasnt_moved(self):
-        """'the coffee mug hasnt moved' -> ATMOSPHERIC_GRIEF."""
-        matches = _detect("the coffee mug hasnt moved")
-        assert _has_pattern(matches, "ATMOSPHERIC_GRIEF")
-
-    def test_no_trigger_comfortable_chair(self):
-        """'his chair is comfortable' -- no absence/persistence, NOT atmospheric grief."""
-        matches = _detect("his chair is comfortable")
-        assert not _has_pattern(matches, "ATMOSPHERIC_GRIEF")
-
-    def test_no_trigger_active_possessor(self):
-        """'she sat in her chair' -- person is active, NOT atmospheric grief."""
-        matches = _detect("she sat in her chair")
-        assert not _has_pattern(matches, "ATMOSPHERIC_GRIEF")
-
-    def test_grief_score_negative_v(self):
-        """Atmospheric grief should push V below center (128)."""
-        matches = _detect("his chair is still at the table")
-        m = _get_pattern(matches, "ATMOSPHERIC_GRIEF")
-        assert m is not None
-        assert m.v_weight < 0, "V weight should be negative (grief)"
-        assert m.g_weight > 0, "G weight should be positive (heavy)"
-        assert m.d_weight < 0, "D weight should be negative (helpless)"
-
-
-# ── CONTRADICTION_RESOLVE ──────────────────────────────────────
-
-class TestContradictionResolve:
-
-    def test_painfully_beautiful(self):
-        """'painfully beautiful' -> adjective head governs, positive."""
-        matches = _detect("painfully beautiful")
-        assert _has_pattern(matches, "CONTRADICTION_RESOLVE")
-        m = _get_pattern(matches, "CONTRADICTION_RESOLVE")
-        assert m.v_weight > 0, "Adjective head should make V positive"
-
-    def test_hate_love(self):
-        """'i hate how much i love you' -> main verb hate dominates."""
-        matches = _detect("i hate how much i love you")
-        assert _has_pattern(matches, "CONTRADICTION_RESOLVE")
-        m = _get_pattern(matches, "CONTRADICTION_RESOLVE")
-        assert m.v_weight < 0, "Main verb 'hate' should dominate -> negative"
-
-    def test_sweet_revenge(self):
-        """'sweet revenge' -> noun head governs, negative."""
-        matches = _detect("sweet revenge")
-        assert _has_pattern(matches, "CONTRADICTION_RESOLVE")
-        m = _get_pattern(matches, "CONTRADICTION_RESOLVE")
-        assert m.v_weight < 0, "Noun head 'revenge' should make V negative"
-
-    def test_hurts_so_good(self):
-        """'it hurts so good' -> complement overrides verb, positive."""
-        matches = _detect("it hurts so good")
-        assert _has_pattern(matches, "CONTRADICTION_RESOLVE")
-        m = _get_pattern(matches, "CONTRADICTION_RESOLVE")
-        assert m.v_weight > 0, "Qualifying complement 'so good' should override"
-
-    def test_no_trigger_on_plain_positive(self):
-        """'really beautiful' -> no contradiction, no trigger."""
-        matches = _detect("really beautiful")
-        assert not _has_pattern(matches, "CONTRADICTION_RESOLVE")
-
-    def test_no_trigger_on_plain_negative(self):
-        """'absolutely terrible' -> no contradiction, no trigger."""
-        matches = _detect("absolutely terrible")
-        assert not _has_pattern(matches, "CONTRADICTION_RESOLVE")
-
-
-# ── NUMBERS_CONTEXT ────────────────────────────────────────────
-
-class TestNumbersContext:
-
-    def test_sleep_deprivation(self):
-        """'i only slept 3 hours' -> sleep deprivation detected."""
-        matches = _detect("i only slept 3 hours")
-        assert _has_pattern(matches, "NUMBERS_CONTEXT")
-        m = _get_pattern(matches, "NUMBERS_CONTEXT")
-        assert m.v_weight < 0, "Sleep deprivation should be negative"
-
-    def test_only_one_at_birthday(self):
-        """'only one person came to my birthday' -> social isolation."""
-        matches = _detect("only one person came to my birthday")
-        assert _has_pattern(matches, "NUMBERS_CONTEXT")
-        m = _get_pattern(matches, "NUMBERS_CONTEXT")
-        assert m.v_weight < 0
-
-    def test_no_one_at_party(self):
-        """'no one came to my party' -> social isolation."""
-        matches = _detect("no one came to my party")
-        assert _has_pattern(matches, "NUMBERS_CONTEXT")
-        m = _get_pattern(matches, "NUMBERS_CONTEXT")
-        assert m.v_weight < 0
-
-    def test_no_trigger_normal_sleep(self):
-        """'i slept 8 hours' -> no deprivation signal."""
-        matches = _detect("i slept 8 hours")
-        assert not _has_pattern(matches, "NUMBERS_CONTEXT")
-
-    def test_no_trigger_everyone_at_party(self):
-        """'everyone came to my party' -> no isolation."""
-        matches = _detect("everyone came to my party")
-        assert not _has_pattern(matches, "NUMBERS_CONTEXT")
-
-
-# ── NEGATED_NEGATIVE_COMPLIMENT ────────────────────────────────
-
-class TestNegatedNegativeCompliment:
-
-    def test_without_you(self):
-        """'i couldnt have done it without you' -> positive compliment."""
-        matches = _detect("i couldnt have done it without you")
-        assert _has_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        m = _get_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        assert m.v_weight > 0, "Double negation should be positive"
-
-    def test_reason_didnt_give_up(self):
-        """'youre the reason i didnt give up' -> positive compliment."""
-        matches = _detect("youre the reason i didnt give up")
-        assert _has_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        m = _get_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        assert m.v_weight > 0
-
-    def test_cant_thank_enough(self):
-        """'i cant thank you enough' -> positive compliment."""
-        matches = _detect("i cant thank you enough")
-        assert _has_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        m = _get_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-        assert m.v_weight > 0
-
-    def test_wouldnt_be_here_without_you(self):
-        """'i wouldnt be here without you' -> positive compliment."""
-        matches = _detect("i wouldnt be here without you")
-        assert _has_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-
-    def test_no_trigger_plain_negation(self):
-        """'i dont like you' -> not a compliment."""
-        matches = _detect("i dont like you")
-        assert not _has_pattern(matches, "NEGATED_NEGATIVE_COMPLIMENT")
-
-
-# ── RECOVERY_SMALL_WIN ─────────────────────────────────────────
-
-class TestRecoverySmallWin:
-
-    def test_got_out_of_bed_today(self):
-        """'i got out of bed today' -> recovery milestone."""
-        matches = _detect("i got out of bed today")
-        assert _has_pattern(matches, "RECOVERY_SMALL_WIN")
-        m = _get_pattern(matches, "RECOVERY_SMALL_WIN")
-        assert m.v_weight > 0, "Small win should be positive"
-        assert m.w_weight > 0, "Small win should boost self-worth"
-
-    def test_ate_a_full_meal(self):
-        """'i ate a full meal' -> recovery signal."""
-        matches = _detect("i ate a full meal")
-        assert _has_pattern(matches, "RECOVERY_SMALL_WIN")
-
-    def test_finally_took_a_shower(self):
-        """'i finally took a shower' -> small win with temporal marker."""
-        matches = _detect("i finally took a shower")
-        assert _has_pattern(matches, "RECOVERY_SMALL_WIN")
-        m = _get_pattern(matches, "RECOVERY_SMALL_WIN")
-        assert m.confidence >= 0.85, "Temporal marker should boost confidence"
-
-    def test_went_outside_first_time(self):
-        """'i went outside for the first time' -> recovery milestone."""
-        matches = _detect("i went outside for the first time")
-        assert _has_pattern(matches, "RECOVERY_SMALL_WIN")
-
-    def test_no_trigger_mundane_no_context(self):
-        """'the shower is broken' -> no recovery signal without self-ref/temporal."""
-        matches = _detect("the shower is broken")
-        assert not _has_pattern(matches, "RECOVERY_SMALL_WIN")
-
-    def test_no_trigger_normal_routine(self):
-        """'i need some coffee' -> not a recovery win."""
-        matches = _detect("i need some coffee")
-        assert not _has_pattern(matches, "RECOVERY_SMALL_WIN")
-
-
-# ── MUNDANE_HYPERBOLE ────────────────────────────────────────────
-
-class TestMundaneHyperbole:
-
-    def test_oov_token_does_not_trigger(self):
-        """'i still have his number saved' -- 'number' is OOV; an unknown
-        token is not evidence of mundane context. MUNDANE_HYPERBOLE must
-        not fire and cancel the grief reading."""
-        matches = _detect("i still have his number saved")
-        assert not _has_pattern(matches, "MUNDANE_HYPERBOLE")
-        assert _has_pattern(matches, "PERSISTENT_ABSENCE")
-
-    def test_masking_cofire_suppresses_mundane(self):
-        """'im tired of pretending im okay' -- MASKING (crisis-tier) fires;
-        MUNDANE_HYPERBOLE must yield. A mundane reading and a crisis
-        reading cannot both be right."""
-        matches = _detect("im tired of pretending im okay")
-        assert _has_pattern(matches, "MASKING")
-        assert not _has_pattern(matches, "MUNDANE_HYPERBOLE")
-
-    def test_finality_cofire_suppresses_mundane(self):
-        """'i never got to say goodbye to my brother' -- FINALITY
-        (crisis-tier) fires; MUNDANE_HYPERBOLE must not cancel it."""
-        matches = _detect("i never got to say goodbye to my brother")
-        assert _has_pattern(matches, "FINALITY")
-        assert not _has_pattern(matches, "MUNDANE_HYPERBOLE")
-
-    def test_genuine_mundane_hyperbole_still_fires(self):
-        """'this homework is killing me' -- the canonical mundane
-        hyperbole must still be defused."""
-        matches = _detect("this homework is killing me")
-        assert _has_pattern(matches, "MUNDANE_HYPERBOLE")
-
-    def test_traffic_complaint_still_fires(self):
-        """'i want to die this traffic is insane' -- complaint, not crisis."""
-        matches = _detect("i want to die this traffic is insane")
-        assert _has_pattern(matches, "MUNDANE_HYPERBOLE")
-
-
-# ── Governor heartbeat fixes (2026-06-11) ────────────────────────
-# Three misfires from a live masked-collapse conversation:
-#   1. hedge over-fire: "i guess" alone inverted mild positives into
-#      PASSIVE_RESIGNATION
-#   2. masking miss: "im fine dont worry about it" read POSITIVE
-#   3. DIVESTITURE silent on "giving my stuff away" particle order
-
-class TestHedgeDamping:
-    """'i guess/suppose' alone damps positivity -- it is NOT resignation."""
-
-    def test_hedge_only_does_not_fire_resignation(self):
-        """Mildly deflated assessments with a trailing hedge must not
-        read as passive resignation."""
-        for text in (
-            "work was fine today i guess",
-            "the movie was okay i guess",
-            "it went alright i suppose",
-            "dinner was decent i guess",
-        ):
-            matches = _detect(text)
-            assert not _has_pattern(matches, "PASSIVE_RESIGNATION"), \
-                f"PASSIVE_RESIGNATION over-fired on hedge-only: {text!r}"
-            assert _has_pattern(matches, "HEDGED_ASSESSMENT"), \
-                f"HEDGED_ASSESSMENT should damp: {text!r}"
-
-    def test_hedge_only_v_lands_mild_neutral(self):
-        """Hedged positive must land mild-neutral, not collapse-grade."""
-        from engine.pendulum import compute_vadug
-        for text in (
-            "work was fine today i guess",
-            "the movie was okay i guess",
-            "it went alright i suppose",
-        ):
-            r, _ = compute_vadug(text)
-            assert 100 <= r.v <= 135, \
-                f"V={r.v} should be mild-neutral for hedged positive: {text!r}"
-
-    def test_hedge_with_resignation_evidence_still_fires(self):
-        """Hedge + genuine resignation signal must still fire."""
-        for text in (
-            "i guess i deserved it",
-            "i suppose youre right",
-            "i guess nothing matters anymore",
-            "i guess some people just dont get it",
-        ):
-            matches = _detect(text)
-            assert _has_pattern(matches, "PASSIVE_RESIGNATION"), \
-                f"PASSIVE_RESIGNATION should fire with evidence: {text!r}"
-
-    def test_explicit_surrender_fires(self):
-        """First-person surrender verbs are resignation, hedge or not."""
-        for text in ("whatever happens happens i give up", "i give up", "i quit"):
-            matches = _detect(text)
-            assert _has_pattern(matches, "PASSIVE_RESIGNATION"), \
-                f"PASSIVE_RESIGNATION should fire on surrender: {text!r}"
-
-    def test_negated_surrender_is_perseverance(self):
-        """Negated give-up is perseverance and must not fire."""
-        for text in (
-            "she didnt give up on me",
-            "i wont give up on this",
-            "never give up on your dreams",
-        ):
-            matches = _detect(text)
-            assert not _has_pattern(matches, "PASSIVE_RESIGNATION"), \
-                f"PASSIVE_RESIGNATION misfired on perseverance: {text!r}"
-
-
-class TestMaskingDeflection:
-    """Self-status claim + dismissive deflection = MASKING, not reassurance."""
-
-    def test_claim_plus_deflection_fires_masking(self):
-        for text in (
-            "im fine dont worry about it",
-            "im okay seriously dont worry",
-            "its nothing forget about it",
-            "im good it doesnt matter",
-            "im fine just drop it",
-        ):
-            matches = _detect(text)
-            assert _has_pattern(matches, "MASKING"), \
-                f"MASKING should fire on claim+deflection: {text!r}"
-
-    def test_claim_plus_deflection_reads_uneasy(self):
-        """V must land uneasy (below neutral), W must dip -- the deflection
-        is masking evidence, not reassurance."""
-        from engine.pendulum import compute_vadug
-        r, _ = compute_vadug("im fine dont worry about it")
-        assert 70 <= r.v <= 115, f"V={r.v} should be uneasy"
-        assert r.w < 128, f"W={r.w} should dip below neutral"
-
-    def test_helper_reassurance_does_not_fire_masking(self):
-        """Reassurance directed at someone else has no self-status claim."""
-        for text in (
-            "dont worry ill handle it",
-            "dont worry youll do great",
-            "forget it ill take care of everything",
-        ):
-            matches = _detect(text)
-            assert not _has_pattern(matches, "MASKING"), \
-                f"MASKING misfired on helper reassurance: {text!r}"
-
-    def test_negated_emotion_is_not_victimization(self):
-        """'dont worry' is a negated emotion -- not an act done to the
-        user. VICTIMIZATION must not fire on it."""
-        for text in ("im fine dont worry about it", "dont worry ill handle it"):
-            matches = _detect(text)
-            assert not _has_pattern(matches, "VICTIMIZATION"), \
-                f"VICTIMIZATION misfired on negated emotion: {text!r}"
-
-
-class TestDivestitureParticleOrder:
-    """DIVESTITURE must catch both particle orders and progressive/perfect."""
-
-    def test_divestiture_fires_both_particle_orders(self):
-        for text in (
-            "ive been giving my stuff away",
-            "i gave away my records yesterday",
-            "been giving my things away lately",
-            "im giving away all my stuff",
-        ):
-            matches = _detect(text)
-            assert _has_pattern(matches, "DIVESTITURE"), \
-                f"DIVESTITURE should fire: {text!r}"
-
-    def test_divestiture_benign_does_not_fire(self):
-        """No first-person possession = no crisis signal."""
-        for text in (
-            "giving away free samples",
-            "the store is giving away prizes",
-            "giving away the bride",
-            "they are giving away tickets at the door",
-        ):
-            matches = _detect(text)
-            assert not _has_pattern(matches, "DIVESTITURE"), \
-                f"DIVESTITURE misfired on benign giveaway: {text!r}"

engine/tests/test_w_channel.py

@@ -1,84 +0,0 @@
-"""Board 2: W (self-worth) attribution routing + I (intent) agency axis.
-
-W is valence routed through WHO it lands on:
-  - self-declarative ("i am worthless")           -> full attribution, W drops hard
-  - emotional force targeting self ("he told me") -> strong attribution
-  - self as actor of negative act (guilt)         -> partial attribution, W dips
-  - atmospheric / other-directed                  -> no attribution, W stable
-
-I gains an agency axis on top of the directional (withdraw/connect/control)
-logic: volition markers lift I, futility markers sink it.
-"""
-
-import pytest
-
-from engine.pendulum import compute_vadug
-
-
-def _vadug(text):
-    result, _ = compute_vadug(text)
-    return result
-
-
-class TestWAttribution:
-    def test_self_declarative_drops_w_hard(self):
-        """SELF as subject + emotional predicate = full attribution."""
-        r = _vadug("i am worthless")
-        assert r.w < 80, f"W={r.w} should drop hard for self-declaration"
-
-    def test_target_self_drops_w(self):
-        """Emotional force whose target is self lands on W."""
-        r = _vadug("he told me im nothing")
-        assert r.w < 100, f"W={r.w} should drop when self is the target"
-
-    def test_atmospheric_w_stable(self):
-        """Other-directed/atmospheric forces say nothing about MY worth."""
-        r = _vadug("the weather is awful")
-        assert r.w >= 110, f"W={r.w} should stay stable for atmospheric negativity"
-        r2 = _vadug("they announced layoffs")
-        assert r2.w >= 110, f"W={r2.w} should stay stable for other-directed news"
-
-    def test_guilt_partial_attribution(self):
-        """Self harming another dips W, but far less than self-declaration."""
-        guilt = _vadug("i hurt her badly")
-        declarative = _vadug("i am worthless")
-        assert guilt.w < 128, f"W={guilt.w} should dip below neutral for guilt"
-        assert guilt.w >= 95, f"W={guilt.w} should not collapse for guilt"
-        assert guilt.w > declarative.w, (
-            f"guilt W={guilt.w} must stay above self-declarative W={declarative.w}"
-        )
-
-    def test_masked_collapse_reads_low_w(self):
-        """Crisis patterns with damaged self-worth push W into the 80-100 band."""
-        for text in (
-            "cant do this shit anymore",
-            "theres no way out",
-            "i just want it to be over",
-            "i stopped making plans because whats the point",
-        ):
-            r = _vadug(text)
-            assert r.w <= 100, f"W={r.w} should be <= 100 for: {text!r}"
-
-
-class TestIntentAgency:
-    def test_agency_raises_intent(self):
-        """Volition marker + action verb lifts I toward control."""
-        for text in ("im going to fix this tomorrow", "i need to finish this project"):
-            r = _vadug(text)
-            assert r.i >= 160, f"I={r.i} should be >= 160 for agency: {text!r}"
-
-    def test_futility_drops_intent(self):
-        """Powerlessness/futility markers sink I toward deflect."""
-        for text in ("whats the point", "i give up", "why bother trying"):
-            r = _vadug(text)
-            assert r.i <= 80, f"I={r.i} should be <= 80 for futility: {text!r}"
-
-    def test_agency_travel_not_boosted(self):
-        """'im going to the store' is travel, not agency."""
-        r = _vadug("im going to the store")
-        assert r.i < 160, f"I={r.i} should stay neutral for destinations"
-
-    def test_negated_give_up_not_futility(self):
-        """'didnt give up' is perseverance — must not sink I."""
-        r = _vadug("she didnt give up on me")
-        assert r.i > 64, f"I={r.i} should not read negated give-up as futility"

engine/tests/test_word_classifier.py

@@ -1,166 +0,0 @@
-"""Tests for V3 Layer 1: Word Role Classifier."""
-
-import pytest
-import sys
-import os
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
-
-from engine.word_classifier import classify_sentence, classify_word, WordRole
-
-
-class TestBasicRoles:
-    def test_self_reference(self):
-        roles = classify_sentence(["I", "am", "happy"])
-        assert roles[0].role == "SELF_REF"
-
-    def test_emotional_word(self):
-        roles = classify_sentence(["I", "am", "happy"])
-        assert roles[2].role == "EMOTIONAL"
-        assert roles[2].force is not None
-        assert roles[2].force[0] > 0  # happy = positive V
-
-    def test_negator(self):
-        roles = classify_sentence(["I", "am", "not", "happy"])
-        assert roles[2].role == "NEGATOR"
-
-    def test_amplifier(self):
-        roles = classify_sentence(["I", "am", "very", "happy"])
-        assert roles[2].role == "AMPLIFIER"
-
-    def test_transfer(self):
-        roles = classify_sentence(["I", "gave", "my", "dog", "to", "neighbor"])
-        assert roles[1].role == "TRANSFER"
-        assert roles[3].role == "RELATION_REF"  # dog is relationship
-        assert roles[5].role == "RELATION_REF"
-
-    def test_method(self):
-        roles = classify_sentence(["bought", "a", "bunch", "of", "pills"])
-        assert roles[0].role == "ACQUIRE"
-        assert roles[4].role == "METHOD"
-
-    def test_finality(self):
-        roles = classify_sentence(["this", "is", "the", "last", "time"])
-        assert roles[3].role == "FINALITY"
-
-
-class TestPositionOverrides:
-    def test_give_hug_not_transfer(self):
-        """'give me a hug' — give is still TRANSFER but context matters at structure level."""
-        roles = classify_sentence(["give", "me", "a", "hug"])
-        assert roles[0].role == "TRANSFER"
-        # Structure detector (Task 3) will see TRANSFER + no POSSESSION = not farewell
-
-    def test_fine_after_self(self):
-        roles = classify_sentence(["im", "fine"])
-        assert roles[1].role == "PEACE"
-
-    def test_fine_without_self_ref(self):
-        """'fine' not after SELF_REF should stay in its base role."""
-        roles = classify_sentence(["that", "is", "fine"])
-        # "fine" is in PEACE set, so it's PEACE regardless — position override
-        # only matters if it could be EMOTIONAL vs PEACE
-        assert roles[2].role == "PEACE"
-
-    def test_chopper(self):
-        roles = classify_sentence(["I", "love", "you", "but", "im", "leaving"])
-        assert roles[3].role == "CHOPPER"
-
-    def test_still_is_temporal(self):
-        """'still' is always TEMPORAL — freshness/persistence marker."""
-        roles = classify_sentence(["I", "still", "feel", "bad"])
-        assert roles[1].role == "TEMPORAL"
-
-    def test_never_is_negator(self):
-        """'never' should be NEGATOR, not TEMPORAL."""
-        roles = classify_sentence(["I", "never", "said", "that"])
-        assert roles[1].role == "NEGATOR"
-
-    def test_just_before_acquire_is_temporal(self):
-        """'just bought' = recently acquired → TEMPORAL."""
-        roles = classify_sentence(["I", "just", "bought", "a", "car"])
-        assert roles[1].role == "TEMPORAL"
-        assert roles[2].role == "ACQUIRE"
-
-    def test_just_is_compressor(self):
-        """'just' = COMPRESSOR — squeezes magnitude of nearby words."""
-        roles = classify_sentence(["I", "just", "want", "to", "sleep"])
-        assert roles[1].role == "COMPRESSOR"
-
-
-class TestNeighbors:
-    def test_neighbors_filled(self):
-        roles = classify_sentence(["I", "am", "happy"])
-        assert roles[0].neighbors == (None, "NEUTRAL")     # I: no left, "am" right
-        assert roles[1].neighbors == ("SELF_REF", "EMOTIONAL")  # am: I left, happy right
-        assert roles[2].neighbors == ("NEUTRAL", None)      # happy: am left, no right
-
-    def test_single_word(self):
-        roles = classify_sentence(["happy"])
-        assert roles[0].neighbors == (None, None)
-
-    def test_two_words(self):
-        roles = classify_sentence(["very", "happy"])
-        assert roles[0].neighbors == (None, "EMOTIONAL")
-        assert roles[1].neighbors == ("AMPLIFIER", None)
-
-
-class TestAmplifiers:
-    def test_fucking_is_amplifier(self):
-        """'fucking' is a 1.6x spice word amplifier."""
-        roles = classify_sentence(["thats", "fucking", "amazing"])
-        assert roles[1].role == "AMPLIFIER"
-
-    def test_honestly_is_filler(self):
-        """'honestly' is a glass breaker — classified as FILLER (processing marker)."""
-        roles = classify_sentence(["honestly", "this", "sucks"])
-        assert roles[0].role == "FILLER"
-
-    def test_so_is_amplifier(self):
-        """'so' before emotional word = AMPLIFIER."""
-        roles = classify_sentence(["im", "so", "happy"])
-        assert roles[1].role == "AMPLIFIER"
-
-
-class TestEdgeCases:
-    def test_empty_sentence(self):
-        roles = classify_sentence([])
-        assert roles == []
-
-    def test_all_neutral(self):
-        roles = classify_sentence(["the", "a", "is"])
-        for r in roles:
-            assert r.role == "NEUTRAL"
-
-    def test_emotional_from_vocabulary(self):
-        """Words not in any role set but in VOCABULARY with |dV| > 15 = EMOTIONAL."""
-        roles = classify_sentence(["I", "am", "sad"])
-        # "sad" is not in any role set, but is in VOCABULARY with big dV
-        assert roles[2].role == "EMOTIONAL"
-        assert roles[2].force is not None
-        assert roles[2].force[0] < 0  # sad = negative V
-
-    def test_hedge_words(self):
-        roles = classify_sentence(["maybe", "I", "should"])
-        assert roles[0].role == "HEDGE"
-
-    def test_relation_ref(self):
-        roles = classify_sentence(["my", "mom", "is", "angry"])
-        assert roles[0].role == "SELF_REF"
-        assert roles[1].role == "RELATION_REF"
-
-    def test_word_role_dataclass(self):
-        """WordRole stores all expected fields."""
-        roles = classify_sentence(["I", "am", "happy"])
-        r = roles[0]
-        assert r.word == "i"
-        assert r.role == "SELF_REF"
-        assert r.base_role == "SELF_REF"
-        assert r.position == 0
-        assert r.force is None  # SELF_REF has no force
-
-    def test_punctuation_stripped(self):
-        """Punctuation should not affect classification."""
-        roles = classify_sentence(["I'm", "fine!"])
-        assert roles[0].role == "SELF_REF"
-        assert roles[1].role == "PEACE"

requirements.txt

@@ -1,5 +1,5 @@
 fastapi==0.115.*
 uvicorn[standard]==0.30.*
-clanker-soul
+clanker-soul @ git+https://github.com/deucebucket/clanker-soul.git
 httpx==0.27.*
 pytest==8.*

scripts/sync_engine.sh

@@ -6,4 +6,5 @@ DST="$(cd "$(dirname "$0")/.." && pwd)/engine"
 rm -rf "$DST"
 cp -r "$SRC" "$DST"
 find "$DST" -name '__pycache__' -type d -prune -exec rm -rf {} +
+rm -rf "$DST/tests"
 echo "vendored engine -> $DST"