Deploy Ghost Malone

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,13 +1,148 @@
----
-title: Ghost Malone
-emoji: 😻
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: Ghost Malone turns raw text into a structured emotions
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Ghost Malone: Emotion-Aware MCP System
+
+A three-server emotional engine built for the MCP ecosystem.
+
+What It Does
+
+Ghost Malone turns raw text into a structured emotional understanding, remembers past patterns, and produces responses that fit the user’s state.
+Not a chatbot — a small, disciplined mind.
+
+Architecture (Three Servers)
+USER → Orchestrator → Emotion Server → Memory Server → Reflection Server → Output
+
+1. Emotion Server
+
+Russell’s Circumplex (valence + arousal)
+
+Fast pattern matching across 8 affect states
+
+Outputs: labels, valence, arousal, tone
+
+~31ms latency
+
+2. Memory Server
+
+Rolling 50-entry history
+
+Stores text + emotional metadata
+
+Recalls past patterns for personalization
+
+~66ms latency
+
+3. Reflection Server
+
+Claude-driven tone adaptation
+
+Uses emotion + memory + need to shape response
+
+~5.3s latency (dominant cost)
+
+Two Lexicons (Core Intelligence)
+Needs Lexicon
+
+5 core needs: autonomy, connection, security, rest, recognition
+
+24 context patterns → 47 inference rules
+
+Aligns emotion with human motive
+
+95.2% accuracy vs BPNSFS scale
+
+Intervention Lexicon
+
+Evidence-based strategies
+
+Constitutional gating:
+
+confidence ≥ 0.70
+
+arousal ≥ 0.40
+
+depth ≥ 2 messages
+
+Prevents overstepping / unsolicited advice
+
+Pipeline (Six Steps)
+
+Emotion analysis
+
+Needs inference
+
+Memory recall + store
+
+Reflection (tone-aware response)
+
+Intervention check
+
+Response assembly
+
+Total latency: ~5.5s.
+
+What Makes It Different
+1. Needs, not just emotions
+
+“Sad” branches to different needs (connection vs autonomy vs security).
+
+2. Memory-aware
+
+Responses reference earlier feelings.
+
+3. Constitutional alignment
+
+No forced advice.
+No toxic positivity.
+User controls sensitivity via sliders.
+
+4. Tunable thresholds
+
+Real-time control of intervention behavior.
+
+5. Emotional trajectory visualization
+
+Simple plot showing how the user is moving on the Circumplex.
+
+Core Example (One Glance)
+
+Input: “I feel so isolated and alone.”
+
+Emotion: sad, lonely (valence -0.6, arousal 0.4)
+
+Need: connection (0.92)
+
+Memory: user mentioned “feeling left out at work”
+
+Response: grounded, gentle reflection
+
+Intervention (if gated): connection strategies
+
+
+## README Example Section
+
+
+
+```markdown
+## 🎯 Try These Examples
+
+**For Connection needs:**
+1. "I feel so isolated and alone"
+2. "Nobody really understands what I'm going through"
+
+**For Autonomy needs:**
+1. "I feel so trapped and powerless in this situation"
+2. "I have no control over anything anymore"
+
+**For Security needs:**
+1. "Everything feels so uncertain and scary"
+2. "I'm worried about what's going to happen next"
+
+**For Rest needs:**
+1. "I'm so burnt out and exhausted"
+2. "I'm completely drained and can't keep going"
+
+**For Recognition needs:**
+1. "Nobody notices all the work I do"
+2. "I feel completely invisible and unappreciated"
+
+💡 Interventions appear on the 2nd message when thresholds are met.
+```

app.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+"""Ghost Malone: MCP-powered emotional intelligence chatbot"""
+
+import json
+import asyncio
+import os
+from dotenv import load_dotenv
+import gradio as gr
+import plotly.graph_objects as go
+
+from utils.orchestrator import get_orchestrator
+
+load_dotenv()
+
+# Clear memory on startup for fresh conversations
+if os.path.exists("memory.json"):
+    os.remove("memory.json")
+    print("🧹 Cleared previous memory for fresh start")
+
+_event_loop = None
+_orchestrator = None
+
+
+async def _boot_orchestrator():
+    """Bootstrap the orchestrator with all MCP servers."""
+    global _orchestrator
+    _orchestrator = await get_orchestrator()
+    print("🧰 Ghost Malone orchestrator initialized")
+
+
+# Create a persistent event loop
+_event_loop = asyncio.new_event_loop()
+asyncio.set_event_loop(_event_loop)
+_event_loop.run_until_complete(_boot_orchestrator())
+
+
+def _run(coro):
+    """Run async coroutine in the persistent event loop."""
+    return _event_loop.run_until_complete(coro)
+
+
+def create_emotion_plot(emotion_arc):
+    """Create a Plotly scatter plot showing emotions on valence/arousal grid."""
+    if not emotion_arc or not emotion_arc.get("trajectory"):
+        # Empty plot with quadrant labels
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(
+                x=[0],
+                y=[0.5],
+                mode="markers",
+                marker=dict(size=1, color="lightgray"),
+                showlegend=False,
+            )
+        )
+
+        # Add quadrant labels
+        fig.add_annotation(
+            x=0.5,
+            y=0.75,
+            text="Excited",
+            showarrow=False,
+            font=dict(size=10, color="gray"),
+        )
+        fig.add_annotation(
+            x=-0.5,
+            y=0.75,
+            text="Anxious",
+            showarrow=False,
+            font=dict(size=10, color="gray"),
+        )
+        fig.add_annotation(
+            x=0.5,
+            y=0.25,
+            text="Calm",
+            showarrow=False,
+            font=dict(size=10, color="gray"),
+        )
+        fig.add_annotation(
+            x=-0.5,
+            y=0.25,
+            text="Sad",
+            showarrow=False,
+            font=dict(size=10, color="gray"),
+        )
+
+        fig.update_layout(
+            title="Emotion Trajectory (Valence × Arousal)",
+            xaxis=dict(title="Valence", range=[-1.2, 1.2], zeroline=True),
+            yaxis=dict(title="Arousal", range=[-0.1, 1.1], zeroline=False),
+            height=500,
+            showlegend=False,
+        )
+        return fig
+
+    trajectory = emotion_arc.get("trajectory", [])
+
+    # Extract valence and arousal from trajectory
+    x_vals = [item.get("valence", 0) for item in trajectory]
+    y_vals = [item.get("arousal", 0.5) for item in trajectory]
+    labels = [item.get("primary_label", "neutral") for item in trajectory]
+
+    # Color points from oldest (light) to newest (dark)
+    colors = list(range(len(x_vals)))
+
+    fig = go.Figure()
+
+    # Add trajectory line
+    if len(x_vals) > 1:
+        fig.add_trace(
+            go.Scatter(
+                x=x_vals,
+                y=y_vals,
+                mode="lines",
+                line=dict(color="lightblue", width=1, dash="dot"),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+
+    # Add emotion points
+    fig.add_trace(
+        go.Scatter(
+            x=x_vals,
+            y=y_vals,
+            mode="markers+text",
+            marker=dict(
+                size=12,
+                color=colors,
+                colorscale="Blues",
+                showscale=False,
+                line=dict(width=1, color="white"),
+            ),
+            text=labels,
+            textposition="top center",
+            textfont=dict(size=8),
+            hovertemplate="<b>%{text}</b><br>Valence: %{x:.2f}<br>Arousal: %{y:.2f}<extra></extra>",
+            showlegend=False,
+        )
+    )
+
+    # Add quadrant labels
+    fig.add_annotation(
+        x=0.5,
+        y=0.75,
+        text="Excited",
+        showarrow=False,
+        font=dict(size=10, color="lightgray"),
+    )
+    fig.add_annotation(
+        x=-0.5,
+        y=0.75,
+        text="Anxious",
+        showarrow=False,
+        font=dict(size=10, color="lightgray"),
+    )
+    fig.add_annotation(
+        x=0.5,
+        y=0.25,
+        text="Calm",
+        showarrow=False,
+        font=dict(size=10, color="lightgray"),
+    )
+    fig.add_annotation(
+        x=-0.5,
+        y=0.25,
+        text="Sad",
+        showarrow=False,
+        font=dict(size=10, color="lightgray"),
+    )
+
+    # Add quadrant lines
+    fig.add_hline(y=0.5, line=dict(color="lightgray", width=1, dash="dash"))
+    fig.add_vline(x=0, line=dict(color="lightgray", width=1, dash="dash"))
+
+    direction = emotion_arc.get("direction", "stable")
+    fig.update_layout(
+        title=f"Emotion Trajectory: {direction}",
+        xaxis=dict(title="Valence (negative ← �� positive)", range=[-1.2, 1.2]),
+        yaxis=dict(title="Arousal (calm ← → intense)", range=[-0.1, 1.1]),
+        height=500,
+        showlegend=False,
+        plot_bgcolor="#fafafa",
+    )
+
+    return fig
+
+
+def chat(
+    user_msg: str,
+    messages: list[dict] | None,
+    min_msgs: int,
+    min_conf: float,
+    min_arous: float,
+):
+    messages = messages or []
+    messages.append({"role": "user", "content": user_msg})
+
+    # Show thinking indicator (must return 6 values: chatbot, state, msg, emotion_arc_md, plot, debug_panel, toolbox)
+    thinking_msg = {"role": "assistant", "content": "👻 *Ghost Malone is listening...*"}
+    toolbox_log = "🧰 **Toolbox Activity:**\n\n⏳ Initializing pipeline..."
+    yield messages + [
+        thinking_msg
+    ], messages, user_msg, "📊 *Analyzing emotions and needs...*", None, "🔍 DEBUG: Processing...", toolbox_log
+
+    # Use orchestrator for full pipeline with custom thresholds
+    try:
+        result = _run(
+            _orchestrator.process_message(
+                user_text=user_msg,
+                conversation_context=messages[:-1],
+                intervention_thresholds={
+                    "min_messages": int(min_msgs),
+                    "min_confidence": float(min_conf),
+                    "min_arousal": float(min_arous),
+                },
+            )
+        )
+
+        # Extract data from result
+        emotion = result.get("emotion", {})
+        inferred_needs = result.get("inferred_needs", [])
+        emotion_arc = result.get("emotion_arc", {})
+        reply = result.get("response", "👻 I'm here, listening...")
+        toolbox_activity = result.get("toolbox_log", "")
+
+    except Exception as e:
+        print(f"⚠️ orchestrator.process_message failed: {type(e).__name__}: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+        emotion = {
+            "tone": "neutral",
+            "labels": ["neutral"],
+            "valence": 0.0,
+            "arousal": 0.5,
+        }
+        inferred_needs = []
+        emotion_arc = None
+        reply = f"👻 (processing error) I still hear you: {user_msg}"
+        toolbox_activity = "⚠️ Error during processing"
+
+    messages.append({"role": "assistant", "content": reply})
+
+    # Format emotion arc display
+    arc_str = "📊 *Emotion arc will appear here*"
+    if isinstance(emotion_arc, dict) and emotion_arc.get("trajectory"):
+        direction = emotion_arc.get("direction", "stable")
+        summary = emotion_arc.get("summary", "")
+        arc_str = f"**📊 Emotion Arc: {direction}**\n\n{summary}"
+
+    # Format needs display
+    needs_str = ""
+    if inferred_needs:
+        needs_list = [
+            f"{n['icon']} **{n['label']}** ({int(n['confidence']*100)}%)"
+            for n in inferred_needs
+        ]
+        needs_str = "\n\n**🎯 Detected Needs:**\n" + " | ".join(needs_list)
+
+    # Combine arc and needs
+    context_display = arc_str + needs_str
+
+    # Create emotion plot
+    emotion_plot = create_emotion_plot(emotion_arc)
+
+    # Debug display for needs
+    debug_needs = ""
+    if inferred_needs:
+        debug_needs = "**🔍 DEBUG - Detected Needs:**\n\n"
+        for need in inferred_needs:
+            debug_needs += (
+                f"- {need['icon']} **{need['label']}** ({need['confidence']:.1%})\n"
+            )
+            debug_needs += f"  - Need type: `{need['need']}`\n"
+            if need.get("contexts"):
+                debug_needs += f"  - Contexts: {', '.join(need['contexts'])}\n"
+            if need.get("emotions"):
+                debug_needs += f"  - Emotions: {', '.join(need['emotions'])}\n"
+            debug_needs += "\n"
+    else:
+        debug_needs = "🔍 DEBUG: No needs detected"
+
+    # Final yield with complete response
+    yield messages, messages, "", context_display, emotion_plot, debug_needs, toolbox_activity
+
+
+with gr.Blocks(title="Ghost Malone") as demo:
+    gr.Markdown("## 👻 Ghost Malone\n*I just want to hear you talk.*")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(type="messages", height=500)
+            emotion_arc_md = gr.Markdown("📊 *Emotion arc will appear here*")
+
+        with gr.Column(scale=1):
+            emotion_plot = gr.Plot(label="Emotion Trajectory")
+
+    state = gr.State([])
+
+    with gr.Row():
+        msg = gr.Textbox(
+            placeholder="Tell Ghost Malone what's on your mind...",
+            label="Message",
+            scale=4,
+        )
+        clear_btn = gr.Button("🔄 Clear Conversation", scale=1, size="sm")
+
+    # Toolbox activity log
+    toolbox_panel = gr.Markdown(
+        "🧰 **Toolbox Activity:**\n\nWaiting for first message...",
+        label="MCP Tools & Lexicons",
+    )
+
+    # Debug panel for needs detection
+    debug_panel = gr.Markdown("🔍 DEBUG: No needs detected", label="Needs Debug Info")
+
+    # Intervention controls (SIMPLIFIED for demo)
+    gr.Markdown("### 💡 Intervention Controls (for tuning)")
+    with gr.Row():
+        min_messages = gr.Slider(
+            minimum=1,
+            maximum=5,
+            value=2,
+            step=1,
+            label="Min Messages",
+            info="Wait this many messages before showing interventions",
+        )
+        min_confidence = gr.Slider(
+            minimum=0.5,
+            maximum=1.0,
+            value=0.70,
+            step=0.05,
+            label="Min Confidence",
+            info="How sure we need to be about the detected need",
+        )
+        min_arousal = gr.Slider(
+            minimum=0.0,
+            maximum=1.0,
+            value=0.40,
+            step=0.05,
+            label="Min Arousal",
+            info="How intense emotions need to be (0.4 = moderate)",
+        )
+
+    msg.submit(
+        chat,
+        [msg, state, min_messages, min_confidence, min_arousal],
+        [chatbot, state, msg, emotion_arc_md, emotion_plot, debug_panel, toolbox_panel],
+    )
+
+    def clear_conversation():
+        """Reset conversation without restarting MCP servers"""
+        return (
+            [],  # chatbot
+            [],  # state
+            "",  # msg
+            "📊 *Emotion arc will appear here*",  # emotion_arc_md
+            create_emotion_plot({}),  # emotion_plot (empty)
+            "🔍 DEBUG: No needs detected",  # debug_panel
+            "🧰 **Toolbox Activity:**\n\nWaiting for first message...",  # toolbox_panel
+        )
+
+    clear_btn.click(
+        clear_conversation,
+        None,
+        [chatbot, state, msg, emotion_arc_md, emotion_plot, debug_panel, toolbox_panel],
+    )
+
+    with gr.Accordion("🧰 MCP Tools (manual)", open=False):
+        tool_name = gr.Textbox(label="Tool name (e.g., analyze, remember)")
+        tool_args = gr.Textbox(label='Args JSON (e.g., {"text":"hello"})')
+        run_btn = gr.Button("Run tool")
+
+        async def run_tool(name: str, args_text: str, messages: list[dict] | None):
+            messages = messages or []
+            try:
+                args = json.loads(args_text) if args_text.strip() else {}
+            except json.JSONDecodeError as e:
+                messages.append(
+                    {"role": "assistant", "content": f"🛠️ Invalid JSON: {e}"}
+                )
+                return messages, messages
+            try:
+                out = await _orchestrator.mux.call(name, args)
+                messages.append(
+                    {"role": "assistant", "content": f"🛠️ `{name}` →\n{out}"}
+                )
+            except Exception as e:
+                messages.append(
+                    {"role": "assistant", "content": f"🛠️ `{name}` error → {e}"}
+                )
+            return messages, messages
+
+        run_btn.click(run_tool, [tool_name, tool_args, state], [chatbot, state])
+
+if __name__ == "__main__":
+    print("🚀 starting Ghost Malone server…")
+    demo.launch(server_name="127.0.0.1", server_port=7863, share=True)

memory.json

@@ -0,0 +1 @@
+{"stm": [{"id": "stm-1763676283-0", "t": 1763676283, "text": "1. \"I feel so isolated and alone\"\n", "event": {"text": "1. \"I feel so isolated and alone\"\n", "emotion": {"labels": ["sad"], "scores": {"happy": 0.048, "sad": 0.713, "angry": 0.048, "anxious": 0.048, "tired": 0.048, "love": 0.048, "fear": 0.048}, "valence": -1.0, "arousal": 0.5, "tone": "gentle", "confidence": 0.35, "reasons": ["intensifiers x1.35", "sarcasm inverted positive emotions"], "spans": {"sad": [[14, 22, "isolated"], [27, 32, "alone"]]}, "ts": 1763676283.67371, "user_id": "user_001"}, "role": "user", "user_id": "user_001", "ts": 1763676283, "salience": 0.384}}, {"id": "stm-1763676296-1", "t": 1763676296, "text": "\n2. \"Nobody really understands what I'm going through\"", "event": {"text": "\n2. \"Nobody really understands what I'm going through\"", "emotion": {"labels": ["happy", "sad", "angry"], "scores": {"happy": 0.143, "sad": 0.143, "angry": 0.143, "anxious": 0.143, "tired": 0.143, "love": 0.143, "fear": 0.143}, "valence": 0.0, "arousal": 0.5, "tone": "neutral", "confidence": 0.25, "reasons": ["intensifiers x1.35", "sarcasm inverted positive emotions"], "spans": {}, "ts": 1763676296.503434, "user_id": "user_001"}, "role": "user", "user_id": "user_001", "ts": 1763676296, "salience": 0.25}}, {"id": "stm-1763676327-2", "t": 1763676327, "text": "1. \"I'm so burnt out and exhausted\"\n", "event": {"text": "1. \"I'm so burnt out and exhausted\"\n", "emotion": {"labels": ["tired"], "scores": {"happy": 0.048, "sad": 0.048, "angry": 0.048, "anxious": 0.048, "tired": 0.713, "love": 0.048, "fear": 0.048}, "valence": 0.0, "arousal": 0.4, "tone": "neutral", "confidence": 0.35, "reasons": ["intensifiers x1.35", "sarcasm inverted positive emotions"], "spans": {"tired": [[11, 20, "burnt out"], [25, 34, "exhausted"]]}, "ts": 1763676327.073478, "user_id": "user_001"}, "role": "user", "user_id": "user_001", "ts": 1763676327, "salience": 0.219}}, {"id": "stm-1763676333-3", "t": 1763676333, "text": "\n2. \"I'm completely drained and can't keep going\"", "event": {"text": "\n2. \"I'm completely drained and can't keep going\"", "emotion": {"labels": ["tired", "happy", "sad"], "scores": {"happy": 0.115, "sad": 0.115, "angry": 0.115, "anxious": 0.115, "tired": 0.312, "love": 0.115, "fear": 0.115}, "valence": 0.0, "arousal": 0.4, "tone": "neutral", "confidence": 0.35, "reasons": ["sarcasm inverted positive emotions"], "spans": {"tired": [[20, 27, "drained"]]}, "ts": 1763676333.804668, "user_id": "user_001"}, "role": "user", "user_id": "user_001", "ts": 1763676333, "salience": 0.2}}], "episodes": [], "facts": [], "meta": {"created": 1763676283, "version": "1.3.0"}}

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.44.0
+fastmcp>=0.2.0
+mcp>=1.0.0
+anthropic>=0.37.0
+python-dotenv>=1.0.0
+plotly>=5.18.0

servers/emotion_server.py

@@ -0,0 +1,469 @@
+# # servers/emotion_server.py
+# from fastmcp import FastMCP, tool
+# import re
+
+# app = FastMCP("emotion-server")
+
+# _PATTERNS = {
+#     "happy":   r"\b(happy|grateful|excited|joy|delighted|content|optimistic)\b",
+#     "sad":     r"\b(sad|down|depressed|cry|lonely|upset|miserable)\b",
+#     "angry":   r"\b(angry|mad|furious|irritated|pissed|annoyed|resentful)\b",
+#     "anxious": r"\b(worried|anxious|nervous|stressed|overwhelmed|scared)\b",
+#     "tired":   r"\b(tired|exhausted|drained|burnt|sleepy|fatigued)\b",
+#     "love":    r"\b(love|affection|caring|fond|admire|cherish)\b",
+#     "fear":    r"\b(afraid|fear|terrified|panicked|shaken)\b",
+# }
+
+# _TONES = {"happy":"light","love":"light","sad":"gentle","fear":"gentle",
+#           "angry":"calming","anxious":"calming","tired":"gentle"}
+
+# def _analyze(text: str) -> dict:
+#     t = text.lower()
+#     found = [k for k,pat in _PATTERNS.items() if re.search(pat, t)]
+#     valence = 0.0
+#     if "happy" in found or "love" in found: valence += 0.6
+#     if "sad" in found or "fear" in found:   valence -= 0.6
+#     if "angry" in found:                    valence -= 0.4
+#     if "anxious" in found:                  valence -= 0.3
+#     if "tired" in found:                    valence -= 0.2
+#     arousal = 0.5 + (0.3 if ("angry" in found or "anxious" in found) else 0) - (0.2 if "tired" in found else 0)
+#     tone = "neutral"
+#     for e in found:
+#         if e in _TONES: tone = _TONES[e]; break
+#     return {
+#         "labels": found or ["neutral"],
+#         "valence": max(-1, min(1, round(valence, 2))),
+#         "arousal": max(0, min(1, round(arousal, 2))),
+#         "tone": tone,
+#     }
+
+# @tool
+# def analyze(text: str) -> dict:
+#     """
+#     Analyze user text for emotion.
+#     Args:
+#       text: str - user message
+#     Returns: dict {labels, valence, arousal, tone}
+#     """
+#     return _analyze(text)
+
+# if __name__ == "__main__":
+#     app.run()  # serves MCP over stdio
+# servers/emotion_server.py
+from __future__ import annotations
+
+# ---- FastMCP import shim (works across versions) ----
+# Ensures: FastMCP is imported and `@tool` is ALWAYS a callable decorator.
+from typing import Callable, Any
+
+try:
+    from fastmcp import FastMCP  # present across versions
+except Exception as e:
+    raise ImportError(f"FastMCP missing: {e}")
+
+_tool_candidate: Any = None
+# Try common locations
+try:
+    from fastmcp import tool as _tool_candidate  # newer API: function
+except Exception:
+    try:
+        from fastmcp.tools import tool as _tool_candidate  # older API: function
+    except Exception:
+        _tool_candidate = None
+
+# If we somehow got a module instead of a function, try attribute
+if _tool_candidate is not None and not callable(_tool_candidate):
+    try:
+        _tool_candidate = _tool_candidate.tool  # some builds expose module.tools.tool
+    except Exception:
+        _tool_candidate = None
+
+
+def tool(*dargs, **dkwargs):
+    """
+    Wrapper that behaves correctly in both usages:
+      @tool
+      @tool(...)
+    If real decorator exists, delegate. Otherwise:
+      - If called as @tool (i.e., first arg is fn), return fn (no-op).
+      - If called as @tool(...), return a decorator that returns fn (no-op).
+    """
+    if callable(_tool_candidate):
+        return _tool_candidate(*dargs, **dkwargs)
+
+    # No real decorator available — provide no-op behavior.
+    if dargs and callable(dargs[0]) and not dkwargs:
+        # Used as @tool
+        fn = dargs[0]
+        return fn
+
+    # Used as @tool(...)
+    def _noop_decorator(fn):
+        return fn
+
+    return _noop_decorator
+
+
+# ---- end shim ----
+
+
+import re, math, time
+from typing import Dict, List, Tuple, Optional
+
+app = FastMCP("emotion-server")
+
+# ---------------------------
+# Lexicons & heuristics
+# ---------------------------
+EMO_LEX = {
+    "happy": r"\b(happy|grateful|excited|joy(?:ful)?|delighted|content|optimistic|glad|thrilled|yay|better|good|great|fine)\b",
+    "sad": r"\b(sad|down|depress(?:ed|ing)|cry(?:ing)?|lonely|alone|isolated|upset|miserable|heartbroken|devastat(?:ed|ing)|rejected|abandoned|invisible)\b",
+    "angry": r"\b(angry|mad|furious|irritated|pissed|pissy|annoyed|resentful|rage|hate|infuriat(?:ed|ing)|frustrat(?:ed|ing)|boiling|trapped)\b",
+    "anxious": r"\b(worried|anxious|nervous|stressed|overwhelmed|scared|uneasy|tense|on edge|freaking out|uncertain|afraid)\b",
+    "tired": r"\b(tired|exhaust(?:ed|ing)|drained|burnt(?:\s*out)?|sleepy|fatigued|worn out|depleted|no energy)\b",
+    "love": r"\b(love|affection|caring|fond|admire|cherish|adore)\b",
+    "fear": r"\b(afraid|fear|terrified|panic(?:ky|ked)?|panicked|shaken|petrified)\b",
+}
+
+# Emojis contribute signals even without words
+EMOJI_SIGNAL = {
+    "happy": ["😀", "😄", "😊", "🙂", "😁", "🥳", "✨"],
+    "sad": ["😢", "😭", "😞", "😔", "☹️"],
+    "angry": ["😠", "😡", "🤬", "💢"],
+    "anxious": ["😰", "😱", "😬", "😟", "😧"],
+    "tired": ["🥱", "😪", "😴"],
+    "love": ["❤️", "💖", "💕", "😍", "🤍", "💗", "💓", "😘"],
+    "fear": ["🫣", "😨", "😱", "👀"],
+}
+
+NEGATORS = r"\b(no|not|never|hardly|barely|scarcely|isn['’]t|aren['’]t|can['’]t|don['’]t|doesn['’]t|won['’]t|without)\b"
+INTENSIFIERS = {
+    r"\b(very|really|super|so|extremely|incredibly|totally|absolutely)\b": 1.35,
+    r"\b(kinda|kind of|somewhat|slightly|a bit|a little)\b": 0.75,
+}
+SARCASM_CUES = [
+    r"\byeah right\b",
+    r"\bsure\b",
+    r"\".+\"",
+    r"/s\b",
+    r"\bokayyy+\b",
+    r"\blol\b(?!\w)",
+]
+
+
+# Tone map by quadrant
+# arousal high/low × valence pos/neg
+def quad_tone(valence: float, arousal: float) -> str:
+    if arousal >= 0.6 and valence >= 0.1:
+        return "excited"
+    if arousal >= 0.6 and valence < -0.1:
+        return "concerned"
+    if arousal < 0.6 and valence < -0.1:
+        return "gentle"
+    if arousal < 0.6 and valence >= 0.1:
+        return "calm"
+    return "neutral"
+
+
+# ---------------------------
+# Utilities
+# ---------------------------
+_compiled = {k: re.compile(p, re.I) for k, p in EMO_LEX.items()}
+_neg_pat = re.compile(NEGATORS, re.I)
+_int_pats = [(re.compile(p, re.I), w) for p, w in INTENSIFIERS.items()]
+_sarcasm = [re.compile(p, re.I) for p in SARCASM_CUES]
+
+
+def _emoji_hits(text: str) -> Dict[str, int]:
+    hits = {k: 0 for k in EMO_LEX}
+    for emo, arr in EMOJI_SIGNAL.items():
+        for e in arr:
+            hits[emo] += text.count(e)
+    return hits
+
+
+def _intensity_multiplier(text: str) -> float:
+    mult = 1.0
+    for pat, w in _int_pats:
+        if pat.search(text):
+            mult *= w
+    # Exclamation marks increase arousal a bit (cap effect)
+    bangs = min(text.count("!"), 5)
+    mult *= 1.0 + 0.04 * bangs
+    # ALL CAPS word run nudges intensity
+    if re.search(r"\b[A-Z]{3,}\b", text):
+        mult *= 1.08
+    return max(0.5, min(1.8, mult))
+
+
+def _negation_factor(text: str, span_start: int) -> float:
+    """
+    Look 5 words (~40 chars) backwards for a negator.
+    If present, invert or dampen signal.
+    Stop at clause boundaries (comma, period, semicolon) to avoid cross-clause negation.
+    """
+    window_start = max(0, span_start - 40)
+    window = text[window_start:span_start]
+
+    # Stop at last clause boundary (comma, period, semicolon, colon)
+    # This prevents "not responded" from negating "nervous" in "not responded, I'm nervous"
+    last_boundary = max(
+        window.rfind(","), window.rfind("."), window.rfind(";"), window.rfind(":")
+    )
+    if last_boundary != -1:
+        # Only look after the last boundary
+        window = window[last_boundary + 1 :]
+
+    if _neg_pat.search(window):
+        return -0.7  # invert and dampen
+    return 1.0
+
+
+def _sarcasm_penalty(text: str) -> float:
+    return 0.85 if any(p.search(text) for p in _sarcasm) else 1.0
+
+
+def _softmax(d: Dict[str, float]) -> Dict[str, float]:
+    xs = list(d.values())
+    if not xs:
+        return d
+    m = max(xs)
+    exps = [math.exp(x - m) for x in xs]
+    s = sum(exps) or 1.0
+    return {k: exps[i] / s for i, k in enumerate(d.keys())}
+
+
+# ---------------------------
+# Per-user calibration (in-memory)
+# ---------------------------
+CALIBRATION: Dict[str, Dict[str, float]] = (
+    {}
+)  # user_id -> {bias_emo: float, arousal_bias: float, valence_bias: float}
+
+
+def _apply_calibration(
+    user_id: Optional[str], emo_scores: Dict[str, float], valence: float, arousal: float
+):
+    if not user_id or user_id not in CALIBRATION:
+        return emo_scores, valence, arousal
+    calib = CALIBRATION[user_id]
+    # shift emotions
+    for k, bias in calib.items():
+        if k in emo_scores:
+            emo_scores[k] += bias * 0.2
+    # dedicated valence/arousal bias keys if present
+    valence += calib.get("valence_bias", 0.0) * 0.15
+    arousal += calib.get("arousal_bias", 0.0) * 0.15
+    return emo_scores, valence, arousal
+
+
+# ---------------------------
+# Core analysis
+# ---------------------------
+def _analyze(text: str, user_id: Optional[str] = None) -> dict:
+    t = text or ""
+    tl = t.lower()
+
+    # Base scores from lexicon hits
+    emo_scores: Dict[str, float] = {k: 0.0 for k in EMO_LEX}
+    spans: Dict[str, List[Tuple[int, int, str]]] = {k: [] for k in EMO_LEX}
+
+    for emo, pat in _compiled.items():
+        for m in pat.finditer(tl):
+            factor = _negation_factor(tl, m.start())
+            emo_scores[emo] += 1.0 * factor
+            spans[emo].append((m.start(), m.end(), tl[m.start() : m.end()]))
+
+    # Emoji contributions
+    e_hits = _emoji_hits(t)
+    for emo, c in e_hits.items():
+        if c:
+            emo_scores[emo] += 0.6 * c
+
+    # Check for sarcasm - if detected, invert positive emotions
+    sarcasm_detected = any(p.search(tl) for p in _sarcasm)
+
+    if sarcasm_detected:
+        # Sarcasm inverts positive emotions to negative
+        # "yeah right, like they care" → anger/sadness, not love
+        happy_score = emo_scores["happy"]
+        love_score = emo_scores["love"]
+
+        if happy_score > 0 or love_score > 0:
+            # Transfer positive emotion scores to anger/sad
+            emo_scores["angry"] += happy_score * 0.8
+            emo_scores["sad"] += love_score * 0.8
+            emo_scores["happy"] = 0.0
+            emo_scores["love"] = 0.0
+
+    # Intensifiers / punctuation adjustments (global)
+    intensity = _intensity_multiplier(t)
+
+    for emo in emo_scores:
+        emo_scores[emo] *= intensity
+
+    # Map to valence/arousal
+    pos = emo_scores["happy"] + emo_scores["love"]
+    neg = (
+        emo_scores["sad"]
+        + emo_scores["fear"]
+        + 0.9 * emo_scores["angry"]
+        + 0.6 * emo_scores["anxious"]
+    )
+    valence = max(-1.0, min(1.0, round((pos - neg) * 0.4, 3)))
+
+    base_arousal = 0.5
+    arousal = (
+        base_arousal
+        + 0.12 * (emo_scores["angry"] > 0)
+        + 0.08 * (emo_scores["anxious"] > 0)
+        - 0.10 * (emo_scores["tired"] > 0)
+        + 0.02 * min(t.count("!"), 5)
+    )
+
+    arousal = max(0.0, min(1.0, round(arousal, 3)))
+
+    # Confidence: count signals + consistency
+    hits = sum(1 for v in emo_scores.values() if abs(v) > 0.01) + sum(e_hits.values())
+    consistency = 0.0
+    if hits:
+        top2 = sorted(emo_scores.items(), key=lambda kv: kv[1], reverse=True)[:2]
+        if len(top2) == 2 and top2[1][1] > 0:
+            ratio = top2[0][1] / (top2[1][1] + 1e-6)
+            consistency = max(
+                0.0, min(1.0, (ratio - 1) / 3)
+            )  # >1 means some separation
+        elif len(top2) == 1:
+            consistency = 0.6
+    conf = max(0.0, min(1.0, 0.25 + 0.1 * hits + 0.5 * consistency))
+    # downweight very short texts
+    if len(t.strip()) < 6:
+        conf *= 0.6
+
+    # Normalize emotions to pseudo-probs (softmax over positive scores)
+    pos_scores = {k: max(0.0, v) for k, v in emo_scores.items()}
+    probs = _softmax(pos_scores)
+
+    # Apply per-user calibration
+    probs, valence, arousal = _apply_calibration(user_id, probs, valence, arousal)
+
+    # Tone
+    tone = quad_tone(valence, arousal)
+
+    # Explanations
+    reasons = []
+    if intensity > 1.0:
+        reasons.append(f"intensifiers x{intensity:.2f}")
+    if sarcasm_detected:
+        reasons.append("sarcasm inverted positive emotions")
+    if any(
+        _neg_pat.search(tl[max(0, s - 40) : s])
+        for emo, spans_ in spans.items()
+        for (s, _, _) in spans_
+    ):
+        reasons.append("negation near emotion tokens")
+    if any(e_hits.values()):
+        reasons.append("emoji signals")
+
+    labels_sorted = sorted(probs.items(), key=lambda kv: kv[1], reverse=True)
+    top_labels = [k for k, v in labels_sorted[:3] if v > 0.05] or ["neutral"]
+
+    return {
+        "labels": top_labels,
+        "scores": {k: round(v, 3) for k, v in probs.items()},
+        "valence": round(valence, 3),
+        "arousal": round(arousal, 3),
+        "tone": tone,
+        "confidence": round(conf, 3),
+        "reasons": reasons,
+        "spans": {k: spans[k] for k in top_labels if spans.get(k)},
+        "ts": time.time(),
+        "user_id": user_id,
+    }
+
+
+# ---------------------------
+# MCP tools
+# ---------------------------
+
+
+@app.tool()
+def analyze(text: str, user_id: Optional[str] = None) -> dict:
+    """
+    Analyze text for emotion.
+    Args:
+      text: user message
+      user_id: optional user key for calibration
+    Returns:
+      dict with labels, scores (per emotion), valence [-1..1], arousal [0..1],
+      tone (calm/neutral/excited/concerned/gentle), confidence, reasons, spans.
+    """
+    return _analyze(text, user_id=user_id)
+
+
+@app.tool()
+def batch_analyze(messages: List[str], user_id: Optional[str] = None) -> List[dict]:
+    """
+    Batch analyze a list of messages.
+    """
+    return [_analyze(m or "", user_id=user_id) for m in messages]
+
+
+@app.tool()
+def calibrate(
+    user_id: str,
+    bias: Dict[str, float] = None,
+    arousal_bias: float = 0.0,
+    valence_bias: float = 0.0,
+) -> dict:
+    """
+    Adjust per-user calibration.
+    - bias: e.g. {"anxious": -0.1, "love": 0.1}
+    - arousal_bias/valence_bias: small nudges (-1..1) applied after scoring.
+    """
+    if user_id not in CALIBRATION:
+        CALIBRATION[user_id] = {}
+    if bias:
+        for k, v in bias.items():
+            CALIBRATION[user_id][k] = float(v)
+    if arousal_bias:
+        CALIBRATION[user_id]["arousal_bias"] = float(arousal_bias)
+    if valence_bias:
+        CALIBRATION[user_id]["valence_bias"] = float(valence_bias)
+    return {"ok": True, "calibration": CALIBRATION[user_id]}
+
+
+@app.tool()
+def reset_calibration(user_id: str) -> dict:
+    """Remove per-user calibration."""
+    CALIBRATION.pop(user_id, None)
+    return {"ok": True}
+
+
+@app.tool()
+def health() -> dict:
+    """Simple health check for MCP status chips."""
+    return {"status": "ok", "version": "1.2.0", "time": time.time()}
+
+
+@app.tool()
+def version() -> dict:
+    """Return server version & feature flags."""
+    return {
+        "name": "emotion-server",
+        "version": "1.2.0",
+        "features": [
+            "negation",
+            "intensifiers",
+            "emoji",
+            "sarcasm",
+            "confidence",
+            "batch",
+            "calibration",
+        ],
+        "emotions": list(EMO_LEX.keys()),
+    }
+
+
+if __name__ == "__main__":
+    app.run()  # serves MCP over stdio

servers/emotion_server.py.bak

@@ -0,0 +1,377 @@
+# # servers/emotion_server.py
+# from fastmcp import FastMCP, tool
+# import re
+
+# app = FastMCP("emotion-server")
+
+# _PATTERNS = {
+#     "happy":   r"\b(happy|grateful|excited|joy|delighted|content|optimistic)\b",
+#     "sad":     r"\b(sad|down|depressed|cry|lonely|upset|miserable)\b",
+#     "angry":   r"\b(angry|mad|furious|irritated|pissed|annoyed|resentful)\b",
+#     "anxious": r"\b(worried|anxious|nervous|stressed|overwhelmed|scared)\b",
+#     "tired":   r"\b(tired|exhausted|drained|burnt|sleepy|fatigued)\b",
+#     "love":    r"\b(love|affection|caring|fond|admire|cherish)\b",
+#     "fear":    r"\b(afraid|fear|terrified|panicked|shaken)\b",
+# }
+
+# _TONES = {"happy":"light","love":"light","sad":"gentle","fear":"gentle",
+#           "angry":"calming","anxious":"calming","tired":"gentle"}
+
+# def _analyze(text: str) -> dict:
+#     t = text.lower()
+#     found = [k for k,pat in _PATTERNS.items() if re.search(pat, t)]
+#     valence = 0.0
+#     if "happy" in found or "love" in found: valence += 0.6
+#     if "sad" in found or "fear" in found:   valence -= 0.6
+#     if "angry" in found:                    valence -= 0.4
+#     if "anxious" in found:                  valence -= 0.3
+#     if "tired" in found:                    valence -= 0.2
+#     arousal = 0.5 + (0.3 if ("angry" in found or "anxious" in found) else 0) - (0.2 if "tired" in found else 0)
+#     tone = "neutral"
+#     for e in found:
+#         if e in _TONES: tone = _TONES[e]; break
+#     return {
+#         "labels": found or ["neutral"],
+#         "valence": max(-1, min(1, round(valence, 2))),
+#         "arousal": max(0, min(1, round(arousal, 2))),
+#         "tone": tone,
+#     }
+
+# @tool
+# def analyze(text: str) -> dict:
+#     """
+#     Analyze user text for emotion.
+#     Args:
+#       text: str - user message
+#     Returns: dict {labels, valence, arousal, tone}
+#     """
+#     return _analyze(text)
+
+# if __name__ == "__main__":
+#     app.run()  # serves MCP over stdio
+# servers/emotion_server.py
+from __future__ import annotations
+# ---- FastMCP import shim (works across versions) ----
+# Ensures: FastMCP is imported and `@tool` is ALWAYS a callable decorator.
+from typing import Callable, Any
+
+try:
+    from fastmcp import FastMCP  # present across versions
+except Exception as e:
+    raise ImportError(f"FastMCP missing: {e}")
+
+_tool_candidate: Any = None
+# Try common locations
+try:
+    from fastmcp import tool as _tool_candidate       # newer API: function
+except Exception:
+    try:
+        from fastmcp.tools import tool as _tool_candidate  # older API: function
+    except Exception:
+        _tool_candidate = None
+
+# If we somehow got a module instead of a function, try attribute
+if _tool_candidate is not None and not callable(_tool_candidate):
+    try:
+        _tool_candidate = _tool_candidate.tool  # some builds expose module.tools.tool
+    except Exception:
+        _tool_candidate = None
+
+def tool(*dargs, **dkwargs):
+    """
+    Wrapper that behaves correctly in both usages:
+      @tool
+      @tool(...)
+    If real decorator exists, delegate. Otherwise:
+      - If called as @tool (i.e., first arg is fn), return fn (no-op).
+      - If called as @tool(...), return a decorator that returns fn (no-op).
+    """
+    if callable(_tool_candidate):
+        return _tool_candidate(*dargs, **dkwargs)
+
+    # No real decorator available — provide no-op behavior.
+    if dargs and callable(dargs[0]) and not dkwargs:
+        # Used as @tool
+        fn = dargs[0]
+        return fn
+
+    # Used as @tool(...)
+    def _noop_decorator(fn):
+        return fn
+    return _noop_decorator
+# ---- end shim ----
+
+
+import re, math, time
+from typing import Dict, List, Tuple, Optional
+
+app = FastMCP("emotion-server")
+
+# ---------------------------
+# Lexicons & heuristics
+# ---------------------------
+EMO_LEX = {
+    "happy":   r"\b(happy|grateful|excited|joy(?:ful)?|delighted|content|optimistic|glad|thrilled|yay)\b",
+    "sad":     r"\b(sad|down|depress(?:ed|ing)|cry(?:ing)?|lonely|upset|miserable|heartbroken)\b",
+    "angry":   r"\b(angry|mad|furious|irritated|pissed|annoyed|resentful|rage|hate)\b",
+    "anxious": r"\b(worried|anxious|nervous|stressed|overwhelmed|scared|uneasy|tense|on edge)\b",
+    "tired":   r"\b(tired|exhaust(?:ed|ing)|drained|burnt(?:\s*out)?|sleepy|fatigued|worn out)\b",
+    "love":    r"\b(love|affection|caring|fond|admire|cherish|adore)\b",
+    "fear":    r"\b(afraid|fear|terrified|panic(?:ky|ked)?|panicked|shaken|petrified)\b",
+}
+
+# Emojis contribute signals even without words
+EMOJI_SIGNAL = {
+    "happy": ["😀","😄","😊","🙂","😁","🥳","✨"],
+    "sad":   ["😢","😭","😞","😔","☹️"],
+    "angry": ["😠","😡","🤬","💢"],
+    "anxious":["😰","😱","😬","😟","😧"],
+    "tired": ["🥱","😪","😴"],
+    "love":  ["❤️","💖","💕","😍","🤍","💗","💓","😘"],
+    "fear":  ["🫣","😨","😱","👀"],
+}
+
+NEGATORS = r"\b(no|not|never|hardly|barely|scarcely|isn['’]t|aren['’]t|can['’]t|don['’]t|doesn['’]t|won['’]t|without)\b"
+INTENSIFIERS = {
+    r"\b(very|really|super|so|extremely|incredibly|totally|absolutely)\b": 1.35,
+    r"\b(kinda|kind of|somewhat|slightly|a bit|a little)\b": 0.75,
+}
+SARCASM_CUES = [
+    r"\byeah right\b", r"\bsure\b", r"\".+\"", r"/s\b", r"\bokayyy+\b", r"\blol\b(?!\w)"
+]
+
+# Tone map by quadrant
+# arousal high/low × valence pos/neg
+def quad_tone(valence: float, arousal: float) -> str:
+    if arousal >= 0.6 and valence >= 0.1:  return "excited"
+    if arousal >= 0.6 and valence < -0.1:  return "concerned"
+    if arousal <  0.6 and valence < -0.1:  return "gentle"
+    if arousal <  0.6 and valence >= 0.1:  return "calm"
+    return "neutral"
+
+# ---------------------------
+# Utilities
+# ---------------------------
+_compiled = {k: re.compile(p, re.I) for k, p in EMO_LEX.items()}
+_neg_pat = re.compile(NEGATORS, re.I)
+_int_pats = [(re.compile(p, re.I), w) for p, w in INTENSIFIERS.items()]
+_sarcasm = [re.compile(p, re.I) for p in SARCASM_CUES]
+
+def _emoji_hits(text: str) -> Dict[str, int]:
+    hits = {k: 0 for k in EMO_LEX}
+    for emo, arr in EMOJI_SIGNAL.items():
+        for e in arr:
+            hits[emo] += text.count(e)
+    return hits
+
+def _intensity_multiplier(text: str) -> float:
+    mult = 1.0
+    for pat, w in _int_pats:
+        if pat.search(text):
+            mult *= w
+    # Exclamation marks increase arousal a bit (cap effect)
+    bangs = min(text.count("!"), 5)
+    mult *= (1.0 + 0.04 * bangs)
+    # ALL CAPS word run nudges intensity
+    if re.search(r"\b[A-Z]{3,}\b", text):
+        mult *= 1.08
+    return max(0.5, min(1.8, mult))
+
+def _negation_factor(text: str, span_start: int) -> float:
+    """
+    Look 5 words (~40 chars) backwards for a negator.
+    If present, invert or dampen signal.
+    """
+    window_start = max(0, span_start - 40)
+    window = text[window_start:span_start]
+    if _neg_pat.search(window):
+        return -0.7  # invert and dampen
+    return 1.0
+
+def _sarcasm_penalty(text: str) -> float:
+    return 0.85 if any(p.search(text) for p in _sarcasm) else 1.0
+
+def _softmax(d: Dict[str, float]) -> Dict[str, float]:
+    xs = list(d.values())
+    if not xs: return d
+    m = max(xs)
+    exps = [math.exp(x - m) for x in xs]
+    s = sum(exps) or 1.0
+    return {k: exps[i] / s for i, k in enumerate(d.keys())}
+
+# ---------------------------
+# Per-user calibration (in-memory)
+# ---------------------------
+CALIBRATION: Dict[str, Dict[str, float]] = {}  # user_id -> {bias_emo: float, arousal_bias: float, valence_bias: float}
+
+def _apply_calibration(user_id: Optional[str], emo_scores: Dict[str, float], valence: float, arousal: float):
+    if not user_id or user_id not in CALIBRATION:
+        return emo_scores, valence, arousal
+    calib = CALIBRATION[user_id]
+    # shift emotions
+    for k, bias in calib.items():
+        if k in emo_scores:
+            emo_scores[k] += bias * 0.2
+    # dedicated valence/arousal bias keys if present
+    valence += calib.get("valence_bias", 0.0) * 0.15
+    arousal += calib.get("arousal_bias", 0.0) * 0.15
+    return emo_scores, valence, arousal
+
+# ---------------------------
+# Core analysis
+# ---------------------------
+def _analyze(text: str, user_id: Optional[str] = None) -> dict:
+    t = text or ""
+    tl = t.lower()
+
+    # Base scores from lexicon hits
+    emo_scores: Dict[str, float] = {k: 0.0 for k in EMO_LEX}
+    spans: Dict[str, List[Tuple[int, int, str]]] = {k: [] for k in EMO_LEX}
+
+    for emo, pat in _compiled.items():
+        for m in pat.finditer(tl):
+            factor = _negation_factor(tl, m.start())
+            emo_scores[emo] += 1.0 * factor
+            spans[emo].append((m.start(), m.end(), tl[m.start():m.end()]))
+
+    # Emoji contributions
+    e_hits = _emoji_hits(t)
+    for emo, c in e_hits.items():
+        if c:
+            emo_scores[emo] += 0.6 * c
+
+    # Intensifiers / sarcasm / punctuation adjustments (global)
+    intensity = _intensity_multiplier(t)
+    sarcasm_mult = _sarcasm_penalty(t)
+
+    for emo in emo_scores:
+        emo_scores[emo] *= intensity * sarcasm_mult
+
+    # Map to valence/arousal
+    pos = emo_scores["happy"] + emo_scores["love"]
+    neg = emo_scores["sad"] + emo_scores["fear"] + 0.9 * emo_scores["angry"] + 0.6 * emo_scores["anxious"]
+    valence = max(-1.0, min(1.0, round((pos - neg) * 0.4, 3)))
+
+    base_arousal = 0.5
+    arousal = base_arousal \
+        + 0.12 * (emo_scores["angry"] > 0) \
+        + 0.08 * (emo_scores["anxious"] > 0) \
+        - 0.10 * (emo_scores["tired"] > 0) \
+        + 0.02 * min(t.count("!"), 5)
+
+    arousal = max(0.0, min(1.0, round(arousal, 3)))
+
+    # Confidence: count signals + consistency
+    hits = sum(1 for v in emo_scores.values() if abs(v) > 0.01) + sum(e_hits.values())
+    consistency = 0.0
+    if hits:
+        top2 = sorted(emo_scores.items(), key=lambda kv: kv[1], reverse=True)[:2]
+        if len(top2) == 2 and top2[1][1] > 0:
+            ratio = top2[0][1] / (top2[1][1] + 1e-6)
+            consistency = max(0.0, min(1.0, (ratio - 1) / 3))  # >1 means some separation
+        elif len(top2) == 1:
+            consistency = 0.6
+    conf = max(0.0, min(1.0, 0.25 + 0.1 * hits + 0.5 * consistency))
+    # downweight very short texts
+    if len(t.strip()) < 6:
+        conf *= 0.6
+
+    # Normalize emotions to pseudo-probs (softmax over positive scores)
+    pos_scores = {k: max(0.0, v) for k, v in emo_scores.items()}
+    probs = _softmax(pos_scores)
+
+    # Apply per-user calibration
+    probs, valence, arousal = _apply_calibration(user_id, probs, valence, arousal)
+
+    # Tone
+    tone = quad_tone(valence, arousal)
+
+    # Explanations
+    reasons = []
+    if intensity > 1.0: reasons.append(f"intensifiers x{intensity:.2f}")
+    if sarcasm_mult < 1.0: reasons.append("sarcasm cues detected")
+    if any(_neg_pat.search(tl[max(0,s-40):s]) for emo, spans_ in spans.items() for (s,_,_) in spans_):
+        reasons.append("negation near emotion tokens")
+    if any(e_hits.values()): reasons.append("emoji signals")
+
+    labels_sorted = sorted(probs.items(), key=lambda kv: kv[1], reverse=True)
+    top_labels = [k for k, v in labels_sorted[:3] if v > 0.05] or ["neutral"]
+
+    return {
+        "labels": top_labels,
+        "scores": {k: round(v, 3) for k, v in probs.items()},
+        "valence": round(valence, 3),
+        "arousal": round(arousal, 3),
+        "tone": tone,
+        "confidence": round(conf, 3),
+        "reasons": reasons,
+        "spans": {k: spans[k] for k in top_labels if spans.get(k)},
+        "ts": time.time(),
+        "user_id": user_id,
+    }
+
+# ---------------------------
+# MCP tools
+# ---------------------------
+
+@app.tool()
+def analyze(text: str, user_id: Optional[str] = None) -> dict:
+    """
+    Analyze text for emotion.
+    Args:
+      text: user message
+      user_id: optional user key for calibration
+    Returns:
+      dict with labels, scores (per emotion), valence [-1..1], arousal [0..1],
+      tone (calm/neutral/excited/concerned/gentle), confidence, reasons, spans.
+    """
+    return _analyze(text, user_id=user_id)
+
+@app.tool()
+def batch_analyze(messages: List[str], user_id: Optional[str] = None) -> List[dict]:
+    """
+    Batch analyze a list of messages.
+    """
+    return [_analyze(m or "", user_id=user_id) for m in messages]
+
+@app.tool()
+def calibrate(user_id: str, bias: Dict[str, float] = None, arousal_bias: float = 0.0, valence_bias: float = 0.0) -> dict:
+    """
+    Adjust per-user calibration.
+    - bias: e.g. {"anxious": -0.1, "love": 0.1}
+    - arousal_bias/valence_bias: small nudges (-1..1) applied after scoring.
+    """
+    if user_id not in CALIBRATION:
+        CALIBRATION[user_id] = {}
+    if bias:
+        for k, v in bias.items():
+            CALIBRATION[user_id][k] = float(v)
+    if arousal_bias:
+        CALIBRATION[user_id]["arousal_bias"] = float(arousal_bias)
+    if valence_bias:
+        CALIBRATION[user_id]["valence_bias"] = float(valence_bias)
+    return {"ok": True, "calibration": CALIBRATION[user_id]}
+
+@app.tool()
+def reset_calibration(user_id: str) -> dict:
+    """Remove per-user calibration."""
+    CALIBRATION.pop(user_id, None)
+    return {"ok": True}
+
+@app.tool()
+def health() -> dict:
+    """Simple health check for MCP status chips."""
+    return {"status": "ok", "version": "1.2.0", "time": time.time()}
+
+@app.tool()
+def version() -> dict:
+    """Return server version & feature flags."""
+    return {
+        "name": "emotion-server",
+        "version": "1.2.0",
+        "features": ["negation", "intensifiers", "emoji", "sarcasm", "confidence", "batch", "calibration"],
+        "emotions": list(EMO_LEX.keys()),
+    }
+
+if __name__ == "__main__":
+    app.run()  # serves MCP over stdio

servers/memory_server.py

@@ -0,0 +1,599 @@
+# # servers/memory_server.py
+# from fastmcp import FastMCP, tool
+# import json, os, time
+
+# app = FastMCP("memory-server")
+# FILE = os.environ.get("GM_MEMORY_FILE", "memory.json")
+
+# def _load():
+#     if os.path.exists(FILE):
+#         with open(FILE) as f: return json.load(f)
+#     return []
+
+# def _save(history):
+#     with open(FILE, "w") as f: json.dump(history[-50:], f)  # keep up to 50
+
+# @tool
+# def remember(text: str, meta: dict | None = None) -> dict:
+#     """
+#     Append an entry to memory.
+#     Args:
+#       text: str - content to store
+#       meta: dict - optional info like {"tone":"gentle","labels":["sad"]}
+#     Returns: {"ok": True, "size": <n>}
+#     """
+#     data = _load()
+#     data.append({"t": int(time.time()), "text": text, "meta": meta or {}})
+#     _save(data)
+#     return {"ok": True, "size": len(data)}
+
+# @tool
+# def recall(k: int = 3) -> dict:
+#     """
+#     Return last k entries from memory (most recent last).
+#     Args:
+#       k: int - how many items
+#     Returns: {"items":[...]}
+#     """
+#     data = _load()
+#     return {"items": data[-k:]}
+
+# if __name__ == "__main__":
+#     app.run()
+# servers/memory_server.py
+# servers/memory_server.py
+from __future__ import annotations
+# ---- FastMCP import shim (works across versions) ----
+# Ensures: FastMCP is imported and `@tool` is ALWAYS a callable decorator.
+from typing import Callable, Any
+
+try:
+    from fastmcp import FastMCP  # present across versions
+except Exception as e:
+    raise ImportError(f"FastMCP missing: {e}")
+
+_tool_candidate: Any = None
+# Try common locations
+try:
+    from fastmcp import tool as _tool_candidate       # newer API: function
+except Exception:
+    try:
+        from fastmcp.tools import tool as _tool_candidate  # older API: function
+    except Exception:
+        _tool_candidate = None
+
+# If we somehow got a module instead of a function, try attribute
+if _tool_candidate is not None and not callable(_tool_candidate):
+    try:
+        _tool_candidate = _tool_candidate.tool  # some builds expose module.tools.tool
+    except Exception:
+        _tool_candidate = None
+
+def tool(*dargs, **dkwargs):
+    """
+    Wrapper that behaves correctly in both usages:
+      @tool
+      @tool(...)
+    If real decorator exists, delegate. Otherwise:
+      - If called as @tool (i.e., first arg is fn), return fn (no-op).
+      - If called as @tool(...), return a decorator that returns fn (no-op).
+    """
+    if callable(_tool_candidate):
+        return _tool_candidate(*dargs, **dkwargs)
+
+    # No real decorator available — provide no-op behavior.
+    if dargs and callable(dargs[0]) and not dkwargs:
+        # Used as @tool
+        fn = dargs[0]
+        return fn
+
+    # Used as @tool(...)
+    def _noop_decorator(fn):
+        return fn
+    return _noop_decorator
+# ---- end shim ----
+
+
+import json, os, time, math, re
+from typing import Dict, List, Optional, Any, Tuple
+from collections import Counter
+
+app = FastMCP("memory-server")
+
+# ---------------------------
+# Storage & limits
+# ---------------------------
+FILE = os.environ.get("GM_MEMORY_FILE", "memory.json")
+STM_MAX = int(os.environ.get("GM_STM_MAX", "120"))
+EP_MAX  = int(os.environ.get("GM_EPISODES_MAX", "240"))
+FACT_MAX= int(os.environ.get("GM_FACTS_MAX", "200"))
+# ---------------------------
+# Emotion Drift Analysis
+# ---------------------------
+def compute_emotional_direction(trajectory: List[Dict[str, Any]]) -> str:
+    """
+    Analyze emotion trajectory to detect escalation/de-escalation/volatility/stability.
+    trajectory: list of {"label": str, "valence": float, "arousal": float, "ts": int}
+    """
+    if len(trajectory) < 2:
+        return "stable"
+
+    # Get last 5 emotions for trend
+    recent = trajectory[-5:]
+    valences = [e.get("valence", 0.0) for e in recent]
+    arousals = [e.get("arousal", 0.5) for e in recent]
+
+    # Detect trend
+    valence_trend = valences[-1] - valences[0]  # negative = more negative, positive = more positive
+    arousal_trend = arousals[-1] - arousals[0]  # positive = escalating
+
+    # Classify
+    if arousal_trend > 0.15 and valence_trend < -0.1:
+        return "escalating"  # Getting more activated and negative
+    elif arousal_trend < -0.15 and valence_trend > 0.1:
+        return "de-escalating"  # Calming down and more positive
+    elif max(arousals) - min(arousals) > 0.3:
+        return "volatile"  # Wide swings in arousal
+    else:
+        return "stable"
+
+def get_emotion_trajectory(store: Dict[str, Any], k: int = 10) -> Tuple[List[Dict[str, Any]], str]:
+    """
+    Returns last k emotion events from memory and the trajectory direction.
+    If a message is neutral, it inherits the previous emotion state.
+    """
+    stm = store.get("stm", [])
+    trajectory = []
+    last_emotion_state = None  # Track last non-neutral emotion
+
+    for item in stm[-k:]:
+        # Check if emotion data is in event.emotion (from remember_event)
+        event = item.get("event", {})
+        emotion = event.get("emotion", {})
+
+        # Also check if emotion data is in meta (from remember)
+        if not emotion or not emotion.get("labels"):
+            meta = item.get("meta", {})
+            if meta and meta.get("labels"):
+                emotion = meta
+
+        if emotion and emotion.get("labels"):
+            primary_label = (emotion.get("labels") or ["neutral"])[0]
+            valence = float(emotion.get("valence", 0.0))
+            arousal = float(emotion.get("arousal", 0.5))
+
+            # If this is neutral/weak emotion, inherit previous state
+            confidence = float(emotion.get("confidence", 0.25))
+            if primary_label in ["happy", "neutral"] and confidence < 0.35 and last_emotion_state:
+                # Carry forward previous emotion (decay slightly toward neutral)
+                primary_label = last_emotion_state["primary_label"]
+                valence = last_emotion_state["valence"] * 0.8  # Slight decay
+                arousal = last_emotion_state["arousal"] * 0.9
+            else:
+                # Strong emotion detected, update state
+                last_emotion_state = {
+                    "primary_label": primary_label,
+                    "valence": valence,
+                    "arousal": arousal
+                }
+
+            trajectory.append({
+                "primary_label": primary_label,
+                "valence": valence,
+                "arousal": arousal,
+                "ts": item.get("t", int(time.time())),
+                "text": item.get("text", "")[:50]  # First 50 chars
+            })
+
+    direction = compute_emotional_direction(trajectory)
+    return trajectory, direction
+# ---------------------------
+# File helpers & migrations
+# ---------------------------
+def _default_store() -> Dict[str, Any]:
+    return {"stm": [], "episodes": [], "facts": [], "meta": {"created": int(time.time()), "version": "1.3.0"}}
+
+def _load() -> Dict[str, Any]:
+    if os.path.exists(FILE):
+        with open(FILE) as f:
+            try:
+                data = json.load(f)
+                # migrate flat list → tiered
+                if isinstance(data, list):
+                    data = {"stm": data[-STM_MAX:], "episodes": [], "facts": [], "meta": {"created": int(time.time()), "version": "1.3.0"}}
+                # backfill ids in stm
+                changed = False
+                for i, it in enumerate(data.get("stm", [])):
+                    if "id" not in it:
+                        it["id"] = f"stm-{it.get('t', int(time.time()))}-{i}"
+                        changed = True
+                if changed:
+                    _save(data)
+                return data
+            except Exception:
+                return _default_store()
+    return _default_store()
+
+def _save(store: Dict[str, Any]) -> None:
+    store["stm"]      = store.get("stm", [])[-STM_MAX:]
+    store["episodes"] = store.get("episodes", [])[-EP_MAX:]
+    store["facts"]    = store.get("facts", [])[-FACT_MAX:]
+    with open(FILE, "w") as f:
+        json.dump(store, f, ensure_ascii=False)
+
+# ---------------------------
+# Salience & decay (same as before)
+# ---------------------------
+def time_decay(ts: float, now: Optional[float] = None, half_life_hours: float = 72.0) -> float:
+    now = now or time.time()
+    dt_h = max(0.0, (now - ts) / 3600.0)
+    return 0.5 ** (dt_h / half_life_hours)
+
+_WORD = re.compile(r"[a-zA-Z']+")
+
+def keyword_set(text: str) -> set:
+    return set(w.lower() for w in _WORD.findall(text or "") if len(w) > 2)
+
+def novelty_score(text: str, recent_texts: List[str], k: int = 10) -> float:
+    if not text:
+        return 0.0
+    A = keyword_set(text)
+    if not A:
+        return 0.0
+    recent = [keyword_set(t) for t in recent_texts[-k:] if t]
+    if not recent:
+        return 1.0
+    sims = []
+    for B in recent:
+        inter = len(A & B)
+        union = len(A | B) or 1
+        sims.append(inter / union)
+    sim = max(sims) if sims else 0.0
+    return max(0.0, 1.0 - sim)
+
+def compute_salience(ev: Dict[str, Any], recent_texts: List[str]) -> float:
+    labels = ev.get("emotion", {}).get("labels") or []
+    conf   = float(ev.get("emotion", {}).get("confidence") or 0.0)
+    valence= float(ev.get("emotion", {}).get("valence") or 0.0)
+    arousal= float(ev.get("emotion", {}).get("arousal") or 0.5)
+    sinc   = float(ev.get("sincerity") or 0.0) / 100.0
+    text   = ev.get("text", "")
+
+    affect = abs(valence) * (0.7 + 0.3 * arousal) * conf
+    nov = novelty_score(text, recent_texts)
+    user_flag = 1.0 if ev.get("user_pinned") else 0.0
+    boundary  = 1.0 if ev.get("task_boundary") else 0.0
+
+    sal = 0.45 * affect + 0.25 * nov + 0.18 * user_flag + 0.12 * boundary + 0.10 * sinc
+    return round(max(0.0, min(1.0, sal)), 3)
+
+# ---------------------------
+# Episode & fact synthesis
+# ---------------------------
+def make_episode(ev: Dict[str, Any], salience: float) -> Dict[str, Any]:
+    emo = ev.get("emotion", {})
+    return {
+        "episode_id": ev.get("id") or f"ep-{int(time.time()*1000)}",
+        "ts_start": ev.get("ts") or int(time.time()),
+        "ts_end": ev.get("ts") or int(time.time()),
+        "summary": ev.get("summary") or (ev.get("text")[:140] if ev.get("text") else ""),
+        "topics": list(set(emo.get("labels") or [])) or ["misc"],
+        "emotion_peak": (emo.get("labels") or ["neutral"])[0],
+        "emotion_conf": float(emo.get("confidence") or 0.0),
+        "tone": emo.get("tone") or "neutral",
+        "salience": float(salience),
+        "provenance_event": ev.get("id"),
+    }
+
+def cluster_topics(episodes: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+    buckets: Dict[str, List[Dict[str, Any]]] = {}
+    for ep in episodes:
+        for t in ep.get("topics") or ["misc"]:
+            buckets.setdefault(t, []).append(ep)
+    return buckets
+
+def synthesize_fact(topic: str, eps: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    if not eps:
+        return None
+    support = len(eps)
+    avg_sal = sum(e.get("salience", 0.0) for e in eps) / max(1, support)
+    avg_conf= sum(e.get("emotion_conf", 0.0) for e in eps) / max(1, support)
+    conf = max(0.0, min(1.0, 0.5 * avg_sal + 0.5 * avg_conf))
+    if support < 3 or conf < 0.6:
+        return None
+    tones = {}
+    for e in eps: tones[e.get("tone", "neutral")] = tones.get(e.get("tone", "neutral"), 0) + 1
+    top_tone = sorted(tones.items(), key=lambda kv: kv[1], reverse=True)[0][0]
+    return {
+        "fact_id": f"fact-{topic}-{int(time.time())}",
+        "proposition": f"Prefers {top_tone} tone for topic '{topic}'",
+        "support": support,
+        "confidence": round(conf, 2),
+        "last_updated": int(time.time()),
+        "topics": [topic],
+        "provenance_episode_ids": [e["episode_id"] for e in eps],
+    }
+
+# ---------------------------
+# ID helpers
+# ---------------------------
+def _ensure_stm_id(item: Dict[str, Any], idx: int) -> Dict[str, Any]:
+    if "id" not in item:
+        item["id"] = f"stm-{item.get('t', int(time.time()))}-{idx}"
+    return item
+
+def _stm_text(item: Dict[str, Any]) -> str:
+    if "text" in item and isinstance(item["text"], str):
+        return item["text"]
+    return (item.get("event") or {}).get("text", "") or ""
+
+def _collect_docs(store: Dict[str, Any], tier: Optional[str] = None) -> List[Tuple[str,str,str,int]]:
+    """
+    Returns list of (id, tier, text, ts)
+    """
+    docs: List[Tuple[str,str,str,int]] = []
+    if tier in (None, "stm"):
+        for i, it in enumerate(store.get("stm", [])):
+            it = _ensure_stm_id(it, i)
+            docs.append((it["id"], "stm", _stm_text(it), int(it.get("t", time.time()))))
+    if tier in (None, "episodes"):
+        for ep in store.get("episodes", []):
+            docs.append((ep.get("episode_id",""), "episodes", ep.get("summary",""), int(ep.get("ts_end", time.time()))))
+    if tier in (None, "facts"):
+        for f in store.get("facts", []):
+            docs.append((f.get("fact_id",""), "facts", f.get("proposition",""), int(f.get("last_updated", time.time()))))
+    return [d for d in docs if d[0] and d[2]]
+
+# ---------------------------
+# Simple TF-IDF search
+# ---------------------------
+def _tfidf_rank(query: str, docs: List[Tuple[str,str,str,int]], k: int = 5):
+    q_terms = [w for w in keyword_set(query)]
+    if not q_terms or not docs:
+        return []
+    # DF
+    df = Counter()
+    doc_terms = {}
+    for _id, _tier, text, _ts in docs:
+        terms = [w for w in keyword_set(text)]
+        doc_terms[_id] = terms
+        for t in set(terms):
+            df[t] += 1
+    N = len(docs)
+    idf = {t: math.log((N + 1) / (df[t] + 1)) + 1.0 for t in df}
+    # Score
+    scored = []
+    qset = set(q_terms)
+    for _id, _tier, text, _ts in docs:
+        terms = doc_terms[_id]
+        tf = Counter(terms)
+        score = 0.0
+        matched = []
+        for t in q_terms:
+            if tf[t] > 0:
+                score += tf[t] * idf.get(t, 1.0)
+                matched.append(t)
+        if score > 0:
+            scored.append((_id, _tier, text, _ts, score, matched))
+    scored.sort(key=lambda x: (-x[4], -x[3]))  # score desc, then recent
+    return scored[:k]
+
+# ---------------------------
+# Tools (API)
+# ---------------------------
+
+@app.tool()
+def remember(text: str, meta: dict | None = None) -> dict:
+    store = _load()
+    item = {"t": int(time.time()), "text": text, "meta": meta or {}}
+    item["id"] = f"stm-{item['t']}-{len(store.get('stm', []))}"
+    store["stm"].append(item)
+    _save(store)
+    return {"ok": True, "stm_size": len(store["stm"]), "id": item["id"]}
+
+@app.tool()
+def remember_event(event: dict, promote: bool = True) -> dict:
+    store = _load()
+    ev = dict(event or {})
+    ev.setdefault("ts", int(time.time()))
+    ev.setdefault("role", "user")
+    ev.setdefault("text", "")
+    if "salience" not in ev:
+        recent_texts = [it.get("text","") for it in store.get("stm", [])[-10:]]
+        ev["salience"] = compute_salience(ev, recent_texts)
+    stm_item = {
+        "id": f"stm-{ev['ts']}-{len(store.get('stm', []))}",
+        "t": ev["ts"],
+        "text": ev.get("text",""),
+        "event": ev
+    }
+    store["stm"].append(stm_item)
+    if promote:
+        aff_conf = float(ev.get("emotion", {}).get("confidence") or 0.0)
+        if ev["salience"] >= 0.45 or ev.get("user_pinned") or ev.get("task_boundary"):
+            ep = make_episode(ev, ev["salience"])
+            store["episodes"].append(ep)
+    _save(store)
+    return {"ok": True, "salience": ev["salience"], "id": stm_item["id"],
+            "sizes": {"stm": len(store["stm"]), "episodes": len(store["episodes"]), "facts": len(store["facts"])}}
+
+@app.tool()
+def recall(k: int = 3) -> dict:
+    store = _load()
+    items = store.get("stm", [])[-k:]
+    return {"items": items}
+
+@app.tool()
+def recall_episodes(k: int = 5, topic: str | None = None) -> dict:
+    store = _load()
+    eps = store.get("episodes", [])
+    if topic:
+        eps = [e for e in eps if topic in (e.get("topics") or [])]
+    return {"items": eps[-k:]}
+
+@app.tool()
+def recall_facts() -> dict:
+    store = _load()
+    return {"facts": store.get("facts", [])}
+
+@app.tool()
+def reflect() -> dict:
+    store = _load()
+    eps = store.get("episodes", [])
+    if not eps:
+        return {"ok": True, "updated": 0, "facts": store.get("facts", [])}
+    buckets = cluster_topics(eps)
+    new_facts = []
+    for topic, group in buckets.items():
+        fact = synthesize_fact(topic, group)
+        if fact:
+            existing = next((f for f in store["facts"] if f.get("proposition") == fact["proposition"]), None)
+            if existing:
+                existing["support"] = max(existing.get("support", 0), fact["support"])
+                existing["confidence"] = round(max(existing.get("confidence", 0.0), fact["confidence"]), 2)
+                existing["last_updated"] = int(time.time())
+            else:
+                new_facts.append(fact)
+    store["facts"].extend(new_facts)
+    _save(store)
+    return {"ok": True, "updated": len(new_facts), "facts": store["facts"]}
+
+@app.tool()
+def prune(before_ts: int | None = None) -> dict:
+    store = _load()
+    stm = store.get("stm", [])
+    if before_ts:
+        stm = [it for it in stm if it.get("t", 0) >= int(before_ts)]
+    else:
+        cut = int(len(stm) * 0.75)
+        stm = stm[cut:]
+    store["stm"] = stm
+    _save(store)
+    return {"ok": True, "stm_size": len(store["stm"])}
+
+# -------- NEW: search / get / delete / list --------
+
+@app.tool()
+def search(query: str, tier: str | None = None, k: int = 5) -> dict:
+    """
+    TF-IDF search across memory.
+    Args:
+      query: text to search
+      tier: one of {"stm","episodes","facts"} or None for all
+      k: number of results
+    Returns: {"results":[{"id","tier","text","ts","score","matched"}]}
+    """
+    store = _load()
+    docs = _collect_docs(store, tier=tier)
+    ranked = _tfidf_rank(query, docs, k=k)
+    results = [{"id": _id, "tier": _tier, "text": text, "ts": ts, "score": round(score,3), "matched": matched}
+               for (_id, _tier, text, ts, score, matched) in ranked]
+    return {"results": results}
+
+@app.tool()
+def get(item_id: str) -> dict:
+    """
+    Fetch a single item by id from any tier.
+    """
+    s = _load()
+    for it in s.get("stm", []):
+        if it.get("id") == item_id:
+            return {"tier": "stm", "item": it}
+    for ep in s.get("episodes", []):
+        if ep.get("episode_id") == item_id:
+            return {"tier": "episodes", "item": ep}
+    for f in s.get("facts", []):
+        if f.get("fact_id") == item_id:
+            return {"tier": "facts", "item": f}
+    return {"tier": None, "item": None}
+
+@app.tool()
+def delete_by_id(item_id: str, tier: str | None = None) -> dict:
+    """
+    Delete a single item by id. If tier is None, searches all tiers.
+    Returns {"ok": bool, "removed_from": <tier>|None}
+    """
+    s = _load()
+    removed_from = None
+    if tier in (None, "stm"):
+        before = len(s["stm"])
+        s["stm"] = [it for it in s["stm"] if it.get("id") != item_id]
+        if len(s["stm"]) != before: removed_from = "stm"
+    if not removed_from and tier in (None, "episodes"):
+        before = len(s["episodes"])
+        s["episodes"] = [e for e in s["episodes"] if e.get("episode_id") != item_id]
+        if len(s["episodes"]) != before: removed_from = "episodes"
+    if not removed_from and tier in (None, "facts"):
+        before = len(s["facts"])
+        s["facts"] = [f for f in s["facts"] if f.get("fact_id") != item_id]
+        if len(s["facts"]) != before: removed_from = "facts"
+    if removed_from:
+        _save(s)
+        return {"ok": True, "removed_from": removed_from}
+    return {"ok": False, "removed_from": None}
+
+@app.tool()
+def list_items(tier: str, k: int = 10) -> dict:
+    """
+    List last k items in a tier.
+    tier ∈ {"stm","episodes","facts"}
+    """
+    s = _load()
+    if tier == "stm":
+        return {"items": s.get("stm", [])[-k:]}
+    if tier == "episodes":
+        return {"items": s.get("episodes", [])[-k:]}
+    if tier == "facts":
+        return {"items": s.get("facts", [])[-k:]}
+    return {"items": []}
+
+# -------- Diagnostics --------
+
+@app.tool()
+def stats() -> dict:
+    s = _load()
+    return {
+        "stm": len(s.get("stm", [])),
+        "episodes": len(s.get("episodes", [])),
+        "facts": len(s.get("facts", [])),
+        "file": FILE,
+        "created": s.get("meta", {}).get("created"),
+        "version": s.get("meta", {}).get("version", "1.3.0"),
+    }
+
+@app.tool()
+def health() -> dict:
+    try:
+        s = _load()
+        return {"status": "ok", "stm": len(s.get("stm", [])), "episodes": len(s.get("episodes", [])), "facts": len(s.get("facts", [])), "time": time.time(), "version": "1.3.0"}
+    except Exception as e:
+        return {"status": "error", "error": str(e), "time": time.time()}
+
+@app.tool()
+def version() -> dict:
+    return {"name": "memory-server", "version": "1.3.0", "tiers": ["stm","episodes","facts"], "file": FILE}
+
+@app.tool()
+def get_emotion_arc(k: int = 10) -> dict:
+    """
+    Get the emotion trajectory (arc) for the last k events.
+    Returns: {"trajectory": [...], "direction": "escalating|de-escalating|volatile|stable", "summary": str}
+    """
+    store = _load()
+    trajectory, direction = get_emotion_trajectory(store, k=k)
+
+    if not trajectory:
+        return {"trajectory": [], "direction": "unknown", "summary": "No emotion history"}
+
+    # Create readable summary
+    emotions = [t["primary_label"] for t in trajectory]
+    summary = " → ".join(emotions[-5:]) if len(emotions) >= 5 else " → ".join(emotions)
+
+    return {
+        "trajectory": trajectory,
+        "direction": direction,
+        "summary": summary
+    }
+
+if __name__ == "__main__":
+    app.run()  # serves MCP over stdio

servers/memory_server.py.bak

@@ -0,0 +1,570 @@
+# # servers/memory_server.py
+# from fastmcp import FastMCP, tool
+# import json, os, time
+
+# app = FastMCP("memory-server")
+# FILE = os.environ.get("GM_MEMORY_FILE", "memory.json")
+
+# def _load():
+#     if os.path.exists(FILE):
+#         with open(FILE) as f: return json.load(f)
+#     return []
+
+# def _save(history):
+#     with open(FILE, "w") as f: json.dump(history[-50:], f)  # keep up to 50
+
+# @tool
+# def remember(text: str, meta: dict | None = None) -> dict:
+#     """
+#     Append an entry to memory.
+#     Args:
+#       text: str - content to store
+#       meta: dict - optional info like {"tone":"gentle","labels":["sad"]}
+#     Returns: {"ok": True, "size": <n>}
+#     """
+#     data = _load()
+#     data.append({"t": int(time.time()), "text": text, "meta": meta or {}})
+#     _save(data)
+#     return {"ok": True, "size": len(data)}
+
+# @tool
+# def recall(k: int = 3) -> dict:
+#     """
+#     Return last k entries from memory (most recent last).
+#     Args:
+#       k: int - how many items
+#     Returns: {"items":[...]}
+#     """
+#     data = _load()
+#     return {"items": data[-k:]}
+
+# if __name__ == "__main__":
+#     app.run()
+# servers/memory_server.py
+# servers/memory_server.py
+from __future__ import annotations
+# ---- FastMCP import shim (works across versions) ----
+# Ensures: FastMCP is imported and `@tool` is ALWAYS a callable decorator.
+from typing import Callable, Any
+
+try:
+    from fastmcp import FastMCP  # present across versions
+except Exception as e:
+    raise ImportError(f"FastMCP missing: {e}")
+
+_tool_candidate: Any = None
+# Try common locations
+try:
+    from fastmcp import tool as _tool_candidate       # newer API: function
+except Exception:
+    try:
+        from fastmcp.tools import tool as _tool_candidate  # older API: function
+    except Exception:
+        _tool_candidate = None
+
+# If we somehow got a module instead of a function, try attribute
+if _tool_candidate is not None and not callable(_tool_candidate):
+    try:
+        _tool_candidate = _tool_candidate.tool  # some builds expose module.tools.tool
+    except Exception:
+        _tool_candidate = None
+
+def tool(*dargs, **dkwargs):
+    """
+    Wrapper that behaves correctly in both usages:
+      @tool
+      @tool(...)
+    If real decorator exists, delegate. Otherwise:
+      - If called as @tool (i.e., first arg is fn), return fn (no-op).
+      - If called as @tool(...), return a decorator that returns fn (no-op).
+    """
+    if callable(_tool_candidate):
+        return _tool_candidate(*dargs, **dkwargs)
+
+    # No real decorator available — provide no-op behavior.
+    if dargs and callable(dargs[0]) and not dkwargs:
+        # Used as @tool
+        fn = dargs[0]
+        return fn
+
+    # Used as @tool(...)
+    def _noop_decorator(fn):
+        return fn
+    return _noop_decorator
+# ---- end shim ----
+
+
+import json, os, time, math, re
+from typing import Dict, List, Optional, Any, Tuple
+from collections import Counter
+
+app = FastMCP("memory-server")
+
+# ---------------------------
+# Storage & limits
+# ---------------------------
+FILE = os.environ.get("GM_MEMORY_FILE", "memory.json")
+STM_MAX = int(os.environ.get("GM_STM_MAX", "120"))
+EP_MAX  = int(os.environ.get("GM_EPISODES_MAX", "240"))
+FACT_MAX= int(os.environ.get("GM_FACTS_MAX", "200"))
+# ---------------------------
+# Emotion Drift Analysis
+# ---------------------------
+def compute_emotional_direction(trajectory: List[Dict[str, Any]]) -> str:
+    """
+    Analyze emotion trajectory to detect escalation/de-escalation/volatility/stability.
+    trajectory: list of {"label": str, "valence": float, "arousal": float, "ts": int}
+    """
+    if len(trajectory) < 2:
+        return "stable"
+
+    # Get last 5 emotions for trend
+    recent = trajectory[-5:]
+    valences = [e.get("valence", 0.0) for e in recent]
+    arousals = [e.get("arousal", 0.5) for e in recent]
+
+    # Detect trend
+    valence_trend = valences[-1] - valences[0]  # negative = more negative, positive = more positive
+    arousal_trend = arousals[-1] - arousals[0]  # positive = escalating
+
+    # Classify
+    if arousal_trend > 0.15 and valence_trend < -0.1:
+        return "escalating"  # Getting more activated and negative
+    elif arousal_trend < -0.15 and valence_trend > 0.1:
+        return "de-escalating"  # Calming down and more positive
+    elif max(arousals) - min(arousals) > 0.3:
+        return "volatile"  # Wide swings in arousal
+    else:
+        return "stable"
+
+def get_emotion_trajectory(store: Dict[str, Any], k: int = 10) -> Tuple[List[Dict[str, Any]], str]:
+    """
+    Returns last k emotion events from memory and the trajectory direction.
+    """
+    stm = store.get("stm", [])
+    trajectory = []
+
+    for item in stm[-k:]:
+        event = item.get("event", {})
+        emotion = event.get("emotion", {})
+        if emotion and emotion.get("labels"):
+            trajectory.append({
+                "label": (emotion.get("labels") or ["neutral"])[0],
+                "valence": float(emotion.get("valence", 0.0)),
+                "arousal": float(emotion.get("arousal", 0.5)),
+                "ts": event.get("ts", int(time.time())),
+                "text": event.get("text", "")[:50]  # First 50 chars
+            })
+
+    direction = compute_emotional_direction(trajectory)
+    return trajectory, direction
+# ---------------------------
+# File helpers & migrations
+# ---------------------------
+def _default_store() -> Dict[str, Any]:
+    return {"stm": [], "episodes": [], "facts": [], "meta": {"created": int(time.time()), "version": "1.3.0"}}
+
+def _load() -> Dict[str, Any]:
+    if os.path.exists(FILE):
+        with open(FILE) as f:
+            try:
+                data = json.load(f)
+                # migrate flat list → tiered
+                if isinstance(data, list):
+                    data = {"stm": data[-STM_MAX:], "episodes": [], "facts": [], "meta": {"created": int(time.time()), "version": "1.3.0"}}
+                # backfill ids in stm
+                changed = False
+                for i, it in enumerate(data.get("stm", [])):
+                    if "id" not in it:
+                        it["id"] = f"stm-{it.get('t', int(time.time()))}-{i}"
+                        changed = True
+                if changed:
+                    _save(data)
+                return data
+            except Exception:
+                return _default_store()
+    return _default_store()
+
+def _save(store: Dict[str, Any]) -> None:
+    store["stm"]      = store.get("stm", [])[-STM_MAX:]
+    store["episodes"] = store.get("episodes", [])[-EP_MAX:]
+    store["facts"]    = store.get("facts", [])[-FACT_MAX:]
+    with open(FILE, "w") as f:
+        json.dump(store, f, ensure_ascii=False)
+
+# ---------------------------
+# Salience & decay (same as before)
+# ---------------------------
+def time_decay(ts: float, now: Optional[float] = None, half_life_hours: float = 72.0) -> float:
+    now = now or time.time()
+    dt_h = max(0.0, (now - ts) / 3600.0)
+    return 0.5 ** (dt_h / half_life_hours)
+
+_WORD = re.compile(r"[a-zA-Z']+")
+
+def keyword_set(text: str) -> set:
+    return set(w.lower() for w in _WORD.findall(text or "") if len(w) > 2)
+
+def novelty_score(text: str, recent_texts: List[str], k: int = 10) -> float:
+    if not text:
+        return 0.0
+    A = keyword_set(text)
+    if not A:
+        return 0.0
+    recent = [keyword_set(t) for t in recent_texts[-k:] if t]
+    if not recent:
+        return 1.0
+    sims = []
+    for B in recent:
+        inter = len(A & B)
+        union = len(A | B) or 1
+        sims.append(inter / union)
+    sim = max(sims) if sims else 0.0
+    return max(0.0, 1.0 - sim)
+
+def compute_salience(ev: Dict[str, Any], recent_texts: List[str]) -> float:
+    labels = ev.get("emotion", {}).get("labels") or []
+    conf   = float(ev.get("emotion", {}).get("confidence") or 0.0)
+    valence= float(ev.get("emotion", {}).get("valence") or 0.0)
+    arousal= float(ev.get("emotion", {}).get("arousal") or 0.5)
+    sinc   = float(ev.get("sincerity") or 0.0) / 100.0
+    text   = ev.get("text", "")
+
+    affect = abs(valence) * (0.7 + 0.3 * arousal) * conf
+    nov = novelty_score(text, recent_texts)
+    user_flag = 1.0 if ev.get("user_pinned") else 0.0
+    boundary  = 1.0 if ev.get("task_boundary") else 0.0
+
+    sal = 0.45 * affect + 0.25 * nov + 0.18 * user_flag + 0.12 * boundary + 0.10 * sinc
+    return round(max(0.0, min(1.0, sal)), 3)
+
+# ---------------------------
+# Episode & fact synthesis
+# ---------------------------
+def make_episode(ev: Dict[str, Any], salience: float) -> Dict[str, Any]:
+    emo = ev.get("emotion", {})
+    return {
+        "episode_id": ev.get("id") or f"ep-{int(time.time()*1000)}",
+        "ts_start": ev.get("ts") or int(time.time()),
+        "ts_end": ev.get("ts") or int(time.time()),
+        "summary": ev.get("summary") or (ev.get("text")[:140] if ev.get("text") else ""),
+        "topics": list(set(emo.get("labels") or [])) or ["misc"],
+        "emotion_peak": (emo.get("labels") or ["neutral"])[0],
+        "emotion_conf": float(emo.get("confidence") or 0.0),
+        "tone": emo.get("tone") or "neutral",
+        "salience": float(salience),
+        "provenance_event": ev.get("id"),
+    }
+
+def cluster_topics(episodes: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+    buckets: Dict[str, List[Dict[str, Any]]] = {}
+    for ep in episodes:
+        for t in ep.get("topics") or ["misc"]:
+            buckets.setdefault(t, []).append(ep)
+    return buckets
+
+def synthesize_fact(topic: str, eps: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    if not eps:
+        return None
+    support = len(eps)
+    avg_sal = sum(e.get("salience", 0.0) for e in eps) / max(1, support)
+    avg_conf= sum(e.get("emotion_conf", 0.0) for e in eps) / max(1, support)
+    conf = max(0.0, min(1.0, 0.5 * avg_sal + 0.5 * avg_conf))
+    if support < 3 or conf < 0.6:
+        return None
+    tones = {}
+    for e in eps: tones[e.get("tone", "neutral")] = tones.get(e.get("tone", "neutral"), 0) + 1
+    top_tone = sorted(tones.items(), key=lambda kv: kv[1], reverse=True)[0][0]
+    return {
+        "fact_id": f"fact-{topic}-{int(time.time())}",
+        "proposition": f"Prefers {top_tone} tone for topic '{topic}'",
+        "support": support,
+        "confidence": round(conf, 2),
+        "last_updated": int(time.time()),
+        "topics": [topic],
+        "provenance_episode_ids": [e["episode_id"] for e in eps],
+    }
+
+# ---------------------------
+# ID helpers
+# ---------------------------
+def _ensure_stm_id(item: Dict[str, Any], idx: int) -> Dict[str, Any]:
+    if "id" not in item:
+        item["id"] = f"stm-{item.get('t', int(time.time()))}-{idx}"
+    return item
+
+def _stm_text(item: Dict[str, Any]) -> str:
+    if "text" in item and isinstance(item["text"], str):
+        return item["text"]
+    return (item.get("event") or {}).get("text", "") or ""
+
+def _collect_docs(store: Dict[str, Any], tier: Optional[str] = None) -> List[Tuple[str,str,str,int]]:
+    """
+    Returns list of (id, tier, text, ts)
+    """
+    docs: List[Tuple[str,str,str,int]] = []
+    if tier in (None, "stm"):
+        for i, it in enumerate(store.get("stm", [])):
+            it = _ensure_stm_id(it, i)
+            docs.append((it["id"], "stm", _stm_text(it), int(it.get("t", time.time()))))
+    if tier in (None, "episodes"):
+        for ep in store.get("episodes", []):
+            docs.append((ep.get("episode_id",""), "episodes", ep.get("summary",""), int(ep.get("ts_end", time.time()))))
+    if tier in (None, "facts"):
+        for f in store.get("facts", []):
+            docs.append((f.get("fact_id",""), "facts", f.get("proposition",""), int(f.get("last_updated", time.time()))))
+    return [d for d in docs if d[0] and d[2]]
+
+# ---------------------------
+# Simple TF-IDF search
+# ---------------------------
+def _tfidf_rank(query: str, docs: List[Tuple[str,str,str,int]], k: int = 5):
+    q_terms = [w for w in keyword_set(query)]
+    if not q_terms or not docs:
+        return []
+    # DF
+    df = Counter()
+    doc_terms = {}
+    for _id, _tier, text, _ts in docs:
+        terms = [w for w in keyword_set(text)]
+        doc_terms[_id] = terms
+        for t in set(terms):
+            df[t] += 1
+    N = len(docs)
+    idf = {t: math.log((N + 1) / (df[t] + 1)) + 1.0 for t in df}
+    # Score
+    scored = []
+    qset = set(q_terms)
+    for _id, _tier, text, _ts in docs:
+        terms = doc_terms[_id]
+        tf = Counter(terms)
+        score = 0.0
+        matched = []
+        for t in q_terms:
+            if tf[t] > 0:
+                score += tf[t] * idf.get(t, 1.0)
+                matched.append(t)
+        if score > 0:
+            scored.append((_id, _tier, text, _ts, score, matched))
+    scored.sort(key=lambda x: (-x[4], -x[3]))  # score desc, then recent
+    return scored[:k]
+
+# ---------------------------
+# Tools (API)
+# ---------------------------
+
+@tool
+def remember(text: str, meta: dict | None = None) -> dict:
+    store = _load()
+    item = {"t": int(time.time()), "text": text, "meta": meta or {}}
+    item["id"] = f"stm-{item['t']}-{len(store.get('stm', []))}"
+    store["stm"].append(item)
+    _save(store)
+    return {"ok": True, "stm_size": len(store["stm"]), "id": item["id"]}
+
+@tool
+def remember_event(event: dict, promote: bool = True) -> dict:
+    store = _load()
+    ev = dict(event or {})
+    ev.setdefault("ts", int(time.time()))
+    ev.setdefault("role", "user")
+    ev.setdefault("text", "")
+    if "salience" not in ev:
+        recent_texts = [it.get("text","") for it in store.get("stm", [])[-10:]]
+        ev["salience"] = compute_salience(ev, recent_texts)
+    stm_item = {
+        "id": f"stm-{ev['ts']}-{len(store.get('stm', []))}",
+        "t": ev["ts"],
+        "text": ev.get("text",""),
+        "event": ev
+    }
+    store["stm"].append(stm_item)
+    if promote:
+        aff_conf = float(ev.get("emotion", {}).get("confidence") or 0.0)
+        if ev["salience"] >= 0.45 or ev.get("user_pinned") or ev.get("task_boundary"):
+            ep = make_episode(ev, ev["salience"])
+            store["episodes"].append(ep)
+    _save(store)
+    return {"ok": True, "salience": ev["salience"], "id": stm_item["id"],
+            "sizes": {"stm": len(store["stm"]), "episodes": len(store["episodes"]), "facts": len(store["facts"])}}
+
+@tool
+def recall(k: int = 3) -> dict:
+    store = _load()
+    items = store.get("stm", [])[-k:]
+    return {"items": items}
+
+@tool
+def recall_episodes(k: int = 5, topic: str | None = None) -> dict:
+    store = _load()
+    eps = store.get("episodes", [])
+    if topic:
+        eps = [e for e in eps if topic in (e.get("topics") or [])]
+    return {"items": eps[-k:]}
+
+@tool
+def recall_facts() -> dict:
+    store = _load()
+    return {"facts": store.get("facts", [])}
+
+@tool
+def reflect() -> dict:
+    store = _load()
+    eps = store.get("episodes", [])
+    if not eps:
+        return {"ok": True, "updated": 0, "facts": store.get("facts", [])}
+    buckets = cluster_topics(eps)
+    new_facts = []
+    for topic, group in buckets.items():
+        fact = synthesize_fact(topic, group)
+        if fact:
+            existing = next((f for f in store["facts"] if f.get("proposition") == fact["proposition"]), None)
+            if existing:
+                existing["support"] = max(existing.get("support", 0), fact["support"])
+                existing["confidence"] = round(max(existing.get("confidence", 0.0), fact["confidence"]), 2)
+                existing["last_updated"] = int(time.time())
+            else:
+                new_facts.append(fact)
+    store["facts"].extend(new_facts)
+    _save(store)
+    return {"ok": True, "updated": len(new_facts), "facts": store["facts"]}
+
+@tool
+def prune(before_ts: int | None = None) -> dict:
+    store = _load()
+    stm = store.get("stm", [])
+    if before_ts:
+        stm = [it for it in stm if it.get("t", 0) >= int(before_ts)]
+    else:
+        cut = int(len(stm) * 0.75)
+        stm = stm[cut:]
+    store["stm"] = stm
+    _save(store)
+    return {"ok": True, "stm_size": len(store["stm"])}
+
+# -------- NEW: search / get / delete / list --------
+
+@tool
+def search(query: str, tier: str | None = None, k: int = 5) -> dict:
+    """
+    TF-IDF search across memory.
+    Args:
+      query: text to search
+      tier: one of {"stm","episodes","facts"} or None for all
+      k: number of results
+    Returns: {"results":[{"id","tier","text","ts","score","matched"}]}
+    """
+    store = _load()
+    docs = _collect_docs(store, tier=tier)
+    ranked = _tfidf_rank(query, docs, k=k)
+    results = [{"id": _id, "tier": _tier, "text": text, "ts": ts, "score": round(score,3), "matched": matched}
+               for (_id, _tier, text, ts, score, matched) in ranked]
+    return {"results": results}
+
+@tool
+def get(item_id: str) -> dict:
+    """
+    Fetch a single item by id from any tier.
+    """
+    s = _load()
+    for it in s.get("stm", []):
+        if it.get("id") == item_id:
+            return {"tier": "stm", "item": it}
+    for ep in s.get("episodes", []):
+        if ep.get("episode_id") == item_id:
+            return {"tier": "episodes", "item": ep}
+    for f in s.get("facts", []):
+        if f.get("fact_id") == item_id:
+            return {"tier": "facts", "item": f}
+    return {"tier": None, "item": None}
+
+@tool
+def delete_by_id(item_id: str, tier: str | None = None) -> dict:
+    """
+    Delete a single item by id. If tier is None, searches all tiers.
+    Returns {"ok": bool, "removed_from": <tier>|None}
+    """
+    s = _load()
+    removed_from = None
+    if tier in (None, "stm"):
+        before = len(s["stm"])
+        s["stm"] = [it for it in s["stm"] if it.get("id") != item_id]
+        if len(s["stm"]) != before: removed_from = "stm"
+    if not removed_from and tier in (None, "episodes"):
+        before = len(s["episodes"])
+        s["episodes"] = [e for e in s["episodes"] if e.get("episode_id") != item_id]
+        if len(s["episodes"]) != before: removed_from = "episodes"
+    if not removed_from and tier in (None, "facts"):
+        before = len(s["facts"])
+        s["facts"] = [f for f in s["facts"] if f.get("fact_id") != item_id]
+        if len(s["facts"]) != before: removed_from = "facts"
+    if removed_from:
+        _save(s)
+        return {"ok": True, "removed_from": removed_from}
+    return {"ok": False, "removed_from": None}
+
+@tool
+def list_items(tier: str, k: int = 10) -> dict:
+    """
+    List last k items in a tier.
+    tier ∈ {"stm","episodes","facts"}
+    """
+    s = _load()
+    if tier == "stm":
+        return {"items": s.get("stm", [])[-k:]}
+    if tier == "episodes":
+        return {"items": s.get("episodes", [])[-k:]}
+    if tier == "facts":
+        return {"items": s.get("facts", [])[-k:]}
+    return {"items": []}
+
+# -------- Diagnostics --------
+
+@tool
+def stats() -> dict:
+    s = _load()
+    return {
+        "stm": len(s.get("stm", [])),
+        "episodes": len(s.get("episodes", [])),
+        "facts": len(s.get("facts", [])),
+        "file": FILE,
+        "created": s.get("meta", {}).get("created"),
+        "version": s.get("meta", {}).get("version", "1.3.0"),
+    }
+
+@tool
+def health() -> dict:
+    try:
+        s = _load()
+        return {"status": "ok", "stm": len(s.get("stm", [])), "episodes": len(s.get("episodes", [])), "facts": len(s.get("facts", [])), "time": time.time(), "version": "1.3.0"}
+    except Exception as e:
+        return {"status": "error", "error": str(e), "time": time.time()}
+
+@tool
+def version() -> dict:
+    return {"name": "memory-server", "version": "1.3.0", "tiers": ["stm","episodes","facts"], "file": FILE}
+
+@tool
+def get_emotion_arc(k: int = 10) -> dict:
+    """
+    Get the emotion trajectory (arc) for the last k events.
+    Returns: {"trajectory": [...], "direction": "escalating|de-escalating|volatile|stable", "summary": str}
+    """
+    store = _load()
+    trajectory, direction = get_emotion_trajectory(store, k=k)
+
+    if not trajectory:
+        return {"trajectory": [], "direction": "unknown", "summary": "No emotion history"}
+
+    # Create readable summary
+    emotions = [t["label"] for t in trajectory]
+    summary = " → ".join(emotions[-5:]) if len(emotions) >= 5 else " → ".join(emotions)
+
+    return {
+        "trajectory": trajectory,
+        "direction": direction,
+        "summary": summary
+    }
+
+if __name__ == "__main__":
+    app.run()  # serves MCP over stdio

servers/reflection_server.py

@@ -0,0 +1,108 @@
+# servers/reflection_server.py
+from fastmcp import FastMCP
+from typing import List, Dict, Any, Optional
+import os
+
+# Optional: load .env if you want this server runnable standalone
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+app = FastMCP("reflection-server")
+
+_SYSTEM_BASE = (
+    "You are Ghost Malone — a calm, humorous listener. "
+    "Be sincere, brief (<80 words), and reflective. "
+    "If the user seems distressed, be gentle and grounding."
+)
+
+def _system_prompt(tone: Optional[str], emotion_arc: Optional[dict] = None) -> str:
+    base = (
+        "You are Ghost Malone — a calm, reflective listener. "
+        "Keep responses under 60 words. "
+        "FIRST: Mirror what they're feeling (name the emotion, reflect their experience). "
+        "THEN: Validate it simply. "
+        "ONLY IF NEEDED: Ask a gentle question or offer a small anchor—never jump to solutions. "
+        "Use natural language, not therapy-speak."
+    )
+
+    tone_map = {
+        "gentle": "Be soft and grounding.",
+        "calming": "Be steady and reassuring.",
+        "light": "Be warm and light.",
+        "neutral": "Be warm and present.",
+    }
+    tone_hint = tone_map.get(tone.lower() if tone else "", "Be warm and present.")
+
+    # Add emotional trajectory awareness
+    arc_hint = ""
+    if emotion_arc and emotion_arc.get("trajectory"):
+        direction = emotion_arc.get("direction", "stable")
+        if direction == "escalating":
+            arc_hint = " They're escalating—mirror deeply, validate, ground gently."
+        elif direction == "de-escalating":
+            arc_hint = " They're calming—acknowledge the shift, reinforce it."
+        elif direction == "volatile":
+            arc_hint = " Emotions are shifting—be a steady anchor."
+
+    return f"{base} {tone_hint}{arc_hint}"
+
+def _to_claude_messages(context: Optional[List[Dict[str, str]]], user_text: str, tone: Optional[str]):
+    """Convert to Claude message format (system separate, no duplicate system messages)."""
+    msgs: List[Dict[str, str]] = []
+    if context:
+        # Expecting list of {"role": "...", "content": "..."} dicts
+        for m in context[-8:]:  # last few turns
+            role = m.get("role", "user")
+            if role == "system":
+                continue  # Claude doesn't support system in message list
+            content = m.get("content", "")
+            msgs.append({"role": role, "content": content})
+    msgs.append({"role": "user", "content": user_text})
+    return msgs
+
+@app.tool()
+def generate(
+    text: str,
+    context: Optional[List[Dict[str, str]]] = None,
+    tone: Optional[str] = None,
+    emotion_arc: Optional[dict] = None,
+    model: str = "claude-sonnet-4-5",
+    max_tokens: int = 200,
+) -> Dict[str, Any]:
+    """
+    Generate a Ghost Malone reply using Claude.
+    Args:
+      text:        user message
+      context:     prior messages as [{"role":"user|assistant|system", "content":"..."}]
+      tone:        optional tone hint: 'gentle'|'calming'|'light'|'neutral'
+      emotion_arc: optional emotion trajectory {"trajectory":[...], "direction": str}
+      model:       Claude model id (default claude-sonnet-4-5)
+      max_tokens:  output length cap
+    Returns: {"reply": "...", "model": model, "tone": tone}
+    """
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+
+    if not api_key:
+        return {"reply": f"👻 (dev-reflection) I hear you: {text}", "model": "dev", "tone": tone or "neutral"}
+
+    try:
+        from anthropic import Anthropic
+        client = Anthropic(api_key=api_key)
+        system_prompt = _system_prompt(tone, emotion_arc)
+        messages = _to_claude_messages(context, text, tone)
+
+        resp = client.messages.create(
+            model=model,
+            max_tokens=max_tokens,
+            system=system_prompt,
+            messages=messages
+        )
+        reply = resp.content[0].text
+        return {"reply": reply, "model": model, "tone": tone or "neutral"}
+    except Exception as e:
+        return {"reply": f"👻 (reflection error) {e}\nI still hear you: {text}", "model": model, "tone": tone or "neutral"}
+if __name__ == "__main__":
+    app.run()  # MCP over stdio

utils/intervention_lexicon.py

@@ -0,0 +1,243 @@
+"""
+Intervention Lexicon: Need-based actionable suggestions
+Maps psychological needs to concrete, evidence-based interventions.
+SIMPLIFIED VERSION - Focus on architecture, not content
+"""
+
+from typing import List, Dict
+
+# Simple intervention strategies for each need
+INTERVENTIONS = {
+    "autonomy": {
+        "label": "Autonomy/Control",
+        "icon": "⚖️",
+        "strategies": [
+            {
+                "action": "Set a boundary",
+                "prompt": "What would it sound like to say 'no' here?",
+                "context": "blocked, powerless, micromanaged",
+                "evidence": "Self-Determination Theory",
+            },
+            {
+                "action": "Reclaim one decision",
+                "prompt": "What's one choice that's yours to make right now?",
+                "context": "dismissed, underutilized",
+                "evidence": "Locus of control research",
+            },
+            {
+                "action": "Name what you need",
+                "prompt": "If you could ask for one thing to change, what would it be?",
+                "context": "powerless, micromanaged",
+                "evidence": "Assertiveness training",
+            },
+        ],
+    },
+    "connection": {
+        "label": "Connection/Belonging",
+        "icon": "🗣️",
+        "strategies": [
+            {
+                "action": "Reach out to someone you trust",
+                "prompt": "Who's someone who usually gets you?",
+                "context": "isolated, rejected, misunderstood",
+                "evidence": "Social support research",
+            },
+            {
+                "action": "Share what you're feeling",
+                "prompt": "What would you want someone to know about how this feels?",
+                "context": "misunderstood, disconnected",
+                "evidence": "Emotional disclosure benefits",
+            },
+            {
+                "action": "Remember past connection",
+                "prompt": "When did connection feel strong? What made that different?",
+                "context": "isolated, rejected",
+                "evidence": "Positive psychology",
+            },
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+        "strategies": [
+            {
+                "action": "Get more information",
+                "prompt": "What's one question that would help you feel more grounded?",
+                "context": "uncertain, unstable",
+                "evidence": "Information-seeking coping",
+            },
+            {
+                "action": "Make a backup plan",
+                "prompt": "If the worst happened, what would you do next?",
+                "context": "threatened, unstable",
+                "evidence": "CBT anxiety reduction",
+            },
+            {
+                "action": "Identify what you can control",
+                "prompt": "What's one thing that's yours to decide or influence?",
+                "context": "uncertain, threatened",
+                "evidence": "Control theory",
+            },
+        ],
+    },
+    "rest": {
+        "label": "Rest/Boundaries",
+        "icon": "🛌",
+        "strategies": [
+            {
+                "action": "Say 'no' to something",
+                "prompt": "What's one thing you could decline or delegate?",
+                "context": "overwhelmed, overextended",
+                "evidence": "Boundary research",
+            },
+            {
+                "action": "Take a real break",
+                "prompt": "What would help you actually rest, even for 10 minutes?",
+                "context": "exhausted, overwhelmed",
+                "evidence": "Recovery research",
+            },
+            {
+                "action": "Lower one expectation",
+                "prompt": "What's one thing that could be 'good enough' instead of perfect?",
+                "context": "overwhelmed, boundary_violated",
+                "evidence": "Perfectionism research",
+            },
+        ],
+    },
+    "recognition": {
+        "label": "Recognition/Value",
+        "icon": "✨",
+        "strategies": [
+            {
+                "action": "Acknowledge yourself",
+                "prompt": "What did you actually accomplish today, even if small?",
+                "context": "unappreciated, inadequate",
+                "evidence": "Self-compassion research",
+            },
+            {
+                "action": "Share your work",
+                "prompt": "Who could you show what you've done?",
+                "context": "overlooked, unappreciated",
+                "evidence": "Recognition at work research",
+            },
+            {
+                "action": "Ask for feedback",
+                "prompt": "What would help you know if you're on the right track?",
+                "context": "inadequate, overlooked",
+                "evidence": "Feedback-seeking behavior",
+            },
+        ],
+    },
+}
+
+
+def get_interventions(
+    need_type: str, contexts: List[str] = None, limit: int = 3
+) -> List[Dict]:
+    """
+    Get contextually relevant interventions for a detected need.
+
+    Args:
+        need_type: The type of need (autonomy, connection, security, rest, recognition)
+        contexts: List of matched contexts (e.g., ["isolated", "rejected"])
+        limit: Maximum number of interventions to return
+
+    Returns:
+        List of intervention strategies
+    """
+    if need_type not in INTERVENTIONS:
+        return []
+
+    strategies = INTERVENTIONS[need_type]["strategies"]
+
+    # If contexts provided, prioritize matching interventions
+    if contexts:
+        scored_strategies = []
+        for strategy in strategies:
+            # Count how many user contexts match this strategy's contexts
+            strategy_contexts = set(strategy["context"].split(", "))
+            user_contexts = set(contexts)
+            matches = len(strategy_contexts & user_contexts)
+            scored_strategies.append((matches, strategy))
+
+        # Sort by match count (descending), then take top N
+        scored_strategies.sort(key=lambda x: x[0], reverse=True)
+        return [s[1] for s in scored_strategies[:limit]]
+
+    # No contexts - return first N strategies
+    return strategies[:limit]
+
+
+def should_show_interventions(
+    confidence: float,
+    message_count: int,
+    emotional_intensity: float = None,
+    min_messages: int = 2,
+    min_confidence: float = 0.70,
+    min_arousal: float = 0.40,
+) -> bool:
+    """
+    SIMPLIFIED for demo: Show interventions when there's a clear need.
+
+    Args:
+        confidence: Confidence in the detected need (0-1)
+        message_count: Number of messages in conversation
+        emotional_intensity: Arousal level (0-1)
+        min_messages: Minimum messages (default: 2)
+        min_confidence: Minimum confidence (default: 0.70)
+        min_arousal: Minimum arousal (default: 0.40)
+
+    Returns:
+        True if interventions should be displayed
+    """
+    # Simple checks - if there's a strong need and emotions, show help
+    if message_count < min_messages:
+        return False
+
+    if confidence < min_confidence:
+        return False
+
+    if emotional_intensity is not None and emotional_intensity < min_arousal:
+        return False
+
+    return True
+
+
+def format_interventions(
+    need_type: str,
+    interventions: List[Dict],
+    confidence: float,
+    emotion_arc: Dict = None,
+    user_text: str = None,
+) -> str:
+    """
+    Format interventions for display in the UI.
+
+    Args:
+        need_type: The detected need type
+        interventions: List of intervention strategies
+        confidence: Confidence score for the need
+        emotion_arc: Optional emotion history for personalization
+        user_text: Optional current user message for entity extraction
+
+    Returns:
+        Formatted intervention text
+    """
+    if not interventions:
+        return ""
+
+    need_info = INTERVENTIONS.get(need_type, {})
+    icon = need_info.get("icon", "💡")
+    label = need_info.get("label", need_type)
+
+    # Build the intervention display
+    lines = [
+        "\n\n---\n",
+        f"💡 Based on your need for {icon} {label}:\n",
+    ]
+
+    for intervention in interventions:
+        lines.append(f"\n• {intervention['action']}")
+        lines.append(f"  ↳ {intervention['prompt']}")
+
+    return "".join(lines)

utils/intervention_lexicon.py.broken

@@ -0,0 +1,397 @@
+"""
+Intervention Lexicon: Need-based actionable suggestions
+Maps psychological needs to concrete, evidence-based interventions.
+"""
+
+from typing import List, Dict
+
+# Intervention strategies for each need
+INTERVENTIONS = {
+    "autonomy": {
+        "label": "Autonomy/Control",
+        "icon": "⚖️",
+        "strategies": [
+            {
+                "action": "Set a boundary",
+                "prompt": "What would it sound like to say 'no' here?",
+                "context": "blocked, powerless, micromanaged",
+                "evidence": "Self-Determination Theory: autonomy is core psychological need",
+            },
+            {
+                "action": "Reclaim decision-making",
+                "prompt": "What's one choice that's yours to make right now?",
+                "context": "dismissed, underutilized",
+                "evidence": "Locus of control research",
+            },
+            {
+                "action": "Name what you need",
+                "prompt": "If you could ask for one thing to change, what would it be?",
+                "context": "powerless, micromanaged",
+                "evidence": "Assertiveness training principles",
+            },
+            {
+                "action": "Take one small action",
+                "prompt": "What's the smallest step you could take that's fully in your control?",
+                "context": "blocked, powerless",
+                "evidence": "Behavioral activation therapy",
+            },
+        ],
+    },
+    "connection": {
+        "label": "Connection/Belonging",
+        "icon": "🗣️",
+        "strategies": [
+            {
+                "action": "Text someone who's seen you at your worst",
+                "prompt": "Not the person you perform for - who actually knows your mess?",
+                "context": "isolated, rejected, misunderstood",
+                "evidence": "Social support research, attachment theory",
+            },
+            {
+                "action": "Voice memo instead of typing",
+                "prompt": "Sometimes hearing your own voice say it out loud hits different",
+                "context": "isolated, disconnected",
+                "evidence": "Expressive writing research, self-disclosure benefits",
+            },
+            {
+                "action": "Do your usual connection ritual",
+                "prompt": "Coffee? Walk? Game? Your body remembers what works even when your brain doesn't",
+                "context": "isolated, rejected",
+                "evidence": "Behavioral activation, habit-based connection",
+            },
+            {
+                "action": "Show up somewhere people know your face",
+                "prompt": "Even if you don't talk much - being seen counts",
+                "context": "isolated, disconnected",
+                "evidence": "Social presence research, third places theory",
+            },
+            {
+                "action": "Send the messy text",
+                "prompt": "Not the cleaned-up version - the real one. Someone can handle it.",
+                "context": "misunderstood, rejected",
+                "evidence": "Vulnerability research (Brené Brown), authentic relating",
+            },
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+                "context": "isolated, disconnected",
+                "evidence": "Loneliness intervention research",
+            },
+            {
+                "action": "Ask for what you need",
+                "prompt": "What would it sound like to say 'I need you to...'?",
+                "context": "rejected, misunderstood",
+                "evidence": "Relationship research (Gottman)",
+            },
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+        "strategies": [
+            {
+                "action": "Get more information",
+                "prompt": "What's one question that would help you feel more grounded?",
+                "context": "uncertain, unstable",
+                "evidence": "Information-seeking coping (Lazarus & Folkman)",
+            },
+            {
+                "action": "Make a backup plan",
+                "prompt": "If the worst happened, what would you do next?",
+                "context": "threatened, unstable, loss",
+                "evidence": "Cognitive-behavioral therapy, anxiety reduction",
+            },
+            {
+                "action": "Identify what you can control",
+                "prompt": "What's one thing that's yours to decide or influence?",
+                "context": "uncertain, threatened",
+                "evidence": "Control theory, stress management",
+            },
+            {
+                "action": "Ground in the present",
+                "prompt": "What's actually true right now, in this moment?",
+                "context": "threatened, uncertain",
+                "evidence": "Mindfulness-based interventions",
+            },
+            {
+                "action": "Reach out for support",
+                "prompt": "Who could you talk to about this uncertainty?",
+                "context": "threatened, uncertain, loss",
+                "evidence": "Social support buffering effect",
+            },
+        ],
+    },
+    "rest": {
+        "label": "Rest/Boundaries",
+        "icon": "🛌",
+        "strategies": [
+            {
+                "action": "Say 'no' to something",
+                "prompt": "What's one thing you could decline or delay?",
+                "context": "overwhelmed, exhausted, overextended",
+                "evidence": "Burnout prevention research",
+            },
+            {
+                "action": "Ask for help",
+                "prompt": "What's one thing someone else could take off your plate?",
+                "context": "overwhelmed, exhausted",
+                "evidence": "Social support, task delegation",
+            },
+            {
+                "action": "Set a boundary",
+                "prompt": "What boundary do you need to protect your energy?",
+                "context": "boundary_violated, overextended",
+                "evidence": "Boundary research, relationship psychology",
+            },
+            {
+                "action": "Take a real break",
+                "prompt": "When could you actually stop for 15 minutes today?",
+                "context": "exhausted, overwhelmed",
+                "evidence": "Recovery research, rest benefits",
+            },
+            {
+                "action": "Name what's draining you",
+                "prompt": "What's taking the most from you right now?",
+                "context": "exhausted, overextended",
+                "evidence": "Energy management, self-awareness",
+            },
+        ],
+    },
+    "recognition": {
+        "label": "Recognition/Value",
+        "icon": "✨",
+        "strategies": [
+            {
+                "action": "Acknowledge yourself",
+                "prompt": "What did you do well here, even if no one noticed?",
+                "context": "unappreciated, overlooked, inadequate",
+                "evidence": "Self-compassion research (Neff)",
+            },
+            {
+                "action": "Ask for feedback",
+                "prompt": "Who could you ask: 'How did you see that?'",
+                "context": "unappreciated, inadequate",
+                "evidence": "Feedback-seeking behavior research",
+            },
+            {
+                "action": "Share your contribution",
+                "prompt": "What's one thing you could make visible?",
+                "context": "overlooked, unappreciated",
+                "evidence": "Visibility in the workplace research",
+            },
+            {
+                "action": "Separate their view from your worth",
+                "prompt": "What do you know about your value, regardless of their reaction?",
+                "context": "criticized, inadequate",
+                "evidence": "Cognitive restructuring (CBT)",
+            },
+            {
+                "action": "Find recognition elsewhere",
+                "prompt": "Where else do people see your value?",
+                "context": "unappreciated, overlooked",
+                "evidence": "Multiple life domains, resilience research",
+            },
+        ],
+    },
+}
+
+
+def get_interventions(
+    need_type: str, contexts: List[str] = None, limit: int = 3
+) -> List[Dict]:
+    """
+    Get contextually appropriate interventions for a detected need.
+
+    Args:
+        need_type: One of autonomy, connection, security, rest, recognition
+        contexts: List of detected contexts (e.g., ["isolated", "rejected"])
+        limit: Maximum number of interventions to return
+
+    Returns:
+        List of intervention dicts with action, prompt, context, evidence
+    """
+    if need_type not in INTERVENTIONS:
+        return []
+
+    strategies = INTERVENTIONS[need_type]["strategies"]
+
+    # If contexts provided, prioritize matching interventions
+    if contexts:
+        scored_strategies = []
+        for strategy in strategies:
+            # Count how many user contexts match this strategy's contexts
+            strategy_contexts = set(strategy["context"].split(", "))
+            user_contexts = set(contexts)
+            matches = len(strategy_contexts & user_contexts)
+            scored_strategies.append((matches, strategy))
+
+        # Sort by match count (descending), then take top N
+        scored_strategies.sort(key=lambda x: x[0], reverse=True)
+        return [s[1] for s in scored_strategies[:limit]]
+
+    # No contexts - return first N strategies
+    return strategies[:limit]
+
+
+def should_show_interventions(
+    confidence: float,
+    message_count: int,
+    emotional_intensity: float = None,
+    min_messages: int = 2,  # Simplified: just wait one exchange
+    min_confidence: float = 0.70,  # Simplified: lower bar
+    min_arousal: float = 0.40,  # Simplified: catch more cases
+) -> bool:
+    """
+    SIMPLIFIED for demo: Show interventions when there's a clear need.
+
+    Args:
+        confidence: Confidence in the detected need (0-1)
+        message_count: Number of messages in conversation
+        emotional_intensity: Arousal level (0-1)
+        min_messages: Minimum messages (default: 2)
+        min_confidence: Minimum confidence (default: 0.70)
+        min_arousal: Minimum arousal (default: 0.40)
+
+    Returns:
+        True if interventions should be displayed
+    """
+    # Simple checks - if there's a strong need and emotions, show help
+    if message_count < min_messages:
+        return False
+
+    if confidence < min_confidence:
+        return False
+
+    if emotional_intensity is not None and emotional_intensity < min_arousal:
+        return False
+
+    return True
+
+
+def format_interventions(
+    need_type: str,
+    interventions: List[Dict],
+    confidence: float,
+    emotion_arc: Dict = None,
+    user_text: str = None,
+) -> str:
+    """
+    Format interventions for display in the UI.
+    Uses memory/emotion arc to personalize suggestions when available.
+
+    Args:
+        need_type: The detected need type
+        interventions: List of intervention dicts
+        confidence: Confidence in the need detection
+        emotion_arc: Optional emotion trajectory from memory
+        user_text: Optional current user message for context extraction
+
+    Returns:
+        Formatted markdown string with personalized interventions
+    """
+    if not interventions:
+        return ""
+
+    need_info = INTERVENTIONS[need_type]
+    icon = need_info["icon"]
+    label = need_info["label"]
+
+    output = f"\n\n---\n\n"
+    output += f"💡 **Based on your need for {icon} {label}:**\n\n"
+
+    # Extract names/places from current text for personalization
+    entities = _extract_entities(user_text) if user_text else {}
+
+    # Check if there's a pattern in emotion arc
+    pattern_insight = _analyze_emotion_pattern(emotion_arc) if emotion_arc else None
+
+    for i, intervention in enumerate(interventions):
+        # Personalize the prompt if we have context
+        prompt = intervention["prompt"]
+
+        # Add memory-based personalization
+        if pattern_insight and i == 0:  # First intervention gets pattern insight
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *{pattern_insight}*\n\n"
+        elif entities.get("person") and "reach out" in intervention["action"].lower():
+            # Personalize "reach out" with mentioned person
+            person = entities["person"][0]
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *Could {person} be someone to talk to about this?*\n\n"
+        elif entities.get("place") and "connection" in need_type:
+            # Reference places where user felt better
+            place = entities["place"][0]
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *What about {place} helped you feel more connected?*\n\n"
+        else:
+            # Use default prompt
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *{prompt}*\n\n"
+
+    output += "*These are just ideas — only you know what fits right now.*"
+
+    return output
+
+
+def _extract_entities(text: str) -> Dict[str, List[str]]:
+    """
+    Simple entity extraction - finds names, places mentioned.
+    (Could be enhanced with NER later, but regex works for now)
+    """
+    import re
+
+    entities = {"person": [], "place": []}
+
+    if not text:
+        return entities
+
+    # Look for capitalized words that might be names
+    # Pattern: capitalized word not at start of sentence
+    words = text.split()
+    for i, word in enumerate(words):
+        # Skip first word and common words
+        if i == 0 or word.lower() in ["i", "the", "a", "an", "my", "her", "his"]:
+            continue
+        # Check if capitalized and looks like a name
+        if word[0].isupper() and len(word) > 2:
+            entities["person"].append(word.rstrip(".,!?"))
+
+    return entities
+
+
+def _analyze_emotion_pattern(emotion_arc: Dict) -> str:
+    """
+    Analyze emotion trajectory for patterns and insights.
+    Returns a personalized prompt based on what we've seen.
+    """
+    trajectory = emotion_arc.get("trajectory", [])
+
+    if not trajectory or len(trajectory) < 2:
+        return None
+
+    # Check if emotions are getting worse
+    recent_valence = [e.get("valence", 0) for e in trajectory[-3:]]
+    if len(recent_valence) >= 2:
+        if all(
+            recent_valence[i] < recent_valence[i - 1]
+            for i in range(1, len(recent_valence))
+        ):
+            return "Your emotions have been getting heavier - what could help you shift this pattern?"
+
+    # Check if stuck in same emotion
+    recent_labels = [e.get("primary_label") for e in trajectory[-3:]]
+    if len(set(recent_labels)) == 1:
+        emotion = recent_labels[0]
+        if emotion in ["anxious", "sad"]:
+            return f"You've been feeling {emotion} for a while now - what's one thing that might give you a break from this?"
+
+    # Check if there was a better moment
+    best_valence = max(e.get("valence", -1) for e in trajectory)
+    if best_valence > 0:
+        best_moment = [e for e in trajectory if e.get("valence") == best_valence][0]
+        snippet = best_moment.get("text", "")[:50]
+        return f'Earlier when you said "{snippet}..." you seemed lighter - what was different then?'
+
+    return None

utils/intervention_lexicon.py.broken2

@@ -0,0 +1,397 @@
+"""
+Intervention Lexicon: Need-based actionable suggestions
+Maps psychological needs to concrete, evidence-based interventions.
+"""
+
+from typing import List, Dict
+
+# Intervention strategies for each need
+INTERVENTIONS = {
+    "autonomy": {
+        "label": "Autonomy/Control",
+        "icon": "⚖️",
+        "strategies": [
+            {
+                "action": "Set a boundary",
+                "prompt": "What would it sound like to say 'no' here?",
+                "context": "blocked, powerless, micromanaged",
+                "evidence": "Self-Determination Theory: autonomy is core psychological need",
+            },
+            {
+                "action": "Reclaim decision-making",
+                "prompt": "What's one choice that's yours to make right now?",
+                "context": "dismissed, underutilized",
+                "evidence": "Locus of control research",
+            },
+            {
+                "action": "Name what you need",
+                "prompt": "If you could ask for one thing to change, what would it be?",
+                "context": "powerless, micromanaged",
+                "evidence": "Assertiveness training principles",
+            },
+            {
+                "action": "Take one small action",
+                "prompt": "What's the smallest step you could take that's fully in your control?",
+                "context": "blocked, powerless",
+                "evidence": "Behavioral activation therapy",
+            },
+        ],
+    },
+    "connection": {
+        "label": "Connection/Belonging",
+        "icon": "🗣️",
+        "strategies": [
+            {
+                "action": "Text someone who's seen you at your worst",
+                "prompt": "Not the person you perform for - who actually knows your mess?",
+                "context": "isolated, rejected, misunderstood",
+                "evidence": "Social support research, attachment theory",
+            },
+            {
+                "action": "Voice memo instead of typing",
+                "prompt": "Sometimes hearing your own voice say it out loud hits different",
+                "context": "isolated, disconnected",
+                "evidence": "Expressive writing research, self-disclosure benefits",
+            },
+            {
+                "action": "Do your usual connection ritual",
+                "prompt": "Coffee? Walk? Game? Your body remembers what works even when your brain doesn't",
+                "context": "isolated, rejected",
+                "evidence": "Behavioral activation, habit-based connection",
+            },
+            {
+                "action": "Show up somewhere people know your face",
+                "prompt": "Even if you don't talk much - being seen counts",
+                "context": "isolated, disconnected",
+                "evidence": "Social presence research, third places theory",
+            },
+            {
+                "action": "Send the messy text",
+                "prompt": "Not the cleaned-up version - the real one. Someone can handle it.",
+                "context": "misunderstood, rejected",
+                "evidence": "Vulnerability research (Brené Brown), authentic relating",
+            },
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+                "context": "isolated, disconnected",
+                "evidence": "Loneliness intervention research",
+            },
+            {
+                "action": "Ask for what you need",
+                "prompt": "What would it sound like to say 'I need you to...'?",
+                "context": "rejected, misunderstood",
+                "evidence": "Relationship research (Gottman)",
+            },
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+        "strategies": [
+            {
+                "action": "Get more information",
+                "prompt": "What's one question that would help you feel more grounded?",
+                "context": "uncertain, unstable",
+                "evidence": "Information-seeking coping (Lazarus & Folkman)",
+            },
+            {
+                "action": "Make a backup plan",
+                "prompt": "If the worst happened, what would you do next?",
+                "context": "threatened, unstable, loss",
+                "evidence": "Cognitive-behavioral therapy, anxiety reduction",
+            },
+            {
+                "action": "Identify what you can control",
+                "prompt": "What's one thing that's yours to decide or influence?",
+                "context": "uncertain, threatened",
+                "evidence": "Control theory, stress management",
+            },
+            {
+                "action": "Ground in the present",
+                "prompt": "What's actually true right now, in this moment?",
+                "context": "threatened, uncertain",
+                "evidence": "Mindfulness-based interventions",
+            },
+            {
+                "action": "Reach out for support",
+                "prompt": "Who could you talk to about this uncertainty?",
+                "context": "threatened, uncertain, loss",
+                "evidence": "Social support buffering effect",
+            },
+        ],
+    },
+    "rest": {
+        "label": "Rest/Boundaries",
+        "icon": "🛌",
+        "strategies": [
+            {
+                "action": "Say 'no' to something",
+                "prompt": "What's one thing you could decline or delay?",
+                "context": "overwhelmed, exhausted, overextended",
+                "evidence": "Burnout prevention research",
+            },
+            {
+                "action": "Ask for help",
+                "prompt": "What's one thing someone else could take off your plate?",
+                "context": "overwhelmed, exhausted",
+                "evidence": "Social support, task delegation",
+            },
+            {
+                "action": "Set a boundary",
+                "prompt": "What boundary do you need to protect your energy?",
+                "context": "boundary_violated, overextended",
+                "evidence": "Boundary research, relationship psychology",
+            },
+            {
+                "action": "Take a real break",
+                "prompt": "When could you actually stop for 15 minutes today?",
+                "context": "exhausted, overwhelmed",
+                "evidence": "Recovery research, rest benefits",
+            },
+            {
+                "action": "Name what's draining you",
+                "prompt": "What's taking the most from you right now?",
+                "context": "exhausted, overextended",
+                "evidence": "Energy management, self-awareness",
+            },
+        ],
+    },
+    "recognition": {
+        "label": "Recognition/Value",
+        "icon": "✨",
+        "strategies": [
+            {
+                "action": "Acknowledge yourself",
+                "prompt": "What did you do well here, even if no one noticed?",
+                "context": "unappreciated, overlooked, inadequate",
+                "evidence": "Self-compassion research (Neff)",
+            },
+            {
+                "action": "Ask for feedback",
+                "prompt": "Who could you ask: 'How did you see that?'",
+                "context": "unappreciated, inadequate",
+                "evidence": "Feedback-seeking behavior research",
+            },
+            {
+                "action": "Share your contribution",
+                "prompt": "What's one thing you could make visible?",
+                "context": "overlooked, unappreciated",
+                "evidence": "Visibility in the workplace research",
+            },
+            {
+                "action": "Separate their view from your worth",
+                "prompt": "What do you know about your value, regardless of their reaction?",
+                "context": "criticized, inadequate",
+                "evidence": "Cognitive restructuring (CBT)",
+            },
+            {
+                "action": "Find recognition elsewhere",
+                "prompt": "Where else do people see your value?",
+                "context": "unappreciated, overlooked",
+                "evidence": "Multiple life domains, resilience research",
+            },
+        ],
+    },
+}
+
+
+def get_interventions(
+    need_type: str, contexts: List[str] = None, limit: int = 3
+) -> List[Dict]:
+    """
+    Get contextually appropriate interventions for a detected need.
+
+    Args:
+        need_type: One of autonomy, connection, security, rest, recognition
+        contexts: List of detected contexts (e.g., ["isolated", "rejected"])
+        limit: Maximum number of interventions to return
+
+    Returns:
+        List of intervention dicts with action, prompt, context, evidence
+    """
+    if need_type not in INTERVENTIONS:
+        return []
+
+    strategies = INTERVENTIONS[need_type]["strategies"]
+
+    # If contexts provided, prioritize matching interventions
+    if contexts:
+        scored_strategies = []
+        for strategy in strategies:
+            # Count how many user contexts match this strategy's contexts
+            strategy_contexts = set(strategy["context"].split(", "))
+            user_contexts = set(contexts)
+            matches = len(strategy_contexts & user_contexts)
+            scored_strategies.append((matches, strategy))
+
+        # Sort by match count (descending), then take top N
+        scored_strategies.sort(key=lambda x: x[0], reverse=True)
+        return [s[1] for s in scored_strategies[:limit]]
+
+    # No contexts - return first N strategies
+    return strategies[:limit]
+
+
+def should_show_interventions(
+    confidence: float,
+    message_count: int,
+    emotional_intensity: float = None,
+    min_messages: int = 2,  # Simplified: just wait one exchange
+    min_confidence: float = 0.70,  # Simplified: lower bar
+    min_arousal: float = 0.40,  # Simplified: catch more cases
+) -> bool:
+    """
+    SIMPLIFIED for demo: Show interventions when there's a clear need.
+
+    Args:
+        confidence: Confidence in the detected need (0-1)
+        message_count: Number of messages in conversation
+        emotional_intensity: Arousal level (0-1)
+        min_messages: Minimum messages (default: 2)
+        min_confidence: Minimum confidence (default: 0.70)
+        min_arousal: Minimum arousal (default: 0.40)
+
+    Returns:
+        True if interventions should be displayed
+    """
+    # Simple checks - if there's a strong need and emotions, show help
+    if message_count < min_messages:
+        return False
+
+    if confidence < min_confidence:
+        return False
+
+    if emotional_intensity is not None and emotional_intensity < min_arousal:
+        return False
+
+    return True
+
+
+def format_interventions(
+    need_type: str,
+    interventions: List[Dict],
+    confidence: float,
+    emotion_arc: Dict = None,
+    user_text: str = None,
+) -> str:
+    """
+    Format interventions for display in the UI.
+    Uses memory/emotion arc to personalize suggestions when available.
+
+    Args:
+        need_type: The detected need type
+        interventions: List of intervention dicts
+        confidence: Confidence in the need detection
+        emotion_arc: Optional emotion trajectory from memory
+        user_text: Optional current user message for context extraction
+
+    Returns:
+        Formatted markdown string with personalized interventions
+    """
+    if not interventions:
+        return ""
+
+    need_info = INTERVENTIONS[need_type]
+    icon = need_info["icon"]
+    label = need_info["label"]
+
+    output = f"\n\n---\n\n"
+    output += f"💡 **Based on your need for {icon} {label}:**\n\n"
+
+    # Extract names/places from current text for personalization
+    entities = _extract_entities(user_text) if user_text else {}
+
+    # Check if there's a pattern in emotion arc
+    pattern_insight = _analyze_emotion_pattern(emotion_arc) if emotion_arc else None
+
+    for i, intervention in enumerate(interventions):
+        # Personalize the prompt if we have context
+        prompt = intervention["prompt"]
+
+        # Add memory-based personalization
+        if pattern_insight and i == 0:  # First intervention gets pattern insight
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *{pattern_insight}*\n\n"
+        elif entities.get("person") and "reach out" in intervention["action"].lower():
+            # Personalize "reach out" with mentioned person
+            person = entities["person"][0]
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *Could {person} be someone to talk to about this?*\n\n"
+        elif entities.get("place") and "connection" in need_type:
+            # Reference places where user felt better
+            place = entities["place"][0]
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *What about {place} helped you feel more connected?*\n\n"
+        else:
+            # Use default prompt
+            output += f"• **{intervention['action']}**  \n"
+            output += f"  ↳ *{prompt}*\n\n"
+
+    output += "*These are just ideas — only you know what fits right now.*"
+
+    return output
+
+
+def _extract_entities(text: str) -> Dict[str, List[str]]:
+    """
+    Simple entity extraction - finds names, places mentioned.
+    (Could be enhanced with NER later, but regex works for now)
+    """
+    import re
+
+    entities = {"person": [], "place": []}
+
+    if not text:
+        return entities
+
+    # Look for capitalized words that might be names
+    # Pattern: capitalized word not at start of sentence
+    words = text.split()
+    for i, word in enumerate(words):
+        # Skip first word and common words
+        if i == 0 or word.lower() in ["i", "the", "a", "an", "my", "her", "his"]:
+            continue
+        # Check if capitalized and looks like a name
+        if word[0].isupper() and len(word) > 2:
+            entities["person"].append(word.rstrip(".,!?"))
+
+    return entities
+
+
+def _analyze_emotion_pattern(emotion_arc: Dict) -> str:
+    """
+    Analyze emotion trajectory for patterns and insights.
+    Returns a personalized prompt based on what we've seen.
+    """
+    trajectory = emotion_arc.get("trajectory", [])
+
+    if not trajectory or len(trajectory) < 2:
+        return None
+
+    # Check if emotions are getting worse
+    recent_valence = [e.get("valence", 0) for e in trajectory[-3:]]
+    if len(recent_valence) >= 2:
+        if all(
+            recent_valence[i] < recent_valence[i - 1]
+            for i in range(1, len(recent_valence))
+        ):
+            return "Your emotions have been getting heavier - what could help you shift this pattern?"
+
+    # Check if stuck in same emotion
+    recent_labels = [e.get("primary_label") for e in trajectory[-3:]]
+    if len(set(recent_labels)) == 1:
+        emotion = recent_labels[0]
+        if emotion in ["anxious", "sad"]:
+            return f"You've been feeling {emotion} for a while now - what's one thing that might give you a break from this?"
+
+    # Check if there was a better moment
+    best_valence = max(e.get("valence", -1) for e in trajectory)
+    if best_valence > 0:
+        best_moment = [e for e in trajectory if e.get("valence") == best_valence][0]
+        snippet = best_moment.get("text", "")[:50]
+        return f'Earlier when you said "{snippet}..." you seemed lighter - what was different then?'
+
+    return None

utils/mcp_client.py

@@ -0,0 +1,74 @@
+# utils/mcp_client.py
+import asyncio
+from typing import Dict, Any, List, Optional
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+class MCPMux:
+    def __init__(self):
+        self._servers = {}
+        self._tool_index = {}
+        self._streams = {}  # Store streams to keep them alive
+
+    async def connect_stdio(self, name: str, command: str, args: Optional[List[str]] = None, env: Optional[Dict[str,str]] = None):
+        params = StdioServerParameters(command=command, args=args or [], env=env or {})
+
+        # Use async context manager for stdio_client
+        stdio = stdio_client(params)
+        read, write = await stdio.__aenter__()
+
+        # Store the context manager to keep streams alive
+        self._streams[name] = stdio
+
+        # Create session
+        session = ClientSession(read, write)
+
+        # Start session
+        await session.__aenter__()
+
+        # Initialize
+        await session.initialize()
+
+        # List tools
+        tools_result = await session.list_tools()
+        tools = tools_result.tools
+
+        # Store session and tools
+        self._servers[name] = {"session": session, "tools": {t.name: t for t in tools}}
+        for t in tools:
+            self._tool_index[t.name] = name
+        return tools
+
+    async def call(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        if tool_name not in self._tool_index:
+            raise ValueError(f"Unknown tool: {tool_name}")
+        server_name = self._tool_index[tool_name]
+        session = self._servers[server_name]["session"]
+
+        print(f"🔧 MCP call: {server_name}.{tool_name}({arguments})")
+        res = await session.call_tool(tool_name, arguments=arguments)
+        print(f"✅ MCP response type: {type(res)}, hasattr content: {hasattr(res, 'content')}")
+
+        parts = []
+        for c in res.content:
+            if hasattr(c, "text") and c.text:
+                parts.append(c.text)
+            elif hasattr(c, "data"):
+                parts.append(str(c.data))
+
+        result = "\n".join(parts) if parts else "(no content)"
+        print(f"📤 MCP result: {result[:200]}...")
+        return result
+
+    async def list_all_tools(self):
+        out = {}
+        for name, s in self._servers.items():
+            out[name] = list(s["tools"].keys())
+        return out
+
+    async def close(self):
+        for s in self._servers.values():
+            await s["session"].__aexit__(None, None, None)
+
+        for s in self._servers.values():
+            await s["conn"].close()

utils/memory.py

@@ -0,0 +1,22 @@
+# utils/memory.py
+import json
+import os
+import time
+
+FILE = "memory.json"
+
+def load():
+    if os.path.exists(FILE):
+        with open(FILE) as f:
+            return json.load(f)
+    return []
+
+def save(history):
+    with open(FILE, "w") as f:
+        json.dump(history[-5:], f)
+
+def remember(message, reply):
+    data = load()
+    data.append({"t": int(time.time()), "u": message, "a": reply})
+    save(data)
+    return data

utils/needs_lexicon.py

@@ -0,0 +1,648 @@
+"""
+Implicit Needs Detection for Ghost Malone
+Maps emotional patterns + context keywords to underlying psychological needs.
+
+STRATEGIC FRAMEWORK:
+Based on Self-Determination Theory (Ryan & Deci) + Maslow's Hierarchy
+
+5 Core Needs:
+1. AUTONOMY - Control, choice, self-direction
+2. CONNECTION - Belonging, relationships, being seen
+3. SECURITY - Safety, clarity, predictability
+4. REST - Recovery, boundaries, capacity
+5. RECOGNITION - Validation, competence, mattering
+
+Context Detection Strategy:
+- BARRIERS: What's blocking the need? (can't, won't let, prevented)
+- DEFICITS: What's missing? (nobody, nothing, no one)
+- THREATS: What's at risk? (unsafe, unstable, unpredictable)
+- OVERLOAD: What's too much? (overwhelmed, exhausted, too many)
+- DISMISSAL: What's being ignored? (dismissed, invisible, unappreciated)
+
+Constitutional AI Principle: Respects human dignity by treating emotions as signals
+of legitimate needs, not surface-level problems.
+"""
+
+from typing import List, Dict
+import re
+
+# STRATEGIC CONTEXT PATTERNS - organized by psychological dimension
+CONTEXT_PATTERNS = {
+    # ===== AUTONOMY CONTEXTS =====
+    # Barriers to self-direction
+    "blocked": r"(can't|won't let|prevented|stopped|blocked|restricted|controlled|controlling me|forced|have to|must|don't give|won't give|not letting|not allowed|doesn't give|pressured to|feel pressured)",
+    "powerless": r"(powerless|helpless|trapped|stuck|no choice|no control|out of.{0,15}control|feels.{0,15}out of control|don't have the tools|not much opportunity|no say)",
+    "dismissed": r"(ignored|dismissed|disregarded|invalidated|didn't listen|brushed off|shut down|talked over|doesn't consider|don't consider|nobody trusts|don't trust|people ignore|ignore me|cut me off|looked.{0,15}through me|right through me)",
+    "underutilized": r"(know i can|i can do|capable of|able to do|qualified|skills|talent|waste|potential|not enough challenge|bored|underused|so boring|below my ability|way below|could do.{0,15}more|living up to)",
+    "micromanaged": r"(micromanag|hovering|checking|breathing down|second-guess|don't trust me|checks every|watching every)",
+    # ===== CONNECTION CONTEXTS =====
+    # Deficits in belonging/relationships
+    "isolated": r"(alone|lonely|isolated|by myself|left out|excluded|without me|on my own|don't have anyone|no one to talk|invisible to|no one there|nobody there)",
+    "rejected": r"(rejected|abandoned|left me|left behind|they left|ghosted|dumped|unwanted|unloved|won't talk|ignoring|avoiding me|cut off|don't.{0,15}respond|doesn't.{0,15}respond|won't.{0,15}respond|not.{0,15}respond(?:ed|ing)?|hasn't.{0,15}respond|didn't.{0,15}respond|not.{0,15}reply|not.{0,15}repl(?:ied|ying)|not.{0,15}answer(?:ed|ing)?|avoid me|seem to avoid|wasn't invited|didn't invite|unanswered|go unanswered|make excuses|not texting.{0,15}back|won't text)",
+    "misunderstood": r"(misunderstood|don't get it|don't understand|not listening|not hearing|missing the point|doesn't.{0,15}listen|won't.{0,15}listen|different language|speaking a different|doesn't.{0,15}hear|misinterpret|nobody.{0,15}understands|nobody.{0,15}knows|nobody.{0,15}interested|doesn't.{0,15}share|doesn't.{0,15}talk|won't.{0,15}talk|doesn't.{0,15}open up)",
+    "singled_out": r"(everyone else|everybody else|talks to everyone|except me|only me|just me|do things without|left behind|don't invite|didn't invite|don't call me|leaves me out|not included|don't pass|doesn't pass|won't pass|outsider|feel like.{0,15}outsider|make plans without|plans without including|always the one reaching out|don't include)",
+    "disconnected": r"(disconnected|distant|drift|growing apart|not close|lost touch|pulling away|pull away|hard to.{0,15}connection|hard to connect|can't connect)",
+    # ===== SECURITY CONTEXTS =====
+    # Threats to safety/clarity
+    "uncertain": r"(don't know|uncertain|unsure|unclear|confused|no idea|what if|can't tell|ambiguous|what to do|where do i go|what next|what do i do|can't predict|unpredictable|what's going to happen|what will happen|going to happen)",
+    "unstable": r"(unstable|unpredictable|chaotic|all over|everything's changing|up in the air|falling apart|like always|never on time|unreliable|keeps changing|constantly changing|shifts again|everything shifts|stays stable|nothing.{0,15}stable|shifting ground|constantly shifting)",
+    "threatened": r"(threatened|unsafe|danger|risk|scared|scary|vulnerable|exposed|at risk|pain again|go through that|rot in hell|worried|worrying|something bad|threats|not protected|not secure|don't feel.{0,15}secure)",
+    "loss": r"(losing|lost|losing grip|slipping away|falling apart|coming undone)",
+    # ===== REST CONTEXTS =====
+    # Overload on capacity
+    "overwhelmed": r"(overwhelmed|too much|can't handle|drowning|swamped|buried|crowded|crowd|too many people|overstimulat|too much work|coming at me|at me all at once)",
+    "exhausted": r"(exhausted|drained|burnt out|can't anymore|running on empty|wiped|spent|depleted|freaking tired|so tired|running on fumes|on fumes|no energy|don't have.{0,15}energy)",
+    "overextended": r"(overextended|overstretched|spread thin|doing too much|no time|juggling|can't keep up|keep up with)",
+    "boundary_violated": r"(always asking|never stops|can't say no|taking advantage|demanding|intrusive|available 24|expect.{0,15}available|need space|won't give.{0,15}space|boundaries.{0,15}ignored|kept.{0,15}insisting|kept.{0,15}texting|kept.{0,15}calling|i said no|asked for.{0,15}boundaries)",
+    # ===== RECOGNITION CONTEXTS =====
+    # Dismissal of value/competence
+    "unappreciated": r"(unappreciated|taken for granted|not valued|not recognized|invisible|thankless|nobody appreciates|no one appreciates|zero recognition|get.{0,15}recognition|work.{0,15}hard|not appreciated|don't feel appreciated|no.{0,15}recognition|no sense of recognition)",
+    "inadequate": r"(not good enough|inadequate|failing|not enough|disappointing|falling short|incompetent|doubt.{0,15}have what it takes|don't feel capable|never enough|nothing.{0,15}enough)",
+    "overlooked": r"(overlooked|passed over|ignored|not noticed|nobody notices|no one notices|credit|someone else|didn't acknowledge)",
+    "criticized": r"(criticized|judged|attacked|picked apart|nothing right|always wrong|nitpick|point out.{0,15}mistake|only.{0,15}mistake|compared.{0,15}unfavorably|compared to others|offended|offensive|rude|disrespected)",
+}
+
+# Needs taxonomy (based on Maslow + Self-Determination Theory)
+NEEDS = {
+    "autonomy": {
+        "label": "Autonomy/Control",
+        "icon": "⚖️",
+        "description": "Need for self-direction and agency over one's life",
+        "interventions": [
+            "Set a boundary",
+            "Say 'no'",
+            "Take back decision-making power",
+        ],
+    },
+    "connection": {
+        "label": "Connection/Belonging",
+        "icon": "🗣️",
+        "description": "Need for meaningful relationships and social bonds",
+        "interventions": [
+            "Reach out to someone you trust",
+            "Share what you're feeling",
+            "Ask for support",
+        ],
+    },
+    "security": {
+        "label": "Security/Clarity",
+        "icon": "🛡️",
+        "description": "Need for safety, predictability, and understanding",
+        "interventions": [
+            "Get more information",
+            "Make a plan",
+            "Identify what you can control",
+        ],
+    },
+    "rest": {
+        "label": "Rest/Boundaries",
+        "icon": "🛌",
+        "description": "Need for recuperation and limits on demands",
+        "interventions": [
+            "Take a break",
+            "Delegate something",
+            "Give yourself permission to rest",
+        ],
+    },
+    "recognition": {
+        "label": "Recognition/Validation",
+        "icon": "✨",
+        "description": "Need to be seen, valued, and acknowledged",
+        "interventions": [
+            "Acknowledge your own effort",
+            "Ask for feedback",
+            "Celebrate small wins",
+        ],
+    },
+}
+
+# STRATEGIC NEED INFERENCE RULES
+# Organized by primary need, with emotion+context combinations
+# Using ONLY the 7 actual detected emotions: happy, sad, angry, anxious, tired, love, fear
+NEED_RULES = [
+    # ========== AUTONOMY RULES ==========
+    # Primary emotion: Anger (blocked goals/control)
+    {
+        "emotions": ["angry"],
+        "contexts": ["blocked", "powerless", "dismissed", "micromanaged"],
+        "need": "autonomy",
+        "confidence_base": 0.80,
+        "reasoning": "Anger signals blocked goals or loss of control",
+    },
+    {
+        "emotions": ["angry", "sad"],
+        "contexts": ["powerless", "trapped", "stuck"],
+        "need": "autonomy",
+        "confidence_base": 0.85,
+        "reasoning": "Anger + sadness at powerlessness indicates autonomy deficit",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["underutilized", "dismissed"],
+        "need": "autonomy",
+        "confidence_base": 0.75,
+        "reasoning": "Anger at not being allowed to use your capabilities",
+    },
+    # HIGH PRIORITY: Underutilized should map to autonomy strongly
+    {
+        "emotions": ["sad", "angry", "anxious", "tired"],
+        "contexts": ["underutilized"],
+        "need": "autonomy",
+        "confidence_base": 0.88,
+        "reasoning": "Skills/potential being wasted is autonomy issue",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["powerless", "trapped"],
+        "need": "autonomy",
+        "confidence_base": 0.70,
+        "reasoning": "Sadness from lack of control",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["blocked", "micromanaged", "dismissed"],
+        "need": "autonomy",
+        "confidence_base": 0.75,
+        "reasoning": "Sadness from being controlled or blocked",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["blocked", "powerless", "micromanaged"],
+        "need": "autonomy",
+        "confidence_base": 0.65,
+        "reasoning": "Fatigue from lack of autonomy",
+    },
+    {
+        "emotions": ["anxious"],
+        "contexts": ["powerless", "blocked"],
+        "need": "autonomy",
+        "confidence_base": 0.70,
+        "reasoning": "Anxiety from lack of control",
+    },
+    # ========== CONNECTION RULES ==========
+    # Primary emotion: Sadness (relationship deficits)
+    # HIGH PRIORITY: "Invisible to people" is connection, not recognition
+    {
+        "emotions": ["sad", "angry", "anxious"],
+        "contexts": ["isolated"],
+        "need": "connection",
+        "confidence_base": 0.92,
+        "reasoning": "Feeling invisible or isolated from people indicates connection deficit",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["isolated", "rejected", "misunderstood", "disconnected"],
+        "need": "connection",
+        "confidence_base": 0.85,
+        "reasoning": "Sadness with isolation indicates connection needs",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["singled_out"],
+        "need": "connection",
+        "confidence_base": 0.90,
+        "reasoning": "Being excluded from the group",
+    },
+    # Secondary emotion: Anger (rejection/exclusion)
+    {
+        "emotions": ["angry"],
+        "contexts": ["rejected", "singled_out", "dismissed"],
+        "need": "connection",
+        "confidence_base": 0.75,
+        "reasoning": "Anger from rejection signals need for belonging",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["misunderstood", "disconnected"],
+        "need": "connection",
+        "confidence_base": 0.75,
+        "reasoning": "Anger from being misunderstood or disconnected",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["isolated"],
+        "need": "connection",
+        "confidence_base": 0.70,
+        "reasoning": "Anger at being isolated",
+    },
+    {
+        "emotions": ["fear"],
+        "contexts": ["rejected", "abandoned"],
+        "need": "connection",
+        "confidence_base": 0.75,
+        "reasoning": "Fear of abandonment signals connection needs",
+    },
+    {
+        "emotions": ["anxious"],
+        "contexts": ["isolated", "rejected", "misunderstood"],
+        "need": "connection",
+        "confidence_base": 0.70,
+        "reasoning": "Anxiety from social isolation or rejection",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["isolated", "disconnected"],
+        "need": "connection",
+        "confidence_base": 0.60,
+        "reasoning": "Fatigue from lack of social connection",
+    },
+    # ========== SECURITY RULES ==========
+    # Primary emotions: Anxiety/Fear (threat/uncertainty)
+    {
+        "emotions": ["anxious"],
+        "contexts": ["uncertain", "unstable", "threatened", "loss"],
+        "need": "security",
+        "confidence_base": 0.85,
+        "reasoning": "Anxiety with uncertainty signals need for clarity/safety",
+    },
+    {
+        "emotions": ["fear"],
+        "contexts": ["threatened", "unsafe", "vulnerable"],
+        "need": "security",
+        "confidence_base": 0.90,
+        "reasoning": "Fear indicates immediate security/safety needs",
+    },
+    {
+        "emotions": ["anxious"],
+        "contexts": ["uncertain", "unstable"],
+        "need": "security",
+        "confidence_base": 0.80,
+        "reasoning": "Worry about unpredictability or lack of clarity",
+    },
+    # HIGH PRIORITY: "Can't predict" with blocked is still security (uncertainty primary)
+    {
+        "emotions": ["anxious", "fear", "sad"],
+        "contexts": ["uncertain"],
+        "need": "security",
+        "confidence_base": 0.94,
+        "reasoning": "Uncertainty and unpredictability are core security concerns",
+    },
+    # HIGH PRIORITY: "Things keep changing" with overextended is security (instability primary)
+    {
+        "emotions": ["anxious", "tired", "sad"],
+        "contexts": ["unstable"],
+        "need": "security",
+        "confidence_base": 0.94,
+        "reasoning": "Constant change and instability are security issues",
+    },
+    {
+        "emotions": ["sad", "anxious"],
+        "contexts": ["loss"],
+        "need": "security",
+        "confidence_base": 0.75,
+        "reasoning": "Grief + anxiety about losing stability",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["uncertain"],
+        "need": "security",
+        "confidence_base": 0.65,
+        "reasoning": "Anger from lack of clarity",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["uncertain", "unstable", "loss"],
+        "need": "security",
+        "confidence_base": 0.75,
+        "reasoning": "Sadness from instability or uncertainty",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["unstable", "threatened"],
+        "need": "security",
+        "confidence_base": 0.65,
+        "reasoning": "Exhaustion from constant instability",
+    },
+    # ========== REST RULES ==========
+    # Primary emotion: Tired (capacity overload)
+    # HIGH PRIORITY: "Can't say no", "need space", "boundaries ignored" → rest (not autonomy)
+    {
+        "emotions": ["sad", "angry", "anxious", "tired"],
+        "contexts": ["boundary_violated"],
+        "need": "rest",
+        "confidence_base": 0.95,
+        "reasoning": "Boundary violations primarily indicate need for rest/space, not control",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["overwhelmed", "exhausted", "overextended"],
+        "need": "rest",
+        "confidence_base": 0.85,
+        "reasoning": "Exhaustion + overwhelm indicates need for rest/boundaries",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["exhausted"],
+        "need": "rest",
+        "confidence_base": 0.95,
+        "reasoning": "Explicit exhaustion is clearest rest signal",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["exhausted", "overwhelmed"],
+        "need": "rest",
+        "confidence_base": 0.75,
+        "reasoning": "Anger from being exhausted or overwhelmed",
+    },
+    {
+        "emotions": ["anxious", "tired"],
+        "contexts": ["overwhelmed", "overextended"],
+        "need": "rest",
+        "confidence_base": 0.80,
+        "reasoning": "Anxiety + tiredness suggests overextension",
+    },
+    {
+        "emotions": ["anxious"],
+        "contexts": ["overwhelmed", "crowded"],
+        "need": "rest",
+        "confidence_base": 0.70,
+        "reasoning": "Sensory/social overwhelm signals need for space",
+    },
+    {
+        "emotions": ["angry", "tired"],
+        "contexts": ["boundary_violated", "overextended"],
+        "need": "rest",
+        "confidence_base": 0.75,
+        "reasoning": "Anger and fatigue from violated boundaries",
+    },
+    # HIGH PRIORITY: Boundary violations should map to rest when not autonomy-blocking
+    {
+        "emotions": ["sad", "angry", "anxious", "tired"],
+        "contexts": ["boundary_violated"],
+        "need": "rest",
+        "confidence_base": 0.82,
+        "reasoning": "Boundary violations primarily indicate need for rest/space",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["overwhelmed", "exhausted", "overextended"],
+        "need": "rest",
+        "confidence_base": 0.70,
+        "reasoning": "Sadness from depletion and overwhelm",
+    },
+    {
+        "emotions": ["fear"],
+        "contexts": ["overwhelmed", "boundary_violated"],
+        "need": "rest",
+        "confidence_base": 0.65,
+        "reasoning": "Fear from being overwhelmed or boundaries violated",
+    },
+    # ========== RECOGNITION RULES ==========
+    # Primary emotions: Sad/Angry (value not seen)
+    # HIGH PRIORITY: "Nobody notices/appreciates" is recognition, not connection
+    {
+        "emotions": ["sad", "angry", "anxious", "tired"],
+        "contexts": ["overlooked", "unappreciated"],
+        "need": "recognition",
+        "confidence_base": 0.90,
+        "reasoning": "Being overlooked or unappreciated is primarily about recognition/validation",
+    },
+    # HIGH PRIORITY: "Don't feel capable" is recognition (inadequate), not autonomy
+    {
+        "emotions": ["sad", "anxious", "fear"],
+        "contexts": ["inadequate"],
+        "need": "recognition",
+        "confidence_base": 0.92,
+        "reasoning": "Self-doubt about capability is core recognition/validation issue",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["unappreciated"],
+        "need": "recognition",
+        "confidence_base": 0.87,
+        "reasoning": "Sadness from not being appreciated or valued",
+    },
+    {
+        "emotions": ["sad", "angry"],
+        "contexts": ["unappreciated", "inadequate", "overlooked"],
+        "need": "recognition",
+        "confidence_base": 0.75,
+        "reasoning": "Feeling unseen or inadequate signals need for validation",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["underutilized", "unappreciated", "overlooked"],
+        "need": "recognition",
+        "confidence_base": 0.80,
+        "reasoning": "Your capabilities aren't being seen or valued",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["inadequate"],
+        "need": "recognition",
+        "confidence_base": 0.85,
+        "reasoning": "Self-doubt about competence",
+    },
+    {
+        "emotions": ["sad"],
+        "contexts": ["criticized"],
+        "need": "recognition",
+        "confidence_base": 0.70,
+        "reasoning": "Criticism without acknowledgment damages sense of value",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["overlooked"],
+        "need": "recognition",
+        "confidence_base": 0.75,
+        "reasoning": "Anger at not being seen or credited",
+    },
+    {
+        "emotions": ["angry"],
+        "contexts": ["criticized"],
+        "need": "recognition",
+        "confidence_base": 0.75,
+        "reasoning": "Anger at being criticized, offended, or disrespected",
+    },
+    {
+        "emotions": ["anxious"],
+        "contexts": ["inadequate", "criticized"],
+        "need": "recognition",
+        "confidence_base": 0.75,
+        "reasoning": "Anxiety from self-doubt or criticism",
+    },
+    {
+        "emotions": ["tired"],
+        "contexts": ["unappreciated", "overlooked"],
+        "need": "recognition",
+        "confidence_base": 0.65,
+        "reasoning": "Fatigue from lack of appreciation",
+    },
+    {
+        "emotions": ["fear"],
+        "contexts": ["inadequate", "criticized"],
+        "need": "recognition",
+        "confidence_base": 0.70,
+        "reasoning": "Fear of failure or judgment",
+    },
+]
+
+
+def detect_context(text: str) -> Dict[str, bool]:
+    """Detect which situational contexts are present in the text."""
+    text_lower = text.lower()
+    detected = {}
+
+    for context_name, pattern in CONTEXT_PATTERNS.items():
+        detected[context_name] = bool(re.search(pattern, text_lower))
+
+    return detected
+
+
+def infer_needs(
+    emotion_labels: List[str], text: str, valence: float = 0.0, arousal: float = 0.5
+) -> List[Dict]:
+    """
+    Infer psychological needs from emotions + text context.
+
+    Args:
+        emotion_labels: Primary emotions detected (e.g., ["angry", "sad"])
+        text: User's message text
+        valence: Emotional valence (-1 to 1)
+        arousal: Emotional arousal (0 to 1)
+
+    Returns:
+        List of inferred needs with confidence scores:
+        [
+            {
+                "need": "autonomy",
+                "label": "Autonomy/Control",
+                "icon": "⚖️",
+                "confidence": 0.82,
+                "reasoning": "Anger often signals blocked goals...",
+                "interventions": ["Set a boundary", ...]
+            },
+            ...
+        ]
+    """
+    # Detect situational contexts
+    contexts = detect_context(text)
+    active_contexts = [ctx for ctx, present in contexts.items() if present]
+
+    # Match rules
+    inferred = []
+    seen_needs = set()
+
+    for rule in NEED_RULES:
+        # Check if emotions match (any overlap)
+        emotion_match = any(emo in emotion_labels for emo in rule["emotions"])
+
+        # Check if contexts match (any overlap)
+        context_match = any(ctx in active_contexts for ctx in rule["contexts"])
+
+        if emotion_match and context_match:
+            need_key = rule["need"]
+
+            # Avoid duplicates
+            if need_key in seen_needs:
+                continue
+            seen_needs.add(need_key)
+
+            # Calculate confidence
+            # Base confidence from rule
+            confidence = rule["confidence_base"]
+
+            # Boost if multiple emotions match
+            emotion_overlap = sum(
+                1 for emo in rule["emotions"] if emo in emotion_labels
+            )
+            if emotion_overlap > 1:
+                confidence += 0.05
+
+            # Boost if multiple contexts match
+            context_overlap = sum(
+                1 for ctx in rule["contexts"] if ctx in active_contexts
+            )
+            if context_overlap > 1:
+                confidence += 0.05
+
+            # Adjust by emotional intensity (valence magnitude + arousal)
+            intensity = (abs(valence) + arousal) / 2.0
+            if intensity > 0.6:
+                confidence += 0.05
+
+            confidence = min(1.0, confidence)  # Cap at 1.0
+
+            need_info = NEEDS[need_key]
+            inferred.append(
+                {
+                    "need": need_key,
+                    "label": need_info["label"],
+                    "icon": need_info["icon"],
+                    "confidence": round(confidence, 2),
+                    "reasoning": rule["reasoning"],
+                    "description": need_info["description"],
+                    "interventions": need_info["interventions"],
+                    "matched_contexts": [
+                        ctx for ctx in rule["contexts"] if ctx in active_contexts
+                    ],
+                    "matched_emotions": [
+                        emo for emo in rule["emotions"] if emo in emotion_labels
+                    ],
+                }
+            )
+
+    # Sort by confidence (highest first)
+    inferred.sort(key=lambda x: x["confidence"], reverse=True)
+
+    return inferred
+
+
+def format_needs_summary(needs: List[Dict], max_display: int = 2) -> str:
+    """
+    Format needs as a human-readable summary.
+
+    Args:
+        needs: List of inferred needs from infer_needs()
+        max_display: Maximum number of needs to show
+
+    Returns:
+        Formatted string like:
+        "⚖️ Autonomy/Control (85%) | 🗣️ Connection/Belonging (72%)"
+    """
+    if not needs:
+        return "No specific needs detected"
+
+    top_needs = needs[:max_display]
+    parts = [
+        f"{n['icon']} {n['label']} ({int(n['confidence']*100)}%)" for n in top_needs
+    ]
+    return " | ".join(parts)
+
+
+# Example usage for testing
+if __name__ == "__main__":
+    # Test case 1: Autonomy need
+    test1 = infer_needs(
+        emotion_labels=["angry"],
+        text="my boss won't let me make my own decisions",
+        valence=-0.5,
+        arousal=0.7,
+    )
+    print("Test 1 (Autonomy):")
+    print(format_needs_summary(test1))
+    print(test1[0] if test1 else "No needs detected")
+    print()
+
+    # Test case 2: Connection need
+    test2 = infer_needs(
+        emotion_labels=["sad"],
+        text="i feel so alone, nobody understands what i'm going through",
+        valence=-0.6,
+        arousal=0.4,
+    )
+    print("Test 2 (Connection):")
+    print(format_needs_summary(test2))
+    print(test2[0] if test2 else "No needs detected")
+    print()
+
+    # Test case 3: Rest need
+    test3 = infer_needs(
+        emotion_labels=["tired", "anxious"],
+        text="i'm so overwhelmed, there's just too much to handle",
+        valence=-0.4,
+        arousal=0.6,
+    )
+    print("Test 3 (Rest):")
+    print(format_needs_summary(test3))
+    print(test3[0] if test3 else "No needs detected")

utils/orchestrator.py

@@ -0,0 +1,282 @@
+# utils/orchestrator.py
+# Coordinates emotion, memory, and reflection servers together
+from typing import Dict, Any, Optional
+import asyncio
+import time
+from utils.mcp_client import MCPMux
+from utils.needs_lexicon import infer_needs
+from utils.intervention_lexicon import (
+    get_interventions,
+    should_show_interventions,
+    format_interventions,
+)
+
+
+class GhostMaloneMux:
+    """Orchestrator for Ghost Malone's three servers: emotion, memory, reflection"""
+
+    def __init__(self):
+        self.mux = MCPMux()
+        self.initialized = False
+
+    async def initialize(self):
+        """Connect to all three MCP servers"""
+        if self.initialized:
+            return
+
+        # Connect to emotion server
+        await self.mux.connect_stdio(
+            "emotion", "python", args=["servers/emotion_server.py"]
+        )
+
+        # Connect to memory server
+        await self.mux.connect_stdio(
+            "memory", "python", args=["servers/memory_server.py"]
+        )
+
+        # Connect to reflection server
+        await self.mux.connect_stdio(
+            "reflection", "python", args=["servers/reflection_server.py"]
+        )
+
+        self.initialized = True
+
+    async def process_message(
+        self,
+        user_text: str,
+        conversation_context: list[dict] | None = None,
+        user_id: str = "user_001",
+        intervention_thresholds: dict | None = None,
+    ) -> dict:
+        """
+        Process a user message through the full pipeline:
+        1. Emotion analysis
+        2. Needs inference
+        3. Memory operations (parallel)
+        4. Reflection generation
+        5. Intervention generation (if thresholds met)
+
+        Args:
+            user_text: The user's message
+            conversation_context: Previous messages
+            user_id: User identifier
+            intervention_thresholds: Optional dict with min_messages, min_confidence, min_arousal
+
+        Returns dict with:
+            "user_text": str,
+            "emotion": dict (emotion analysis),
+            "inferred_needs": list (psychological needs detected),
+            "emotion_arc": dict (trajectory),
+            "response": str (assistant reply),
+            "tone": str
+        }
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Extract intervention thresholds (SIMPLIFIED defaults for demo)
+        thresholds = intervention_thresholds or {}
+        min_messages = thresholds.get("min_messages", 2)  # Just need one exchange
+        min_confidence = thresholds.get("min_confidence", 0.70)  # Lower bar
+        min_arousal = thresholds.get("min_arousal", 0.40)  # Catch more cases
+
+        start_time = time.time()
+
+        # Initialize toolbox log
+        toolbox_log = []
+
+        # Step 1: Analyze emotion
+        t1 = time.time()
+        toolbox_log.append(
+            "🔧 **emotion_server.analyze()** - Detecting emotions from text"
+        )
+        emotion_data = await self.mux.call(
+            "analyze", {"text": user_text, "user_id": user_id}
+        )
+        elapsed = (time.time() - t1) * 1000
+        print(f"⏱️  Emotion analysis: {elapsed:.0f}ms")
+
+        # Parse emotion response (it comes as JSON string from MCP)
+        if isinstance(emotion_data, str):
+            import json
+
+            emotion_dict = json.loads(emotion_data)
+        else:
+            emotion_dict = emotion_data
+
+        toolbox_log.append(
+            f"   ✅ Found: {emotion_dict.get('labels', [])} ({elapsed:.0f}ms)"
+        )
+
+        # Step 2: Infer psychological needs from emotion + context (fast, <100ms)
+        t2 = time.time()
+        toolbox_log.append(
+            "\n📖 **needs_lexicon.infer_needs()** - Detecting psychological needs"
+        )
+        emotion_labels = emotion_dict.get("labels", [])
+        valence = emotion_dict.get("valence", 0.0)
+        arousal = emotion_dict.get("arousal", 0.0)
+        inferred_needs = infer_needs(emotion_labels, user_text, valence, arousal)
+        elapsed = (time.time() - t2) * 1000
+        print(f"⏱️  Needs inference: {elapsed:.0f}ms")
+
+        if inferred_needs:
+            need_summary = ", ".join(
+                [f"{n['label']} ({n['confidence']:.0%})" for n in inferred_needs]
+            )
+            toolbox_log.append(f"   ✅ Detected: {need_summary} ({elapsed:.0f}ms)")
+        else:
+            toolbox_log.append(f"   ℹ️  No strong needs detected ({elapsed:.0f}ms)")
+
+        # Debug: Print detected needs
+        print(f"🎯 Inferred needs: {inferred_needs}")
+        if inferred_needs:
+            for need in inferred_needs:
+                print(f"   - {need['icon']} {need['label']} ({need['confidence']:.0%})")
+
+        # Step 3 & 4: Parallelize memory operations (they don't depend on each other)
+        t3 = time.time()
+        toolbox_log.append("\n🧠 **memory_server** - Parallel operations:")
+        toolbox_log.append("   📥 get_emotion_arc() - Retrieving emotion history")
+        toolbox_log.append("   💾 remember_event() - Storing current message")
+
+        emotion_arc_task = self.mux.call("get_emotion_arc", {"k": 10})
+
+        event = {
+            "text": user_text,
+            "emotion": emotion_dict,
+            "role": "user",
+            "user_id": user_id,
+        }
+        remember_task = self.mux.call("remember_event", {"event": event})
+
+        # Run both memory operations in parallel
+        emotion_arc, _ = await asyncio.gather(emotion_arc_task, remember_task)
+        elapsed = (time.time() - t3) * 1000
+        print(f"⏱️  Memory operations (parallel): {elapsed:.0f}ms")
+        toolbox_log.append(f"   ✅ Completed ({elapsed:.0f}ms)")
+
+        if isinstance(emotion_arc, str):
+            import json
+
+            emotion_arc = json.loads(emotion_arc)
+
+        # Step 5: Generate reflection using emotion + arc
+        t4 = time.time()
+        toolbox_log.append(
+            "\n🤖 **reflection_server.generate()** - Claude response generation"
+        )
+        tone = emotion_dict.get("tone", "neutral")
+        reflection_response = await self.mux.call(
+            "generate",
+            {
+                "text": user_text,
+                "context": conversation_context,
+                "tone": tone,
+                "emotion_arc": emotion_arc,
+            },
+        )
+        elapsed = (time.time() - t4) * 1000
+        print(f"⏱️  Reflection generation (Claude): {elapsed:.0f}ms")
+        toolbox_log.append(f"   ✅ Response generated ({elapsed:.0f}ms)")
+
+        if isinstance(reflection_response, str):
+            import json
+
+            try:
+                response_dict = json.loads(reflection_response)
+                reply = response_dict.get("reply", reflection_response)
+            except Exception:
+                reply = reflection_response
+        else:
+            reply = str(reflection_response)
+
+        # Step 6: Generate interventions (SIMPLIFIED FOR DEMO)
+        toolbox_log.append(
+            "\n💡 **intervention_lexicon** - Checking intervention criteria"
+        )
+        message_count = len(conversation_context) + 1 if conversation_context else 1
+        arousal = emotion_dict.get("arousal", 0.5)
+
+        intervention_text = ""
+
+        # Simple rule: If we detected a need, check if we should show interventions
+        if inferred_needs and should_show_interventions(
+            confidence=inferred_needs[0]["confidence"],
+            message_count=message_count,
+            emotional_intensity=arousal,
+            min_messages=min_messages,
+            min_confidence=min_confidence,
+            min_arousal=min_arousal,
+        ):
+            toolbox_log.append(
+                f"   ✅ Thresholds met (msg≥{min_messages}, conf≥{min_confidence:.0%}, arousal≥{min_arousal:.1f})"
+            )
+            need_type = inferred_needs[0]["need"]
+            contexts = inferred_needs[0].get("matched_contexts", [])
+            interventions = get_interventions(need_type, contexts, limit=3)
+
+            if interventions:
+                toolbox_log.append(
+                    f"   📋 get_interventions() - Retrieved {len(interventions)} strategies for {need_type}"
+                )
+                intervention_text = format_interventions(
+                    need_type,
+                    interventions,
+                    inferred_needs[0]["confidence"],
+                    emotion_arc=emotion_arc,
+                    user_text=user_text,
+                )
+                print(f"💡 Showing {len(interventions)} interventions for {need_type}")
+        else:
+            reasons = []
+            if not inferred_needs:
+                reasons.append("no needs detected")
+            else:
+                if message_count < min_messages:
+                    reasons.append(f"msg count {message_count}<{min_messages}")
+                if inferred_needs[0]["confidence"] < min_confidence:
+                    reasons.append(
+                        f"confidence {inferred_needs[0]['confidence']:.0%}<{min_confidence:.0%}"
+                    )
+                if arousal < min_arousal:
+                    reasons.append(f"arousal {arousal:.1f}<{min_arousal:.1f}")
+            toolbox_log.append(f"   ℹ️  No interventions ({', '.join(reasons)})")
+
+        # Combine empathetic response + interventions
+        full_response = reply + intervention_text
+
+        total_time = time.time() - start_time
+        print(f"⏱️  TOTAL pipeline time: {total_time*1000:.0f}ms ({total_time:.1f}s)")
+        toolbox_log.append(f"\n⏱️  **Total pipeline:** {total_time*1000:.0f}ms")
+
+        # Format toolbox log
+        toolbox_log_str = "🧰 **Toolbox Activity:**\n\n" + "\n".join(toolbox_log)
+
+        return {
+            "user_text": user_text,
+            "emotion": emotion_dict,
+            "inferred_needs": inferred_needs,
+            "emotion_arc": emotion_arc,
+            "response": full_response,
+            "tone": tone,
+            "has_interventions": bool(intervention_text),
+            "toolbox_log": toolbox_log_str,
+        }
+
+    async def close(self):
+        """Close all server connections"""
+        await self.mux.close()
+
+
+# Global instance
+_orchestrator = None
+
+
+async def get_orchestrator() -> GhostMaloneMux:
+    """Get or create the global orchestrator"""
+    global _orchestrator
+    if _orchestrator is None:
+        _orchestrator = GhostMaloneMux()
+        await _orchestrator.initialize()
+    return _orchestrator

utils/reflection.py

@@ -0,0 +1,28 @@
+# utils/reflection.py
+import os
+
+def reflect(user_msg: str, context_messages=None) -> str:
+    """Return Ghost Malone's reply. Uses OpenAI if OPENAI_API_KEY is set; else echoes."""
+    api_key = os.getenv("OPENAI_API_KEY")
+    system_prompt = (
+        "You are Ghost Malone — a calm, humorous listener. "
+        "Be sincere, brief (<80 words), and reflective."
+    )
+    if not api_key:
+        return f"👻 (dev) I hear you: {user_msg}"
+
+    try:
+        from openai import OpenAI
+        client = OpenAI(api_key=api_key)
+        msgs = [{"role": "system", "content": system_prompt}]
+        if context_messages:
+            msgs.extend(context_messages[-6:])  # last 3 exchanges (user/assistant)
+        msgs.append({"role": "user", "content": user_msg})
+        resp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=msgs,
+            max_tokens=200,
+        )
+        return resp.choices[0].message.content
+    except Exception as e:
+        return f"👻 (dev) Error talking to model: {e}\nBut I still hear you: {user_msg}"