interim commit-v3

witgym/conversation.py

@@ -2,7 +2,7 @@
 from typing import List, Tuple, Set
 from loguru import logger
 from witgym import config
-from witgym.schemas import ComedyArchetype
+from witgym.schemas import ComedyArchetype, ComedyMetadata
 
 COMPRESS_PROMPT = """\
 Summarise the following conversation into a compact factual paragraph (max 100 words).
@@ -20,20 +20,29 @@ class ConversationManager:
         self.history: List[Tuple[str, str]] = []   # (user, assistant)
         self.used_archetypes: Set[ComedyArchetype] = set()
         self._summary: str = ""  # Compressed summary of old turns
+        self._mechanisms: List[Tuple[str, str, str]] = []  # (archetype, tension, distance)
 
-    def add_turn(self, user_input: str, response: str, archetype: ComedyArchetype):
+    def add_turn(self, user_input: str, response: str, metadata: ComedyMetadata):
         self.history.append((user_input, response))
-        self.used_archetypes.add(archetype)
+        self.used_archetypes.add(metadata.archetype)
+        self._mechanisms.append((
+            metadata.archetype.value,
+            metadata.tension_type.value,
+            metadata.violation_distance.value,
+        ))
 
     def get_context_string(self) -> str:
-        """Return the last N turns as formatted string, prefixed with summary if compressed."""
-        recent = self.history[-config.KEEP_LAST_N_TURNS:]
+        """Return the last N turns as mechanism-only context.
+
+        Structural goal: preserve callback potential (what kind of jokes were made),
+        while avoiding lexical bleed from raw user/assistant text across turns.
+        """
+        recent = self._mechanisms[-config.KEEP_LAST_N_TURNS:]
         lines = []
         if self._summary:
             lines.append(f"[Earlier conversation summary]: {self._summary}")
-        for user, assistant in recent:
-            lines.append(f"User: {user}")
-            lines.append(f"WitGym: {assistant}")
+        for i, (arch, tension, dist) in enumerate(recent, 1):
+            lines.append(f"Turn -{len(recent) - i + 1}: archetype={arch}, tension={tension}, distance={dist}")
         return "\n".join(lines)
 
     def needs_compression(self, tokenizer) -> bool:

witgym/engine.py

@@ -50,7 +50,7 @@ class WitGymEngine:
         if metadata.twist_potential < 4:
             logger.info(f"twist_potential={metadata.twist_potential} < 4 — returning straight reply")
             selected = "Yeah, that tracks."
-            self.conversation.add_turn(user_input, selected, metadata.archetype)
+            self.conversation.add_turn(user_input, selected, metadata)
             return WitGymResponse(
                 metadata=metadata,
                 retrieved_scenes=[],
@@ -68,12 +68,12 @@ class WitGymEngine:
 
         # PASS 2 — Generate persona candidates.
         # Medium inputs (4-6): run cynic + absurdist only.
-        # Rich inputs (> 6): run all three including frame_switcher.
+        # Rich inputs (> 6): run all three including conviction.
         context_str = self.conversation.get_context_string()
         personas_to_run = None  # None = all three
         if metadata.twist_potential <= 6:
-            personas_to_run = ["cynic", "absurdist"]  # Frame switcher needs rich tension
-            logger.info(f"twist_potential={metadata.twist_potential} ≤ 6 — skipping frame_switcher")
+            personas_to_run = ["cynic", "absurdist"]  # Conviction needs richer tension to land cleanly
+            logger.info(f"twist_potential={metadata.twist_potential} ≤ 6 — skipping conviction")
 
         candidates = generate_candidates(
             user_input, metadata, scenes,
@@ -92,7 +92,7 @@ class WitGymEngine:
         selected = _cap_two_sentences(selected)
 
         # Update state
-        self.conversation.add_turn(user_input, selected, metadata.archetype)
+        self.conversation.add_turn(user_input, selected, metadata)
 
         return WitGymResponse(
             metadata=metadata,

witgym/extractor.py

@@ -23,6 +23,14 @@ Return ONLY a JSON object with these exact fields (no explanation, no markdown,
 }}
 
 Think carefully about the ARCHETYPE — pick the one that most accurately describes the comedy mechanism hiding in this input.
+Archetype selection guidance (avoid overusing self_delusion):
+- status_assertion: claiming authority/status/rightness as if saying it makes it true
+- misplaced_conf: confident competence claim immediately unsupported by reality
+- anxiety_escalation: small trigger spun into catastrophe / inevitable doom logic
+- social_fail: awkward performance, norm violation, cringe, saying the wrong thing at the wrong time
+- power_inversion: low-status person is the only honest/correct one, or social power overrides institutional power
+- self_delusion: specifically a self-image story ("I'm fine / I'm great / I'm the best") contradicted by behavior/evidence in the same moment
+If unsure between self_delusion vs social_fail/anxiety_escalation, prefer the more specific one (social_fail/anxiety_escalation) unless there is an explicit self-image contradiction.
 For twist_potential: score high if the input has self-delusion, status gap, or absurd logic. Score low if it is a neutral factual statement with no tension.
 Return ONLY the JSON. Nothing else."""
 

witgym/generator.py

@@ -20,15 +20,12 @@ PERSONA_INSTRUCTIONS = {
         "Open with the situation, the consequence, or the outcome as your subject — "
         "lead with something concrete and specific, not a generic observation about the person."
     ),
-    "frame_switcher": (
-        "This situation is actually being processed by a completely unrelated formal institution. "
-        "Choose whichever institution maps most absurdly and precisely onto the specific tension in this input — "
-        "a regulatory body, a scientific agency, a legal tribunal, a certification board, an athletic committee, "
-        "or any other formal system whose rules would make this situation absurd. "
-        "Do not list the institution's name as a setup — just speak in its voice directly. "
-        "Check the CONVERSATION CONTEXT: if a prior WitGym response already used a particular institution type, "
-        "pick a different one. "
-        "Report with total conviction, as if this framing is obviously correct."
+    "conviction": (
+        "You have a firm, specific belief about how this situation works. "
+        "State it as established fact with total sincerity. "
+        "Do not hedge. Do not qualify. Do not acknowledge any other interpretation exists. "
+        "The belief should be wrong in a way that exposes something true about the speaker. "
+        "No irony. No wink. Absolute conviction."
     ),
     "absurdist": (
         "You're the only person in the room who sees where this logically ends. "
@@ -256,13 +253,13 @@ def rank_candidates(
 
 
 _COMPRESS_PROMPT = """\
-The following comedy line is good but possibly too long. Compress it to ≤12 words while keeping the punchline completely intact.
+The following comedy line is good but possibly too long. Compress it to ≤18 words while keeping the punchline completely intact.
 
 Original: "{winner}"
 
 Rules:
 - The FINAL CLAUSE of the sentence is almost always the punchline. NEVER cut it. Cut from the setup or the middle only.
-- If the final clause must be removed to hit ≤12 words, return the original UNCHANGED.
+- If the final clause must be removed to hit ≤18 words, return the original UNCHANGED.
 - Do NOT change the joke structure — only remove filler words from the setup.
 - Return ONLY the compressed version or the original. No explanation. No quotes."""
 
@@ -270,10 +267,10 @@ Rules:
 def compress_winner(winner: str, model, tokenizer) -> str:
     """Swartzwelder compression pass: generate loose, cut ruthless.
 
-    Skipped if winner is already ≤12 words (already tight).
+    Skipped if winner is already ≤18 words (already tight).
     Guards: rejects output that is < 4 words or longer than the original.
     """
-    if len(winner.split()) <= 12:
+    if len(winner.split()) <= 18:
         return winner  # Already tight — skip the LLM call
 
     prompt = _COMPRESS_PROMPT.format(winner=winner)
@@ -292,6 +289,19 @@ def compress_winner(winner: str, model, tokenizer) -> str:
         logger.debug(f"Compression rejected (fragment start: '{compressed[:20]}'). Keeping original.")
         return winner
 
+    # Grammar-ish guard: reject "telegraphic" outputs that drop almost all function words.
+    # This is intentionally crude but catches the common failure mode:
+    # "Stared at smoking toaster until fire needs human response registered like software update."
+    _FUNCTION_WORDS = {
+        "a", "an", "the",
+        "to", "of", "for", "in", "on", "at", "with", "as", "by", "from", "into",
+        "like", "than", "then", "that", "which", "because", "until", "while", "since",
+    }
+    words = [w.lower() for w in _re.findall(r"\b\w+\b", compressed)]
+    if len(words) >= 8 and not any(w in _FUNCTION_WORDS for w in words):
+        logger.debug("Compression rejected (telegraphic/no function words). Keeping original.")
+        return winner
+
     logger.info(f"Compressed: {len(winner.split())}w → {len(compressed.split())}w | '{compressed}'")
     return compressed
 

witgym/model.py

@@ -136,8 +136,7 @@ def generate_text(
         )
     elif config_type == "rank":
         gen_kwargs = dict(
-            temperature=config.RANK_TEMP,
-            do_sample=True,
+            do_sample=False,
             max_new_tokens=10,
         )
     else:

witgym/retriever.py

@@ -43,8 +43,14 @@ def retrieve_scenes(
     Over-fetches (top_k * 3) then filters out already-used archetypes to
     prevent repetition across the conversation.
     """
-    # Build query string from comedy metadata — NOT from raw user text
-    query = f"{metadata.archetype.value} {metadata.tension_type.value} {metadata.violation_distance.value}"
+    # Mirror the indexed representation: keep the structural labels, then add
+    # the extracted subtext so the query has semantic detail comparable to setup.
+    query = (
+        f"{metadata.archetype.value} "
+        f"{metadata.tension_type.value} "
+        f"{metadata.violation_distance.value} "
+        f"{metadata.subtext}"
+    )
     logger.debug(f"RAG query: '{query}'")
 
     query_emb = embed_model.encode(