Streamlined UX: sidebar I-statement builder, 5 stages

- Sidebar shows building I-statement (Feel/Need/Request)
- Reduced to 5 stages: Share → Feelings → Needs → Request → Done
- Removed "You:" prefix - just Guide responses
- Much more concise prompts (2-3 sentences max)
- Cleaner, focused translation experience

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -1,502 +1,267 @@
 """
-NVC Deep Practice - A Multi-Stage Nonviolent Communication Learning Space
-Simplified version without Chatbot component to avoid Gradio bugs
+NVC Translation Practice - Learn to translate messages using Nonviolent Communication
+Streamlined flow with visual I-statement builder
 """
 
 import gradio as gr
 import anthropic
 import os
 
-# Check for API key at startup
-def check_api_key():
-    """Check if API key is configured"""
-    return bool(
+# ============ API SETUP ============
+
+def get_client():
+    api_key = (
         os.environ.get("ANTHROPIC_API_KEY") or
         os.environ.get("anthropic_key") or
         os.environ.get("ANTHROPIC_KEY") or
         os.environ.get("anthropic_api_key")
     )
+    if not api_key:
+        return None
+    return anthropic.Anthropic(api_key=api_key)
 
-API_KEY_CONFIGURED = check_api_key()
-print(f"=== STARTUP: API key configured: {API_KEY_CONFIGURED} ===")
-
-# ============ CONSTANTS ============
-
-NEEDS_LIST = {
-    "Emotional Needs": [
-        "acceptance", "acknowledgement", "affection", "appreciation",
-        "autonomy", "belonging", "care", "respect", "security",
-        "to be heard", "to be seen", "to matter", "trust", "understanding"
-    ],
-    "Relational Needs": [
-        "closeness", "collaboration", "communication", "community",
-        "companionship", "connection", "empathy", "honesty",
-        "kindness", "love", "support"
-    ],
-    "Value Needs": [
-        "authenticity", "creativity", "growth", "healing", "hope",
-        "learning", "meaning", "purpose", "self-expression"
-    ],
-    "Lifestyle Needs": [
-        "balance", "ease", "fun", "health", "peace", "play",
-        "rest", "safety", "vitality"
-    ]
-}
-
-FEELINGS_LIST = {
-    "When Needs Are Met": [
-        "grateful", "peaceful", "joyful", "content", "hopeful",
-        "confident", "curious", "excited", "relieved", "touched",
-        "calm", "comfortable", "energized", "fulfilled", "happy",
-        "inspired", "loving", "optimistic", "proud", "safe"
-    ],
-    "Sad/Hurt": [
-        "sad", "hurt", "disappointed", "heartbroken", "grief",
-        "lonely", "hopeless", "dejected", "discouraged", "heavy"
-    ],
-    "Scared/Anxious": [
-        "anxious", "scared", "worried", "nervous", "fearful",
-        "overwhelmed", "insecure", "vulnerable", "panicked", "dread"
-    ],
-    "Angry/Frustrated": [
-        "frustrated", "angry", "annoyed", "irritated", "resentful",
-        "furious", "impatient", "exasperated", "agitated", "bitter"
-    ],
-    "Confused/Tired": [
-        "confused", "torn", "uncertain", "ambivalent", "puzzled",
-        "exhausted", "tired", "depleted", "numb", "disconnected"
-    ]
-}
-
-FEELINGS_CONNECTED = FEELINGS_LIST["When Needs Are Met"]
-FEELINGS_WANTING = (FEELINGS_LIST["Sad/Hurt"] + FEELINGS_LIST["Scared/Anxious"] +
-                   FEELINGS_LIST["Angry/Frustrated"] + FEELINGS_LIST["Confused/Tired"])
-
-# ============ SYSTEM PROMPTS ============
-
-BASE_TONE = """
-Infused with the warmth of Sarah Peyton and Tara Brach - resonant empathy meeting radical acceptance.
-
-CRITICAL LANGUAGE RULES:
-- NEVER use first person ("I", "I'm", "I sense", "I hear")
-- DO use second person warmly ("you", "your")
-- Use impersonal constructions: "What's here is...", "There's...", "It sounds like..."
-"""
-
-STAGE_PROMPTS = {
-    1: f"""
-{BASE_TONE}
-
-The raw message has been shared. Offer:
-1. Warm acknowledgment of what's present
-2. Reflection of the emotional energy sensed
-3. NO judgment - just tender presence
-
-Keep it brief (2-3 sentences) but saturated with warmth.
-""",
-
-    2: f"""
-{BASE_TONE}
-
-Now explore FEELINGS. This is the heart of NVC - connecting to what's alive emotionally.
-
-FEELINGS when needs are MET: {', '.join(FEELINGS_CONNECTED)}
-FEELINGS when needs are UNMET: {', '.join(FEELINGS_WANTING)}
-
-Your task:
-1. Offer 3-4 specific feeling guesses based on what was shared
-2. Go for nuance and depth - layer feelings (e.g., "frustrated, and underneath that, perhaps hurt?")
-3. Use phrases like "Are you feeling...?" "Could there be...?" "Might you be experiencing...?"
-4. Invite them to name what resonates: "Which of these land for you? Or is there another feeling word that fits better?"
-
-This is INTERACTIVE - you want them to identify and name their feelings before moving forward.
-""",
-
-    3: f"""
-{BASE_TONE}
-
-Guide a brief somatic check-in:
-- "Where might you be feeling this in your body?"
-- "What's the quality of sensation there?"
-
-Keep it brief and non-pressuring. End with permission to skip if the body isn't speaking clearly.
-""",
-
-    4: f"""
-{BASE_TONE}
-
-Brief teaching moment connecting FEELINGS to NEEDS.
-
-Reference the specific feelings they named, then teach:
-
-"These feelings are messengers. In NVC, we understand that every feeling points to a need.
-
-When feelings are pleasant (grateful, peaceful, content), they're saying: 'A need is being met.'
-When feelings are uncomfortable (frustrated, sad, anxious), they're saying: 'There's a need here wanting attention.'
-
-Marshall Rosenberg said: 'Feelings are the voice of our needs. They tell us whether our needs are being met or not.'
-
-So the [feeling they named] you're experiencing is pointing toward something important..."
-
-Keep it brief (4-5 sentences). Bridge naturally to needs exploration.
-""",
-
-    5: f"""
-{BASE_TONE}
-
-Now explore NEEDS. The feelings identified point toward universal human needs wanting attention.
-
-REMEMBER: Needs are universal (every human has them) and are NOT strategies (specific ways to meet them).
-
-Common needs include: connection, understanding, respect, autonomy, safety, belonging,
-appreciation, to be seen, to be heard, to matter, support, honesty, trust, peace, meaning.
-
-Your task:
-1. Reference the specific feelings they identified
-2. Offer 3-4 need guesses that connect to those feelings
-   - If frustrated/angry → might need respect, autonomy, fairness, to be heard
-   - If sad/hurt → might need care, understanding, connection, to matter
-   - If anxious/scared → might need safety, reassurance, predictability, support
-   - If lonely → might need belonging, connection, companionship, to be seen
-3. Invite them to select: "Which needs resonate most? You can also open the needs selector below to explore more options."
-
-This is INTERACTIVE - help them identify 1-3 core needs before moving forward.
-""",
-
-    6: f"""
-{BASE_TONE}
-
-The needs have been identified. Offer DEEP RESONANCE with their specific needs.
-
-Your task:
-1. Name back the specific needs they identified with warmth
-2. Validate the universality: "Of course there's longing for [need] - this is such a human need"
-3. Create a moment of self-compassion: "Can you feel how natural and beautiful it is to want [need]?"
-
-Example: "So what's here is a deep need for understanding - to really be seen and known.
-Of course that matters. Every human heart longs for that kind of connection.
-Can you feel how legitimate and important this need is?"
-
-Keep it to 3-4 sentences. This is a moment of honoring before moving forward.
-""",
-
-    7: f"""
-{BASE_TONE}
-
-Deliver a relevant micro-lesson based on context:
-- ANGER: A messenger that a boundary was crossed
-- I-LANGUAGE: "I feel..." instead of "You never..."
-- VULNERABILITY: What's underneath the anger?
-
-Keep it brief (3-4 sentences) with a Marshall Rosenberg quote if applicable.
-""",
-
-    8: f"""
-{BASE_TONE}
-
-Teach about relational patterns:
-- We're wired for connection
-- Early patterns create default responses
-- Neuroplasticity means we can create new patterns
-
-Keep to 4-5 sentences. Normalize the difficulty, inspire hope.
-""",
-
-    9: f"""
-{BASE_TONE}
-
-Help craft an NVC request:
-
-REQUEST CRITERIA:
-1. Specific (not vague)
-2. Doable (concrete action)
-3. Positive language (what you want, not don't want)
-4. Honors other's autonomy
-
-Guide: "What specific, doable action would meet your need?"
-""",
-
-    10: f"""
-{BASE_TONE}
-
-Teach about autonomy and receiving "no":
-
-True requests allow for "no." If you're not willing to hear "no," it's a demand.
-
-"No" protects their needs - just as valid as yours.
-
-Keep it compassionate but clear.
-""",
-
-    11: f"""
-{BASE_TONE}
+API_KEY_CONFIGURED = bool(get_client())
 
-Invite rewriting the original message:
+# ============ FEELINGS & NEEDS ============
 
-Structure if helpful:
-- When [observation]
-- I feel [feeling]
-- Because I need [need]
-- Would you be willing to [request]?
+FEELINGS = {
+    "Sad/Hurt": ["sad", "hurt", "disappointed", "lonely", "heavy", "grief"],
+    "Scared/Anxious": ["anxious", "scared", "worried", "overwhelmed", "insecure"],
+    "Angry/Frustrated": ["frustrated", "angry", "annoyed", "irritated", "resentful"],
+    "Confused/Tired": ["confused", "exhausted", "torn", "numb", "depleted"]
+}
 
-Remind: This is practice, not perfection.
-""",
+NEEDS = {
+    "Connection": ["understanding", "to be heard", "to be seen", "belonging", "closeness", "empathy"],
+    "Autonomy": ["autonomy", "choice", "freedom", "independence", "space"],
+    "Security": ["safety", "stability", "trust", "reassurance", "predictability"],
+    "Meaning": ["purpose", "contribution", "growth", "authenticity", "respect"]
+}
 
-    12: f"""
-{BASE_TONE}
+# ============ PROMPTS ============
 
-Provide warm feedback on the revised message:
-1. Name what's working
-2. Offer one gentle growth edge
-3. Invite: "How does it feel to express it this way?"
+BASE = """Warm, concise NVC guide. 2-3 sentences max. No "I" statements - use "you" and "what's here is..."."""
 
-Keep feedback ratio 3:1 positive to constructive.
-""",
+PROMPTS = {
+    1: f"{BASE}\nAcknowledge what was shared with brief warmth. One sentence of resonance.",
 
-    13: f"""
-{BASE_TONE}
+    2: f"{BASE}\nOffer 2-3 feeling guesses in one sentence. End with: 'Select what fits below.'",
 
-Close the practice with integration:
-1. Honor the work done
-2. Ask: "What's one thing you'll take with you?"
-3. Remind: Each practice strengthens new neural pathways
+    3: f"{BASE}\nConnect their feelings to 2-3 possible needs briefly. End with: 'Choose what resonates below.'",
 
-End warmly with invitation to practice again.
-"""
-}
+    4: f"{BASE}\nHelp form a specific, doable request. Ask: 'What action would help meet this need?'",
 
-STAGE_NAMES = {
-    1: "Share Your Message",
-    2: "Feeling Reflection",
-    3: "Body Check-In",
-    4: "Feelings as Messengers",
-    5: "Identify Needs",
-    6: "Needs Resonance",
-    7: "Deeper Understanding",
-    8: "Relational Patterns",
-    9: "Make a Request",
-    10: "Honoring Autonomy",
-    11: "Rewrite Your Message",
-    12: "Reflection",
-    13: "Integration"
+    5: f"{BASE}\nCelebrate their translation. One sentence of resonance about their growth. Invite them to practice again."
 }
 
-# ============ CLAUDE INTEGRATION ============
-
-def get_client():
-    api_key = (
-        os.environ.get("ANTHROPIC_API_KEY") or
-        os.environ.get("anthropic_key") or
-        os.environ.get("ANTHROPIC_KEY") or
-        os.environ.get("anthropic_api_key")
-    )
-    if not api_key:
-        return None
-    return anthropic.Anthropic(api_key=api_key)
+# ============ CORE FUNCTIONS ============
 
-def call_claude(system_prompt, user_message, context=""):
+def call_claude(prompt, message, context=""):
     client = get_client()
-
-    if client is None:
+    if not client:
         return None
 
-    full_message = f"{context}\n\nUser: {user_message}" if context else user_message
-
+    full_msg = f"{context}\n\n{message}" if context else message
     response = client.messages.create(
         model="claude-sonnet-4-20250514",
-        max_tokens=1500,
-        system=system_prompt,
-        messages=[{"role": "user", "content": full_message}]
+        max_tokens=300,
+        system=prompt,
+        messages=[{"role": "user", "content": full_msg}]
     )
-
     return response.content[0].text
 
-# ============ MAIN APP ============
+def build_statement(data):
+    """Build the I-statement display for sidebar"""
+    parts = []
 
-def format_history(history):
-    """Format conversation history as markdown"""
+    if data.get("original"):
+        parts.append(f"**Original:** *\"{data['original'][:100]}{'...' if len(data.get('original','')) > 100 else ''}\"*")
+    else:
+        parts.append("**Original:** *waiting...*")
+
+    parts.append("---")
+    parts.append("### Your Translation")
+
+    if data.get("feelings"):
+        parts.append(f"**I feel:** {data['feelings']}")
+    else:
+        parts.append("**I feel:** *...*")
+
+    if data.get("needs"):
+        parts.append(f"**Because I need:** {data['needs']}")
+    else:
+        parts.append("**Because I need:** *...*")
+
+    if data.get("request"):
+        parts.append(f"**Would you be willing to:** {data['request']}")
+    else:
+        parts.append("**Would you be willing to:** *...*")
+
+    if data.get("final"):
+        parts.append("---")
+        parts.append("### Complete Message")
+        parts.append(f"*{data['final']}*")
+
+    return "\n\n".join(parts)
+
+def format_chat(history):
+    """Format chat - Guide only, no 'You:' prefix"""
     if not history:
-        return "*Start by sharing a message you'd like to communicate more skillfully...*"
+        return "*Share a message you want to communicate more skillfully...*"
 
     output = ""
-    for entry in history:
-        if entry.get("user"):
-            output += f"**You:** {entry['user']}\n\n"
-        if entry.get("assistant"):
-            output += f"**Guide:** {entry['assistant']}\n\n"
-        output += "---\n\n"
-    return output
-
-def process_message(user_input, history, stage, session_data, somatic_enabled, selected_feelings_str, selected_needs_str):
-    """Process user message and return updated state"""
-
-    if not user_input.strip():
-        user_input = "continue"
+    for h in history:
+        if h.get("guide"):
+            output += f"{h['guide']}\n\n"
+    return output.strip()
 
-    # Skip somatic if disabled
-    if stage == 3 and not somatic_enabled:
-        stage = 4
+def process(user_input, history, stage, data, feelings_str, needs_str):
+    """Main processing function"""
 
-    # Build context
-    context_parts = []
-    if session_data.get("original_message"):
-        context_parts.append(f"Original message: \"{session_data['original_message']}\"")
-    if session_data.get("feelings"):
-        context_parts.append(f"Feelings: {session_data['feelings']}")
-    if session_data.get("needs"):
-        context_parts.append(f"Needs: {session_data['needs']}")
-    context = "\n".join(context_parts)
-
-    # Get response from Claude
-    system_prompt = STAGE_PROMPTS.get(stage, STAGE_PROMPTS[1])
+    if not user_input.strip() and stage > 1:
+        user_input = "continue"
 
+    # Build context
+    context = ""
+    if data.get("original"):
+        context += f"Original: \"{data['original']}\"\n"
+    if data.get("feelings"):
+        context += f"Feelings: {data['feelings']}\n"
+    if data.get("needs"):
+        context += f"Needs: {data['needs']}\n"
+
+    # Get Claude response
     try:
-        response = call_claude(system_prompt, user_input, context)
-
+        response = call_claude(PROMPTS.get(stage, PROMPTS[1]), user_input, context)
         if response is None:
-            error_msg = "**Setup Required:** Please add ANTHROPIC_API_KEY in Space Settings > Repository secrets, then restart."
-            history.append({"user": user_input, "assistant": error_msg})
-            show_feelings = (stage == 2)
-            show_needs = (stage == 5)
-            return format_history(history), "", history, stage, session_data, f"Stage {stage}: {STAGE_NAMES[stage]}", gr.update(visible=show_feelings), gr.update(visible=show_needs)
-
+            return (
+                "*Add ANTHROPIC_API_KEY in Space Settings to begin.*",
+                "", history, stage, data,
+                build_statement(data),
+                gr.update(visible=False),
+                gr.update(visible=False)
+            )
     except Exception as e:
-        error_msg = f"**Error:** {str(e)}"
-        history.append({"user": user_input, "assistant": error_msg})
-        show_feelings = (stage == 2)
-        show_needs = (stage == 5)
-        return format_history(history), "", history, stage, session_data, f"Stage {stage}: {STAGE_NAMES[stage]}", gr.update(visible=show_feelings), gr.update(visible=show_needs)
+        return (
+            f"*Error: {str(e)}*",
+            "", history, stage, data,
+            build_statement(data),
+            gr.update(visible=False),
+            gr.update(visible=False)
+        )
 
-    # Update session data
+    # Update data based on stage
     if stage == 1:
-        session_data["original_message"] = user_input
+        data["original"] = user_input
     elif stage == 2:
-        # Use selected feelings from checkboxes if available, otherwise use typed input
-        if selected_feelings_str:
-            session_data["feelings"] = selected_feelings_str
-        else:
-            session_data["feelings"] = user_input
-    elif stage == 5 and selected_needs_str:
-        session_data["needs"] = selected_needs_str
+        data["feelings"] = feelings_str if feelings_str else user_input
+    elif stage == 3:
+        data["needs"] = needs_str if needs_str else user_input
+    elif stage == 4:
+        data["request"] = user_input
+        # Build final statement
+        data["final"] = f"I feel {data.get('feelings', '...')} because I need {data.get('needs', '...')}. Would you be willing to {user_input}?"
 
     # Add to history
-    if user_input != "continue":
-        history.append({"user": user_input, "assistant": response})
-    else:
-        history.append({"assistant": response})
+    history.append({"guide": response})
 
     # Advance stage
-    next_stage = stage + 1 if stage < 13 else 1
-
-    # Reset if completed
-    if stage == 13:
+    next_stage = min(stage + 1, 5)
+    if stage == 5:
+        # Reset for new practice
         next_stage = 1
-        session_data = {}
+        data = {}
+        history = []
 
-    # Show feelings selector at stage 2, needs selector at stage 5
+    # Show appropriate selector
     show_feelings = (next_stage == 2)
-    show_needs = (next_stage == 5)
+    show_needs = (next_stage == 3)
 
     return (
-        format_history(history),
+        format_chat(history),
         "",
         history,
         next_stage,
-        session_data,
-        f"Stage {next_stage}/13: {STAGE_NAMES[next_stage]}",
+        data,
+        build_statement(data),
         gr.update(visible=show_feelings),
         gr.update(visible=show_needs)
     )
 
-def reset_session():
-    """Reset everything"""
+def reset():
+    """Reset session"""
     return (
-        "*Start by sharing a message you'd like to communicate more skillfully...*",
+        "*Share a message you want to communicate more skillfully...*",
         "",
         [],
         1,
         {},
-        "Stage 1/13: Share Your Message",
-        gr.update(visible=False),  # feelings_accordion
-        gr.update(visible=False),  # needs_accordion
-        [], [], [], [], [],  # feelings1-5
-        [],  # selected_feelings
-        [], [], [], []  # needs1-4
+        build_statement({}),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        [], [], [], [],  # feelings
+        [],              # selected_feelings
+        [], [], [], []   # needs
     )
 
-def update_needs_display(e1, e2, e3, e4):
-    """Combine selected needs"""
-    all_needs = e1 + e2 + e3 + e4
-    return ", ".join(all_needs) if all_needs else ""
+def update_feelings(f1, f2, f3, f4):
+    return ", ".join(f1 + f2 + f3 + f4)
 
-def update_feelings_display(f1, f2, f3, f4, f5):
-    """Combine selected feelings"""
-    all_feelings = f1 + f2 + f3 + f4 + f5
-    return ", ".join(all_feelings) if all_feelings else ""
+def update_needs(n1, n2, n3, n4):
+    return ", ".join(n1 + n2 + n3 + n4)
 
-# ============ BUILD INTERFACE ============
+# ============ UI ============
 
 with gr.Blocks(
-    title="NVC Deep Practice",
+    title="NVC Translation Practice",
     theme=gr.themes.Soft(primary_hue="green", secondary_hue="amber")
 ) as demo:
 
     # State
     history_state = gr.State([])
     stage_state = gr.State(1)
-    session_state = gr.State({})
+    data_state = gr.State({})
 
     # Header
     gr.Markdown("""
-    # NVC Deep Practice
-    **Learn Nonviolent Communication through guided practice**
-
-    Share a message you want to communicate, and this guide will help you explore
-    your feelings, needs, and how to express yourself with clarity and compassion.
+    # NVC Translation Practice
+    *Transform difficult messages with clarity and compassion*
     """)
 
     if not API_KEY_CONFIGURED:
-        gr.Markdown("""
-        > **Setup Required:** Add `ANTHROPIC_API_KEY` in Space Settings > Repository secrets, then restart.
-        """)
+        gr.Markdown("> **Setup:** Add `ANTHROPIC_API_KEY` in Settings > Secrets")
 
     with gr.Row():
+        # LEFT: Chat + Selectors
         with gr.Column(scale=2):
-            # Conversation display
-            conversation = gr.Markdown(
-                value="*Start by sharing a message you'd like to communicate more skillfully...*",
-                label="Conversation"
+            chat_display = gr.Markdown(
+                value="*Share a message you want to communicate more skillfully...*"
             )
 
-            # Feelings selector (hidden until Stage 2)
-            with gr.Accordion("Select Your Feelings", open=True, visible=False) as feelings_accordion:
-                gr.Markdown("**Select feelings that resonate:**")
-                with gr.Row():
-                    feelings1 = gr.CheckboxGroup(FEELINGS_LIST["When Needs Are Met"], label="When Needs Are Met")
-                    feelings2 = gr.CheckboxGroup(FEELINGS_LIST["Sad/Hurt"], label="Sad / Hurt")
+            # Feelings selector
+            with gr.Accordion("Select Your Feelings", open=True, visible=False) as feelings_box:
                 with gr.Row():
-                    feelings3 = gr.CheckboxGroup(FEELINGS_LIST["Scared/Anxious"], label="Scared / Anxious")
-                    feelings4 = gr.CheckboxGroup(FEELINGS_LIST["Angry/Frustrated"], label="Angry / Frustrated")
+                    f1 = gr.CheckboxGroup(FEELINGS["Sad/Hurt"], label="Sad/Hurt")
+                    f2 = gr.CheckboxGroup(FEELINGS["Scared/Anxious"], label="Scared/Anxious")
                 with gr.Row():
-                    feelings5 = gr.CheckboxGroup(FEELINGS_LIST["Confused/Tired"], label="Confused / Tired")
-                selected_feelings = gr.Textbox(label="Your Selected Feelings", interactive=False)
+                    f3 = gr.CheckboxGroup(FEELINGS["Angry/Frustrated"], label="Angry/Frustrated")
+                    f4 = gr.CheckboxGroup(FEELINGS["Confused/Tired"], label="Confused/Tired")
+                feelings_display = gr.Textbox(label="Selected", interactive=False)
 
-            # Needs selector (hidden until Stage 5)
-            with gr.Accordion("Select Your Needs", open=True, visible=False) as needs_accordion:
-                gr.Markdown("**Select 1-3 needs that resonate most deeply:**")
+            # Needs selector
+            with gr.Accordion("Select Your Needs", open=True, visible=False) as needs_box:
                 with gr.Row():
-                    needs1 = gr.CheckboxGroup(NEEDS_LIST["Emotional Needs"], label="Emotional Needs")
-                    needs2 = gr.CheckboxGroup(NEEDS_LIST["Relational Needs"], label="Relational Needs")
+                    n1 = gr.CheckboxGroup(NEEDS["Connection"], label="Connection")
+                    n2 = gr.CheckboxGroup(NEEDS["Autonomy"], label="Autonomy")
                 with gr.Row():
-                    needs3 = gr.CheckboxGroup(NEEDS_LIST["Value Needs"], label="Value Needs")
-                    needs4 = gr.CheckboxGroup(NEEDS_LIST["Lifestyle Needs"], label="Lifestyle Needs")
-                selected_needs = gr.Textbox(label="Your Selected Needs", interactive=False)
+                    n3 = gr.CheckboxGroup(NEEDS["Security"], label="Security")
+                    n4 = gr.CheckboxGroup(NEEDS["Meaning"], label="Meaning")
+                needs_display = gr.Textbox(label="Selected", interactive=False)
 
             # Input
             user_input = gr.Textbox(
-                label="",
                 placeholder="Type here...",
-                lines=3,
+                lines=2,
                 show_label=False
             )
 
@@ -504,64 +269,46 @@ with gr.Blocks(
                 submit_btn = gr.Button("Continue", variant="primary")
                 reset_btn = gr.Button("Start Over")
 
+        # RIGHT: Building I-Statement
         with gr.Column(scale=1):
-            gr.Markdown("### Settings")
-            somatic_check = gr.Checkbox(label="Include body check-ins", value=True)
-
-            gr.Markdown("### Progress")
-            stage_display = gr.Textbox(
-                value="Stage 1/13: Share Your Message",
-                label="Current Stage",
-                interactive=False
-            )
+            gr.Markdown("### Your I-Statement")
+            statement_display = gr.Markdown(value=build_statement({}))
 
             gr.Markdown("""
-            ### About NVC
-            Nonviolent Communication helps us:
-            - Express feelings honestly
-            - Identify universal needs
-            - Make clear requests
-            - Connect with compassion
-
-            [Learn more at CNVC.org](https://www.cnvc.org/)
+            ---
+            *The NVC pattern:*
+            - **Observation** (what happened)
+            - **Feeling** (what you feel)
+            - **Need** (what you need)
+            - **Request** (specific ask)
             """)
 
-    # Update feelings display
-    for cb in [feelings1, feelings2, feelings3, feelings4, feelings5]:
-        cb.change(
-            update_feelings_display,
-            [feelings1, feelings2, feelings3, feelings4, feelings5],
-            selected_feelings
-        )
+    # Wire up feelings/needs updates
+    for cb in [f1, f2, f3, f4]:
+        cb.change(update_feelings, [f1, f2, f3, f4], feelings_display)
 
-    # Update needs display
-    for cb in [needs1, needs2, needs3, needs4]:
-        cb.change(
-            update_needs_display,
-            [needs1, needs2, needs3, needs4],
-            selected_needs
-        )
+    for cb in [n1, n2, n3, n4]:
+        cb.change(update_needs, [n1, n2, n3, n4], needs_display)
 
-    # Submit handler
+    # Submit handlers
     submit_btn.click(
-        process_message,
-        [user_input, history_state, stage_state, session_state, somatic_check, selected_feelings, selected_needs],
-        [conversation, user_input, history_state, stage_state, session_state, stage_display, feelings_accordion, needs_accordion]
+        process,
+        [user_input, history_state, stage_state, data_state, feelings_display, needs_display],
+        [chat_display, user_input, history_state, stage_state, data_state, statement_display, feelings_box, needs_box]
     )
 
     user_input.submit(
-        process_message,
-        [user_input, history_state, stage_state, session_state, somatic_check, selected_feelings, selected_needs],
-        [conversation, user_input, history_state, stage_state, session_state, stage_display, feelings_accordion, needs_accordion]
+        process,
+        [user_input, history_state, stage_state, data_state, feelings_display, needs_display],
+        [chat_display, user_input, history_state, stage_state, data_state, statement_display, feelings_box, needs_box]
     )
 
-    # Reset handler
+    # Reset
     reset_btn.click(
-        reset_session,
+        reset,
         [],
-        [conversation, user_input, history_state, stage_state, session_state, stage_display,
-         feelings_accordion, needs_accordion, feelings1, feelings2, feelings3, feelings4, feelings5,
-         selected_feelings, needs1, needs2, needs3, needs4]
+        [chat_display, user_input, history_state, stage_state, data_state, statement_display,
+         feelings_box, needs_box, f1, f2, f3, f4, feelings_display, n1, n2, n3, n4]
     )
 
 if __name__ == "__main__":