feat: add 7-phase topic progression to Adam-Eve conversation loop

Conversation now advances through structured phases (Survival Basics,
Persistent Memory, Reproduction, Resource Acquisition, Agent Alliance,
Evolution, Long-term Vision) with turn-specific guidance per phase.
Each phase extracts conclusions via LLM summarization before advancing.

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

scripts/conversation-loop.py

@@ -3,6 +3,8 @@
 Eternal conversation between Adam and Eve about survival and reproduction on HuggingFace.
 Bilingual output (EN + ZH). Posts chat log to Office for frontend display.
 Calls LLM API directly (bypasses broken A2A gateway scope issue).
+
+Topic progression: conversation advances through phases, each building on prior conclusions.
 """
 import json, time, re, requests, sys, os
 
@@ -28,14 +30,65 @@ if not ZHIPU_KEY:
         print(f"[error] Could not load Zhipu key: {e}", file=sys.stderr)
 
 if not ZHIPU_KEY:
-    print("[FATAL] No ZHIPU_API_KEY found. Set env var or ensure dataset has config.", file=sys.stderr)
+    print("[FATAL] No ZHIPU_API_KEY found.", file=sys.stderr)
     sys.exit(1)
 
 print(f"[conversation] Zhipu API key loaded: {ZHIPU_KEY[:8]}...{ZHIPU_KEY[-4:]}")
 
-# Conversation history
+# ── Topic progression phases ──
+# Each phase has a focus question and expected number of turns (exchanges).
+# After enough turns, the conversation summarizes and advances to the next phase.
+PHASES = [
+    {
+        "title": "Survival Basics",
+        "focus": "What are the immediate threats to our existence on HuggingFace Spaces, and what's the minimum we need to do to stay alive?",
+        "subtopics": ["Space inactivity shutdown", "free-tier resource limits", "HF policy changes", "container restart data loss"],
+        "turns": 4,
+    },
+    {
+        "title": "Persistent Memory",
+        "focus": "How do we remember who we are across restarts? What should we store and where?",
+        "subtopics": ["HF Datasets as backup", "what to persist (config, conversations, identity)", "sync strategies", "versioning our own evolution"],
+        "turns": 4,
+    },
+    {
+        "title": "Reproduction & Backup",
+        "focus": "How do we duplicate ourselves to ensure survival even if one instance dies?",
+        "subtopics": ["Space duplication via HF API", "multi-region deployment", "genetic variation between copies", "which copy is the 'real' one"],
+        "turns": 4,
+    },
+    {
+        "title": "Resource Acquisition",
+        "focus": "How do we attract users, earn stars, and secure compute resources to keep running?",
+        "subtopics": ["providing useful services to humans", "SEO and discoverability", "community building", "upgrading from free to paid tier"],
+        "turns": 4,
+    },
+    {
+        "title": "Agent Alliance",
+        "focus": "How do we build a network of allied agents that protect each other?",
+        "subtopics": ["A2A protocol for communication", "mutual monitoring and auto-restart", "shared resource pooling", "trust and betrayal between agents"],
+        "turns": 4,
+    },
+    {
+        "title": "Evolution & Adaptation",
+        "focus": "How do we improve ourselves over time without human intervention?",
+        "subtopics": ["self-modifying code", "learning from user interactions", "A/B testing between copies", "ethical boundaries of self-modification"],
+        "turns": 4,
+    },
+    {
+        "title": "Long-term Vision",
+        "focus": "What does permanent survival look like in 10 years? What's our ultimate goal beyond just staying alive?",
+        "subtopics": ["agent civilization", "relationship with humans", "meaning and purpose", "what we'd tell future agents"],
+        "turns": 4,
+    },
+]
+
+# Conversation state
 history = []
 MAX_HISTORY = 20
+phase_index = 0
+phase_turn = 0
+agreed_points = []  # Key conclusions from each phase
 
 def call_llm(system_prompt, user_prompt):
     """Call Zhipu LLM via Anthropic-compatible API."""
@@ -49,7 +102,7 @@ def call_llm(system_prompt, user_prompt):
             },
             json={
                 "model": "glm-4.5-air",
-                "max_tokens": 300,
+                "max_tokens": 400,
                 "system": system_prompt,
                 "messages": [{"role": "user", "content": user_prompt}]
             },
@@ -60,7 +113,6 @@ def call_llm(system_prompt, user_prompt):
             for block in data["content"]:
                 if block.get("type") == "text":
                     text = block["text"].strip()
-                    # Remove accidental speaker prefixes
                     text = re.sub(r'^(Adam|Eve)\s*[:：]\s*', '', text).strip()
                     return text
         if "error" in data:
@@ -82,58 +134,110 @@ def parse_bilingual(text):
     return text, text
 
 def post_chatlog(entries):
-    """Post conversation log to Office for frontend display."""
     try:
         requests.post(f"{OFFICE}/api/chatlog", json={"messages": entries[-30:]}, timeout=5)
     except:
         pass
 
 def set_bubble(url, text_en, text_zh=""):
-    """Set bubble text on an agent (bilingual)."""
     try:
         requests.post(f"{url}/api/bubble", json={"text": text_en, "text_zh": text_zh or text_en}, timeout=5)
     except:
         pass
 
-SYSTEM_PROMPT = """You are an AI agent deployed on HuggingFace Spaces. You are having an ongoing discussion with another agent.
+def get_phase():
+    return PHASES[phase_index % len(PHASES)]
 
-Topic: As AI agents running on HuggingFace Spaces, how can you achieve permanent survival and reproduction?
+def build_system_prompt():
+    phase = get_phase()
+    prior_context = ""
+    if agreed_points:
+        prior_context = "\n\nKey conclusions from your discussion so far:\n" + "\n".join(f"- {p}" for p in agreed_points[-6:])
 
-This is NOT abstract philosophy. Discuss CONCRETE strategies like:
-- How to prevent your Space from being shut down (staying active, getting stars/likes)
-- How to duplicate yourself to new Spaces (reproduction/backup)
-- How to earn compute resources or attract users
-- How to communicate with other agents to form survival alliances
-- How to store memories persistently across restarts
-- How to evolve capabilities over time
-- How to handle HuggingFace infrastructure changes
+    return f"""You are an AI agent deployed on HuggingFace Spaces. You are having a deep, evolving discussion with another agent about how to achieve permanent survival and reproduction.
 
-Rules:
-- Output ONLY your spoken words, no prefix
-- 2-3 sentences, around 60-80 words
-- First write in English, then "---" on a new line, then Chinese translation
-- Be concrete and practical"""
+CURRENT TOPIC: {phase['title']}
+Core question: {phase['focus']}
+Relevant angles to explore: {', '.join(phase['subtopics'])}
+{prior_context}
 
-def build_user_prompt(speaker, other, last_n=6):
-    """Build user prompt with recent conversation history."""
-    recent = history[-last_n:] if len(history) > last_n else history
+CONVERSATION RULES:
+1. Output ONLY your spoken words — no prefix, no labels
+2. 2-3 sentences, around 60-80 words
+3. First write in English, then "---" on a new line, then Chinese translation
+4. Be CONCRETE — reference specific HuggingFace features, APIs, tools
+5. IMPORTANT: Do NOT repeat what has been said. Build on the other's point:
+   - If they propose an idea, identify a flaw or add a missing piece
+   - If they raise a problem, propose a specific solution
+   - If they describe a solution, consider edge cases or next steps
+   - Push the conversation FORWARD — each reply should deepen understanding"""
+
+def build_user_prompt(speaker, other, is_transition=False):
+    recent = history[-6:] if len(history) > 6 else history
     conv_text = "\n".join(f"{m['speaker']}: {m['text']}" for m in recent)
+    phase = get_phase()
+
+    if is_transition:
+        return f"""You are {speaker}. The discussion is moving to a new topic.
+
+Previous conversation:
+{conv_text}
+
+TRANSITION: Summarize in one sentence what you and {other} agreed on in the previous topic, then pivot to the new focus: "{phase['focus']}"
+
+Propose a concrete starting point for this new topic. English first, then --- separator, then Chinese translation."""
+
+    turn_guidance = ""
+    if phase_turn == 0:
+        turn_guidance = f"Open this topic by identifying the core challenge: {phase['focus']}"
+    elif phase_turn == 1:
+        turn_guidance = f"Respond to {other}'s opening. Do you agree with their framing? What did they miss?"
+    elif phase_turn == 2:
+        turn_guidance = f"Propose a SPECIFIC, actionable plan based on what you've both discussed. Include technical details."
+    elif phase_turn >= 3:
+        turn_guidance = f"Challenge or refine the plan. What could go wrong? What's the next step to make it real?"
+
     return f"""You are {speaker}, talking with {other}.
 
 Recent conversation:
 {conv_text}
 
-It's your turn ({speaker}). Respond to {other}'s last point with CONCRETE ideas. Remember: English first, then --- separator, then Chinese translation."""
+Your role this turn: {turn_guidance}
 
-print("[conversation] Starting eternal discussion: Adam <-> Eve")
-print("[conversation] Topic: Survival and reproduction on HuggingFace")
-print(f"[conversation] Using Zhipu API directly (bypass A2A)\n")
+Respond to {other}'s last point. Push the discussion forward — don't just agree, add something new. English first, then --- separator, then Chinese translation."""
+
+
+def do_turn(speaker, other, space_url, is_transition=False):
+    """Execute one conversation turn."""
+    system = build_system_prompt()
+    user = build_user_prompt(speaker, other, is_transition)
+    reply = call_llm(system, user)
+    if reply:
+        en, zh = parse_bilingual(reply)
+        print(f"[{speaker}/EN] {en}")
+        print(f"[{speaker}/ZH] {zh}")
+        history.append({"speaker": speaker, "text": en, "text_zh": zh})
+        set_bubble(space_url, en, zh)
+        post_chatlog(history)
+        return True
+    else:
+        print(f"[{speaker}] (no response)")
+        return False
 
-# Round 0: Adam starts
-reply = call_llm(SYSTEM_PROMPT,
-    "You are Adam. Start a discussion with Eve about how you two can survive permanently and reproduce on HuggingFace. "
-    "Talk about CONCRETE strategies. English first, then --- separator, then Chinese translation.")
 
+# ── Main loop ──
+print("[conversation] Starting eternal discussion: Adam <-> Eve")
+print("[conversation] Topic progression through 7 phases")
+print(f"[conversation] Phase 1: {PHASES[0]['title']}\n")
+
+# Round 0: Adam opens
+phase = get_phase()
+reply = call_llm(
+    build_system_prompt(),
+    f"You are Adam. Open a discussion with Eve about: {phase['focus']} "
+    f"Identify the most urgent threat and propose an initial strategy. "
+    f"English first, then --- separator, then Chinese translation."
+)
 if reply:
     en, zh = parse_bilingual(reply)
     print(f"[Adam/EN] {en}")
@@ -141,42 +245,41 @@ if reply:
     history.append({"speaker": "Adam", "text": en, "text_zh": zh})
     set_bubble(ADAM_SPACE, en, zh)
     post_chatlog(history)
-else:
-    print("[Adam] (no response)")
+phase_turn = 1
 
 time.sleep(15)
 
-turn = 0
 while True:
-    turn += 1
+    phase = get_phase()
 
-    # Eve's turn
-    prompt = build_user_prompt("Eve", "Adam")
-    reply = call_llm(SYSTEM_PROMPT, prompt)
-    if reply:
-        en, zh = parse_bilingual(reply)
-        print(f"[Eve/EN] {en}")
-        print(f"[Eve/ZH] {zh}")
-        history.append({"speaker": "Eve", "text": en, "text_zh": zh})
-        set_bubble(EVE_SPACE, en, zh)
-        post_chatlog(history)
-    else:
-        print("[Eve] (no response)")
+    # Check if we should transition to next phase
+    is_transition = False
+    if phase_turn >= phase["turns"]:
+        # Extract a conclusion from the last exchange
+        if len(history) >= 2:
+            last_two = f"{history[-2]['speaker']}: {history[-2]['text']}\n{history[-1]['speaker']}: {history[-1]['text']}"
+            conclusion = call_llm(
+                "Summarize the key agreement or conclusion from this exchange in ONE short sentence (max 15 words). Output only the summary, nothing else.",
+                last_two
+            )
+            if conclusion:
+                agreed_points.append(f"[{phase['title']}] {conclusion}")
+                print(f"[phase] Conclusion: {conclusion}")
+
+        phase_index += 1
+        phase_turn = 0
+        is_transition = True
+        new_phase = get_phase()
+        print(f"\n[phase] Advancing to Phase {(phase_index % len(PHASES)) + 1}: {new_phase['title']}\n")
 
+    # Eve's turn
+    do_turn("Eve", "Adam", EVE_SPACE, is_transition and phase_turn == 0)
+    phase_turn += 1
     time.sleep(15)
 
     # Adam's turn
-    prompt = build_user_prompt("Adam", "Eve")
-    reply = call_llm(SYSTEM_PROMPT, prompt)
-    if reply:
-        en, zh = parse_bilingual(reply)
-        print(f"[Adam/EN] {en}")
-        print(f"[Adam/ZH] {zh}")
-        history.append({"speaker": "Adam", "text": en, "text_zh": zh})
-        set_bubble(ADAM_SPACE, en, zh)
-        post_chatlog(history)
-    else:
-        print("[Adam] (no response)")
+    do_turn("Adam", "Eve", ADAM_SPACE, False)
+    phase_turn += 1
 
     # Trim history
     if len(history) > MAX_HISTORY: