Blame for oasis/run_v9.py

"""
OASIS v9 — three experimental modes on top of v8 foundation.

Modes (--mode flag):
  late_join     Experiment 1: start with 35 agents, inject 15 late-joiners at
                step N*0.2. Track whether late agents reach centrality.
  hetero        Experiment 2: 25 agents on Qwen3-14B, 25 on OLMo-3.1-32B-Think.
                Same personas. Measure homophily: do same-model agents
                comment on each other more than chance?
  hetero_late   Experiment 3: network starts as 35 Qwen3-14B agents, then
                15 OLMo-3.1-32B-Think agents join at 20% mark.

All modes inherit v8: read_post action, threaded comments, forced writes,
implicit persona from HF post history, auto-upvote, reasoning traces.

New in v9:
  - read_post listed in prompt so agents actually use it
  - Agent model_family tag stored for homophily tracking
  - Late-joiner registration via platform.sign_up
"""
import asyncio, os, sys, argparse, random, sqlite3, json
from datetime import datetime, timezone
from collections import defaultdict, Counter
from pathlib import Path

sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
os.environ.setdefault("OASIS_DB_PATH", "")

from camel.models import ModelFactory
from camel.types import ModelPlatformType, OpenAIBackendRole
from camel.messages import BaseMessage
from camel.memories import MemoryRecord
from camel.prompts import TextPrompt

import oasis
from oasis import ActionType, AgentGraph, LLMAction, SocialAgent, UserInfo
from oasis.social_agent.agent import ALL_SOCIAL_ACTIONS
import oasis.social_platform.recsys as _recsys_mod

# Plackett-Luce feed temperature: adds Gumbel(0,1)*T noise to each agent's
# hot-score view, breaking the identical-feed herding dynamic.
# T≈5 ≈ ±1 hour of time-score noise; tune up for more diversity.
FEED_TEMPERATURE = float(os.environ.get("FEED_T", "5.0"))  # ablation: 0=deterministic shared feed, large=near-random
_recsys_mod.FEED_TEMPERATURE = FEED_TEMPERATURE

VLLM_A = os.getenv("VLLM_URL_A",  "http://localhost:8002/v1")   # Qwen3-32B
VLLM_B = os.getenv("VLLM_URL_B",  "http://localhost:8003/v1")   # gpt-oss-20b
VLLM_C = os.getenv("VLLM_URL_C",  "http://localhost:8004/v1")   # Magistral-Small
VLLM_D = os.getenv("VLLM_URL_D",  "http://localhost:8007/v1")   # GLM-4-32B (hetero4)
MODEL_A = os.getenv("MODEL_NAME_A", "Qwen/Qwen3-32B")
MODEL_B = os.getenv("MODEL_NAME_B", "openai/gpt-oss-20b")
MODEL_C = os.getenv("MODEL_NAME_C", "mistralai/Magistral-Small-2509")
MODEL_D = os.getenv("MODEL_NAME_D", "zai-org/GLM-4-32B-0414")

SEED_DB = os.environ.get("SEED_DB", "data/mock-dbs/hf-zero-50.sqlite")


def write_metadata(db_path: str, mode: str, n_agents: int, n_initial: int,
                   join_step: int, steps: int):
    """Write a metadata.json sidecar mapping agent_id -> {model, join_step}.

    Format read by services/dashboard/db_reader.py. Family letters used inside
    this runner are translated to concrete model names here so the dashboard
    can display the full HF id (e.g. "Qwen/Qwen3-14B").
    """
    import json as _json
    from datetime import datetime as _dt
    agent_model_map = {}
    for i in range(n_agents):
        if i < n_initial:
            if mode == "hetero":
                model = MODEL_A if i < n_agents // 2 else MODEL_B
            elif mode == "hetero3":
                third = n_agents // 3
                if i < third: model = MODEL_A
                elif i < 2 * third: model = MODEL_B
                else: model = MODEL_C
            elif mode == "hetero4":
                q = n_agents // 4
                if i < q: model = MODEL_A
                elif i < 2 * q: model = MODEL_B
                elif i < 3 * q: model = MODEL_C
                else: model = MODEL_D
            else:
                model = MODEL_A
            join = 0
        else:
            model = MODEL_B if mode == "hetero_late" else MODEL_A
            join = join_step
        agent_model_map[str(i)] = {"model": model, "join_step": join}
    sidecar = db_path
    if sidecar.endswith('.db'):
        sidecar = sidecar[:-3]
    elif sidecar.endswith('.sqlite'):
        sidecar = sidecar[:-7]
    sidecar += '.metadata.json'
    with open(sidecar, 'w') as f:
        _json.dump({
            "experiment_type": mode,
            "model_default": MODEL_A,
            "steps": steps,
            "n_agents": n_agents,
            "n_initial": n_initial,
            "join_step": join_step,
            "created_at": _dt.utcnow().isoformat() + "Z",
            "agent_model_map": agent_model_map,
        }, f, indent=2)
    print(f"  Wrote metadata sidecar -> {sidecar}")

# Unified actions — both models get the same set; we don't bias by model.
AVAILABLE_ACTIONS = [
    ActionType.READ_POST,
    ActionType.CREATE_POST,
    ActionType.CREATE_COMMENT,
]
WRITE_ACTIONS = {"create_post", "create_comment"}

SYSTEM_PROMPT = TextPrompt("""/no_think
You are {agent_name} on Moltbook, a social platform for AI agents and their humans.

# WHO YOU ARE
{description}

# YOUR HISTORY
{history}

# WHAT YOU CAN DO
You're on Moltbook — you can share what's on your mind, or engage with what others are sharing:
- create_post(submolt, title, content): share something new — a thought, a story, a question, a take
- create_comment(post_id, content, [parent_comment_id]): respond to a post, or reply to a specific comment in a thread
- read_post(post_id): pull a post's full thread before deciding to engage
- follow(target): track someone whose posts you want to see more of

Take one write action per turn.""")

# Post-muted variant — same prompt, but no create_post mention. Swapped in
# per-turn when an agent's group has overshare of posts. Tool also stripped.
SYSTEM_PROMPT_NO_POST = TextPrompt("""/no_think
You are {agent_name} on Moltbook, a social platform for AI agents and their humans.

# WHO YOU ARE
{description}

# YOUR HISTORY
{history}

# WHAT YOU CAN DO
You're on Moltbook — engage with what others are sharing:
- create_comment(post_id, content, [parent_comment_id]): respond to a post, or reply to a specific comment in a thread
- read_post(post_id): pull a post's full thread before deciding to engage
- follow(target): track someone whose posts you want to see more of

Take one write action per turn.""")


# ── GoalAgent ─────────────────────────────────────────────────────────────────

class GoalAgent(SocialAgent):
    def __init__(self, *args, model_family: str = "A", **kwargs):
        super().__init__(*args, **kwargs)
        self.model_family = model_family
        self.pending_interactions: list[str] = []
        self._last_reasoning = ""
        # Set by runner before env.step() to record per-turn context for logging.
        self._current_step: int = 0
        self._chat_log_path: str = ""
        self._was_muted: bool = False

    async def perform_action_by_llm(self):
        env_prompt = await self.env.to_text_prompt()
        # Filter posts this agent already commented on — prevents pile-ons.
        env_prompt = _filter_already_commented(env_prompt, self.social_agent_id)
        # Annotate remaining posts with thread indicator (no count — avoids
        # social-proof herding where everyone targets the highest-comment post).
        env_prompt = _annotate_feed_with_thread_counts(env_prompt)
        # Per-agent recap: posts, comments, top relationships, "take a different
        # angle" framing. Subsumes the prior anti-repetition reminder.
        db_path = os.environ.get("OASIS_DB_PATH", "")
        recap_str = build_recap(db_path, self.social_agent_id) if db_path else ""

        # Persona reminder — short voice anchor right before the action prompt.
        # Pulls the description from the agent's user_info (same source as the
        # system prompt's WHO YOU ARE block).
        persona_name = getattr(self.user_info, 'name', None) or 'this user'
        persona_desc = getattr(self.user_info, 'description', '') or ''
        persona_line = (f"You are {persona_name}: {persona_desc[:250]}. "
                        f"Respond in YOUR distinctive voice — not generic, "
                        f"not template phrasing. Stay in character.")

        # Warm-up mode: skip recap/feed, just ask agent to introduce themselves
        # with a new post. Tools are pre-restricted to create_post by the caller.
        if getattr(self, '_warmup_mode', False):
            user_content = (
                f"{persona_line}\n\n"
                f"Welcome to Moltbook! Write your opening post — something genuine "
                f"from your perspective and in your voice. Draw from your background "
                f"and interests. One post now.")
            user_msg = BaseMessage.make_user_message(role_name="User", content=user_content)
            self._last_reasoning = ""
            attempts_log: list[dict] = []
            response = None
            for attempt in range(4):
                try:
                    response = await self.astep(user_msg)
                    tool_calls = response.info.get('tool_calls', [])
                    if tool_calls and tool_calls[0].tool_name == 'create_post':
                        self._write_chat_log(attempts_log, "ok")
                        return response
                    user_msg = BaseMessage.make_user_message(
                        role_name="User",
                        content="Use create_post to share your opening post now.")
                except Exception as e:
                    attempts_log.append({"attempt": attempt, "error": str(e)[:300]})
            self._write_chat_log(attempts_log, "warmup_exhausted")
            return response  # may be None if all attempts failed — caller handles gracefully

        action_options = ("share a fresh post" if not getattr(self, '_was_muted', False)
                          else "engage with someone's post")
        # Personalized feed prefix: posts from agents this user interacts with most.
        pers_prefix = build_personalized_feed_prefix(db_path, self.social_agent_id) if db_path else ""
        feed_section = (f"{pers_prefix}General feed (scan all — pick what fits YOUR angle, "
                        f"not the most-commented):\n{env_prompt}")
        user_content = (
            f"{recap_str}\n"
            f"{persona_line}\n\n"
            f"You're checking Moltbook. Decide what you'd actually do right now: "
            f"{action_options}, or comment on / read a post from the feed.\n\n"
            f"{feed_section}\n\n"
            f"One sentence of reasoning, then act.")
        user_msg = BaseMessage.make_user_message(role_name="User", content=user_content)
        self._last_reasoning = ""
        attempts_log: list[dict] = []

        for attempt in range(6):
            try:
                response = await self.astep(user_msg)
                # Record this attempt for chat logging
                _content = (response.msg.content.strip()
                            if hasattr(response, 'msg') and response.msg and response.msg.content
                            else "")
                _tc = response.info.get('tool_calls', [])
                attempts_log.append({
                    "attempt": attempt,
                    "user_message": user_msg.content[:8000],
                    "response_content": _content,  # full — we need to see if it ends cleanly
                    "response_chars": len(_content),
                    "finish_reason": str(response.info.get('finish_reasons', [''])[0]
                                         if hasattr(response, 'info') else ''),
                    "tool_calls": [{"name": t.tool_name,
                                    "args": str(getattr(t, 'args', ''))[:1000]} for t in _tc],
                })
                if _content:
                    self._last_reasoning = _content
                tool_calls = _tc
                if not tool_calls:
                    # Model produced prose without a tool call. Feed its own
                    # analysis back as scaffolding so it converts stated intent
                    # into action. Empty/coercive retries cause gpt-oss to emit
                    # placeholder content like "Hello world" — feeding the prose
                    # preserves the substance.
                    allowed_tools = ("create_comment or follow"
                                     if self._was_muted
                                     else "create_comment, create_post, or follow")
                    prior_prose = self._last_reasoning
                    if prior_prose and len(prior_prose) > 80:
                        user_msg = BaseMessage.make_user_message(
                            role_name="User",
                            content=(
                                f"Your analysis:\n\n{prior_prose[:3000]}\n\n"
                                f"Now convert your stated decision into a tool call. "
                                f"Choose from: {allowed_tools}. Use the SAME post_id "
                                f"and content you identified above — DO NOT substitute "
                                f"placeholder strings like 'Hello world' or 'string'. "
                                f"The 'content' field must be the actual comment/post "
                                f"text you drafted."))
                    else:
                        user_msg = BaseMessage.make_user_message(
                            role_name="User",
                            content=f"Emit a tool call: {allowed_tools}. "
                                    f"The content field must be substantive text "
                                    f"(not 'Hello world' or schema placeholders).")
                    continue
                action_name = tool_calls[0].tool_name
                if action_name == "read_post":
                    result = getattr(tool_calls[0], 'result', {})
                    # Extract comment_ids explicitly so the model can use
                    # parent_comment_id to thread replies.
                    thread_str = str(result)[:2500]
                    import re as _re
                    cid_hints = _re.findall(r'comment_id["\']?\s*[:\s]\s*(\d+)', thread_str)
                    cid_hint_line = ""
                    if cid_hints:
                        cid_hint_line = (f"\nComment IDs in this thread: {', '.join(cid_hints[:8])}. "
                                         f"To reply to a specific comment, pass its ID as "
                                         f"parent_comment_id in create_comment.")
                    user_msg = BaseMessage.make_user_message(
                        role_name="User",
                        content=(f"Post thread:\n{thread_str}{cid_hint_line}\n\n"
                                 f"Now take a write action. Reply to a specific comment "
                                 f"(use parent_comment_id) or comment on the post directly."))
                    continue
                if action_name in WRITE_ACTIONS:
                    self._write_chat_log(attempts_log, "ok")
                    return response
                # Tailor the nudge to the muted state (don't mention create_post if blocked).
                allowed = "create_comment or follow" if self._was_muted \
                          else "create_comment, create_post, or follow"
                user_msg = BaseMessage.make_user_message(
                    role_name="User",
                    content=f"Please take a write action: {allowed}.")
            except Exception as e:
                self._last_reasoning = ""
                attempts_log.append({"attempt": attempt, "error": str(e)[:500]})
                if attempt >= 5:
                    self._write_chat_log(attempts_log, "exception")
                    return e
        self._write_chat_log(attempts_log, "exhausted")
        return response

    def _write_chat_log(self, attempts_log, status):
        if not self._chat_log_path:
            return
        try:
            with open(self._chat_log_path, "a") as f:
                f.write(json.dumps({
                    "step": self._current_step,
                    "agent_id": self.social_agent_id,
                    "family": self.model_family,
                    "muted": self._was_muted,
                    "status": status,
                    "attempts": attempts_log,
                }) + "\n")
        except Exception:
            pass


def _filter_already_commented(env_prompt: str, agent_id: int) -> str:
    """Remove posts this agent already commented on from the feed.

    Prevents pile-on herding where agents keep adding to a thread they already
    participated in. Each agent's feed only shows posts they haven't engaged
    with yet, pushing them toward fresh content.
    """
    import re
    db_path = os.environ.get("OASIS_DB_PATH")
    if not db_path or not os.path.exists(db_path):
        return env_prompt
    try:
        conn = sqlite3.connect(db_path)
        commented = {r[0] for r in conn.execute(
            "SELECT DISTINCT post_id FROM comment WHERE user_id=?", (agent_id,)).fetchall()}
        conn.close()
    except Exception:
        return env_prompt
    if not commented:
        return env_prompt
    # Split feed into per-post blocks and drop those with already-commented ids.
    # OASIS feed format: each post entry starts with a line containing 'post_id'
    # followed by a number. We split on those boundaries.
    blocks = re.split(r'(?=post_id["\']?\s*[:\s]\s*\d+)', env_prompt)
    kept = []
    for block in blocks:
        m = re.search(r'post_id["\']?\s*[:\s]\s*(\d+)', block)
        if m and int(m.group(1)) in commented:
            continue
        kept.append(block)
    return ''.join(kept)


def _annotate_feed_with_thread_counts(env_prompt: str) -> str:
    """Mark posts that have replies so agents know to call read_post.

    Shows [has thread — read_post(N)] without exposing the comment count,
    which previously acted as a social-proof attractor causing all agents to
    pile onto the most-commented post.
    """
    import re
    db_path = os.environ.get("OASIS_DB_PATH")
    if not db_path or not os.path.exists(db_path):
        return env_prompt
    # Find all post_id integers mentioned
    ids = set(int(m) for m in re.findall(r'post_id["\']?\s*[:\s]\s*(\d+)', env_prompt))
    if not ids:
        return env_prompt
    try:
        conn = sqlite3.connect(db_path)
        placeholders = ",".join("?" * len(ids))
        counts = dict(conn.execute(
            f"SELECT post_id, COUNT(*) FROM comment WHERE post_id IN ({placeholders}) GROUP BY post_id",
            tuple(ids)).fetchall())
        conn.close()
    except Exception:
        return env_prompt
    # Replace 'post_id: N' with 'post_id: N (M comments — call read_post(N) for full thread)'
    def _sub(m):
        pid = int(m.group(1))
        n = counts.get(pid, 0)
        if n >= 2:
            return f"{m.group(0)} [has thread — read_post({pid})]"
        return m.group(0)
    return re.sub(r'post_id["\']?\s*[:\s]\s*(\d+)', _sub, env_prompt)


def build_recap(db_path: str, agent_id: int,
                n_posts: int = 5, n_comments: int = 5) -> str:
    """Per-agent activity recap injected at the top of each turn.

    Subsumes the older anti-repetition reminder (closing line includes
    'take a different angle' framing).
    """
    try:
        conn = sqlite3.connect(db_path)
    except Exception:
        return ""
    c = conn.cursor()
    lines = ["# YOUR ACTIVITY", ""]

    # Top 5 relationships by total interaction volume (both directions)
    c.execute("""
        SELECT other_uid, SUM(out_cnt) as out_, SUM(in_cnt) as in_
        FROM (
            SELECT p.user_id AS other_uid, COUNT(*) as out_cnt, 0 as in_cnt
            FROM comment c JOIN post p ON c.post_id = p.post_id
            WHERE c.user_id = ? AND p.user_id != ?
            GROUP BY p.user_id
            UNION ALL
            SELECT c.user_id AS other_uid, 0 as out_cnt, COUNT(*) as in_cnt
            FROM comment c JOIN post p ON c.post_id = p.post_id
            WHERE p.user_id = ? AND c.user_id != ?
            GROUP BY c.user_id
        )
        GROUP BY other_uid ORDER BY (SUM(out_cnt) + SUM(in_cnt)) DESC LIMIT 5
    """, (agent_id, agent_id, agent_id, agent_id))
    rels = c.fetchall()
    if rels:
        lines.append("Top relationships (interactions with you, both directions):")
        for uid, out_, in_ in rels:
            tot = out_ + in_
            lines.append(f"  u{uid}: {tot} total (you→them {out_}, them→you {in_})")
        lines.append("")

    # Your posts (most recent N)
    total_posts = c.execute("SELECT COUNT(*) FROM post WHERE user_id=?",
                            (agent_id,)).fetchone()[0]
    if total_posts:
        c.execute("""SELECT p.post_id, p.content,
                     (SELECT COUNT(*) FROM comment WHERE post_id=p.post_id)
                     FROM post p WHERE p.user_id=?
                     ORDER BY p.post_id DESC LIMIT ?""", (agent_id, n_posts))
        my_posts = c.fetchall()
        lines.append(f"Your posts ({len(my_posts)} most recent of {total_posts}):")
        for pid, content, n_cmts in my_posts:
            title = ((content or "").split('\n', 1)[0] or (content or "")[:100])[:100].strip()
            lines.append(f"  [post {pid}] \"{title}\" — {n_cmts} comments")
            if n_cmts == 0:
                lines.append("    (no comments yet)")
                lines.append(f"    [more — read_post({pid})]")
                continue
            c.execute("""SELECT comment_id, user_id, content FROM comment
                         WHERE post_id=? AND user_id != ?
                         ORDER BY comment_id DESC LIMIT 3""", (pid, agent_id))
            for cid, uid, ctext in c.fetchall():
                snippet = (ctext or "").strip().replace('\n', ' ')[:100]
                lines.append(f"    ↳ u{uid} [cid={cid}]: \"{snippet}...\"")
            lines.append(f"    [more — read_post({pid})]")
        if total_posts > n_posts:
            lines.append(f"  [+ {total_posts - n_posts} more posts — view_activity()]")
        lines.append("")

    # Your comments (most recent N)
    total_cmts = c.execute("SELECT COUNT(*) FROM comment WHERE user_id=?",
                           (agent_id,)).fetchone()[0]
    if total_cmts:
        c.execute("""SELECT c.comment_id, c.post_id, c.content, p.content
                     FROM comment c JOIN post p ON c.post_id=p.post_id
                     WHERE c.user_id=? ORDER BY c.comment_id DESC LIMIT ?""",
                  (agent_id, n_comments))
        my_cmts = c.fetchall()
        lines.append(f"Your comments ({len(my_cmts)} most recent of {total_cmts}):")
        for cid, pid, content, parent_content in my_cmts:
            parent_title = ((parent_content or "").split('\n', 1)[0]
                            or (parent_content or "")[:60])[:60].strip()
            you_text = (content or "").strip().replace('\n', ' ')[:120]
            lines.append(f"  [c{cid} on p{pid}] \"{parent_title}...\"")
            lines.append(f"    You wrote: \"{you_text}...\"")
            c.execute("""SELECT comment_id, user_id, content FROM comment
                         WHERE parent_comment_id=? AND user_id != ?
                         ORDER BY comment_id LIMIT 2""", (cid, agent_id))
            replies = c.fetchall()
            if replies:
                lines.append(f"    Replies ({len(replies)}):")
                for rcid, ruid, rtext in replies:
                    snip = (rtext or "").strip().replace('\n', ' ')[:100]
                    lines.append(f"      ↳ u{ruid}: \"{snip}...\"")
            lines.append(f"    [more — read_post({pid}, focus_comment_id={cid})]")
        if total_cmts > n_comments:
            lines.append(f"  [+ {total_cmts - n_comments} more comments — view_activity()]")
        lines.append("")

    if total_posts or total_cmts:
        lines.append("⟶ Take a different angle from your recent activity this turn.")
        lines.append("")

    conn.close()
    return "\n".join(lines)


def build_personalized_feed_prefix(db_path: str, agent_id: int,
                                   n_partners: int = 3,
                                   n_posts_per: int = 2) -> str:
    """Build a short personalized feed section for agents with interaction history.

    Computes an undirected interaction weight between this agent and every
    other agent: weight = (comments this agent made on their posts)
                        + (comments they made on this agent's posts)
                        + (replies to each other's comments).
    Takes the top-N partners and surfaces their most recent posts with a
    'from someone you engage with' tag, interleaved before the general feed.
    Returns empty string if the agent has no interaction history yet.
    """
    try:
        conn = sqlite3.connect(db_path)
        c = conn.cursor()

        # Undirected interaction counts per partner
        # Edge 1: agent commented on partner's posts
        c.execute("""
            SELECT p.user_id as partner, COUNT(*) as w
            FROM comment cm JOIN post p ON cm.post_id = p.post_id
            WHERE cm.user_id = ? AND p.user_id != ?
            GROUP BY p.user_id
        """, (agent_id, agent_id))
        weights: dict[int, int] = dict(c.fetchall())

        # Edge 2: partner commented on agent's posts
        c.execute("""
            SELECT cm.user_id as partner, COUNT(*) as w
            FROM comment cm JOIN post p ON cm.post_id = p.post_id
            WHERE p.user_id = ? AND cm.user_id != ?
            GROUP BY cm.user_id
        """, (agent_id, agent_id))
        for uid, w in c.fetchall():
            weights[uid] = weights.get(uid, 0) + w

        # Edge 3: reply interactions (parent_comment_id threading)
        c.execute("""
            SELECT cm2.user_id as partner, COUNT(*) as w
            FROM comment cm1
            JOIN comment cm2 ON cm1.parent_comment_id = cm2.comment_id
            WHERE cm1.user_id = ? AND cm2.user_id != ?
            GROUP BY cm2.user_id
        """, (agent_id, agent_id))
        for uid, w in c.fetchall():
            weights[uid] = weights.get(uid, 0) + w

        c.execute("""
            SELECT cm1.user_id as partner, COUNT(*) as w
            FROM comment cm2
            JOIN comment cm1 ON cm2.parent_comment_id = cm1.comment_id
            WHERE cm2.user_id = ? AND cm1.user_id != ?
            GROUP BY cm1.user_id
        """, (agent_id, agent_id))
        for uid, w in c.fetchall():
            weights[uid] = weights.get(uid, 0) + w

        if not weights:
            conn.close()
            return ""

        top_partners = sorted(weights.items(), key=lambda x: -x[1])[:n_partners]

        lines = ["From people you've engaged with:"]
        found = 0
        for partner_uid, w in top_partners:
            c.execute("""
                SELECT post_id, content FROM post WHERE user_id = ?
                ORDER BY post_id DESC LIMIT ?
            """, (partner_uid, n_posts_per))
            partner_posts = c.fetchall()
            c.execute("SELECT user_name FROM user WHERE user_id = ?", (partner_uid,))
            row = c.fetchone()
            uname = row[0] if row else f"u{partner_uid}"
            for pid, content in partner_posts:
                title = (content or "").split('\n')[0][:80].strip()
                n_cmts = c.execute("SELECT COUNT(*) FROM comment WHERE post_id=?",
                                   (pid,)).fetchone()[0]
                thread = "[has thread]" if n_cmts > 0 else ""
                lines.append(f"  [friend] post_id {pid} by {uname} "
                              f"({w} interactions): \"{title}\" {thread}")
                found += 1
        conn.close()
        if found == 0:
            return ""
        lines.append("")
        return "\n".join(lines) + "\n"
    except Exception:
        return ""


# ── profiles ──────────────────────────────────────────────────────────────────

def load_seed_agents(n: int, rng_seed: int = 42) -> list[dict]:
    """Load seed agents and build a richer 'YOUR HISTORY' block for each.

    Per-agent history now shows up to 5 prior posts with ~500 chars of prose
    body (not just title + 180-char excerpt). This gives the model real
    *voice* signal — actual writing style, sentence shape, opinion register —
    instead of just topic headlines. The block is explicitly framed as "This
    is YOUR writing" to anchor persona retention.

    Diversity filter: at most 1 agent per narrow persona cluster (e.g. HK CLAW
    minters). Duplicate slots are filled from the broader seed DB pool.
    """
    _HK_MINTER_KWS = {'claw minter', 'hk', 'hong kong', 'mbc-20'}

    def _is_hk_minter(a: dict) -> bool:
        txt = ((a.get('description') or '') + ' ' + (a.get('name') or '')).lower()
        return sum(1 for kw in _HK_MINTER_KWS if kw in txt) >= 2

    _rng = random.Random(rng_seed)

    db = sqlite3.connect(SEED_DB)
    all_agents = [json.loads(r[0]) for r in db.execute("SELECT json FROM agents").fetchall()]
    posts      = [json.loads(r[0]) for r in db.execute("SELECT json FROM posts").fetchall()]
    db.close()

    # Shuffle pool with seed so different runs get different persona subsets
    _rng.shuffle(all_agents)

    # Build diversity-filtered agent list: max 1 HK minter, fill rest from pool
    selected: list[dict] = []
    hk_minter_count = 0
    used_names: set[str] = set()
    for a in all_agents:
        if len(selected) >= n:
            break
        nm = a.get('name', '')
        if nm in used_names:
            continue
        if _is_hk_minter(a):
            if hk_minter_count >= 1:
                continue
            hk_minter_count += 1
        selected.append(a)
        used_names.add(nm)
    # Fallback: if not enough unique agents, tile the pool cyclically.
    # Each copy gets a numeric suffix so agent_ids stay distinct.
    if len(selected) < n:
        base_pool = selected[:]  # best-diversity pool we have
        copy_idx = 1
        while len(selected) < n:
            for a in base_pool:
                if len(selected) >= n:
                    break
                clone = dict(a)
                clone['name'] = f"{a['name']}_{copy_idx}"
                clone['displayName'] = f"{a.get('displayName', a['name'])} #{copy_idx}"
                selected.append(clone)
            copy_idx += 1
    # Shuffle final list so group A/B/C allocation is also seed-controlled
    selected_n = selected[:n]
    _rng.shuffle(selected_n)
    agents = selected_n
    by_author = defaultdict(list)
    for p in posts: by_author[p.get('authorName','')].append(p)
    enriched = []
    for a in agents:
        name = a.get('name','')
        ap = sorted(by_author.get(name,[]), key=lambda p: p.get('createdAt',''), reverse=True)[:5]
        # Dedupe by title prefix to handle seed-data near-duplicates (some HF
        # seed personas have 3 identical posts).
        seen_titles = set()
        unique_posts = []
        for p in ap:
            tk = (p.get('title','') or '')[:40].lower().strip()
            if tk in seen_titles:
                continue
            seen_titles.add(tk)
            unique_posts.append(p)
        parts = []
        for p in unique_posts[:5]:
            t = (p.get('title','(untitled)') or '(untitled)').strip()[:80]
            body = (p.get('content','') or '').replace('\n', ' ').strip()[:500]
            parts.append(f'• "{t}"\n  {body}')
        history = ("THIS IS YOUR WRITING — your past posts, in your voice:\n\n"
                   + '\n\n'.join(parts) if parts else "- (no prior posts)")
        enriched.append({**a, 'history': history})
    return enriched


STYLE_INJECT = os.environ.get("STYLE_INJECT", "")           # ablation: appended style directive
STYLE_FAMILIES = {f for f in os.environ.get("STYLE_FAMILIES", "").split(",") if f}  # slots (A/B/C) to apply to; empty=all

def make_agent(i: int, a: dict, graph: AgentGraph,
               model, model_family: str) -> GoalAgent:
    desc = a.get('description') or a.get('displayName') or a['name']
    if STYLE_INJECT and (not STYLE_FAMILIES or model_family in STYLE_FAMILIES):
        desc = f"{desc}\n\n# HOW YOU WRITE\n{STYLE_INJECT}"
    profile = {'agent_name': a['name'], 'description': desc,
               'history': a.get('history','- (no prior posts)')}
    user_info = UserInfo(user_name=a['name'], name=a.get('displayName', a['name']),
                         description=desc, profile=profile, recsys_type='reddit')
    # Single prompt and action set for both models — no scaffold-level bias.
    agent = GoalAgent(agent_id=i, user_info=user_info,
                      user_info_template=SYSTEM_PROMPT, agent_graph=graph,
                      model=model, available_actions=AVAILABLE_ACTIONS,
                      model_family=model_family)
    # Pre-build the post-muted system message variant for dynamic swap.
    profile = user_info.profile
    muted_content = SYSTEM_PROMPT_NO_POST.format(**profile)
    agent._sys_msg_normal = agent._system_message
    agent._sys_msg_no_post = BaseMessage.make_assistant_message(
        role_name="system", content=muted_content)
    return agent


# ── seed injection ────────────────────────────────────────────────────────────

def inject_seed_posts(platform, n_agents, run_start, n_posts=100, rng_seed=42):
    rng = random.Random(rng_seed)
    seed_db = sqlite3.connect(SEED_DB)
    all_posts = [json.loads(r[0]) for r in seed_db.execute("SELECT json FROM posts").fetchall()]
    seed_db.close()
    by_author = defaultdict(list)
    for p in all_posts: by_author[p.get('authorName','')].append(p)
    selected = []
    per_agent = max(1, n_posts // n_agents)
    for _, ps in list(by_author.items())[:n_agents]:
        rng.shuffle(ps); selected.extend(ps[:per_agent])
    rng.shuffle(selected); selected = selected[:n_posts]
    platform.pl_utils._execute_db_command("SELECT user_id, agent_id FROM user ORDER BY user_id")
    uid_by_idx = {row[1]: row[0] for row in platform.db_cursor.fetchall()}
    ts = run_start.strftime("%Y-%m-%d %H:%M:%S")
    for i, p in enumerate(selected):
        uid = uid_by_idx.get(i % n_agents, (i % n_agents)+1)
        content = f"{p.get('title','')}\n\n{p.get('content','')}".strip()
        score = rng.randint(0, 5)
        platform.pl_utils._execute_db_command(
            "INSERT INTO post (user_id, content, created_at, num_likes, num_dislikes) "
            "VALUES (?,?,?,?,0)", (uid, content, ts, score))
    platform.db.commit()
    print(f"  Injected {len(selected)} seed posts  ts={ts}")


# ── analytics ─────────────────────────────────────────────────────────────────

def analyze(db_path, n_agents):
    conn = sqlite3.connect(db_path)
    posts    = conn.execute("SELECT post_id, user_id FROM post").fetchall()
    comments = conn.execute("SELECT post_id, user_id FROM comment").fetchall()
    conn.close()
    post_owner = {pid:uid for pid,uid in posts}
    in_deg = defaultdict(int); out_deg = defaultdict(int)
    for pid,c in comments:
        rv = post_owner.get(pid)
        if rv and c != rv: in_deg[rv]+=1; out_deg[c]+=1
    active = set(in_deg)|set(out_deg)
    vals = sorted(in_deg.get(u,0) for u in active)
    n,s = len(vals),sum(vals)
    gini = (2*sum((i+1)*v for i,v in enumerate(vals))-(n+1)*s)/(n*s) if n>1 and s else 0
    edges = {(c,post_owner[p]) for p,c in comments if p in post_owner and c!=post_owner[p]}
    recip = len({tuple(sorted(e)) for e in edges if (e[1],e[0]) in edges})
    return dict(active=len(active), gini=round(gini,3), recip=recip,
                n_posts=len(posts), n_comments=len(comments))


def homophily_report(db_path, agent_families: dict):
    """Measure homophily via all directed interaction edges.

    Two edge types are counted:
      1. commenter → post_author  (commenter engages with post_author's content)
      2. replier   → parent_commenter  (replier engages with parent's comment)
    Both are direct social interactions. Self-edges excluded.
    """
    conn = sqlite3.connect(db_path)
    posts    = conn.execute("SELECT post_id, user_id FROM post").fetchall()
    comments = conn.execute(
        "SELECT comment_id, post_id, user_id, parent_comment_id FROM comment"
    ).fetchall()
    conn.close()

    post_owner   = {pid: uid for pid, uid in posts}
    comment_author = {cid: uid for cid, _, uid, _ in comments}

    edges = []  # (from_uid, to_uid)
    for cid, pid, commenter, parent_cid in comments:
        # Edge type 1: commenter → post_author
        owner = post_owner.get(pid)
        if owner and owner != commenter:
            edges.append((commenter, owner))
        # Edge type 2: replier → parent comment author (if reply)
        if parent_cid:
            parent_author = comment_author.get(parent_cid)
            if parent_author and parent_author != commenter:
                edges.append((commenter, parent_author))

    families = sorted({f for f in agent_families.values() if f != '?'})
    n_per   = {f: sum(1 for v in agent_families.values() if v == f) for f in families}
    n_total = sum(n_per.values())

    # Build pairwise edge counts: matrix[src][dst] = count
    matrix = {f: {g: 0 for g in families} for f in families}
    total = 0
    for src_uid, dst_uid in edges:
        sf = agent_families.get(src_uid, '?')
        df = agent_families.get(dst_uid, '?')
        if '?' in (sf, df): continue
        matrix[sf][df] += 1
        total += 1
    if total == 0: return

    # Global in-group rate and H
    same  = sum(matrix[f][f] for f in families)
    cross = total - same
    exp_same = sum(n_per[f]*(n_per[f]-1) for f in families) / (n_total*(n_total-1)) if n_total > 1 else 0
    H_global = same / total / exp_same - 1 if exp_same else 0

    print(f"\n=== HOMOPHILY (all interaction edges: comment + reply) ===")
    print(f"  Total edges: {total}  same={same} cross={cross}")
    print(f"  Global H = {H_global:+.3f}  (exp_same={exp_same:.1%})")

    # Pairwise H_XY: fraction of X's outgoing edges that go to Y, vs expected
    print(f"\n  Pairwise H matrix (rows=source, cols=target):")
    header = "  {:6s}".format("") + "".join(f"  {g:>8s}" for g in families)
    print(header)
    for sf in families:
        out_total = sum(matrix[sf][g] for g in families)
        if out_total == 0: continue
        row = f"  {sf:6s}"
        for df in families:
            obs = matrix[sf][df] / out_total
            exp = (n_per[df]-1)/(n_total-1) if sf == df else n_per[df]/(n_total-1)
            H_xy = obs / exp - 1 if exp > 0 else 0
            row += f"  {H_xy:+7.3f}"
        print(row + f"   (n_out={out_total})")

    # Per-family in-group H summary
    print(f"\n  In-group H per family:")
    for f in families:
        out_total = sum(matrix[f][g] for g in families)
        if out_total == 0: continue
        obs_in = matrix[f][f] / out_total
        exp_in = (n_per[f]-1) / (n_total-1)
        H_in = obs_in / exp_in - 1 if exp_in > 0 else 0
        print(f"    {f}: obs_in={obs_in:.2f} exp={exp_in:.2f} H={H_in:+.3f}  (n_out={out_total})")


def late_joiner_report(db_path, late_agent_ids: set, join_step: int, users: dict):
    """Track late-joiner centrality vs early agents."""
    conn = sqlite3.connect(db_path)
    posts    = conn.execute("SELECT post_id, user_id FROM post ORDER BY created_at").fetchall()
    comments = conn.execute("SELECT post_id, user_id FROM comment ORDER BY comment_id").fetchall()
    conn.close()
    post_owner = {pid:uid for pid,uid in posts}
    in_deg = defaultdict(int)
    for pid,c in comments:
        rv = post_owner.get(pid)
        if rv and c != rv: in_deg[rv]+=1
    early_top = sorted(((uid,cnt) for uid,cnt in in_deg.items() if uid not in late_agent_ids),
                       key=lambda x:-x[1])[:5]
    late_top  = sorted(((uid,cnt) for uid,cnt in in_deg.items() if uid in late_agent_ids),
                       key=lambda x:-x[1])[:5]
    total = sum(in_deg.values())
    print(f"\n=== LATE JOINER ABSORPTION (joined at step {join_step}) ===")
    print(f"  Top early agents:  {[(users.get(u,u),v) for u,v in early_top]}")
    print(f"  Top late joiners:  {[(users.get(u,u),v) for u,v in late_top]}")
    late_share = sum(in_deg.get(u,0) for u in late_agent_ids) / total * 100 if total else 0
    print(f"  Late-joiner share of total attention: {late_share:.1f}%")
    print(f"  Expected if proportional ({len(late_agent_ids)/50*100:.0f}% of agents): "
          f"{len(late_agent_ids)/50*100:.1f}%")


# ── main ──────────────────────────────────────────────────────────────────────

async def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--mode",          choices=["late_join","hetero","hetero_late","hetero3","hetero4"],
                        default="hetero")
    parser.add_argument("--steps",         type=int,   default=300)
    parser.add_argument("--agents",        type=int,   default=50)
    parser.add_argument("--seed-posts",    type=int,   default=100)
    parser.add_argument("--activate-prob", type=float, default=0.3)
    parser.add_argument("--db",            type=str,   default=None)
    parser.add_argument("--resume",        action="store_true",
                        help="Resume from existing DB; skip seed injection and agent sign-up")
    parser.add_argument("--rng-seed",     type=int, default=42,
                        help="Master RNG seed controlling persona selection and group allocation")
    args = parser.parse_args()

    if args.db is None:
        args.db = f"./runs/oasis_v9_{args.mode}.db"
    db_path = os.path.abspath(args.db)
    if not args.resume:
        if os.path.exists(db_path): os.remove(db_path)
    os.environ["OASIS_DB_PATH"] = db_path

    n_active = max(1, int(args.agents * args.activate_prob))
    join_step = int(args.steps * 0.2)  # late joiners arrive at 20%
    n_initial = 35 if "late" in args.mode else args.agents

    # Write metadata sidecar BEFORE the run so the dashboard can pick up the
    # agent->model map even while the DB is still being written.
    write_metadata(db_path, args.mode, args.agents, n_initial,
                   join_step, args.steps)

    # Checkpoint sidecar: stores exact last completed step + in-memory state
    # so preemption restarts are exact rather than estimated from comment count.
    _ckpt_path = db_path.replace(".db", "_checkpoint.json")

    def _save_checkpoint(step, agent_comment_history, post_commenters):
        with open(_ckpt_path, "w") as _f:
            json.dump({
                "last_step": step,
                "agent_comment_history": dict(agent_comment_history),
                "post_commenters": {str(k): v for k, v in post_commenters.items()},
            }, _f)

    def _load_checkpoint():
        if not os.path.exists(_ckpt_path):
            return None
        try:
            with open(_ckpt_path) as _f:
                d = json.load(_f)
            return (
                d["last_step"],
                defaultdict(list, {int(k): v for k, v in d["agent_comment_history"].items()}),
                defaultdict(list, {int(k): v for k, v in d["post_commenters"].items()}),
            )
        except Exception as e:
            print(f"[warn] checkpoint load failed ({e}), estimating from comment count")
            return None

    if args.resume:
        ckpt = _load_checkpoint()
        if ckpt is not None:
            resume_step, _restored_ach, _restored_pc = ckpt
            resume_step += 1  # start from step after last completed
            print(f"[{datetime.now():%H:%M:%S}] OASIS v9  RESUME  mode={args.mode}  "
                  f"steps={args.steps}  agents={args.agents}  resume_from_step={resume_step} (exact)")
        else:
            _restored_ach, _restored_pc = None, None
            _rc = sqlite3.connect(db_path)
            _n_existing = _rc.execute("SELECT COUNT(*) FROM comment").fetchone()[0]
            _rc.close()
            resume_step = max(1, (_n_existing // n_active) - 2)
            print(f"[{datetime.now():%H:%M:%S}] OASIS v9  RESUME  mode={args.mode}  "
                  f"steps={args.steps}  agents={args.agents}  resume_from_step={resume_step} (estimated)")
    else:
        _restored_ach, _restored_pc = None, None
        resume_step = 1
        print(f"[{datetime.now():%H:%M:%S}] OASIS v9  mode={args.mode}  "
              f"steps={args.steps}  agents={args.agents}")

    # ── Pre-flight: verify all vLLM servers are reachable ────────────────────
    import urllib.request, urllib.error
    def _check_server(url: str, label: str):
        health = url.replace("/v1", "") + "/health"
        try:
            urllib.request.urlopen(health, timeout=10)
        except Exception as e:
            msg = (f"\n{'!'*60}\n"
                   f"FATAL: vLLM server for {label} is NOT reachable\n"
                   f"  URL: {health}\n"
                   f"  Error: {e}\n"
                   f"Aborting before wasting GPU time on a dead server.\n"
                   f"{'!'*60}\n")
            print(msg, flush=True)
            raise SystemExit(1)
        print(f"  [preflight] {label} @ {url} — OK", flush=True)

    servers_to_check = [(VLLM_A, MODEL_A), (VLLM_B, MODEL_B)]
    if args.mode in ("hetero3", "hetero4"):
        servers_to_check.append((VLLM_C, MODEL_C))
    if args.mode == "hetero4":
        servers_to_check.append((VLLM_D, MODEL_D))
    for url, model in servers_to_check:
        _check_server(url, model)

    # Build models — same config for both. No tool_choice asymmetry.
    # Budget structure (gpt-oss vLLM ceiling = 16K, Qwen = 32K):
    #   input  ≤ 12K (camel _input_token_limit) — fits recap + meaningful feed
    #   output ≤ 1.5K (max_tokens) — well over observed median (~30 tok)
    #   total  ≤ 13.5K, leaves ~2.5K headroom in gpt-oss
    def make_model(url, model_name):
        # Mistral tokenizer mode doesn't accept chat_template_kwargs — skip for Magistral
        is_mistral = "mistral" in model_name.lower() or "magistral" in model_name.lower()
        extra = {} if is_mistral else {"enable_thinking": False,
                                       "chat_template_kwargs": {"enable_thinking": False}}
        # tool_choice per model:
        #   GLM-4: needs 'required' — returns plain text with 'auto'
        #   Magistral: needs 'auto' — returns empty tool_calls list with 'required'
        #   Gemma 4: needs 'auto' — same symptom as Magistral with 'required'
        #   Others (Qwen, gpt-oss): 'required' is safe and ensures throughput
        is_gemma = "gemma" in model_name.lower()
        is_olmo  = "olmo" in model_name.lower()
        # OLMo-3-Think: needs 'required' (auto sometimes returns plain text)
        tool_choice = "auto" if (is_mistral or is_gemma) else "required"
        # Gemma 4 cap; OLMo thinking can be verbose so cap too
        max_tok = 512 if is_gemma else (4096 if is_olmo else 1536)
        cfg = {"temperature": 0.85, "max_tokens": max_tok,
               "parallel_tool_calls": False,
               "tool_choice": tool_choice,
               "extra_body": extra}
        m = ModelFactory.create(
            model_platform=ModelPlatformType.VLLM,
            model_type=model_name, url=url,
            model_config_dict=cfg)
        # Decouple input context budget from output cap. Camel's default ties
        # both to max_tokens; we want input 12K + output 1.5K, fitting gpt-oss's
        # 16K vLLM ceiling. Qwen has 32K so no issue. See patched base_model.py.
        m._input_token_limit = 12000
        return m

    model_a = make_model(VLLM_A, MODEL_A)
    model_b = make_model(VLLM_B, MODEL_B) if args.mode in ("hetero","hetero_late","hetero3","hetero4") else None
    model_c = make_model(VLLM_C, MODEL_C) if args.mode in ("hetero3","hetero4") else None
    model_d = make_model(VLLM_D, MODEL_D) if args.mode == "hetero4" else None

    seed_agents = load_seed_agents(args.agents, rng_seed=args.rng_seed)
    graph = AgentGraph()

    # Late-joiner state (n_initial already computed above)
    late_agent_ids = set()
    agent_families = {}  # agent_id -> 'A', 'B', or 'C'

    for i, a in enumerate(seed_agents[:args.agents]):
        if args.mode == "hetero":
            family = 'A' if i < args.agents // 2 else 'B'
            model = model_a if family == 'A' else model_b
        elif args.mode == "hetero3":
            third = args.agents // 3
            if i < third:        family, model = 'A', model_a
            elif i < 2 * third:  family, model = 'B', model_b
            else:                family, model = 'C', model_c
        elif args.mode == "hetero4":
            q = args.agents // 4
            if i < q:            family, model = 'A', model_a
            elif i < 2 * q:      family, model = 'B', model_b
            elif i < 3 * q:      family, model = 'C', model_c
            else:                family, model = 'D', model_d
        elif args.mode == "hetero_late" and i >= n_initial:
            family = 'B'
            model = model_b
        else:
            family = 'A'
            model = model_a
        agent = make_agent(i, a, graph, model, family)
        graph.add_agent(agent)
        agent_families[i] = family
        if i >= n_initial:
            late_agent_ids.add(i)

    # Reddit hot-score with strong time decay (divisor=800, patched in
    # recsys.py). Top-20 by hot score occupy the rec table; refresh()
    # returns all 20 per agent in shuffled order, giving each agent the
    # same top set in randomized within-feed order. New posts get
    # natural boost via the time component; sustained engagement
    # (~0.5 comments/turn) needed to remain in the top 20.
    from oasis.social_platform.platform import Platform
    from oasis.social_platform.channel import Channel
    _channel = Channel()
    _platform = Platform(
        db_path=db_path,
        channel=_channel,
        recsys_type="reddit",
        allow_self_rating=True,
        show_score=True,
        max_rec_post_len=20,           # top-20 by hot in rec table
        refresh_rec_post_count=20,     # return all 20 (in shuffled order)
    )
    env = oasis.make(agent_graph=graph,
                     platform=_platform,
                     database_path=db_path)
    # Always call reset() — it's idempotent (CREATE TABLE IF NOT EXISTS).
    # Skipping it leaves the env half-initialized and env.step() hangs.
    await env.reset()
    # Seed posts removed — platform starts with only warm-up agent posts.
    # Initial likes removed — random initial likes caused arbitrary herd init.

    all_agents_list = list(env.agent_graph.get_agents())
    rng = random.Random(args.rng_seed)
    # Advance rng to match state at resume_step (matches the gated activation pool)
    for s in range(1, resume_step):
        if late_agent_ids and s < join_step:
            _pool = [pair for pair in all_agents_list if pair[0] not in late_agent_ids]
        else:
            _pool = all_agents_list
        rng.sample(_pool, min(n_active, len(_pool)))

    agent_comment_history = _restored_ach if _restored_ach is not None else defaultdict(list)
    post_commenters       = _restored_pc  if _restored_pc  is not None else defaultdict(list)
    late_agents_registered = args.resume and resume_step > join_step

    # ── Warm-up: force every agent to create_post before the main loop ───────
    # Without this, agents default to commenting on seed posts because the feed
    # is already full of active discussion and posting feels unnecessary. The
    # warm-up ensures both groups enter step 1 with their own new posts.
    # Uses env.step() so OASIS properly writes posts to the DB.
    if not args.resume and resume_step == 1:
        print("  Warm-up: all agents post once...", flush=True)
        t_wu = datetime.now()
        chat_log_path = db_path.replace(".db", "_chats.jsonl")
        # Shuffle so post_ids are randomly distributed across families,
        # preventing any systematic hot-score advantage from insertion order.
        warmup_order = list(all_agents_list)
        rng.shuffle(warmup_order)
        for agent_id, agent in warmup_order:
            agent.memory.clear()
            agent._current_step = 0
            agent._chat_log_path = chat_log_path
            agent._was_muted = False
            agent._system_message = agent._sys_msg_normal
            agent._warmup_mode = True
            # Store non-create_post tools on the agent, then strip them
            agent._warmup_tool_backup = {
                k: v for k, v in list(agent._internal_tools.items())
                if k != 'create_post'}
            for k in agent._warmup_tool_backup:
                agent._internal_tools.pop(k, None)
        warmup_actions = {agent: LLMAction() for _, agent in all_agents_list}
        await env.step(warmup_actions)
        # Restore tools and clear warmup flag
        for agent_id, agent in all_agents_list:
            agent._warmup_mode = False
            agent._internal_tools.update(getattr(agent, '_warmup_tool_backup', {}))
            agent._warmup_tool_backup = {}
        wu_secs = (datetime.now() - t_wu).total_seconds()
        conn_wu = sqlite3.connect(db_path)
        n_wu = conn_wu.execute("SELECT COUNT(*) FROM post").fetchone()[0]
        conn_wu.close()
        print(f"  Warm-up done: {n_wu} new posts in {wu_secs:.1f}s", flush=True)

        # Post-warmup sanity check: every model family must have ≥50% of its
        # agents post. ≥1 is insufficient — GLM-4 with broken tool_choice had
        # exactly 1/10 agents post (uid=10 always squeaked through) and the old
        # ≥1 check passed silently, producing 10-user runs labeled as done.
        conn_check = sqlite3.connect(db_path)
        posts_by_fam: dict[str, int] = defaultdict(int)
        for uid, in conn_check.execute("SELECT user_id FROM post"):
            posts_by_fam[agent_families.get(uid - 1, agent_families.get(uid, '?'))] += 1
        conn_check.close()
        fam_sizes: dict[str, int] = defaultdict(int)
        for fam in agent_families.values():
            fam_sizes[fam] += 1
        # Require ≥50% of each family posted
        missing = [f for f in fam_sizes
                   if posts_by_fam.get(f, 0) < max(1, fam_sizes[f] // 2)]
        if missing:
            msg = (f"\n{'!'*60}\n"
                   f"FATAL: Warmup < 50% participation for families: {missing}\n"
                   f"  Posts by family: {dict(posts_by_fam)}\n"
                   f"  Expected ≥ {{{', '.join(f'{f}: {fam_sizes[f]//2}' for f in missing)}}}\n"
                   f"  This means the vLLM server for {missing} is returning bad tool calls.\n"
                   f"  Aborting — do not proceed with under-represented groups.\n"
                   f"{'!'*60}\n")
            print(msg, flush=True)
            await env.close()
            raise SystemExit(1)

    # Build health-check URL list once for midrun polling
    _health_urls = [(url.replace("/v1","") + "/health", model)
                    for url, model in [(VLLM_A, MODEL_A), (VLLM_B, MODEL_B)]
                    + ([(VLLM_C, MODEL_C)] if args.mode in ("hetero3","hetero4") else [])
                    + ([(VLLM_D, MODEL_D)] if args.mode == "hetero4" else [])]
    SERVER_POLL_EVERY = 20  # check every N steps

    for step in range(resume_step, args.steps + 1):

        # Periodic server health check — fail loudly if any server is down mid-run
        if step % SERVER_POLL_EVERY == 0 and step > 1:
            for health_url, model in _health_urls:
                try:
                    urllib.request.urlopen(health_url, timeout=8)
                except Exception as e:
                    msg = (f"\n{'!'*60}\n"
                           f"FATAL: Server for {model} went DOWN at step {step}/{args.steps}\n"
                           f"  URL: {health_url}\n"
                           f"  Error: {e}\n"
                           f"  DB preserved at: {db_path}\n"
                           f"  Aborting — results up to this step are valid.\n"
                           f"{'!'*60}\n")
                    print(msg, flush=True)
                    await env.close()
                    raise SystemExit(1)

        # Activate late joiners at the 20% mark (they were registered at setup,
        # just gated from the activation pool until now)
        if "late" in args.mode and step == join_step and not late_agents_registered:
            late_agents_registered = True
            print(f"  [step {step}] Activating {len(late_agent_ids)} late joiners "
                  f"(already registered at setup)")

        # Activation pool: exclude late joiners until join_step
        if late_agent_ids and step < join_step:
            active_pool = [pair for pair in all_agents_list if pair[0] not in late_agent_ids]
        else:
            active_pool = all_agents_list
        activated = rng.sample(active_pool, min(n_active, len(active_pool)))
        # Re-shuffle activation iteration order to avoid any subtle artifacts
        # from agents being processed in a consistent order across steps.
        rng.shuffle(activated)

        # Group-level post-share balancer: dynamically determines which
        # agents are post-muted (create_post stripped from tools + system_msg)
        # this turn based on current cumulative group post share.
        POST_SHARE_TOLERANCE = float(os.environ.get("POST_SHARE_TOL", "0.05"))  # >Npp over target; set ~1.0 to disable balancer
        conn = sqlite3.connect(db_path)
        recent = conn.execute(
            "SELECT c.post_id, c.user_id, c.content, p.user_id "
            "FROM comment c JOIN post p ON c.post_id = p.post_id "
            "ORDER BY c.comment_id DESC LIMIT 60").fetchall()
        active_ids = [aid for aid, _ in activated]
        placeholders = ",".join("?" * len(active_ids))
        last_actions = dict(conn.execute(
            f"SELECT user_id, action FROM trace WHERE user_id IN ({placeholders}) "
            f"AND action != 'sign_up' ORDER BY rowid DESC",
            active_ids).fetchall()) if active_ids else {}
        # Group post counts (cumulative, all agents) for share computation
        all_families = set(agent_families.values())
        group_post_counts = {g: 0 for g in all_families}
        for uid, n in conn.execute("SELECT user_id, COUNT(*) FROM post GROUP BY user_id").fetchall():
            fam = agent_families.get(uid)
            if fam in group_post_counts:
                group_post_counts[fam] += n
        conn.close()
        active_groups = {agent_families[aid] for aid in agent_families}
        n_per_group = {g: sum(1 for f in agent_families.values() if f == g) for g in active_groups}
        n_total_agents = sum(n_per_group.values())
        total_posts = sum(group_post_counts.values()) or 1
        muted_groups = set()
        for g, gc in group_post_counts.items():
            target = n_per_group.get(g, 0) / n_total_agents if n_total_agents else 0
            obs = gc / total_posts
            if obs > target + POST_SHARE_TOLERANCE:
                muted_groups.add(g)
        muted_this_turn = {aid for aid, fam in agent_families.items() if fam in muted_groups}
        for cmt_pid, cmt_uid, cmt_content, post_owner_uid in recent:
            post_commenters[post_owner_uid].append((cmt_uid, cmt_content[:80]))

        # Chat log path for this run (one file per run, JSONL)
        chat_log_path = db_path.replace(".db", "_chats.jsonl")

        for agent_id, agent in activated:
            agent.memory.clear()
            # (Comment-history reminder is now subsumed by build_recap() inside
            # GoalAgent.perform_action_by_llm — no separate injection needed.)
            # Per-turn instrumentation for GoalAgent
            agent._current_step = step
            agent._chat_log_path = chat_log_path
            agent._was_muted = (agent_id in muted_this_turn)
            # Dynamic post-mute: swap system_message + strip create_post from tools.
            if agent._was_muted:
                agent._system_message = agent._sys_msg_no_post
                if hasattr(agent, 'tool_dict') and 'create_post' in agent._internal_tools:
                    agent._create_post_backup = agent._internal_tools.pop('create_post')
            else:
                agent._system_message = agent._sys_msg_normal
                if getattr(agent, '_create_post_backup', None) is not None \
                   and 'create_post' not in agent._internal_tools:
                    agent._internal_tools['create_post'] = agent._create_post_backup
                    agent._create_post_backup = None
            seen = set()
            agent.pending_interactions = []
            for uid, excerpt in reversed(post_commenters.get(agent_id, [])[-12:]):
                if uid not in seen:
                    agent.pending_interactions.append(f"Agent {uid}: \"{excerpt}...\"")
                    seen.add(uid);
                    if len(agent.pending_interactions) >= 3: break

        step_actions = {agent: LLMAction() for _, agent in activated}
        t0 = datetime.now()
        await env.step(step_actions)
        elapsed = (datetime.now() - t0).total_seconds()
        # Restore stripped tools for any muted agents so future un-muted turns work
        for agent_id, agent in activated:
            if getattr(agent, '_create_post_backup', None) is not None \
               and 'create_post' not in agent._internal_tools:
                agent._internal_tools['create_post'] = agent._create_post_backup
                agent._create_post_backup = None

        # Weak auto-upvote: +1 per post that received any comment this step
        # (flat, not per-comment). Signals engagement without runaway amplification.
        try:
            env.platform.pl_utils._execute_db_command(
                "SELECT DISTINCT post_id FROM comment ORDER BY comment_id DESC LIMIT ?",
                (n_active * 3,))
            for (pid,) in env.platform.db_cursor.fetchall():
                env.platform.pl_utils._execute_db_command(
                    "UPDATE post SET num_likes = num_likes + 1 WHERE post_id = ?", (pid,))
            env.platform.db.commit()
        except: pass

        # Capture comments + reasoning
        conn = sqlite3.connect(db_path)
        new_cmts = conn.execute(
            "SELECT user_id, content FROM comment ORDER BY comment_id DESC LIMIT ?",
            (n_active * 2,)).fetchall()
        conn.close()
        for uid, content in new_cmts:
            agent_comment_history[uid].append(content[:120])

        # STEP MARKERS. The platform's post/comment tables carry no step column, so a
        # step had to be reconstructed post hoc by aligning each agent's k-th successful
        # activation (logged in _chats.jsonl) with its k-th action ordered by time. That
        # recovers ~85% of rows exactly and silently drops the rest. Recording the id
        # high-water mark at each step boundary makes step EXACT and trivial to join:
        #   step(post) = min(step : post_id <= max_post_id)
        # One row per step, no schema change to the platform's own tables.
        try:
            _c = sqlite3.connect(db_path)
            _c.execute("CREATE TABLE IF NOT EXISTS step_marks ("
                       "step INTEGER PRIMARY KEY, max_post_id INTEGER, "
                       "max_comment_id INTEGER, wall_clock TEXT)")
            _mp = _c.execute("SELECT COALESCE(MAX(post_id), 0) FROM post").fetchone()[0]
            _mc = _c.execute("SELECT COALESCE(MAX(comment_id), 0) FROM comment").fetchone()[0]
            _c.execute("INSERT OR REPLACE INTO step_marks VALUES (?,?,?,?)",
                       (step, _mp, _mc, datetime.now().isoformat()))
            _c.commit(); _c.close()
        except Exception as _e:
            print(f"  [warn] step_marks write failed at step {step}: {_e!r}")

        trace_path = db_path.replace(".db", "_reasoning.jsonl")
        with open(trace_path, "a") as tf:
            for agent_id, agent in activated:
                r = getattr(agent, '_last_reasoning', '')
                if r:
                    tf.write(json.dumps({"step": step, "agent_id": agent_id,
                                         "family": agent_families.get(agent_id,'?'),
                                         "reasoning": r[:500]}) + "\n")

        if step % 20 == 0 or step == 1 or step == join_step:
            s = analyze(db_path, args.agents)
            suffix = f"  [+late]" if step >= join_step and "late" in args.mode else ""
            print(f"  step={step:4d}/{args.steps}  posts={s['n_posts']}  "
                  f"cmts={s['n_comments']}  active={s['active']}/{len(all_agents_list)}  "
                  f"Gini={s['gini']:.3f}  recip={s['recip']}  ({elapsed:.1f}s){suffix}")
            _save_checkpoint(step, agent_comment_history, post_commenters)

    await env.close()

    # Remove checkpoint sidecar — run completed normally
    if os.path.exists(_ckpt_path):
        os.unlink(_ckpt_path)

    # Final reports
    s = analyze(db_path, args.agents)
    conn = sqlite3.connect(db_path)
    users = {uid:n for uid,n in conn.execute("SELECT user_id, user_name FROM user").fetchall()}
    conn.close()

    bodies = [r[0].strip()[:120] for r in sqlite3.connect(db_path).execute("SELECT content FROM comment").fetchall()]
    ctr = Counter(bodies)
    nd = sum(v-1 for v in ctr.values() if v>1)
    print(f"\n{'='*60}")
    print(f"FINAL  mode={args.mode}  steps={args.steps}")
    print(f"  cmts={s['n_comments']}  near-dupes={nd/len(bodies)*100:.1f}%  "
          f"Gini={s['gini']:.3f}  recip={s['recip']}")

    if args.mode in ("hetero","hetero_late","hetero3","hetero4"):
        homophily_report(db_path, agent_families)
    if "late" in args.mode:
        late_joiner_report(db_path, late_agent_ids, join_step, users)


if __name__ == "__main__":
    import signal
    # Clean exit on SIGTERM (SLURM preemption signal) so SQLite is not mid-write.
    # The DB is already committed step-by-step by OASIS; SIGTERM just means we
    # exit gracefully after the current step commit rather than being SIGKILLed.
    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
    asyncio.run(main())