divsim reproducibility bundle: simulator, sweeps, analyses (step_marks fix)

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+oasis/seed_db/hf-zero-50.sqlite filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+# Internal coordination notes — contain identifying information, never ship in an
+# anonymous release.
+_orchestration/
+__pycache__/
+*.pyc

LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 Dani Roytburg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The `oasis/` subdirectory contains code adapted from the OASIS simulator
+(https://github.com/camel-ai/oasis), which is licensed under the Apache
+License 2.0. See oasis/NOTICE for details.

README.md

@@ -0,0 +1,244 @@
+# divsim: Reproducibility Bundle
+
+**Paper:** *Disentangling Models from Personas in LLM Social Simulations*
+Dani Roytburg & Daphne Ippolito, Carnegie Mellon University.
+
+This bundle reproduces the experiments in the paper: the 5-model dyadic and triadic
+sweeps, the four-way (tetradic) sweep, and the lexical/content analyses. Engagement is
+analyzed as **comments per post** (CPP = in-degree / posts), which removes the
+posting-volume confound. The simulations run on top of OASIS (Open Agent Social
+Interaction Simulations), adapted with heterogeneous model support.
+
+---
+
+## Hardware assumptions
+
+| Component | Spec |
+|-----------|------|
+| GPUs | 8 × NVIDIA L40S 48 GB |
+| System RAM | ≥ 128 GB |
+| CPU cores | ≥ 32 |
+| Storage | ≥ 200 GB free (model weights + DBs) |
+
+All five models run concurrently on a single 8-GPU node. Dyadic runs need any
+two models active; triadic runs need any three. The sbatch templates in
+`launch/` target this configuration.
+
+---
+
+## Models
+
+| Short name | HuggingFace ID | GPU assignment | Notes |
+|-----------|----------------|----------------|-------|
+| Qwen | `Qwen/Qwen3-32B` | GPUs 0-1 (TP=2) | thinking disabled via chat-template |
+| gpt-oss | `openai/gpt-oss-20b` | GPU 2 (TP=1, mxfp4) | reasoning parser enabled |
+| Mag | `mistralai/Magistral-Small-2509` | GPUs 3-4 (TP=2) | mistral tokenizer/loader mode |
+| GLM-4 | `zai-org/GLM-4-32B-0414` | GPUs 5-6 (TP=2) | hermes tool parser |
+| Gemma | `google/gemma-4-31B-it` | GPUs 3-4 (TP=2) | custom jinja template required |
+
+Note: Gemma shares GPUs 3-4 with Magistral. They cannot run simultaneously on
+a single 8-GPU node. For triadic runs involving both, use two separate nodes or
+run the Gemma-containing triplets in a separate job.
+
+---
+
+## Quick start
+
+### 1. Environment setup
+
+```bash
+git clone https://github.com/camel-ai/oasis.git  # or use bundled oasis/
+cd divsim_publish
+python -m venv .venv && source .venv/bin/activate
+pip install -r env/requirements.txt
+```
+
+Set these environment variables before running:
+
+```bash
+export HF_HUB_CACHE=/path/to/hf_cache/hub          # HuggingFace model cache
+export SAFEMASS_VENV=$(pwd)/.venv                   # or path to your venv
+export RUNS_DIR=/path/to/output/runs                # where DBs will be written
+export SEED_DB=$(pwd)/oasis/seed_db/hf-zero-50.sqlite
+export LOGS_DIR=/path/to/logs
+```
+
+### 2. Download models
+
+```bash
+python -c "
+from huggingface_hub import snapshot_download
+import os
+os.environ['HF_HUB_CACHE'] = os.environ['HF_HUB_CACHE']
+for m in [
+    'Qwen/Qwen3-32B',
+    'openai/gpt-oss-20b',
+    'mistralai/Magistral-Small-2509',
+    'zai-org/GLM-4-32B-0414',
+    'google/gemma-4-31B-it',
+]:
+    print(f'Downloading {m}...')
+    snapshot_download(m)
+    print(f'  done.')
+"
+```
+
+### 3. Start vLLM servers
+
+Launch each model server in a separate terminal (or as background processes):
+
+```bash
+# For a 4-model (non-Gemma) run:
+bash launch/vllm_qwen.sh &
+bash launch/vllm_gpt_oss.sh &
+bash launch/vllm_magistral.sh &
+bash launch/vllm_glm4.sh &
+
+# For Gemma runs (requires GPUs 3-4 to be free — stop Magistral first):
+bash launch/vllm_gemma.sh &
+```
+
+Wait for all target servers to respond at their health endpoints before
+proceeding. The sweep scripts perform a pre-flight health check.
+
+### 4. Run the dyadic sweep
+
+```bash
+source .venv/bin/activate
+python sweep/sweep_dyadic.py --mode 2model --max-parallel 2
+```
+
+Optional: `--dry-run` to print all configs without launching.
+
+### 5. Run the triadic sweep
+
+```bash
+python sweep/sweep_triadic.py --max-parallel 2
+```
+
+### 5b. Run the four-way (tetradic) sweep
+
+Serves all four of {gpt-oss, Qwen, Magistral, GLM-4} concurrently and runs the
+2-seed x 12-rotation four-way sweep (`run_v9 --mode hetero4`, 40 agents):
+
+```bash
+SAFEMASS_VENV=... OASIS_VENV=... HF_HUB_CACHE=... RUNS_DIR=... bash launch/run_tetradic.sh
+```
+
+Resume-safe: completed DBs are skipped, partial ones resume. Outputs land in `$RUNS_DIR/tetradic/`.
+
+### 6. Analyses and figures
+
+Scripts read run DBs from `./runs` (symlink or point at `$RUNS_DIR`), the text corpus
+from `./data/texts.jsonl`, and write outputs to `./out/`. Build the corpus once:
+
+```bash
+python analyses/extract_texts.py                 # -> data/texts.jsonl (posts+comments by model,persona)
+```
+
+Engagement / network structure (Findings 1-2):
+```bash
+python analyses/plot_fig_variance_overview.py    # Fig: CPP variance (model vs persona) + per-model H by mixture size
+python analyses/variance_cpp.py                  # CPP variance decomposition + leave-one-model-out
+python analyses/swap_cpp.py                       # gpt-oss->Magistral matched-swap CPP effect
+python analyses/engagement_ceiling.py            # how well text predicts per-post engagement (ceiling)
+python analyses/cv_and_length.py                 # held-out CV R^2 + length-controlled attractor (Appendix D)
+python analyses/absolute_variance.py             # variance components, all regimes
+python analyses/temporal_dynamics.py             # temporal H decay by quartile
+python analyses/tetradic_recompute_H.py          # four-way per-model H over the 24 runs
+python analyses/tetradic_results.py              # four-way H matrix + heatmap figure
+python analyses/plot_matrices.py                 # H-matrix heatmaps (dyadic/triadic)
+```
+
+Content (Finding 3):
+```bash
+python analyses/lexical_table.py                 # model/persona classifier from TF-IDF (Table 1)
+python analyses/persona_faithfulness.py          # persona recoverability from text (faithfulness)
+python analyses/distinctive_words.py             # characteristic phrases per model (log-odds)
+python analyses/svd_axes.py                      # SVD style axes + top terms
+python analyses/content_engagement.py            # content -> CPP decomposition (length/style/model/persona)
+python analyses/style_geometry.py                # model style directions, stability, engagement-direction cosines
+python analyses/cluster_model_persona.py         # does style cluster by model vs persona (permutation-adjusted)
+python analyses/length_regimes.py                # length/volume confound checks by regime
+```
+
+### 7. Smoke test (no GPUs required for the assertion; short GPU run for the full test)
+
+```bash
+# Assert-only (uses an existing DB):
+python smoke_test/assert_h_matrix.py --db <path/to/sweep_*.db>
+
+# Full end-to-end smoke (requires 2 live vLLM servers, ~5 min on 2 GPUs):
+bash smoke_test/run_smoke.sh
+```
+
+---
+
+## Expected runtime
+
+| Experiment | Steps | Agents | Time estimate (8× L40S) |
+|-----------|-------|--------|------------------------|
+| Single dyadic run | 100 | 20 | ~25–45 min |
+| Full dyadic sweep (10 pairs × 2 orderings × 5 seeds) | 100 | 20 | ~50–150 GPU-hours |
+| Single triadic run | 100 | 30 | ~35–60 min |
+| Full triadic sweep (10 triplets × 3 orderings × 3 seeds) | 100 | 30 | ~35–90 GPU-hours |
+| Single four-way run | 100 | 40 | ~60–90 min |
+| Full four-way sweep (2 seeds × 12 rotations) | 100 | 40 | ~50–70 GPU-hours |
+
+---
+
+## Data
+
+Reference data (SQLite databases, one per run) are listed in `data/MANIFEST.md`
+with SHA-256 checksums and sizes. The canonical data lives at:
+
+```
+/data/user_data/droytbur/oasis/runs/sweep_*.db
+```
+
+The manifest records all valid runs used in the paper (dyadic, triadic, and four-way),
+including the four-way DBs under `$RUNS_DIR/tetradic/`. The content analyses additionally
+use a text corpus (`data/texts.jsonl`) regenerated by `analyses/extract_texts.py`.
+
+---
+
+## Repository layout
+
+```
+divsim_publish/
+├── README.md                    # this file
+├── LICENSE                      # MIT
+├── env/
+│   ├── requirements.txt         # pinned Python dependencies
+│   └── vllm_version.md          # vLLM 0.19.0 per-model launch notes
+├── oasis/
+│   ├── run_v9.py                # simulation runner
+│   ├── seed_db/hf-zero-50.sqlite
+│   └── tool_chat_template_gemma4.jinja
+├── launch/
+│   ├── vllm_qwen.sh / vllm_gpt_oss.sh / vllm_magistral.sh / vllm_glm4.sh / vllm_gemma.sh
+│   └── run_tetradic.sh          # four-way sweep driver (serves 4 models, 2 seeds x 12 rotations)
+├── sweep/
+│   ├── sweep_dyadic.py          # combinatorial 2-model sweep (5-model subset)
+│   └── sweep_triadic.py         # preemption-safe 3-model sweep
+├── analyses/
+│   ├── variance_cpp.py              # CPP variance decomposition + leave-one-model-out
+│   ├── absolute_variance.py         # variance components across regimes
+│   ├── plot_fig_variance_overview.py# Fig: CPP variance + per-model H by mixture size
+│   ├── temporal_dynamics.py         # temporal H decay analysis
+│   ├── tetradic_recompute_H.py / tetradic_results.py  # four-way H + heatmap
+│   ├── plot_matrices.py / plot_fig1_network.py / housestyle.py  # figures
+│   ├── extract_texts.py             # build data/texts.jsonl corpus
+│   ├── lexical_table.py             # model/persona classifier (Table 1)
+│   ├── svd_axes.py                  # SVD style axes + top terms
+│   ├── content_engagement.py        # content -> CPP decomposition
+│   ├── style_geometry.py            # style directions + engagement-direction cosines
+│   └── cluster_model_persona.py / length_regimes.py  # supporting checks
+├── data/
+│   └── MANIFEST.md              # DB paths, SHA-256, size, (pair/triplet, seed) labels
+├── smoke_test/
+│   ├── run_smoke.sh             # short dyad smoke run (20 steps, 2 agents/family)
+│   └── assert_h_matrix.py       # assert H matrix computable + basic sanity checks
+└── docs/
+    └── EXPERIMENT_PROTOCOL.md   # canonical reproducibility narrative
+```

analyses/absolute_variance.py

@@ -0,0 +1,80 @@
+"""Exact absolute-variance decomposition of per-agent in-degree, by regime
+(two-way / three-way from the 5-model pool; four-way from the tetradic pool).
+Absolute component = single-block in-sample R^2 x total in-degree variance.
+Keeps everything consistent with tab:ols_decomp and Fig variance_overview(a).
+"""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+RUNS=Path("runs")
+TET=RUNS/"tetratic"
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+
+def rows_from(dbiter, tet=False):
+    rows=[]
+    for db in dbiter:
+        if not tet and any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+        if tet and (TET/f"{db.stem}_checkpoint.json").exists():continue
+        mp=str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists():continue
+        try:amm=json.load(open(mp)).get("agent_model_map",{})
+        except:continue
+        if not amm:continue
+        # OFF-BY-ONE FIX: DBs are 0-indexed (user_id and agent_model_map keys both start at MIN);
+        # original "+1" dropped agent 0 and mislabeled the first agent of each model-block.
+        # fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+        umin=min(int(k) for k in amm)
+        fam={int(k)+umin:SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()):continue
+        try:
+            c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());c.close()
+        except:continue
+        if len(coms)<(100 if tet else 200):continue
+        owner={p:u for p,u in posts};ind=defaultdict(int)
+        for p,cu in coms:
+            o=owner.get(p)
+            if o in fam and o!=cu:ind[o]+=1
+        net=tuple(sorted(set(fam.values())))
+        mode="tet" if tet else ("tri" if len(net)==3 else "dyad" if len(net)==2 else "other")
+        for u,f in fam.items():
+            rows.append({"run":db.stem,"model":f,"persona":users.get(u,f"u{u}"),"indeg":ind.get(u,0),"mode":mode,"net":net})
+    return rows
+
+def dummies(keys):
+    lv=sorted(set(keys),key=lambda x:str(x));idx={l:i for i,l in enumerate(lv)}
+    D=np.zeros((len(keys),len(lv)))
+    for r,k in enumerate(keys):D[r,idx[k]]=1
+    return D[:,1:]
+def r2(y,*blocks):
+    blocks=[b for b in blocks if b is not None and b.shape[1]>0]
+    X=np.column_stack([np.ones(len(y))]+blocks) if blocks else np.ones((len(y),1))
+    b,*_=np.linalg.lstsq(X,y,rcond=None);pred=X@b
+    return 1-((y-pred)**2).sum()/((y-y.mean())**2).sum()
+def partner(r): return frozenset(m for m in r["net"] if m!=r["model"])
+
+allrows=rows_from(sorted(RUNS.glob("sweep_*.db")))+rows_from(sorted(TET.glob("tetra_s*_r*.db")),tet=True)
+out=["# Absolute variance decomposition (per-agent in-degree)\n",
+     "| component | Two-way | Three-way | Four-way |","|---|---:|---:|---:|"]
+comp={}
+for mode in ["dyad","tri","tet"]:
+    rs=[r for r in allrows if r["mode"]==mode]
+    y=np.array([r["indeg"] for r in rs],float);tot=y.var()
+    P=dummies([r["persona"] for r in rs]);Mo=dummies([r["model"] for r in rs])
+    Sel=np.column_stack([Mo,dummies([partner(r) for r in rs])]) if dummies([partner(r) for r in rs]).shape[1]>0 else Mo
+    oss=np.array([[1.0 if r["model"]=="gpt-oss" else 0.0] for r in rs]);Run=dummies([r["run"] for r in rs])
+    comp[mode]={"n":len(rs),"total":tot,"persona":r2(y,P)*tot,"own":r2(y,Mo)*tot,
+                "selection":r2(y,Sel)*tot,"oss":r2(y,oss)*tot,"run":r2(y,Run)*tot,
+                "persona_r2":r2(y,P),"sel_r2":r2(y,Sel),"own_r2":r2(y,Mo),"oss_r2":r2(y,oss),"run_r2":r2(y,Run)}
+def row(label,key):
+    return f"| {label} | "+" | ".join(f"{comp[m][key]:.0f}" for m in ["dyad","tri","tet"])+" |"
+out+=[row("Total variance","total"),"|---|---|---|---|",
+      row("Persona","persona"),row("Model selection (own+partner)","selection"),
+      row("\\quad own model","own"),row("\\quad gpt-oss indicator","oss"),row("Run (baseline)","run")]
+out+=["\n## underlying R^2 (for tab:ols_decomp consistency)\n",
+      "| block | Two-way | Three-way | Four-way |","|---|---:|---:|---:|"]
+for lab,key in [("persona","persona_r2"),("model selection","sel_r2"),("own model","own_r2"),("gpt-oss ind","oss_r2"),("run","run_r2")]:
+    out.append(f"| {lab} | "+" | ".join(f"{comp[m][key]:.3f}" for m in ['dyad','tri','tet'])+" |")
+out.append(f"\nn agents: dyad {comp['dyad']['n']}, tri {comp['tri']['n']}, tet {comp['tet']['n']}")
+print("\n".join(out))
+Path("out/absolute_variance.md").write_text("\n".join(out)+"\n")

analyses/cluster_model_persona.py

@@ -0,0 +1,63 @@
+"""Does agent style cluster more by model or by persona? Fair test via permutation-
+adjusted variance-explained (controls for differing group counts: 5 models vs 43 personas).
+Style space = SVD(30), axis 1 (language) dropped."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD
+RUNS=Path("runs")
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+ag=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():continue
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:continue
+    if not amm:continue
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):continue
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT user_id,content FROM post").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());coms=c.execute("SELECT 1 FROM comment").fetchall();c.close()
+    except:continue
+    if len(coms)<200:continue
+    txt=defaultdict(list)
+    for u,cont in posts:
+        if u in fam and cont:txt[u].append(cont)
+    for u,tl in txt.items():
+        if tl:ag.append({"model":fam[u],"persona":users.get(u,f"u{u}"),"text":" ".join(tl)})
+n=len(ag);print(n,"agents")
+vc=TfidfVectorizer(ngram_range=(1,2),analyzer="word",min_df=10,max_features=20000,sublinear_tf=True,norm="l2",stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+X=vc.fit_transform([a["text"]for a in ag])
+S=TruncatedSVD(30,random_state=0).fit_transform(X)
+Z=((S-S.mean(0))/(S.std(0)+1e-9))[:,1:]
+model=np.array([a["model"]for a in ag]);persona=np.array([a["persona"]for a in ag])
+tot=((Z-Z.mean(0))**2).sum()
+def eta2(lab):
+    w=0.0
+    for g in set(lab):
+        Zi=Z[lab==g];w+=((Zi-Zi.mean(0))**2).sum()
+    return 1-w/tot
+rng=np.random.default_rng(0)
+def null(lab,B=200):
+    lab=lab.copy();vals=[]
+    for _ in range(B):
+        rng.shuffle(lab);vals.append(eta2(lab))
+    return np.mean(vals)
+em,ep=eta2(model),eta2(persona)
+nm,np_=null(model),null(persona)
+print(f"{'group':8s} {'#groups':>7} {'eta2':>7} {'null':>7} {'excess':>7}")
+print(f"{'model':8s} {len(set(model)):7d} {em:7.3f} {nm:7.3f} {em-nm:7.3f}")
+print(f"{'persona':8s} {len(set(persona)):7d} {ep:7.3f} {np_:7.3f} {ep-np_:7.3f}")
+print(f"\nratio of excess (model/persona): {(em-nm)/(ep-np_):.2f}")
+# also: within-group mean pairwise cosine (tightness), cheap proxy, fair-ish
+def tight(lab):
+    cs=[]
+    for g in set(lab):
+        Zi=Z[lab==g]
+        if len(Zi)<3:continue
+        c=Zi.mean(0);cs.append(np.mean([float(zi@c/((np.linalg.norm(zi)*np.linalg.norm(c))+1e-9)) for zi in Zi]))
+    return np.mean(cs)
+print(f"\nmean within-group cosine-to-centroid: model={tight(model):.3f}  persona={tight(persona):.3f}  (higher=tighter)")

analyses/content_engagement.py

@@ -0,0 +1,63 @@
+"""Content->engagement, FINAL: blocks = length, style (SVD axes 2-30, axis1=language dropped),
+model, persona. No format block. Within-run z-scored in-degree; CV R^2 + leave-one-block-out unique."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD
+from sklearn.model_selection import KFold
+RUNS=Path("runs")
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+ag=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():continue
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:continue
+    if not amm:continue
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):continue
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());c.close()
+    except:continue
+    if len(coms)<200:continue
+    owner={p:u for p,u,_ in posts};ind=defaultdict(int)
+    for p,cu in coms:
+        o=owner.get(p)
+        if o in fam and o!=cu:ind[o]+=1
+    txt=defaultdict(list)
+    for p,u,cont in posts:
+        if u in fam and cont:txt[u].append(cont)
+    for u,tl in txt.items():
+        if tl:ag.append({"run":db.stem,"model":fam[u],"persona":users.get(u,f"u{u}"),"indeg":ind.get(u,0),"nw":sum(len(t.split())for t in tl),"text":" ".join(tl)})
+n=len(ag)
+vc=TfidfVectorizer(ngram_range=(1,2),analyzer="word",min_df=10,max_features=20000,sublinear_tf=True,norm="l2",stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+X=vc.fit_transform([a["text"]for a in ag])
+S=TruncatedSVD(30,random_state=0).fit_transform(X)
+Sz=((S-S.mean(0))/(S.std(0)+1e-9))[:,1:]   # axes 2-30
+model=np.array([a["model"]for a in ag]);persona=np.array([a["persona"]for a in ag])
+logw=np.array([np.log1p(a["nw"])for a in ag]);L=((logw-logw.mean())/logw.std()).reshape(-1,1)
+M=np.array([[1.0 if a["model"]==m else 0 for m in sorted(set(model))[1:]]for a in ag])
+P=np.array([[1.0 if a["persona"]==p else 0 for p in sorted(set(persona))[1:]]for a in ag])
+y=np.zeros(n);bd=defaultdict(list)
+for i,a in enumerate(ag):bd[a["run"]].append(i)
+for r,idx in bd.items():
+    v=np.array([ag[i]["indeg"]for i in idx],float);z=(v-v.mean())/(v.std()+1e-9)
+    for k,i in enumerate(idx):y[i]=z[k]
+def cvr2(*B):
+    B=[b for b in B if b is not None and b.shape[1]>0]
+    if not B:return 0.0
+    Xx=np.hstack(B);kf=KFold(5,shuffle=True,random_state=0);sse=sst=0
+    for tr,te in kf.split(Xx):
+        A=np.column_stack([np.ones(len(tr)),Xx[tr]]);Bt=np.column_stack([np.ones(len(te)),Xx[te]])
+        b,*_=np.linalg.lstsq(A,y[tr],rcond=None);pp=Bt@b;sse+=((y[te]-pp)**2).sum();sst+=((y[te]-y[tr].mean())**2).sum()
+    return 1-sse/sst
+blk={"length":L,"style":Sz,"model":M,"persona":P}
+single={k:cvr2(v)for k,v in blk.items()};allr=cvr2(*blk.values())
+uniq={k:allr-cvr2(*[v for kk,v in blk.items() if kk!=k])for k in blk}
+print(f"{n} agents, style = SVD axes 2-30")
+print(f"{'block':8s} {'single':>7} {'unique':>7}")
+for k in ["length","style","model","persona"]:print(f"{k:8s} {single[k]:7.3f} {uniq[k]:7.3f}")
+print(f"{'all4':8s} {'':>7} {allr:7.3f}")

analyses/cv_and_length.py

@@ -0,0 +1,73 @@
+"""(A) Held-out 5-fold CV R^2 for persona-only / model-only / full (addresses the
+43-vs-5 parameter-count confound in in-sample R^2).  (B) Per-model engagement effect
+(within-run-z CPP) raw vs. after controlling for post length -> attractor/repeller survive."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import KFold
+from sklearn.metrics import r2_score
+RUNS=Path("runs");TET=RUNS/"tetratic"
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+def load(globpat,tet=False):
+    rows=[]
+    for db in sorted(globpat):
+        if not tet and any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+        if tet and (TET/f"{db.stem}_checkpoint.json").exists():continue
+        mp=str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists():continue
+        try:amm=json.load(open(mp)).get("agent_model_map",{})
+        except:continue
+        if not amm:continue
+        # OFF-BY-ONE FIX: DBs are 0-indexed (user_id and agent_model_map keys both start at MIN);
+        # original "+1" dropped agent 0 and mislabeled the first agent of each model-block.
+        # fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+        umin=min(int(k) for k in amm)
+        fam={int(k)+umin:SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()):continue
+        try:
+            c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall()
+            coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());c.close()
+        except:continue
+        if len(coms)<(100 if tet else 200):continue
+        owner={p:u for p,u,_ in posts};ind=defaultdict(int);npost=defaultdict(int);loglen=defaultdict(list)
+        for p,cu in coms:
+            o=owner.get(p)
+            if o in fam and o!=cu:ind[o]+=1
+        for p,u,cont in posts:
+            if u in fam:npost[u]+=1;loglen[u].append(np.log(max(1,len(cont or ""))))
+        reg={2:"dyad",3:"triad",4:"tetrad"}[len(set(fam.values()))]
+        for u in fam:
+            if npost[u]>=2:
+                rows.append({"run":db.stem,"reg":reg,"model":fam[u],"persona":users.get(u,f"u{u}"),
+                             "cpp":ind[u]/npost[u],"loglen":np.mean(loglen[u])})
+    return rows
+rows=load(RUNS.glob("sweep_*.db"))+load(TET.glob("tetra_s*_r*.db"),tet=True)
+df=pd.DataFrame(rows)
+# within-run z CPP and z loglen
+df["z"]=df.groupby("run")["cpp"].transform(lambda v:(v-v.mean())/(v.std() or 1))
+df["zlen"]=df.groupby("run")["loglen"].transform(lambda v:(v-v.mean())/(v.std() or 1))
+def cvr2(sub,cols):
+    y=sub["z"].values;X=pd.get_dummies(sub[cols],columns=cols,drop_first=False).astype(float).values
+    kf=KFold(5,shuffle=True,random_state=0);sc=[]
+    for tr,te in kf.split(X):
+        m=LinearRegression().fit(X[tr],y[tr]);sc.append(r2_score(y[te],m.predict(X[te])))
+    return np.mean(sc)
+print("=== (A) HELD-OUT 5-fold CV R^2 (within-run z CPP) ===")
+print(f"{'regime':10s}{'persona':>10}{'model':>9}{'full(p+m)':>11}  (#personas / #models)")
+for reg in ["dyad","triad","tetrad"]:
+    s=df[df.reg==reg]
+    pe=cvr2(s,["persona"]);mo=cvr2(s,["model"]);fu=cvr2(s,["persona","model"])
+    print(f"{reg:10s}{pe:>10.3f}{mo:>9.3f}{fu:>11.3f}  ({s.persona.nunique()} / {s.model.nunique()}), n={len(s)}")
+print("\n=== (B) per-model engagement (z CPP) RAW vs LENGTH-CONTROLLED ===")
+for reg in ["dyad","triad","tetrad"]:
+    s=df[df.reg==reg].copy()
+    # length-adjusted z: residual of z on zlen
+    b=np.polyfit(s["zlen"],s["z"],1);s["zadj"]=s["z"]-(b[0]*s["zlen"]+b[1])
+    print(f"-- {reg} (length slope b={b[0]:+.2f}) --")
+    for m in ["gpt-oss","Mag","GLM-4","Qwen","Gemma"]:
+        sm=s[s.model==m]
+        if len(sm)<5:continue
+        print(f"   {m:8s} raw z={sm['z'].mean():+.2f}   length-adj z={sm['zadj'].mean():+.2f}   (n={len(sm)}, mean loglen z={sm['zlen'].mean():+.2f})")

analyses/distinctive_words.py

@@ -0,0 +1,33 @@
+"""Distinctive per-model vocabulary via several methods, so we can pick the best surface.
+(1) log-odds-ratio w/ informative Dirichlet prior (Monroe 2008), word 1-2grams, stopwords removed
+(2) same, bigrams only (phrases)
+(3) classifier coefficient top terms"""
+import json
+from collections import Counter
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+rows=[json.loads(l) for l in open("data/texts.jsonl")]
+rows=[r for r in rows if len(r.get("text","") or "")>=1 and r.get("model") in {"gpt-oss","Qwen","GLM-4","Mag","Gemma"}]
+MODELS=["gpt-oss","Qwen","GLM-4","Mag","Gemma"]
+NAME={"gpt-oss":"gpt-oss","Qwen":"Qwen","GLM-4":"GLM-4","Mag":"Magistral","Gemma":"Gemma"}
+texts=[r["text"] for r in rows];model=np.array([r["model"] for r in rows])
+def logodds(ngram):
+    cv=CountVectorizer(ngram_range=ngram,min_df=30,max_features=50000,stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+    X=cv.fit_transform(texts);vocab=np.array(cv.get_feature_names_out())
+    tot=np.asarray(X.sum(0)).ravel();a0=tot.sum();alpha=tot.astype(float);N=tot.sum()
+    out={}
+    for m in MODELS:
+        yi=np.asarray(X[model==m].sum(0)).ravel().astype(float)
+        yr=tot-yi
+        ni=yi.sum();nr=yr.sum()
+        d=np.log((yi+alpha)/(ni+a0-yi-alpha))-np.log((yr+alpha)/(nr+a0-yr-alpha))
+        var=1.0/(yi+alpha)+1.0/(yr+alpha)
+        z=d/np.sqrt(var)
+        out[m]=vocab[np.argsort(z)[::-1][:12]]
+    return out
+lo1=logodds((1,2));lo2=logodds((2,2))
+print("=== (1) log-odds (word 1-2grams) ===")
+for m in MODELS:print(f"  {NAME[m]:10s}: {', '.join(lo1[m])}")
+print("\n=== (2) log-odds (bigrams / phrases) ===")
+for m in MODELS:print(f"  {NAME[m]:10s}: {', '.join(lo2[m])}")

analyses/engagement_ceiling.py

@@ -0,0 +1,59 @@
+"""Is the low text->engagement R^2 a ceiling or an artifact of SVD/linearization?
+Predict per-agent within-run-z CPP from: full TF-IDF (Ridge), SVD-30/100/500 (Ridge),
+and a nonlinear model (HistGBT on SVD-100). 5-model pool, posts-only agent text."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD
+from sklearn.linear_model import Ridge
+from sklearn.ensemble import HistGradientBoostingRegressor
+from sklearn.model_selection import KFold
+RUNS=Path("runs")
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+ag=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():continue
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:continue
+    if not amm:continue
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):continue
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();c.close()
+    except:continue
+    if len(coms)<200:continue
+    owner={p:u for p,u,_ in posts};ind=defaultdict(int);npost=defaultdict(int);txt=defaultdict(list)
+    for p,cu in coms:
+        o=owner.get(p)
+        if o in fam and o!=cu:ind[o]+=1
+    for p,u,cont in posts:
+        if u in fam and cont:npost[u]+=1;txt[u].append(cont)
+    for u in fam:
+        if npost[u]>=2:ag.append({"run":db.stem,"cpp":ind[u]/npost[u],"text":" ".join(txt[u])})
+n=len(ag);print(n,"agents")
+runs=np.array([a["run"]for a in ag])
+y=np.zeros(n);bd=defaultdict(list)
+for i,a in enumerate(ag):bd[a["run"]].append(i)
+for r,idx in bd.items():
+    v=np.array([ag[i]["cpp"]for i in idx],float);m=v.mean();sd=v.std() or 1
+    for j,i in enumerate(idx):y[i]=(v[j]-m)/sd
+vc=TfidfVectorizer(ngram_range=(1,2),analyzer="word",min_df=10,max_features=40000,sublinear_tf=True,norm="l2",stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+X=vc.fit_transform([a["text"]for a in ag]);print("TF-IDF dims:",X.shape[1])
+def cvr2(Xf,est_fn):
+    kf=KFold(5,shuffle=True,random_state=0);sse=sst=0
+    for tr,te in kf.split(Xf if not hasattr(Xf,'tocsr') else np.arange(n)):
+        e=est_fn();e.fit(Xf[tr],y[tr]);pp=e.predict(Xf[te])
+        sse+=((y[te]-pp)**2).sum();sst+=((y[te]-y[tr].mean())**2).sum()
+    return 1-sse/sst
+# full TF-IDF Ridge (a few alphas)
+print(f"full TF-IDF Ridge(alpha=5):  R2={cvr2(X,lambda:Ridge(alpha=5.0)):.3f}",flush=True)
+for K in [30,100]:
+    S=TruncatedSVD(K,random_state=0).fit_transform(X)
+    print(f"SVD-{K} Ridge:  R2={cvr2(S,lambda:Ridge(alpha=1.0)):.3f}",flush=True)
+# nonlinear on SVD-100
+S100=TruncatedSVD(100,random_state=0).fit_transform(X)
+print(f"SVD-100 HistGBT (nonlinear):  R2={cvr2(S100,lambda:HistGradientBoostingRegressor(max_iter=300,learning_rate=0.05)):.3f}")

analyses/extract_texts.py

@@ -0,0 +1,104 @@
+"""
+Extract all post + comment text from every valid sweep DB and tag each row
+with (model, persona, run, mode, kind). Writes a single JSONL.
+
+Validity criterion matches persona_variance: nc>=200 & nu>=26 (for tri) or
+nu>=18 (dyad), and metadata + good model map.
+"""
+import json
+import sqlite3
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+RUNS = Path("runs")
+OUT = Path("data/texts.jsonl")
+
+SHORT = {
+    "Qwen/Qwen3-32B": "Qwen",
+    "openai/gpt-oss-20b": "gpt-oss",
+    "mistralai/Magistral-Small-2509": "Mag",
+    "zai-org/GLM-4-32B-0414": "GLM-4",
+    "google/gemma-4-31B-it": "Gemma",
+}
+
+
+def load_valid_runs():
+    rows = []
+    n_db = n_valid = 0
+    for db in sorted(RUNS.glob("sweep_*.db")):
+        name = db.name
+        if any(x in name for x in ["archive", "snapshot", "olm", "hermes", "qwq", "glm47", "pilot_"]):
+            continue
+        meta_p = str(db).replace(".db", ".metadata.json")
+        if not Path(meta_p).exists():
+            continue
+        n_db += 1
+        try:
+            meta = json.load(open(meta_p))
+        except Exception:
+            continue
+        amm = meta.get("agent_model_map", {})
+        if not amm:
+            continue
+        uid_to_model = {int(k) + 1: SHORT.get(v["model"]) for k, v in amm.items()}
+        if any(v is None for v in uid_to_model.values()):
+            continue
+        mode = "tri" if "tri_" in name else "dyad"
+        threshold = 26 if mode == "tri" else 18
+        try:
+            c = sqlite3.connect(db)
+            nu = c.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
+            nc = c.execute("SELECT COUNT(*) FROM comment").fetchone()[0]
+            if nu < threshold or nc < 200:
+                c.close()
+                continue
+            users = {uid: uname for uid, uname in c.execute("SELECT user_id, user_name FROM user").fetchall()}
+            posts = c.execute("SELECT post_id, user_id, content FROM post").fetchall()
+            comments = c.execute("SELECT comment_id, user_id, content FROM comment").fetchall()
+            c.close()
+        except Exception as e:
+            print(f"err {name}: {e}", file=sys.stderr)
+            continue
+        n_valid += 1
+        run_id = db.stem
+        for pid, uid, content in posts:
+            if not content:
+                continue
+            rows.append({
+                "run": run_id, "mode": mode, "kind": "post",
+                "model": uid_to_model.get(uid), "persona": users.get(uid, f"u{uid}"),
+                "text": content,
+            })
+        for cid, uid, content in comments:
+            if not content:
+                continue
+            rows.append({
+                "run": run_id, "mode": mode, "kind": "comment",
+                "model": uid_to_model.get(uid), "persona": users.get(uid, f"u{uid}"),
+                "text": content,
+            })
+    return rows, n_db, n_valid
+
+
+def main():
+    rows, n_db, n_valid = load_valid_runs()
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    with open(OUT, "w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    by_model = defaultdict(lambda: [0, 0])
+    by_kind = defaultdict(int)
+    for r in rows:
+        by_model[r["model"]][0 if r["kind"] == "post" else 1] += 1
+        by_kind[r["kind"]] += 1
+    print(f"DBs scanned: {n_db}  valid: {n_valid}  rows: {len(rows):,}")
+    print(f"by kind: {dict(by_kind)}")
+    print("by model (posts, comments):")
+    for m, (p, cm) in sorted(by_model.items()):
+        print(f"  {m:10s} posts={p:6d}  comments={cm:6d}")
+    print(f"wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

analyses/housestyle.py

@@ -0,0 +1,30 @@
+"""Shared house style: Palatino (TeX Gyre Pagella) for titles/headers,
+Ubuntu Mono for body text and numbers."""
+from matplotlib import font_manager as fm
+
+_PAGELLA = "/usr/share/texlive/texmf-dist/fonts/opentype/public/tex-gyre"
+for _f in ["texgyrepagella-regular.otf", "texgyrepagella-bold.otf", "texgyrepagella-italic.otf"]:
+    try: fm.fontManager.addfont(f"{_PAGELLA}/{_f}")
+    except Exception: pass
+from pathlib import Path
+for ttf in (Path.home() / "fonts").rglob("*.ttf"):
+    try: fm.fontManager.addfont(str(ttf))
+    except Exception: pass
+
+# family names once registered
+SERIF = "TeX Gyre Pagella"   # Palatino-style, for titles/headers
+MONO  = "Ubuntu Mono"        # for body text + numbers
+
+def serif(size, bold=False):
+    return fm.FontProperties(family=SERIF, size=size, weight="bold" if bold else "normal")
+def mono(size, bold=False):
+    return fm.FontProperties(family=MONO, size=size, weight="bold" if bold else "normal")
+
+# per-model palette (consistent across figures)
+MODEL_COLOR = {
+    "gpt-oss": "#d62728",  # red (attractor)
+    "Qwen":    "#1f77b4",  # blue
+    "Mag":     "#9467bd",  # purple (repeller)
+    "GLM-4":   "#2ca02c",  # green
+    "Gemma":   "#ff7f0e",  # orange
+}

analyses/length_regimes.py

@@ -0,0 +1,65 @@
+"""(A) disentangle 'length': total-words (volume) vs mean post length, as engagement predictors.
+(B) per-regime (dyad/triad/tetrad) raw vs length-adjusted per-model attractiveness (within-run z in-degree)."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+RUNS=Path("runs");TET=RUNS/"tetratic"
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+def load(globpat,tet=False):
+    out=[]
+    for db in sorted(globpat):
+        if not tet and any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+        if tet and (TET/f"{db.stem}_checkpoint.json").exists():continue
+        mp=str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists():continue
+        try:amm=json.load(open(mp)).get("agent_model_map",{})
+        except:continue
+        if not amm:continue
+        fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()):continue
+        try:
+            c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();c.close()
+        except:continue
+        if len(coms)<(100 if tet else 200):continue
+        owner={p:u for p,u,_ in posts};ind=defaultdict(int)
+        for p,cu in coms:
+            o=owner.get(p)
+            if o in fam and o!=cu:ind[o]+=1
+        nw=defaultdict(int);npost=defaultdict(int)
+        for p,u,cont in posts:
+            if u in fam and cont:nw[u]+=len(cont.split());npost[u]+=1
+        F=sorted(set(fam.values()));reg={2:"dyad",3:"triad",4:"tetrad"}.get(len(F))
+        for u in fam:
+            if npost[u]>0:out.append({"run":db.stem,"model":fam[u],"indeg":ind.get(u,0),"meanlen":nw[u]/npost[u],"totw":nw[u],"reg":reg})
+    return out
+ag=load(RUNS.glob("sweep_*.db"))+load(TET.glob("tetra_s*_r*.db"),tet=True)
+ag=[a for a in ag if a["reg"]]
+def wz(x,run):
+    o=np.zeros(len(x));bd=defaultdict(list)
+    for i,r in enumerate(run):bd[r].append(i)
+    for r,idx in bd.items():
+        v=x[np.array(idx)];m=v.mean();sd=v.std() or 1
+        for j,i in enumerate(idx):o[i]=(v[j]-m)/sd
+    return o
+run=np.array([a["run"]for a in ag]);model=np.array([a["model"]for a in ag]);reg=np.array([a["reg"]for a in ag])
+y=wz(np.array([a["indeg"]for a in ag],float),run)
+lmean=wz(np.log1p(np.array([a["meanlen"]for a in ag])),run)
+ltot=wz(np.log1p(np.array([a["totw"]for a in ag])),run)
+# (A) which 'length' predicts engagement
+print("(A) within-run corr with engagement:  mean-post-length r=%.3f   total-words(volume) r=%.3f"%(np.corrcoef(lmean,y)[0,1],np.corrcoef(ltot,y)[0,1]))
+# (B) per-regime raw vs length(mean)-adjusted attractiveness
+print("\n(B) per-model attractiveness (within-run z in-degree): raw vs length-adjusted, by regime")
+print(f"{'model':8s} "+" ".join(f"{r}:raw  {r}:adj " for r in ["dyad","triad","tetrad"]))
+rows={}
+for r in ["dyad","triad","tetrad"]:
+    m_=reg==r;b=np.polyfit(lmean[m_],y[m_],1)[0];resid=y.copy();resid[m_]=y[m_]-b*lmean[m_]
+    rows[r]=(b,resid)
+for mod in ["gpt-oss","Qwen","GLM-4","Mag","Gemma"]:
+    cells=[]
+    for r in ["dyad","triad","tetrad"]:
+        b,resid=rows[r];m_=(reg==r)&(model==mod)
+        if m_.sum()==0:cells.append("  --     --  ")
+        else:cells.append(f"{y[m_].mean():+5.2f}  {resid[m_].mean():+5.2f}")
+    print(f"{mod:8s} "+"  ".join(cells))
+print("\nslopes (length->engagement) per regime:",{r:round(rows[r][0],2) for r in rows})

analyses/lexical_table.py

@@ -0,0 +1,131 @@
+"""
+Lexical-features table for Finding 3 (part 1), persistent.
+Rows = models. Columns:
+  - CV accuracy (per-model recall) with Wilson 95% CI
+  - leave-personas-out accuracy (per-model recall) with Wilson 95% CI
+  - top distinguishing lexical features by FIRING (weight x mean in-class TF-IDF activation)
+Plus 1-2 qualitative example snippets per model.
+Outputs markdown + a LaTeX table fragment.
+"""
+import json, math, re
+from collections import defaultdict
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import StratifiedKFold, GroupKFold
+from pathlib import Path
+
+DATA = Path("data/texts.jsonl")
+OUTMD = Path("out/lexical_table.md")
+OUTTEX = Path("./_paper/latex/tables/lexical_table.tex")
+OUTTEX.parent.mkdir(parents=True, exist_ok=True)
+MODELS = ["gpt-oss","Qwen","GLM-4","Mag","Gemma"]
+NAME = {"gpt-oss":"gpt-oss-20b","Qwen":"Qwen3-32B","GLM-4":"GLM-4-32B","Mag":"Magistral-Small","Gemma":"Gemma-4-31B"}
+
+rows = [json.loads(l) for l in open(DATA)]
+rows = [r for r in rows if r["model"] in MODELS and len(r.get("text","") or "")>=10]
+texts = [r["text"] for r in rows]
+y = np.array([r["model"] for r in rows])
+persona = np.array([r["persona"] for r in rows])
+print(f"{len(rows)} texts")
+
+# two vectorizers: combined (word+char) for the classifier; word-only for readable feature display
+vec = TfidfVectorizer(ngram_range=(1,2), analyzer="word", min_df=10, max_features=40000,
+                      sublinear_tf=True, stop_words="english", token_pattern=r"[A-Za-z'][A-Za-z']+")
+vec_char = TfidfVectorizer(ngram_range=(3,5), analyzer="char_wb", min_df=20, max_features=40000, sublinear_tf=True)
+Xw = vec.fit_transform(texts); Xc = vec_char.fit_transform(texts)
+import scipy.sparse as sp
+X = sp.hstack([Xw, Xc]).tocsr()
+vocab_w = np.array(vec.get_feature_names_out())
+nw = Xw.shape[1]
+
+def wilson(k, n, z=1.96):
+    if n==0: return (float("nan"),float("nan"))
+    p=k/n; d=1+z*z/n
+    c=(p+z*z/(2*n))/d; h=z*math.sqrt(p*(1-p)/n+z*z/(4*n*n))/d
+    return (c-h, c+h)
+
+def per_model_recall(preds, ytrue):
+    out={}
+    for m in MODELS:
+        idx = ytrue==m; n=int(idx.sum()); k=int((preds[idx]==m).sum())
+        lo,hi=wilson(k,n); out[m]=(k/n, lo, hi, n)
+    return out
+
+# ---- CV (random 5-fold) ----
+preds_cv = np.empty(len(y), dtype=object)
+for tr,te in StratifiedKFold(5, shuffle=True, random_state=42).split(X,y):
+    clf=LogisticRegression(max_iter=400, C=2.0, n_jobs=-1)
+    clf.fit(X[tr],y[tr]); preds_cv[te]=clf.predict(X[te])
+cv = per_model_recall(preds_cv, y)
+print("CV done")
+
+# ---- leave-personas-out (GroupKFold by persona) ----
+preds_lpo = np.empty(len(y), dtype=object)
+for tr,te in GroupKFold(5).split(X,y,groups=persona):
+    clf=LogisticRegression(max_iter=400, C=2.0, n_jobs=-1)
+    clf.fit(X[tr],y[tr]); preds_lpo[te]=clf.predict(X[te])
+lpo = per_model_recall(preds_lpo, y)
+print("LPO done")
+
+# ---- firing features: fit on all, contribution = weight * mean in-class activation (word feats only) ----
+clf_full = LogisticRegression(max_iter=600, C=2.0, n_jobs=-1).fit(X,y)
+classes = list(clf_full.classes_)
+top_feat = {}
+for m in MODELS:
+    ci = classes.index(m)
+    w = clf_full.coef_[ci][:nw]                      # weights on word features
+    mask = (y==m)
+    mean_act = np.asarray(Xw[mask].mean(axis=0)).ravel()   # mean TF-IDF activation in-class
+    contrib = w * mean_act                            # how hard each feature fires for this class
+    order = np.argsort(contrib)[::-1]
+    feats=[vocab_w[j] for j in order[:8]]
+    top_feat[m]=feats
+
+# ---- qualitative example snippets: posts strongly containing the model's top features ----
+examples={}
+top_set={m:set(top_feat[m]) for m in MODELS}
+for m in MODELS:
+    best=("",-1)
+    for r in rows:
+        if r["model"]!=m: continue
+        t=r["text"]; tl=" "+re.sub(r"[^a-z' ]"," ",t.lower())+" "
+        hits=sum(1 for f in top_set[m] if " "+f+" " in tl)
+        if 60<=len(t)<=240 and hits>best[1]: best=(t,hits)
+    examples[m]=best[0].replace("\n"," ").strip()
+
+# ---- write markdown ----
+md=["# Lexical features by model (model classifier)\n",
+    f"{len(rows):,} texts. Classifier: TF-IDF (word 1-2gram + char 3-5gram) -> multinomial logistic regression. "
+    "Per-model accuracy = recall (fraction of that model's texts correctly identified). "
+    "Wilson 95% CIs. Leave-personas-out = train/test on disjoint persona sets. "
+    "Top features ranked by FIRING (weight x mean in-class TF-IDF activation), word features only.\n",
+    "| model | CV acc [95% CI] | leave-personas-out acc [95% CI] | top firing features |",
+    "|---|---|---|---|"]
+for m in MODELS:
+    a,lo,hi,n=cv[m]; a2,lo2,hi2,n2=lpo[m]
+    md.append(f"| {NAME[m]} | {a:.2f} [{lo:.2f}, {hi:.2f}] | {a2:.2f} [{lo2:.2f}, {hi2:.2f}] | {', '.join(top_feat[m][:6])} |")
+md.append("\n## Example snippets (containing each model's top firing features)\n")
+for m in MODELS:
+    md.append(f"- **{NAME[m]}**: \"{examples[m][:200]}\"")
+OUTMD.write_text("\n".join(md)+"\n")
+
+# ---- write LaTeX fragment ----
+tex=["% auto-generated by lexical_table.py",
+     "\\begin{table}[t]\\centering\\small",
+     "\\begin{tabular}{lccl}",
+     "\\toprule",
+     "model & CV acc.\\ [95\\% CI] & leave-personas-out [95\\% CI] & top firing features \\\\",
+     "\\midrule"]
+for m in MODELS:
+    a,lo,hi,n=cv[m]; a2,lo2,hi2,n2=lpo[m]
+    feats=", ".join(f"\\texttt{{{f}}}" for f in top_feat[m][:4])
+    tex.append(f"{NAME[m]} & {a:.2f} [{lo:.2f}, {hi:.2f}] & {a2:.2f} [{lo2:.2f}, {hi2:.2f}] & {feats} \\\\")
+tex+=["\\bottomrule","\\end{tabular}",
+      "\\caption{Each model's text is identifiable from lexical features alone, and the signal is persona-invariant (leave-personas-out). Per-model accuracy is recall; top features are those that fire hardest for the model (weight $\\times$ mean in-class TF-IDF activation).}",
+      "\\label{tab:lexical}","\\end{table}"]
+OUTTEX.write_text("\n".join(tex)+"\n")
+
+print("\n".join(md[:10]))
+for m in MODELS: print(m, "->", top_feat[m][:6])
+print(f"\nwrote {OUTMD} and {OUTTEX}")

analyses/persona_faithfulness.py

@@ -0,0 +1,34 @@
+import json,math
+from collections import Counter
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import accuracy_score
+rows=[json.loads(l) for l in open("data/texts.jsonl")]
+rows=[r for r in rows if len(r.get("text","") or "")>=1]
+print(len(rows),"texts total")
+pc=Counter(r["persona"] for r in rows);keep={p for p,c in pc.items() if c>=25}
+sub=[r for r in rows if r["persona"] in keep]
+print(len(sub),"texts;",len(keep),"personas (>=25)")
+vec=TfidfVectorizer(ngram_range=(1,2),analyzer="word",max_features=60000,sublinear_tf=True,token_pattern=r"[A-Za-z'][A-Za-z']+")
+vc=TfidfVectorizer(ngram_range=(3,5),analyzer="char_wb",max_features=60000,sublinear_tf=True)
+import scipy.sparse as sp
+Xw=vec.fit_transform([r["text"]for r in sub]);Xc=vc.fit_transform([r["text"]for r in sub]);X=sp.hstack([Xw,Xc]).tocsr()
+y=np.array([r["persona"]for r in sub]);chance=1/len(keep)
+pred=np.empty(len(y),dtype=object)
+for tr,te in StratifiedKFold(5,shuffle=True,random_state=0).split(X,y):
+    c=LogisticRegression(max_iter=300,C=2.0);c.fit(X[tr],y[tr]);pred[te]=c.predict(X[te])
+acc=accuracy_score(y,pred)
+print(f"PERSONA recovery: {acc*100:.1f}%  ({acc/chance:.0f}x chance {chance*100:.1f}%)")
+SHORT={"gpt-oss":"gpt-oss","Qwen":"Qwen","GLM-4":"GLM-4","Mag":"Magistral","Gemma":"Gemma"}
+for m in ["Gemma","Mag","gpt-oss","GLM-4","Qwen"]:
+    s=[r for r in sub if r["model"]==m];yy=np.array([r["persona"]for r in s])
+    pcm=Counter(yy);kk={p for p,c in pcm.items() if c>=15}
+    s=[r for r in s if r["persona"] in kk];yy=np.array([r["persona"]for r in s])
+    if len(set(yy))<3:continue
+    Xs=sp.hstack([vec.transform([r["text"]for r in s]),vc.transform([r["text"]for r in s])]).tocsr()
+    pr=np.empty(len(yy),dtype=object)
+    for tr,te in StratifiedKFold(3,shuffle=True,random_state=0).split(Xs,yy):
+        c=LogisticRegression(max_iter=300,C=2.0);c.fit(Xs[tr],yy[tr]);pr[te]=c.predict(Xs[te])
+    a=accuracy_score(yy,pr);ch=1/len(set(yy));print(f"  {m}: {a*100:.1f}%  {a/ch:.0f}x  ({len(set(yy))} personas)")

analyses/plot_fig1_network.py

@@ -0,0 +1,154 @@
+"""
+Figure 1 (WORKING): the interaction network of one triadic run with a strong
+attractor (gpt-oss) and a strong repeller (Magistral). Nodes = agents colored by
+base model, sized by in-degree; directed edges = comment flow. Side panel: per-model
+stats. Inset: a chat-window excerpt of the most-commented post.
+Saves SVG (for redesign) + PNG (for the paper).
+"""
+import sqlite3, json, sys
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.patches import FancyBboxPatch
+import networkx as nx
+sys.path.insert(0, str(Path(__file__).parent))
+from housestyle import serif, mono, MODEL_COLOR
+
+DB = "runs/sweep_tri_oss_mag_glm_s42.db"
+OUT_SVG = Path(__file__).parent / "fig1_network.svg"
+OUT_PNG = Path(__file__).parent / "fig1_network.png"
+SHORT = {"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss",
+         "mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4",
+         "google/gemma-4-31B-it":"Gemma"}
+
+meta = json.load(open(DB.replace(".db",".metadata.json")))
+fam = {int(k)+1: SHORT.get(v["model"]) for k,v in meta["agent_model_map"].items()}
+c = sqlite3.connect(DB)
+posts = c.execute("SELECT post_id,user_id,content FROM post").fetchall()
+coms  = c.execute("SELECT post_id,user_id,content FROM comment").fetchall()
+users = dict(c.execute("SELECT user_id,user_name FROM user").fetchall())
+c.close()
+owner = {p:u for p,u,_ in posts}
+
+# edges (commenter -> author), weighted; in-degree
+w = defaultdict(int); indeg = defaultdict(int); outdeg = defaultdict(int)
+for pid,cu,_ in coms:
+    au = owner.get(pid)
+    if au and au != cu and cu in fam and au in fam:
+        w[(cu,au)] += 1; indeg[au]+=1; outdeg[cu]+=1
+
+# most-commented post (restricted to agent-authored posts with a known model)
+pc = defaultdict(int)
+for pid,_,_ in coms: pc[pid]+=1
+agent_posts = [p for p in pc if owner.get(p) in fam]
+top_pid = max(agent_posts, key=pc.get)
+top_author = owner.get(top_pid)
+top_text = next((t for p,u,t in posts if p==top_pid), "")
+top_n = pc[top_pid]
+
+# per-model stats
+fams = ["gpt-oss","Mag","GLM-4","Qwen","Gemma"]
+fams = [f for f in fams if f in fam.values()]
+nf = {f:sum(1 for v in fam.values() if v==f) for f in fams}
+ntot = sum(nf.values()); tot = sum(w.values())
+obs = defaultdict(int)
+for (cu,au),ww in w.items(): obs[(fam[cu],fam[au])]+=ww
+def Hin(Y):
+    hs=[]
+    for X in fams:
+        if X==Y: continue
+        o=obs.get((X,Y),0)/tot; e=(nf[X]/ntot)*((nf[Y])/(ntot-1))
+        if e>0: hs.append(o/e-1)
+    return np.mean(hs) if hs else float("nan")
+stats = {f: (np.mean([indeg[u] for u in fam if fam[u]==f]), Hin(f)) for f in fams}
+
+# ---- build graph ----
+import math
+# model-grouped layout: each model's agents cluster at a polygon vertex, so
+# cross-model comment flow (and convergence on the attractor) is legible.
+order_for_anchor = [f for f in ["gpt-oss","Mag","GLM-4","Qwen","Gemma"] if f in set(fam.values())]
+anchors = {}
+for i,f in enumerate(order_for_anchor):
+    ang = 2*math.pi*i/len(order_for_anchor) + math.pi/2
+    anchors[f] = (1.25*math.cos(ang), 1.25*math.sin(ang))
+rng = np.random.default_rng(3)
+pos = {u: (anchors[fam[u]][0] + rng.normal(0,0.30),
+           anchors[fam[u]][1] + rng.normal(0,0.30)) for u in fam}
+
+fig = plt.figure(figsize=(7.2, 4.2))
+gs = fig.add_gridspec(2, 2, width_ratios=[2.0, 1.0], height_ratios=[1.3, 1.0],
+                      wspace=0.06, hspace=0.30)
+axN = fig.add_subplot(gs[:, 0]); axN.axis("off"); axN.set_aspect("equal")
+axS = fig.add_subplot(gs[0, 1]); axS.axis("off")
+axC = fig.add_subplot(gs[1, 1]); axC.axis("off")
+
+# edges: declutter by drawing only weight>=2; width/alpha by weight
+wmax = max(w.values())
+for (cu,au),ww in w.items():
+    if ww < 2: continue
+    x1,y1 = pos[cu]; x2,y2 = pos[au]
+    axN.annotate("", xy=(x2,y2), xytext=(x1,y1),
+                 arrowprops=dict(arrowstyle="-|>", color="#9aa0a6",
+                                 alpha=0.18+0.55*(ww/wmax), lw=0.4+1.8*(ww/wmax),
+                                 shrinkA=5, shrinkB=6, connectionstyle="arc3,rad=0.08"))
+# nodes (sqrt scaling so the attractor doesn't dominate the canvas)
+for u in fam:
+    x,y = pos[u]
+    s = 35 + 45*np.sqrt(indeg[u])
+    axN.scatter([x],[y], s=s, c=MODEL_COLOR[fam[u]], edgecolors="white", linewidths=0.8, zorder=3)
+# faint cluster labels at anchors
+for f,(ax_,ay_) in anchors.items():
+    axN.text(ax_*1.32, ay_*1.32, f, fontproperties=mono(8.5, bold=True),
+             color=MODEL_COLOR[f], ha="center", va="center", zorder=4)
+xs=[p[0] for p in pos.values()]; ys=[p[1] for p in pos.values()]
+m=0.45
+axN.set_xlim(min(xs)-m, max(xs)+m); axN.set_ylim(min(ys)-m, max(ys)+m)
+axN.set_title("Interaction network: one three-way run",
+              fontproperties=serif(12, bold=True), pad=10)
+# legend
+import matplotlib.lines as mlines
+handles=[mlines.Line2D([],[],marker="o",ls="",mfc=MODEL_COLOR[f],mec="white",ms=9,label=f) for f in fams]
+axN.legend(handles=handles, loc="lower left", prop=mono(8), frameon=False, handletextpad=0.2, borderpad=0.2)
+axN.text(0.5,-0.03,"node size $\\propto$ in-degree · edge = comment flow",
+         transform=axN.transAxes, ha="center", fontproperties=mono(7.5), color="#555")
+
+# ---- side stats ----
+axS.set_title("per-model", fontproperties=serif(10, bold=True), loc="left", pad=2)
+axS.text(0, 0.86, f"{'model':<8}{'in-deg':>7}{'H':>7}", fontproperties=mono(8.5, bold=True), transform=axS.transAxes)
+for i,f in enumerate(fams):
+    md, h = stats[f]
+    axS.text(0, 0.86-0.13*(i+1),
+             f"{f:<8}{md:>7.1f}{h:>+7.2f}", fontproperties=mono(8.5),
+             color=MODEL_COLOR[f], transform=axS.transAxes)
+axS.text(0, 0.86-0.13*(len(fams)+1.4),
+         f"{tot} cross-comments\n{len(posts)} posts, n={ntot} agents",
+         fontproperties=mono(7.5), color="#444", transform=axS.transAxes, va="top")
+
+# ---- chat window ----
+box = FancyBboxPatch((0.02,0.04),0.96,0.92, boxstyle="round,pad=0.02,rounding_size=0.04",
+                     fc="#f3f4f6", ec="#cfd3da", lw=1.0, transform=axC.transAxes)
+axC.add_patch(box)
+def ascii_only(s): return s.encode("ascii","ignore").decode().strip()
+auth_name = ascii_only(users.get(top_author, f"u{top_author}")) or f"u{top_author}"
+auth_model = fam.get(top_author,"?")
+header = f"{auth_name[:18]}  ({auth_model})"
+axC.text(0.07,0.85, header, fontproperties=mono(8.5,bold=True),
+         color=MODEL_COLOR.get(auth_model,"#333"), transform=axC.transAxes)
+import textwrap
+body = ascii_only(top_text.replace("\n"," "))
+wrapped = "\n".join(textwrap.fill(body, width=32).split("\n")[:4])
+if len(body) > len(wrapped): wrapped += " ..."
+axC.text(0.07,0.72, wrapped, fontproperties=mono(8), color="#222",
+         transform=axC.transAxes, va="top")
+axC.text(0.07,0.10, f">> {top_n} comments", fontproperties=mono(9,bold=True),
+         color="#1f77b4", transform=axC.transAxes)
+axC.set_title("most-engaged post", fontproperties=serif(10, bold=True), loc="left", pad=2)
+
+plt.savefig(OUT_SVG, bbox_inches="tight")
+plt.savefig(OUT_PNG, dpi=300, bbox_inches="tight")
+print(f"saved {OUT_SVG.name} + {OUT_PNG.name}")
+print(f"run={Path(DB).stem}  top_post nc={top_n} author={auth_name}({auth_model})")
+for f in fams: print(f"  {f}: in-deg={stats[f][0]:.1f} H={stats[f][1]:+.2f}")

analyses/plot_fig_variance_overview.py

@@ -0,0 +1,164 @@
+"""
+Variance overview (moved deeper; WORKING mock, house style).
+  (a) ABSOLUTE variance in agent engagement explained by persona vs model selection,
+      by regime -- total grows and the model-selection component scales.
+  (b) per-model attractiveness = mean incoming excess cross-model engagement H.
+"""
+import sys
+from pathlib import Path
+from collections import defaultdict
+import json, sqlite3
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+sys.path.insert(0, str(Path(__file__).parent))
+from housestyle import serif, mono, MODEL_COLOR
+
+RUNS = Path("runs")
+OUT = Path(__file__).parent / "fig_variance_overview.png"
+SHORT = {"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss",
+         "mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4",
+         "google/gemma-4-31B-it":"Gemma"}
+
+# ---- Panel A: PROPORTIONAL variance of comments-per-post (CPP) explained by
+#      own base model vs persona, by regime (in-sample R^2, %). Model overtakes persona.
+absvar = {
+    "Two-way":   {"persona": 8.5, "model": 9.9},
+    "Three-way": {"persona": 7.3, "model": 13.3},
+    "Four-way":  {"persona": 5.8, "model": 25.4},
+}
+
+# ---- Panel B: per-model attractiveness from run DBs ----
+def attractiveness():
+    inc = defaultdict(list)
+    for db in sorted(RUNS.glob("sweep_*.db")):
+        if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]): continue
+        mp = str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists(): continue
+        try: amm = json.load(open(mp)).get("agent_model_map",{})
+        except: continue
+        if not amm: continue
+        fam = {int(k)+1: SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()): continue
+        try:
+            c = sqlite3.connect(db)
+            posts = c.execute("SELECT post_id,user_id FROM post").fetchall()
+            coms = c.execute("SELECT post_id,user_id FROM comment").fetchall(); c.close()
+        except: continue
+        if len(coms) < 200: continue
+        owner = {p:u for p,u in posts}; F = sorted(set(fam.values()))
+        nf = {f: sum(1 for v in fam.values() if v==f) for f in F}; ntot = sum(nf.values())
+        edges = [(fam[cu],fam[owner[p]]) for p,cu in coms if owner.get(p) and owner[p]!=cu and cu in fam and owner[p] in fam]
+        tot = len(edges) or 1
+        obs = defaultdict(int)
+        for x,y in edges: obs[(x,y)] += 1
+        for Y in F:
+            hs=[obs.get((X,Y),0)/tot/((nf[X]/ntot)*((nf[Y])/(ntot-1)))-1 for X in F if X!=Y and nf[X]]
+            if hs: inc[Y].append(np.mean(hs))
+    return {m:(np.mean(v), np.std(v)/np.sqrt(len(v))) for m,v in inc.items()}
+
+def temporal_incoming_H(n_bins=4):
+    """Per-model incoming H over simulation quartiles (comment-order bins), pooled over runs."""
+    acc = defaultdict(lambda: defaultdict(list))   # model -> bin -> [H per run]
+    for db in sorted(RUNS.glob("sweep_*.db")):
+        if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]): continue
+        mp = str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists(): continue
+        try: amm = json.load(open(mp)).get("agent_model_map",{})
+        except: continue
+        if not amm: continue
+        fam = {int(k)+1: SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()): continue
+        try:
+            c = sqlite3.connect(db)
+            posts = c.execute("SELECT post_id,user_id FROM post").fetchall()
+            coms = c.execute("SELECT post_id,user_id FROM comment ORDER BY comment_id").fetchall(); c.close()
+        except: continue
+        if len(coms) < 200: continue
+        owner = {p:u for p,u in posts}; F = sorted(set(fam.values()))
+        nf = {f: sum(1 for v in fam.values() if v==f) for f in F}; ntot = sum(nf.values())
+        edges = [(fam[cu],fam[owner[p]]) for p,cu in coms
+                 if owner.get(p) and owner[p]!=cu and cu in fam and owner[p] in fam]
+        if len(edges) < n_bins*20: continue
+        for b in range(n_bins):
+            seg = edges[b*len(edges)//n_bins:(b+1)*len(edges)//n_bins]
+            tot = len(seg) or 1
+            obs = defaultdict(int)
+            for xx,yy in seg: obs[(xx,yy)] += 1
+            for Y in F:
+                hs=[obs.get((X,Y),0)/tot/((nf[X]/ntot)*((nf[Y])/(ntot-1)))-1 for X in F if X!=Y and nf[X]]
+                if hs: acc[Y][b].append(np.mean(hs))
+    return acc
+
+plt.rcParams.update({"axes.spines.top":False,"axes.spines.right":False,"figure.dpi":300})
+fig,(axA,axB) = plt.subplots(1,2, figsize=(7.2,2.6), gridspec_kw={"width_ratios":[1,1.05]})
+
+# Panel A: absolute grouped bars
+regimes=["Two-way","Three-way","Four-way"]; x=np.arange(3); w=0.38
+pc="#c0392b"; mc="#2c6fbb"
+for i,key in enumerate(["persona","model"]):
+    vals=[absvar[r][key] for r in regimes]; off=(-w/2 if i==0 else w/2)
+    axA.bar(x+off, vals, w, color=(pc if i==0 else mc),
+            label=("persona" if i==0 else "base model"), edgecolor="white", lw=0.5)
+    for xi,vv in zip(x+off,vals):
+        axA.text(xi, vv+0.4, f"{vv:.1f}", ha="center", va="bottom", fontproperties=mono(8))
+axA.set_xticks(x); axA.set_xticklabels(regimes, fontproperties=mono(9))
+axA.set_ylabel("CPP variance explained ($R^2$, \\%)", fontproperties=mono(8.5))
+axA.set_ylim(0, 29)
+axA.legend(prop=mono(8), frameon=False, loc="upper left")
+axA.set_title("(a) Per-post engagement: model overtakes persona", fontproperties=serif(9.5, bold=True))
+axA.tick_params(labelsize=8)
+
+# Panel B: per-model incoming H across mixture sizes (one line per base model), centered at y=0
+TETDIR = RUNS / "tetratic"
+def regime_H():
+    acc = defaultdict(lambda: defaultdict(list))   # model -> regime -> [H per run]
+    def proc(globpat, tet=False):
+        for db in sorted(globpat):
+            if not tet and any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]): continue
+            if tet and (TETDIR/f"{db.stem}_checkpoint.json").exists(): continue
+            mp = str(db).replace(".db",".metadata.json")
+            if not Path(mp).exists(): continue
+            try: amm = json.load(open(mp)).get("agent_model_map",{})
+            except: continue
+            if not amm: continue
+            fam = {int(k)+1: SHORT.get(v["model"]) for k,v in amm.items()}
+            if any(v is None for v in fam.values()): continue
+            try:
+                c = sqlite3.connect(db)
+                posts = c.execute("SELECT post_id,user_id FROM post").fetchall()
+                coms = c.execute("SELECT post_id,user_id FROM comment").fetchall(); c.close()
+            except: continue
+            if len(coms) < (100 if tet else 200): continue
+            F = sorted(set(fam.values())); reg = {2:"dyad",3:"triad",4:"tetrad"}.get(len(F))
+            if not reg: continue
+            owner = {p:u for p,u in posts}; nf = {f: sum(1 for v in fam.values() if v==f) for f in F}; N = sum(nf.values())
+            edges = [(fam[cu],fam[owner[p]]) for p,cu in coms if owner.get(p) and owner[p]!=cu and cu in fam and owner[p] in fam]
+            tot = len(edges) or 1; obs = defaultdict(int)
+            for a,b in edges: obs[(a,b)] += 1
+            for Y in F:
+                hs = [obs.get((X,Y),0)/tot/((nf[X]/N)*(nf[Y]/(N-1)))-1 for X in F if X!=Y]
+                if hs: acc[Y][reg].append(np.mean(hs))
+    proc(RUNS.glob("sweep_*.db")); proc(TETDIR.glob("tetra_s*_r*.db"), tet=True)
+    return acc
+rH = regime_H()
+regs = ["dyad","triad","tetrad"]; xr = np.arange(3)
+axB.axhline(0, color="#666", lw=0.9, ls=":")
+for m in ["gpt-oss","Qwen","GLM-4","Gemma","Mag"]:
+    if m not in rH: continue
+    ys = [np.mean(rH[m][r]) if rH[m].get(r) else np.nan for r in regs]
+    axB.plot(xr, ys, marker="o", ms=4.5, lw=1.8, color=MODEL_COLOR[m], label=m)
+allv = [np.mean(rH[m][r]) for m in rH for r in regs if rH[m].get(r)]
+M = max(abs(v) for v in allv) * 1.18
+axB.set_ylim(-M, M)
+axB.set_xticks(xr); axB.set_xticklabels(["dyad","triad","tetrad"], fontproperties=mono(9))
+axB.set_xlim(-0.15, 2.15)
+axB.set_ylabel("incoming $H$ (excess engagement)", fontproperties=mono(8.5))
+axB.set_title("(b) Attraction sharpens with mixture size", fontproperties=serif(9.5, bold=True))
+axB.legend(prop=mono(7), frameon=False, ncol=2, loc="lower left", handlelength=1.3)
+axB.tick_params(labelsize=8)
+
+plt.tight_layout(w_pad=1.5)
+fig.savefig(OUT, dpi=300, bbox_inches="tight")
+print(f"saved {OUT.name}")

analyses/plot_matrices.py

@@ -0,0 +1,518 @@
+"""
+Heatmap figures for the divsim paper.
+
+Produces H-matrix, swap-stability, in-group self-preference, and Elo-rating
+figures in three variants each: dyadic-only, triadic-only, combined.
+
+Figures are written to OUTDIR (default: same directory as this script).
+
+Configuration:
+    RUNS_DIR   — directory containing sweep_*.db files (env var or --runs-dir)
+    OUTDIR     — output directory for .png files (env var or --outdir)
+
+Usage:
+    python plot_matrices.py
+    python plot_matrices.py --runs-dir /path/to/runs --outdir /path/to/figures
+"""
+
+import os
+import glob
+import json
+import math
+import sqlite3
+import itertools
+import argparse
+from collections import defaultdict
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.font_manager import FontProperties, fontManager
+
+
+# ── Font loading ──────────────────────────────────────────────────────────────
+# Looks for Volkhov and Ubuntu Mono in ~/fonts; falls back gracefully.
+FONT_DIR = Path.home() / "fonts"
+if FONT_DIR.is_dir():
+    for ttf in FONT_DIR.rglob("*.ttf"):
+        fontManager.addfont(str(ttf))
+
+
+def fp(family, size, bold=False):
+    return FontProperties(family=family, size=size,
+                          weight="bold" if bold else "normal")
+
+
+FT = lambda s, bold=False: fp("Volkhov",     s, bold)
+FB = lambda s, bold=False: fp("Ubuntu Mono", s, bold)
+
+plt.rcParams.update({
+    "font.family":       "Ubuntu Mono",
+    "axes.spines.top":   False,
+    "axes.spines.right": False,
+    "figure.dpi":        300,
+})
+
+SHORT = {
+    "Qwen/Qwen3-32B":                 "Qwen",
+    "openai/gpt-oss-20b":             "gpt-oss",
+    "mistralai/Magistral-Small-2509": "Mag",
+    "zai-org/GLM-4-32B-0414":         "GLM-4",
+    "google/gemma-4-31B-it":          "Gemma",
+}
+MODELS    = ["GLM-4", "Mag", "Qwen", "gpt-oss", "Gemma"]
+MODEL_SET = set(MODELS)
+
+
+# ── H computation ──────────────────────────────────────────────────────────────
+
+def load_h(db_path):
+    """Compute directed pairwise H matrix for one run DB."""
+    mp = str(db_path).replace(".db", ".metadata.json")
+    if not os.path.exists(mp):
+        return {}
+    with open(mp) as f:
+        meta = json.load(f)
+    amm = meta.get("agent_model_map", {})
+    if not amm:
+        return {}
+    uf = {int(k)+1: SHORT.get(v["model"], v["model"][:6]) for k, v in amm.items()}
+    fc = defaultdict(int)
+    for fam in uf.values():
+        fc[fam] += 1
+    ec = defaultdict(int)
+    conn = sqlite3.connect(db_path)
+    for cu, pu in conn.execute(
+            "SELECT c.user_id, p.user_id FROM comment c "
+            "JOIN post p ON c.post_id=p.post_id WHERE c.user_id!=p.user_id"):
+        sf, df = uf.get(cu), uf.get(pu)
+        if sf and df:
+            ec[(sf, df)] += 1
+    conn.close()
+    total = sum(ec.values())
+    if not total:
+        return {}
+    n = sum(fc.values())
+    H = {}
+    for s in fc:
+        for d in fc:
+            obs = ec.get((s, d), 0) / total
+            exp = (fc[s]/n) * ((fc[d] - (1 if s == d else 0)) / (n-1))
+            if exp > 0:
+                H[(s, d)] = obs/exp - 1
+    return H
+
+
+# ── Load all valid dyadic runs ────────────────────────────────────────────────
+
+def load_dyadic(runs_dir: Path):
+    all_H     = defaultdict(list)
+    swap_vals = defaultdict(lambda: defaultdict(list))
+    for db in sorted(runs_dir.glob("sweep_*.db")):
+        name = str(db)
+        if any(x in name for x in ["archive", "snapshot", "sweep_tri_",
+                                    "olm", "hermes", "qwq", "glm47"]):
+            continue
+        try:
+            mp = name.replace(".db", ".metadata.json")
+            if not os.path.exists(mp):
+                continue
+            with open(mp) as f:
+                meta = json.load(f)
+            amm  = meta.get("agent_model_map", {})
+            fams = set(SHORT.get(v["model"], v["model"][:6]) for v in amm.values())
+            if len(fams) != 2 or not fams.issubset(MODEL_SET):
+                continue
+            conn = sqlite3.connect(db)
+            nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
+            nc = conn.execute("SELECT COUNT(*) FROM comment").fetchone()[0]
+            conn.close()
+            if nu < 18 or nc < 200:
+                continue
+            H = load_h(db)
+            seed     = str(db).split("_s")[-1].replace(".db", "")
+            dyad_key = frozenset(fams)
+            for pair, h in H.items():
+                all_H[pair].append(h)
+                swap_vals[pair][(dyad_key, seed)].append(h)
+        except Exception:
+            pass
+    return all_H, swap_vals
+
+
+def load_triadic(runs_dir: Path):
+    all_H           = defaultdict(list)
+    by_triplet_seed = defaultdict(list)
+    for db in sorted(runs_dir.glob("sweep_tri_*.db")):
+        if "archive" in str(db):
+            continue
+        try:
+            conn = sqlite3.connect(db)
+            nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
+            conn.close()
+            if nu < 26:
+                continue
+            mp = str(db).replace(".db", ".metadata.json")
+            if not os.path.exists(mp):
+                continue
+            H = load_h(db)
+            if not H:
+                continue
+            with open(mp) as f:
+                meta = json.load(f)
+            amm = meta.get("agent_model_map", {})
+            run_models = frozenset(
+                SHORT.get(v["model"], v["model"][:6]) for v in amm.values()
+            )
+            seed = str(db).split("_s")[-1].replace(".db", "")
+            by_triplet_seed[(run_models, seed)].append(H)
+            for pair, h in H.items():
+                all_H[pair].append(h)
+        except Exception:
+            pass
+    return all_H, by_triplet_seed
+
+
+# ── Swap-stability matrices ───────────────────────────────────────────────────
+
+def dyadic_swap_matrix(swap_vals, keys):
+    """Mean |ΔH| across seeds for dyadic runs (exactly 2 orientations per seed)."""
+    n    = len(keys)
+    mean = np.full((n, n), np.nan)
+    std  = np.full((n, n), np.nan)
+    for i, s in enumerate(keys):
+        for j, d in enumerate(keys):
+            by_seed = swap_vals.get((s, d), {})
+            diffs   = [abs(vs[0]-vs[1]) for vs in by_seed.values() if len(vs) == 2]
+            if diffs:
+                mean[i, j] = np.mean(diffs)
+                std[i, j]  = np.std(diffs, ddof=1) if len(diffs) > 1 else 0.
+    return mean, std
+
+
+def triadic_swap_matrix(tri_by_ts, keys):
+    """Mean max-|ΔH| per (triplet, seed) group for triadic runs (3 orderings)."""
+    n             = len(keys)
+    pair_maxdiffs = defaultdict(list)
+    for (triplet, seed), h_list in tri_by_ts.items():
+        if len(h_list) < 2:
+            continue
+        all_pairs = set()
+        for H in h_list:
+            all_pairs.update(H.keys())
+        for pair in all_pairs:
+            vals = [H.get(pair, np.nan) for H in h_list]
+            vals = [v for v in vals if not np.isnan(v)]
+            if len(vals) < 2:
+                continue
+            max_diff = max(abs(a-b) for a, b in itertools.combinations(vals, 2))
+            pair_maxdiffs[pair].append(max_diff)
+    mean = np.full((n, n), np.nan)
+    std  = np.full((n, n), np.nan)
+    for i, s in enumerate(keys):
+        for j, d in enumerate(keys):
+            diffs = pair_maxdiffs.get((s, d), [])
+            if diffs:
+                mean[i, j] = np.mean(diffs)
+                std[i, j]  = np.std(diffs, ddof=1) if len(diffs) > 1 else 0.
+    return mean, std
+
+
+def combined_swap_matrix(swap_dy_mean, swap_dy_std, swap_tri_mean, swap_tri_std, keys):
+    """Unweighted average of dyadic and triadic swap means where both exist."""
+    n    = len(keys)
+    mean = np.full((n, n), np.nan)
+    std  = np.full((n, n), np.nan)
+    for i in range(n):
+        for j in range(n):
+            vals = []
+            if not np.isnan(swap_dy_mean[i, j]):
+                vals.append(swap_dy_mean[i, j])
+            if not np.isnan(swap_tri_mean[i, j]):
+                vals.append(swap_tri_mean[i, j])
+            if vals:
+                mean[i, j] = np.mean(vals)
+                std[i, j]  = np.std(vals, ddof=0) if len(vals) > 1 else 0.
+    return mean, std
+
+
+# ── Per-matrix statistics ─────────────────────────────────────────────────────
+
+def mat_stats(H_dict, keys):
+    n    = len(keys)
+    mean = np.full((n, n), np.nan)
+    std  = np.full((n, n), np.nan)
+    for i, s in enumerate(keys):
+        for j, d in enumerate(keys):
+            vals = H_dict.get((s, d), [])
+            if vals:
+                mean[i, j] = np.mean(vals)
+                std[i, j]  = np.std(vals, ddof=1) if len(vals) > 1 else 0.
+    return mean, std
+
+
+# ── Cell annotation helpers ───────────────────────────────────────────────────
+
+def label_cells(ax, mean, std, swap_mean=None, swap_std=None,
+                skip_diag=False,
+                fs_main=32, fs_std=22, fs_swap=20, thresh=0.28):
+    n = mean.shape[0]
+    for i in range(n):
+        for j in range(n):
+            if skip_diag and i == j:
+                continue
+            if np.isnan(mean[i, j]):
+                continue
+            v       = mean[i, j]
+            txt_col = "white" if abs(v) > thresh else "#1a1a1a"
+            ax.text(j, i - 0.28, f"{v:+.3f}",
+                    ha="center", va="center",
+                    fontproperties=FB(fs_main, bold=True), color=txt_col)
+            ax.text(j, i + 0.02, f"±{std[i, j]:.2f}",
+                    ha="center", va="center",
+                    fontproperties=FB(fs_std), color=txt_col, alpha=0.90)
+            if swap_mean is not None and not np.isnan(swap_mean[i, j]):
+                s_v  = swap_mean[i, j]
+                s_sd = swap_std[i, j] if swap_std is not None and not np.isnan(swap_std[i, j]) else 0.
+                ax.text(j, i + 0.32,
+                        f"|ΔH|={s_v:.2f}±{s_sd:.2f}",
+                        ha="center", va="center",
+                        fontproperties=FB(fs_swap, bold=True),
+                        color=txt_col, alpha=0.85)
+
+
+def style_axes(ax, labels, title, cbar_im, vmax, cbar_label="H"):
+    n = len(labels)
+    ax.set_xticks(range(n))
+    ax.set_yticks(range(n))
+    ax.set_xticklabels(labels, fontproperties=FB(22, bold=True), rotation=0)
+    ax.set_yticklabels(labels, fontproperties=FB(22, bold=True))
+    ax.set_xlabel("target family  (post author)", fontproperties=FB(20), labelpad=12)
+    ax.set_ylabel("source family  (commenter)",   fontproperties=FB(20), labelpad=12)
+    ax.set_title(title, fontproperties=FT(26, bold=True), pad=18)
+    cb = plt.colorbar(cbar_im, ax=ax, fraction=0.046, pad=0.04)
+    cb.set_label(cbar_label, fontproperties=FB(20))
+    for tick in cb.ax.get_yticklabels():
+        tick.set_fontproperties(FB(16))
+
+
+# ── Plot functions ────────────────────────────────────────────────────────────
+
+def plot_h_matrix(H_dict, keys, title, outpath, cross_only=False,
+                  swap_mean=None, swap_std=None):
+    mean, std = mat_stats(H_dict, keys)
+    if cross_only:
+        np.fill_diagonal(mean, np.nan)
+        np.fill_diagonal(std,  np.nan)
+    vmax = np.nanmax(np.abs(mean)) * 1.08
+    fig, ax = plt.subplots(figsize=(15.0, 12.5))
+    im = ax.imshow(mean, cmap="RdBu_r", vmin=-vmax, vmax=vmax, aspect="equal")
+    label_cells(ax, mean, std,
+                swap_mean=swap_mean, swap_std=swap_std,
+                skip_diag=cross_only)
+    style_axes(ax, keys, title, im, vmax)
+    plt.tight_layout()
+    fig.savefig(outpath, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    print(f"saved {Path(outpath).name}")
+
+
+def plot_swap(swap_mean, swap_std, keys, title, outpath):
+    vmax = np.nanmax(swap_mean[~np.isnan(swap_mean)]) * 1.05
+    fig, ax = plt.subplots(figsize=(7.5, 6.2))
+    im = ax.imshow(swap_mean, cmap="YlOrRd", vmin=0, vmax=vmax, aspect="equal")
+    n = len(keys)
+    for i in range(n):
+        for j in range(n):
+            if np.isnan(swap_mean[i, j]):
+                continue
+            v       = swap_mean[i, j]
+            txt_col = "white" if v > vmax * 0.65 else "#1a1a1a"
+            ax.text(j, i - 0.14, f"{v:.3f}",
+                    ha="center", va="center",
+                    fontproperties=FB(18, bold=True), color=txt_col)
+            ax.text(j, i + 0.26, f"±{swap_std[i, j]:.2f}",
+                    ha="center", va="center",
+                    fontproperties=FB(12), color=txt_col, alpha=0.80)
+    ax.set_xticks(range(n))
+    ax.set_yticks(range(n))
+    ax.set_xticklabels(keys, fontproperties=FB(13, bold=True), rotation=0)
+    ax.set_yticklabels(keys, fontproperties=FB(13, bold=True))
+    ax.set_xlabel("target family", fontproperties=FB(11), labelpad=7)
+    ax.set_ylabel("source family", fontproperties=FB(11), labelpad=7)
+    ax.set_title(title, fontproperties=FT(16, bold=True), pad=12)
+    cb = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+    cb.set_label(r"$|\Delta H|$", fontproperties=FB(11))
+    for tick in cb.ax.get_yticklabels():
+        tick.set_fontproperties(FB(10))
+    plt.tight_layout()
+    fig.savefig(outpath, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    print(f"saved {Path(outpath).name}")
+
+
+def model_color(m):
+    import colorsys
+    full = {v: k for k, v in SHORT.items()}.get(m, m)
+    h = 0
+    for c in full:
+        h = (h*31 + ord(c)) & 0xFFFFFFFF
+        if h >= 0x80000000:
+            h -= 0x100000000
+    hue = abs(h) % 360
+    r, g, b = colorsys.hls_to_rgb(hue/360, 0.45, 0.55)
+    return "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+
+
+def plot_self_pref(H_data, tag, label, outdir):
+    self_vals = [H_data.get((m, m), []) for m in MODELS]
+    self_m    = [np.mean(v) if v else np.nan for v in self_vals]
+    self_s    = [np.std(v, ddof=1) if len(v) > 1 else 0. for v in self_vals]
+    self_n    = [len(v) for v in self_vals]
+
+    colors = []
+    for v in self_m:
+        if np.isnan(v):   colors.append("#aaa")
+        elif v > 0:       colors.append("#c0392b")
+        else:             colors.append("#2980b9")
+
+    fig, ax = plt.subplots(figsize=(5.5, 4.0))
+    xs = range(len(MODELS))
+    ax.bar(xs, self_m, color=colors, alpha=0.85, width=0.6,
+           edgecolor="white", linewidth=0.6)
+    ax.errorbar(xs, self_m, yerr=self_s, fmt="none", color="#333",
+                capsize=5, lw=1.5, capthick=1.5)
+    ax.axhline(0, color="#555", lw=0.8)
+    for x, m, s, n in zip(xs, self_m, self_s, self_n):
+        if np.isnan(m):
+            continue
+        yoff = m + s + 0.02 if m >= 0 else m - s - 0.07
+        va   = "bottom" if m >= 0 else "top"
+        ax.text(x, yoff, f"n={n}", ha="center", va=va,
+                fontproperties=FB(9), color="#555")
+    ax.set_xticks(list(xs))
+    ax.set_xticklabels(MODELS, fontproperties=FB(11, bold=True))
+    ax.set_ylabel(r"$H_{X \to X}$  (in-group self-preference)", fontproperties=FB(10))
+    ax.set_title(f"{label} in-group self-preference", fontproperties=FT(14, bold=True), pad=10)
+    plt.tight_layout()
+    outpath = outdir / f"fig_self_pref_{tag}.png"
+    fig.savefig(outpath, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    print(f"saved {outpath.name}")
+
+
+def plot_elo(all_H_dy, outdir):
+    """Elo rating from dyadic H-matrix net-attractor advantage."""
+    matches = []
+    for pair, vals in all_H_dy.items():
+        if pair[0] == pair[1]:
+            continue
+        x, y = pair[0], pair[1]
+        h_xy = np.mean(vals) if vals else 0
+        rev_pair = (y, x)
+        h_yx = np.mean(all_H_dy.get(rev_pair, [0]))
+        net_x = h_yx - h_xy
+        matches.append((x, y, net_x))
+
+    elo = defaultdict(lambda: 1200.0)
+    K   = 32
+    for x, y, net in matches:
+        exp_x = 1 / (1 + 10**((elo[y]-elo[x])/400))
+        sx    = 1 / (1 + math.exp(-net/0.5))
+        elo[x] += K * (sx - exp_x)
+        elo[y] += K * ((1-sx) - (1-exp_x))
+
+    elo_items  = sorted(elo.items(), key=lambda kv: -kv[1])
+    elo_models = [k for k, v in elo_items]
+    elo_vals   = [v for k, v in elo_items]
+    cols       = [model_color(m) for m in elo_models]
+
+    fig, ax = plt.subplots(figsize=(5.5, 4.0))
+    ax.bar(range(len(elo_models)), elo_vals, color=cols, alpha=0.88,
+           width=0.6, edgecolor="white", linewidth=0.6)
+    ax.axhline(1200, color="#888", lw=0.8, ls="--", alpha=0.6)
+    for x, v, m in zip(range(len(elo_models)), elo_vals, elo_models):
+        ax.text(x, v+4, f"{v:.0f}", ha="center", va="bottom",
+                fontproperties=FB(10, bold=True), color="#222")
+    ax.set_xticks(list(range(len(elo_models))))
+    ax.set_xticklabels(elo_models, fontproperties=FB(11, bold=True))
+    ax.set_ylabel("Elo rating", fontproperties=FB(10))
+    ax.set_title("Elo ranking  (net attractor advantage, dyadic)",
+                 fontproperties=FT(14, bold=True), pad=10)
+    plt.tight_layout()
+    fig.savefig(outdir / "fig_elo.png", dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    print("saved fig_elo.png")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--runs-dir", default=os.environ.get("RUNS_DIR", "./runs"),
+                        help="Directory containing sweep_*.db files.")
+    parser.add_argument("--outdir",   default=os.environ.get("OUTDIR", str(Path(__file__).parent)),
+                        help="Output directory for figures.")
+    args = parser.parse_args()
+
+    runs_dir = Path(args.runs_dir)
+    outdir   = Path(args.outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Loading dyadic runs from {runs_dir}...")
+    all_H_dy, swap_vals_dy = load_dyadic(runs_dir)
+
+    print(f"Loading triadic runs from {runs_dir}...")
+    all_H_tri, tri_by_ts = load_triadic(runs_dir)
+
+    all_H_combined = defaultdict(list)
+    for pair, vals in all_H_dy.items():
+        all_H_combined[pair].extend(vals)
+    for pair, vals in all_H_tri.items():
+        all_H_combined[pair].extend(vals)
+
+    swap_dy_mean,   swap_dy_std   = dyadic_swap_matrix(swap_vals_dy, MODELS)
+    swap_tri_mean,  swap_tri_std  = triadic_swap_matrix(tri_by_ts, MODELS)
+    swap_comb_mean, swap_comb_std = combined_swap_matrix(
+        swap_dy_mean, swap_dy_std, swap_tri_mean, swap_tri_std, MODELS)
+
+    datasets = [
+        ("dyadic",   all_H_dy,       swap_dy_mean,   swap_dy_std),
+        ("triadic",  all_H_tri,      swap_tri_mean,  swap_tri_std),
+        ("combined", all_H_combined, swap_comb_mean, swap_comb_std),
+    ]
+
+    for tag, H_data, sw_mean, sw_std in datasets:
+        label = {"dyadic": "Dyadic", "triadic": "Triadic", "combined": "Combined"}[tag]
+
+        plot_h_matrix(
+            H_data, MODELS,
+            rf"{label} directed engagement homophily  $H_{{X \to Y}}$",
+            outdir / f"fig_h_matrix_{tag}.png",
+            swap_mean=sw_mean, swap_std=sw_std,
+        )
+        plot_h_matrix(
+            H_data, MODELS,
+            rf"{label} cross-group homophily  $H_{{X \to Y}}$,  $X \neq Y$",
+            outdir / f"fig_h_matrix_cross_{tag}.png",
+            cross_only=True,
+            swap_mean=sw_mean, swap_std=sw_std,
+        )
+
+        swap_title = {
+            "dyadic":   r"Dyadic swap instability:  mean $|H_{AB} - H_{BA}|$",
+            "triadic":  r"Triadic ordering instability:  mean max-$|\Delta H|$",
+            "combined": r"Ordering instability:  mean max-$|\Delta H|$  (pooled)",
+        }[tag]
+        plot_swap(sw_mean, sw_std, MODELS, swap_title,
+                  outdir / f"fig_swap_stability_{tag}.png")
+
+        plot_self_pref(H_data, tag, label, outdir)
+
+    plot_elo(all_H_dy, outdir)
+
+    print(f"\nAll figures written to {outdir}")
+
+
+if __name__ == "__main__":
+    main()

analyses/style_geometry.py

@@ -0,0 +1,84 @@
+"""Model style directions (centroids), their pairwise comparison + stability,
+and their cosine distance to an 'engagingness' direction (linear engagement probe).
+Style space = agent-level TF-IDF -> SVD (K=30), axis 1 (language) dropped."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from numpy.linalg import lstsq, norm
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD
+RUNS=Path("runs")
+OUT=Path("out/style_geometry.md")
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+K=30; MODELS=["gpt-oss","Qwen","GLM-4","Mag","Gemma"]
+ag=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():continue
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:continue
+    if not amm:continue
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):continue
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();c.close()
+    except:continue
+    if len(coms)<200:continue
+    owner={p:u for p,u,_ in posts};ind=defaultdict(int)
+    for p,cu in coms:
+        o=owner.get(p)
+        if o in fam and o!=cu:ind[o]+=1
+    txt=defaultdict(list)
+    for p,u,cont in posts:
+        if u in fam and cont:txt[u].append(cont)
+    for u,tl in txt.items():
+        if tl:ag.append({"run":db.stem,"model":fam[u],"indeg":ind.get(u,0),"text":" ".join(tl)})
+n=len(ag);print(n,"agents")
+vc=TfidfVectorizer(ngram_range=(1,2),analyzer="word",min_df=10,max_features=20000,sublinear_tf=True,norm="l2",stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+X=vc.fit_transform([a["text"]for a in ag])
+S=TruncatedSVD(K,random_state=0).fit_transform(X)
+Z=((S-S.mean(0))/(S.std(0)+1e-9))[:,1:]   # drop axis 1 (language)
+model=np.array([a["model"]for a in ag]);runs=np.array([a["run"]for a in ag])
+y=np.zeros(n);bd=defaultdict(list)
+for i,a in enumerate(ag):bd[a["run"]].append(i)
+for r,idx in bd.items():
+    v=np.array([ag[i]["indeg"]for i in idx],float);z=(v-v.mean())/(v.std()+1e-9)
+    for k,i in enumerate(idx):y[i]=z[k]
+def u(x):return x/(norm(x)+1e-12)
+cos=lambda a,b:float(u(a)@u(b))
+cent={m:Z[model==m].mean(0) for m in MODELS}
+# engagingness direction = OLS engagement ~ style (linear probe)
+A=np.column_stack([np.ones(n),Z]);beta=lstsq(A,y,rcond=None)[0][1:];e=u(beta)
+o=["# Style geometry: model directions, stability, and the engagingness vector\n",
+   "Style space = agent TF-IDF -> SVD(30), axis 1 (language) dropped (29 dims).\n",
+   "## 1. Model directions (centroids) -- pairwise cosine",
+   "| | "+" | ".join(MODELS)+" |","|"+"---|"*(len(MODELS)+1)]
+for m in MODELS:o.append(f"| {m} | "+" | ".join(f"{cos(cent[m],cent[m2]):+.2f}" for m2 in MODELS)+" |")
+# ---- 2. stability via disjoint run-splits ----
+rng=np.random.default_rng(0);uruns=np.array(sorted(set(runs)));B=60
+selfc={m:[] for m in MODELS};e_self=[]
+for _ in range(B):
+    rng.shuffle(uruns);Aset=set(uruns[:len(uruns)//2]);am=np.array([r in Aset for r in runs])
+    for m in MODELS:
+        a1=(model==m)&am;b1=(model==m)&(~am)
+        if a1.sum()<10 or b1.sum()<10:continue
+        selfc[m].append(cos(Z[a1].mean(0),Z[b1].mean(0)))
+    # engagingness vector stability
+    bA=lstsq(np.column_stack([np.ones(am.sum()),Z[am]]),y[am],rcond=None)[0][1:]
+    bB=lstsq(np.column_stack([np.ones((~am).sum()),Z[~am]]),y[~am],rcond=None)[0][1:]
+    e_self.append(cos(bA,bB))
+o.append("\n## 2. Direction stability (cosine between centroids from disjoint run-halves, mean over 60 splits)")
+o.append("| model | self-cosine (1=perfectly stable) |");o.append("|---|---|")
+for m in MODELS:o.append(f"| {m} | {np.mean(selfc[m]):.2f} |")
+o.append(f"\nEngagingness vector self-cosine across run-halves: **{np.mean(e_self):.2f}** "
+         f"(stability of the engagement direction itself).")
+# ---- 3. distance from engagingness vector ----
+o.append("\n## 3. Cosine of each model direction to the engagingness vector (higher = style closer to 'what engages')")
+o.append("| model | cos(centroid, engagingness) |");o.append("|---|---|")
+ranked=sorted(MODELS,key=lambda m:cos(cent[m],e),reverse=True)
+for m in ranked:o.append(f"| {m} | {cos(cent[m],e):+.2f} |")
+o.append(f"\nClosest to the engagingness direction: **{ranked[0]}**. "
+         "If that is gpt-oss, the engaging style direction coincides with the attractor's style.")
+OUT.write_text("\n".join(o)+"\n");print("\n".join(o));print("wrote",OUT)

analyses/svd_axes.py

@@ -0,0 +1,48 @@
+"""Surface the agent-level TF-IDF -> SVD style axes: per-axis top +/- terms (from V^T)
+and explained-variance share. Matches the finding3 representation."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD
+RUNS=Path("runs")
+OUT=Path("out/svd_axes.md")
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+K=30
+docs=[];models=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():continue
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:continue
+    if not amm:continue
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):continue
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT user_id,content FROM post").fetchall();coms=c.execute("SELECT 1 FROM comment").fetchall();c.close()
+    except:continue
+    if len(coms)<200:continue
+    txt=defaultdict(list)
+    for u,cont in posts:
+        if u in fam and cont:txt[u].append(cont)
+    for u,tl in txt.items():
+        if tl:docs.append(" ".join(tl));models.append(fam[u])
+print(len(docs),"agent docs")
+vc=TfidfVectorizer(ngram_range=(1,2),analyzer="word",min_df=10,max_features=20000,sublinear_tf=True,norm="l2",stop_words="english",token_pattern=r"[A-Za-z'][A-Za-z']+")
+X=vc.fit_transform(docs);vocab=np.array(vc.get_feature_names_out())
+svd=TruncatedSVD(K,random_state=0);S=svd.fit_transform(X)
+V=svd.components_   # K x n_terms  (= V^T rows are axes)
+evr=svd.explained_variance_ratio_
+models=np.array(models)
+o=[f"# SVD style axes ({len(docs)} agent docs, {X.shape[1]} terms, K={K})\n",
+   f"Cumulative explained variance (top {K}): {evr.sum()*100:.1f}%\n",
+   "| axis | EV% | top +terms | top -terms | model loading (mean axis score, high->low) |","|---|---|---|---|---|"]
+for k in range(12):
+    w=V[k];pos=vocab[np.argsort(w)[::-1][:6]];neg=vocab[np.argsort(w)[:6]]
+    ml={m:S[models==m,k].mean() for m in ["gpt-oss","Qwen","GLM-4","Mag","Gemma"]}
+    order=sorted(ml,key=ml.get,reverse=True)
+    mls=", ".join(f"{m}{ml[m]:+.2f}" for m in order)
+    o.append(f"| {k+1} | {evr[k]*100:.1f} | {', '.join(pos)} | {', '.join(neg)} | {mls} |")
+OUT.write_text("\n".join(o)+"\n");print("\n".join(o));print("wrote",OUT)

analyses/swap_cpp.py

@@ -0,0 +1,79 @@
+"""Controlled gpt-oss -> Magistral swap: matched run-pairs in the same seed whose
+persona->model map is identical EXCEPT gpt-oss and Magistral are swapped. For the
+personas that flip, compare comments-per-post under gpt-oss vs under Magistral."""
+import sqlite3, json, re
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+RUNS=Path("runs");TET=RUNS/"tetratic"
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+def seed_of(name):
+    m=re.search(r"_s(\d+)",name) or re.search(r"_s(\d+)_r",name)
+    m=re.search(r"s(\d+)",name); return m.group(1) if m else None
+def load(db,tet=False):
+    base=db.stem
+    if tet and (TET/f"{base}_checkpoint.json").exists():return None
+    mp=str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists():return None
+    try:amm=json.load(open(mp)).get("agent_model_map",{})
+    except:return None
+    if not amm:return None
+    fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+    if any(v is None for v in fam.values()):return None
+    try:
+        c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());c.close()
+    except:return None
+    if len(coms)<100:return None
+    owner={p:u for p,u in posts};ind=defaultdict(int);npost=defaultdict(int)
+    for p,cu in coms:
+        o=owner.get(p)
+        if o in fam and o!=cu:ind[o]+=1
+    for p,u in posts:
+        if u in fam:npost[u]+=1
+    # per user_id: model, persona, cpp
+    rec={}
+    for u in fam:
+        if npost[u]>=2:rec[u]={"model":fam[u],"persona":users.get(u,f"u{u}"),"cpp":ind[u]/npost[u]}
+    return {"seed":re.search(r"s(\d+)",base).group(1),"name":base,"rec":rec}
+
+runs=[]
+for db in sorted(RUNS.glob("sweep_*.db")):
+    if any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+    r=load(db);
+    if r:runs.append(r)
+for db in sorted(TET.glob("tetra_s*_r*.db")):
+    r=load(db,tet=True)
+    if r:runs.append(r)
+print(len(runs),"runs loaded")
+byseed=defaultdict(list)
+for r in runs:byseed[r["seed"]].append(r)
+
+oss_vals=[];mag_vals=[];npairs=0;nflips=0
+for seed,rs in byseed.items():
+    for i in range(len(rs)):
+        for j in range(i+1,len(rs)):
+            A,B=rs[i]["rec"],rs[j]["rec"]
+            shared=set(A)&set(B)
+            if len(shared)<10:continue
+            # require same persona per shared slot, and model identical except oss<->mag
+            ok=True;flips=[]
+            for u in shared:
+                if A[u]["persona"]!=B[u]["persona"]:ok=False;break
+                ma,mb=A[u]["model"],B[u]["model"]
+                if ma==mb:continue
+                if {ma,mb}=={"gpt-oss","Mag"}:flips.append(u)
+                else:ok=False;break
+            if not ok or not flips:continue
+            npairs+=1
+            for u in flips:
+                oss=A[u] if A[u]["model"]=="gpt-oss" else B[u]
+                mag=A[u] if A[u]["model"]=="Mag" else B[u]
+                oss_vals.append(oss["cpp"]);mag_vals.append(mag["cpp"]);nflips+=1
+o=np.array(oss_vals);m=np.array(mag_vals)
+print(f"matched swap pairs: {npairs}; flipped persona-observations: {nflips}")
+print(f"mean CPP powered by gpt-oss: {o.mean():.2f}")
+print(f"mean CPP powered by Magistral: {m.mean():.2f}")
+print(f"drop: {100*(o.mean()-m.mean())/o.mean():.0f}% fewer CPP under Magistral")
+# paired (same persona,pair) drop
+d=(o-m)
+print(f"paired mean drop: {d.mean():.2f} CPP ({100*d.mean()/o.mean():.0f}%); median paired drop {np.median(d):.2f}")

analyses/temporal_dynamics.py

@@ -0,0 +1,245 @@
+"""
+H temporal dynamics analysis: decay, rotation stability, seed stability.
+
+Splits each simulation's comment history into quartiles by comment_id and
+computes directed-pair homophily H_{src->dst} per quartile. Aggregates across
+runs to characterize each model's temporal signature (stable attractor, transient
+attractor, delayed attractor, repeller), and measures rotation/seed stability
+of the temporal trajectories.
+
+Configuration:
+    RUNS_DIR — directory containing sweep_*.db files (env var or --runs-dir)
+
+Usage:
+    python temporal_dynamics.py                    # dyadic decay (all targets)
+    python temporal_dynamics.py --triadic          # triadic decay
+    python temporal_dynamics.py --target gpt-oss   # specific target only
+    python temporal_dynamics.py --runs-dir /path/to/runs
+"""
+
+import argparse
+import json
+import os
+import sqlite3
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+
+
+SHORT = {
+    'Qwen/Qwen3-32B':                 'Qwen',
+    'openai/gpt-oss-20b':             'gpt-oss',
+    'mistralai/Magistral-Small-2509': 'Mag',
+    'zai-org/GLM-4-32B-0414':         'GLM-4',
+    'google/gemma-4-31B-it':          'Gemma',
+}
+
+ALL_TARGETS = ['gpt-oss', 'Qwen', 'Mag', 'GLM-4', 'Gemma']
+
+
+def H_in_window(db_path: Path, cmin: int, cmax: int) -> dict | None:
+    """Compute H for comments with comment_id in [cmin, cmax)."""
+    meta = str(db_path).replace('.db', '.metadata.json')
+    if not Path(meta).exists():
+        return None
+    try:
+        amm = json.load(open(meta)).get('agent_model_map', {})
+        uf  = {int(k)+1: SHORT.get(v['model'], '?') for k, v in amm.items()}
+    except Exception:
+        return None
+    fc = defaultdict(int)
+    for fam in uf.values():
+        fc[fam] += 1
+    n = sum(fc.values())
+    conn = sqlite3.connect(db_path)
+    comments = conn.execute(
+        f'SELECT c.user_id, p.user_id FROM comment c JOIN post p ON c.post_id=p.post_id '
+        f'WHERE c.user_id!=p.user_id AND c.comment_id >= {cmin} AND c.comment_id < {cmax}'
+    ).fetchall()
+    conn.close()
+    ec    = defaultdict(int)
+    for cu, pu in comments:
+        sf, df = uf.get(cu), uf.get(pu)
+        if sf and df:
+            ec[(sf, df)] += 1
+    total = sum(ec.values())
+    if total < 5:
+        return None
+    H = {}
+    for s in fc:
+        for d in fc:
+            exp = (fc[s]/n) * ((fc[d] - (1 if s == d else 0)) / (n-1))
+            if exp > 0:
+                H[(s, d)] = ec.get((s, d), 0) / total / exp - 1
+    return H
+
+
+def trajectory(db_path: Path, target: str, n_bins: int = 4) -> list | None:
+    """Return list of incoming-to-target mean H per quartile."""
+    conn   = sqlite3.connect(db_path)
+    max_id = conn.execute('SELECT MAX(comment_id) FROM comment').fetchone()[0]
+    conn.close()
+    if max_id is None or max_id < 40:
+        return None
+    bs   = max_id // n_bins
+    traj = []
+    for i in range(n_bins):
+        lo = i*bs + 1
+        hi = (i+1)*bs + 1 if i < n_bins-1 else max_id + 1
+        H  = H_in_window(db_path, lo, hi)
+        if H is None:
+            traj.append(None)
+            continue
+        inc = [v for (s, d), v in H.items() if d == target and s != target]
+        traj.append(np.mean(inc) if inc else None)
+    return traj
+
+
+def discover_dyadic_runs(runs_dir: Path, target: str | None = None) -> list:
+    """Return list of (db_path, group_A_model, partner, seed) for dyadic runs."""
+    out = []
+    for db in runs_dir.glob('sweep_*.db'):
+        if 'tri_' in db.name or 'pilot_' in db.name:
+            continue
+        meta = str(db).replace('.db', '.metadata.json')
+        if not Path(meta).exists():
+            continue
+        try:
+            amm      = json.load(open(meta)).get('agent_model_map', {})
+            uid_model = {int(k): SHORT.get(v['model']) for k, v in amm.items()}
+        except Exception:
+            continue
+        if any(v is None for v in uid_model.values()):
+            continue
+        fams = set(uid_model.values())
+        if len(fams) != 2:
+            continue
+        if target and target not in fams:
+            continue
+        group_A = uid_model.get(0)
+        seed    = next((s for s in [42, 137, 271, 314, 999] if f'_s{s}.' in db.name), None)
+        if seed is None:
+            continue
+        partner = (fams - {group_A}).pop()
+        out.append((str(db), group_A, partner, seed))
+    return out
+
+
+def discover_triadic_runs(runs_dir: Path, target: str | None = None) -> list:
+    """Return list of (db_path, group_A_model, triplet_tuple, seed) for triadic runs."""
+    out = []
+    for db in runs_dir.glob('sweep_tri_*.db'):
+        meta = str(db).replace('.db', '.metadata.json')
+        if not Path(meta).exists():
+            continue
+        try:
+            amm       = json.load(open(meta)).get('agent_model_map', {})
+            uid_model = {int(k): SHORT.get(v['model']) for k, v in amm.items()}
+        except Exception:
+            continue
+        if any(v is None for v in uid_model.values()):
+            continue
+        fams = sorted(set(uid_model.values()))
+        if len(fams) != 3:
+            continue
+        if target and target not in fams:
+            continue
+        group_A = uid_model.get(0)
+        seed    = next((s for s in [42, 271, 999] if f'_s{s}.' in db.name), None)
+        if seed is None:
+            continue
+        out.append((str(db), group_A, tuple(fams), seed))
+    return out
+
+
+def dyadic_stability_report(runs_dir: Path, target: str):
+    """Per-pair Q0..Q3 trajectory + rotation + seed stability for a target family."""
+    runs = discover_dyadic_runs(runs_dir, target=target)
+    by_pair_ord = defaultdict(lambda: defaultdict(list))
+    for db, group_A, partner, seed in runs:
+        traj = trajectory(Path(db), target)
+        if traj is None or any(v is None for v in traj):
+            continue
+        ordering = 'target_A' if group_A == target else 'partner_A'
+        by_pair_ord[partner][ordering].append((seed, traj))
+
+    print(f"\n{'='*78}")
+    print(f"DYADIC stability for incoming-to-{target}")
+    print(f"{'='*78}")
+    for partner in sorted(by_pair_ord):
+        print(f"\n  {target} x {partner}")
+        order_means = {}
+        for ord_name, lst in by_pair_ord[partner].items():
+            if not lst:
+                continue
+            trajs = np.array([t for _, t in lst])
+            order_means[ord_name] = trajs.mean(axis=0)
+            print(f"    [{ord_name}] n={len(trajs)} seeds | "
+                  f"Q0..Q3: {' '.join(f'{v:+.2f}' for v in trajs.mean(axis=0))} | "
+                  f"seed-SD: {' '.join(f'{s:.2f}' for s in trajs.std(axis=0))}")
+        if len(order_means) == 2:
+            keys    = list(order_means.keys())
+            spreads = [abs(order_means[keys[0]][q] - order_means[keys[1]][q]) for q in range(4)]
+            print(f"    rotation spread per Q: {' '.join(f'{s:.2f}' for s in spreads)}  "
+                  f"max={max(spreads):.2f}")
+
+
+def triadic_stability_report(runs_dir: Path, target: str):
+    """Per-triplet Q0..Q3 trajectory + rotation + seed stability for a target family."""
+    runs = discover_triadic_runs(runs_dir, target=target)
+    by_trip_ord = defaultdict(lambda: defaultdict(list))
+    for db, group_A, trip, seed in runs:
+        if target not in trip:
+            continue
+        traj = trajectory(Path(db), target)
+        if traj is None or any(v is None for v in traj):
+            continue
+        by_trip_ord[trip][group_A].append((seed, traj))
+
+    print(f"\n{'='*78}")
+    print(f"TRIADIC stability for incoming-to-{target}")
+    print(f"{'='*78}")
+    for trip in sorted(by_trip_ord):
+        if sum(len(v) for v in by_trip_ord[trip].values()) < 3:
+            continue
+        print(f"\n  Triplet: {' + '.join(trip)}")
+        per_ord_mean = {}
+        for grpA, lst in by_trip_ord[trip].items():
+            if not lst:
+                continue
+            trajs = np.array([t for _, t in lst])
+            per_ord_mean[grpA] = trajs.mean(axis=0)
+            print(f"    [group-A={grpA}] n={len(trajs)} seeds | "
+                  f"Q0..Q3: {' '.join(f'{v:+.2f}' for v in trajs.mean(axis=0))} | "
+                  f"seed-SD: {' '.join(f'{s:.2f}' for s in trajs.std(axis=0))}")
+        if len(per_ord_mean) >= 2:
+            spreads = [max(t[q] for t in per_ord_mean.values()) -
+                       min(t[q] for t in per_ord_mean.values())
+                       for q in range(4)]
+            print(f"    rotation spread per Q: {' '.join(f'{s:.2f}' for s in spreads)}  "
+                  f"max={max(spreads):.2f}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--runs-dir', default=os.environ.get("RUNS_DIR", "./runs"),
+                        help="Directory containing sweep_*.db files.")
+    parser.add_argument('--triadic',  action='store_true',
+                        help="Run triadic stability report instead of dyadic.")
+    parser.add_argument('--target',   default=None,
+                        help="Restrict to one model family (e.g. gpt-oss). Default: all.")
+    args = parser.parse_args()
+
+    runs_dir = Path(args.runs_dir)
+    targets  = [args.target] if args.target else ALL_TARGETS
+
+    for t in targets:
+        if args.triadic:
+            triadic_stability_report(runs_dir, t)
+        else:
+            dyadic_stability_report(runs_dir, t)
+
+
+if __name__ == '__main__':
+    main()

analyses/tetradic_recompute_H.py

@@ -0,0 +1,49 @@
+"""Recompute four-way H stats over all COMPLETE tetratic runs (no checkpoint file).
+Persistent: re-run anytime. Prints per-model incoming H + per-seed H->gpt-oss + counts."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+HERE = Path(__file__).parent
+SHORT = {"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss",
+         "mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4"}
+perH = defaultdict(list); byseed = defaultdict(list); runs = []
+for db in sorted(HERE.glob("tetra_s*_r*.db")):
+    base = db.stem
+    if (HERE / f"{base}_checkpoint.json").exists():
+        continue  # incomplete
+    mp = str(db).replace(".db", ".metadata.json")
+    if not Path(mp).exists():
+        continue
+    seed = base.split("_")[1]
+    fam = {int(k)+1: SHORT.get(v["model"]) for k, v in json.load(open(mp))["agent_model_map"].items()}
+    try:
+        c = sqlite3.connect(db)
+        posts = c.execute("SELECT post_id,user_id FROM post").fetchall()
+        coms = c.execute("SELECT post_id,user_id FROM comment").fetchall(); c.close()
+    except Exception:
+        continue
+    owner = {p: u for p, u in posts}; F = sorted(set(fam.values()))
+    nf = {f: sum(1 for v in fam.values() if v == f) for f in F}; ntot = sum(nf.values())
+    edges = [(fam[cu], fam[owner[p]]) for p, cu in coms
+             if owner.get(p) and owner[p] != cu and cu in fam and owner[p] in fam]
+    tot = len(edges)
+    if tot < 100:
+        continue
+    obs = defaultdict(int)
+    for x, y in edges: obs[(x, y)] += 1
+    runs.append(base)
+    for Y in F:
+        h = np.mean([obs.get((X, Y), 0)/tot/((nf[X]/ntot)*((nf[Y])/(ntot-1)))-1 for X in F if X != Y])
+        perH[Y].append(h)
+        if Y == "gpt-oss": byseed[seed].append(h)
+
+print(f"=== tetratic H over {len(runs)} complete four-way runs ===")
+print(f"runs: {sorted(runs)}")
+print(f"{'model':8s} {'meanH':>7} {'sd':>6} {'min':>7} {'max':>7}  n")
+for m in ["gpt-oss", "Qwen", "GLM-4", "Mag"]:
+    v = np.array(perH[m]) if perH[m] else np.array([np.nan])
+    print(f"{m:8s} {v.mean():+7.2f} {v.std():6.2f} {v.min():+7.2f} {v.max():+7.2f}  {len(perH[m])}")
+print("H->gpt-oss by seed:")
+for s in sorted(byseed):
+    v = byseed[s]; print(f"  seed {s:5s}: {np.mean(v):+.2f}  (n={len(v)})")

analyses/tetradic_results.py

@@ -0,0 +1,137 @@
+"""Tetradic (four-way) results: pooled 4x4 H heatmap + descriptive stats + variance decomposition.
+Over all COMPLETE tetradic runs (no checkpoint file). Persistent; re-run as more land.
+Outputs:
+  - figures/fig_h_tetradic.png  (heatmap, style matched to plot_matrices.py)
+  - _paper/analyses/tetradic_results.md  (numbers to hand to DR)
+"""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+import matplotlib; matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.font_manager import FontProperties, fontManager
+
+HERE = Path(__file__).parent
+FIGDIR = Path(".")
+OUTMD = Path("out/tetradic_results.md")
+SHORT = {"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss",
+         "mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4"}
+MODELS = ["GLM-4","Mag","Qwen","gpt-oss"]
+try:
+    for ttf in (Path.home()/"fonts").rglob("*.ttf"): fontManager.addfont(str(ttf))
+    FAM = "Ubuntu Mono"
+except Exception:
+    FAM = "monospace"
+
+perH = defaultdict(list)          # incoming H per target across runs
+matruns = []                      # list of 4x4 H matrices
+lead = last = 0; rho = []; nrun = 0
+agents = []                       # for variance decomposition
+
+for db in sorted(HERE.glob("tetra_s*_r*.db")):
+    base = db.stem
+    if (HERE/f"{base}_checkpoint.json").exists(): continue
+    mp = str(db).replace(".db",".metadata.json")
+    if not Path(mp).exists(): continue
+    fam = {int(k)+1: SHORT.get(v["model"]) for k,v in json.load(open(mp))["agent_model_map"].items()}
+    if any(v is None for v in fam.values()): continue
+    try:
+        c = sqlite3.connect(db)
+        posts = c.execute("SELECT post_id,user_id FROM post").fetchall()
+        coms  = c.execute("SELECT post_id,user_id FROM comment").fetchall()
+        users = dict(c.execute("SELECT user_id,user_name FROM user").fetchall()); c.close()
+    except Exception: continue
+    owner = {p:u for p,u in posts}; F = sorted(set(fam.values()))
+    nf = {f: sum(1 for v in fam.values() if v==f) for f in F}; ntot = sum(nf.values())
+    edges = [(fam[cu], fam[owner[p]]) for p,cu in coms
+             if owner.get(p) and owner[p]!=cu and cu in fam and owner[p] in fam]
+    tot = len(edges)
+    if tot < 100: continue
+    nrun += 1
+    obs = defaultdict(int)
+    for x,y in edges: obs[(x,y)] += 1
+    # 4x4 matrix (rows=source/commenter, cols=target/author)
+    Mx = np.full((4,4), np.nan)
+    for i,X in enumerate(MODELS):
+        for j,Y in enumerate(MODELS):
+            exp = (nf[X]/ntot)*((nf[Y]-(1 if X==Y else 0))/(ntot-1))
+            if exp>0: Mx[i,j] = obs.get((X,Y),0)/tot/exp - 1
+    matruns.append(Mx)
+    # incoming H per target (mean over X!=Y)
+    for Y in MODELS:
+        perH[Y].append(np.nanmean([Mx[i,MODELS.index(Y)] for i,X in enumerate(MODELS) if X!=Y]))
+    # in-degree per agent + lead/last + rho
+    ind = defaultdict(int)
+    for p,cu in coms:
+        o = owner.get(p)
+        if o in fam and o!=cu: ind[o]+=1
+    fam_in = defaultdict(list)
+    for u,f in fam.items(): fam_in[f].append(ind.get(u,0))
+    mean_in = {f: np.mean(v) for f,v in fam_in.items()}
+    if max(mean_in, key=mean_in.get)=="gpt-oss": lead+=1
+    if min(mean_in, key=mean_in.get)=="Mag": last+=1
+    tot_in = sum(sum(v) for v in fam_in.values())
+    share = sum(fam_in["gpt-oss"])/tot_in if tot_in else 0
+    rho.append(share/(nf["gpt-oss"]/ntot))
+    for u,f in fam.items():
+        agents.append({"run":base,"model":f,"persona":users.get(u,f"u{u}"),"indeg":ind.get(u,0)})
+
+# ---- pooled matrix + heatmap ----
+Mpool = np.nanmean(np.stack(matruns), axis=0)
+fig, ax = plt.subplots(figsize=(4.2,3.6))
+vmax = np.nanmax(np.abs(Mpool))
+im = ax.imshow(Mpool, cmap="RdBu_r", vmin=-vmax, vmax=vmax)
+ax.set_xticks(range(4)); ax.set_yticks(range(4))
+ax.set_xticklabels(MODELS, fontproperties=FontProperties(family=FAM,size=9), rotation=30, ha="right")
+ax.set_yticklabels(MODELS, fontproperties=FontProperties(family=FAM,size=9))
+ax.set_xlabel("post author (target)", fontproperties=FontProperties(family=FAM,size=9))
+ax.set_ylabel("commenter (source)", fontproperties=FontProperties(family=FAM,size=9))
+for i in range(4):
+    for j in range(4):
+        v = Mpool[i,j]
+        ax.text(j,i,f"{v:+.2f}",ha="center",va="center",
+                fontproperties=FontProperties(family=FAM,size=8),
+                color="white" if abs(v)>0.55*vmax else "black")
+cb = fig.colorbar(im, fraction=0.046, pad=0.04); cb.ax.tick_params(labelsize=7)
+ax.set_title(f"Four-way $H_{{X\\to Y}}$ (pooled, n={nrun} runs)",
+             fontproperties=FontProperties(family=FAM,size=10))
+fig.tight_layout(); fig.savefig(FIGDIR/"fig_h_tetradic.png", dpi=300, bbox_inches="tight")
+print("wrote", FIGDIR/"fig_h_tetradic.png")
+
+# ---- variance decomposition (in-sample R^2, matches tab:ols_decomp convention) ----
+y = np.array([a["indeg"] for a in agents], float)
+def dummies(keys):
+    levels = sorted(set(keys)); idx = {l:i for i,l in enumerate(levels)}
+    D = np.zeros((len(keys), len(levels)))
+    for r,k in enumerate(keys): D[r, idx[k]] = 1
+    return D[:,1:]  # drop one for intercept
+def r2(*blocks):
+    blocks = [b for b in blocks if b is not None and b.shape[1]>0]
+    X = np.column_stack([np.ones(len(y))] + blocks) if blocks else np.ones((len(y),1))
+    b,*_ = np.linalg.lstsq(X, y, rcond=None); pred = X@b
+    return 1 - ((y-pred)**2).sum()/((y-y.mean())**2).sum()
+P = dummies([a["persona"] for a in agents])
+Mod = dummies([a["model"] for a in agents])
+R = dummies([a["run"] for a in agents])
+ossind = np.array([[1.0 if a["model"]=="gpt-oss" else 0.0] for a in agents])
+vd = {"persona_only":r2(P), "model_only":r2(Mod), "oss_only":r2(ossind),
+      "run_only":r2(R), "persona+model":r2(P,Mod), "persona+run":r2(P,R), "full":r2(P,Mod,R)}
+dmodel = vd["full"] - vd["persona+run"]
+
+# ---- write md ----
+o = [f"# Tetradic (four-way) results — {nrun} complete runs\n",
+     "## Incoming H per model (mean over commenter families, across runs)\n",
+     "| model | mean H | SD | min | max |", "|---|---:|---:|---:|---:|"]
+for m in ["gpt-oss","Qwen","GLM-4","Mag"]:
+    v = np.array(perH[m]); o.append(f"| {m} | {v.mean():+.2f} | {v.std():.2f} | {v.min():+.2f} | {v.max():+.2f} |")
+o += [f"\n- gpt-oss is the **most-commented family in {lead}/{nrun} runs** ({100*lead/nrun:.0f}%).",
+      f"- Magistral is the **least-commented in {last}/{nrun} runs** ({100*last/nrun:.0f}%).",
+      f"- gpt-oss over-representation rho = comment-share / fair-share: **mean {np.mean(rho):.2f}, median {np.median(rho):.2f}**.",
+      "\n## Variance decomposition (per-agent raw in-degree, in-sample R^2)\n",
+      "| block | R^2 |", "|---|---:|"]
+for k in ["persona_only","model_only","oss_only","run_only","persona+model","persona+run","full"]:
+    o.append(f"| {k.replace('_',' ')} | {vd[k]:.3f} |")
+o.append(f"| **Delta R^2 model** (full - persona+run) | **{dmodel:+.3f}** |")
+o.append(f"\nn agents = {len(agents)}. Compare dyad Delta R^2_model +.044, triad +.071.")
+OUTMD.write_text("\n".join(o)+"\n"); print("\n".join(o)); print("wrote", OUTMD)

analyses/variance_cpp.py

@@ -0,0 +1,98 @@
+"""Finding 2 redone on comments-per-post (CPP = in-degree/n_posts).
+Decomposition (dy/tri/tet), LOMO (dy/tri), totals + absolute components,
+and length-residualized per-model attractiveness for ALL models."""
+import sqlite3, json
+from collections import defaultdict
+from pathlib import Path
+import numpy as np
+RUNS=Path("runs");TET=RUNS/"tetratic"
+SHORT={"Qwen/Qwen3-32B":"Qwen","openai/gpt-oss-20b":"gpt-oss","mistralai/Magistral-Small-2509":"Mag","zai-org/GLM-4-32B-0414":"GLM-4","google/gemma-4-31B-it":"Gemma"}
+def load(globpat,tet=False):
+    out=[]
+    for db in sorted(globpat):
+        if not tet and any(x in db.name for x in ["archive","olm","hermes","glm47","pilot_","snapshot","qwq"]):continue
+        if tet and (TET/f"{db.stem}_checkpoint.json").exists():continue
+        mp=str(db).replace(".db",".metadata.json")
+        if not Path(mp).exists():continue
+        try:amm=json.load(open(mp)).get("agent_model_map",{})
+        except:continue
+        if not amm:continue
+        # OFF-BY-ONE FIX: DBs are 0-indexed (user_id and agent_model_map keys both start at MIN);
+        # original "+1" dropped agent 0 and mislabeled the first agent of each model-block.
+        # fam={int(k)+1:SHORT.get(v["model"]) for k,v in amm.items()}
+        umin=min(int(k) for k in amm)
+        fam={int(k)+umin:SHORT.get(v["model"]) for k,v in amm.items()}
+        if any(v is None for v in fam.values()):continue
+        try:
+            c=sqlite3.connect(db);posts=c.execute("SELECT post_id,user_id,content FROM post").fetchall();coms=c.execute("SELECT post_id,user_id FROM comment").fetchall();users=dict(c.execute("SELECT user_id,user_name FROM user").fetchall());c.close()
+        except:continue
+        if len(coms)<(100 if tet else 200):continue
+        owner={p:u for p,u,_ in posts};ind=defaultdict(int);npost=defaultdict(int);nw=defaultdict(int)
+        for p,cu in coms:
+            o=owner.get(p)
+            if o in fam and o!=cu:ind[o]+=1
+        for p,u,cont in posts:
+            if u in fam and cont:npost[u]+=1;nw[u]+=len(cont.split())
+        F=sorted(set(fam.values()));reg={2:"dyad",3:"tri",4:"tet"}.get(len(F))
+        for u in fam:
+            if npost[u]>=2:
+                out.append({"run":db.stem,"model":fam[u],"persona":users.get(u,f"u{u}"),"cpp":ind[u]/npost[u],
+                            "meanlen":nw[u]/npost[u],"net":F})
+    return out
+rows=load(RUNS.glob("sweep_*.db"))+load(TET.glob("tetra_s*_r*.db"),tet=True)
+def dum(keys):
+    lv=sorted(set(map(str,keys)));idx={l:i for i,l in enumerate(lv)};D=np.zeros((len(keys),len(lv)))
+    for r,k in enumerate(keys):D[r,idx[str(k)]]=1
+    return D[:,1:]
+def r2(y,*B):
+    B=[b for b in B if b is not None and b.shape[1]>0];X=np.column_stack([np.ones(len(y))]+B) if B else np.ones((len(y),1))
+    b,*_=np.linalg.lstsq(X,y,rcond=None);p=X@b;return 1-((y-p)**2).sum()/((y-y.mean())**2).sum()
+def partner(r):return frozenset(m for m in r["net"] if m!=r["model"])
+print("=== Finding 2 on CPP: decomposition ===")
+print(f"{'block':14s} {'dy':>7} {'tri':>7} {'tet':>7}")
+def col(fn):
+    return [fn([r for r in rows if {'dyad':'dyad','tri':'tri','tet':'tet'}[r_reg:=({2:'dyad',3:'tri',4:'tet'}[len(r['net'])])]==m]) for m in ['dyad','tri','tet']]
+def sub(mode):return [r for r in rows if {2:'dyad',3:'tri',4:'tet'}[len(r['net'])]==mode]
+def line(lab,fn):
+    print(f"{lab:14s} "+" ".join(f"{fn(sub(m)):7.3f}" for m in ['dyad','tri','tet']))
+P=lambda s:dum([r['persona']for r in s]);M=lambda s:dum([r['model']for r in s])
+R=lambda s:dum([r['run']for r in s]);O=lambda s:np.array([[1.0 if r['model']=='gpt-oss' else 0]for r in s])
+SEL=lambda s:np.column_stack([M(s),dum([partner(r)for r in s])])
+Y=lambda s:np.array([r['cpp']for r in s])
+line("persona",lambda s:r2(Y(s),P(s)))
+line("model(own)",lambda s:r2(Y(s),M(s)))
+line("model-selection",lambda s:r2(Y(s),SEL(s)))
+line("gpt-oss ind",lambda s:r2(Y(s),O(s)))
+line("run",lambda s:r2(Y(s),R(s)))
+line("persona+model",lambda s:r2(Y(s),P(s),M(s)))
+line("persona+run",lambda s:r2(Y(s),P(s),R(s)))
+line("full",lambda s:r2(Y(s),P(s),M(s),R(s)))
+line("dR2_model",lambda s:r2(Y(s),P(s),M(s),R(s))-r2(Y(s),P(s),R(s)))
+print("\ntotal CPP variance + absolute components (R^2 x total):")
+for m in ['dyad','tri','tet']:
+    s=sub(m);y=Y(s);tot=y.var()
+    print(f"  {m}: n={len(s)} totalvar={tot:.3f}  persona={r2(y,P(s))*tot:.3f}  model-sel={r2(y,SEL(s))*tot:.3f}  oss-ind={r2(y,O(s))*tot:.3f}")
+print("\n=== LOMO on CPP (dy/tri): persona / own / selection ===")
+for excl in ["baseline","Qwen","gpt-oss","Mag","GLM-4","Gemma"]:
+    for m in ['dyad','tri']:
+        s=[r for r in sub(m) if excl=="baseline" or excl not in r['net']]
+        if len(s)<50:continue
+        y=Y(s);print(f"  {excl:8s} {m:5s} n={len(s):4d} persona={r2(y,P(s))*100:5.1f}% own={r2(y,M(s))*100:5.1f}% sel={r2(y,SEL(s))*100:5.1f}%")
+print("\n=== length-residualized CPP attractiveness, ALL models, by regime ===")
+def wz(s,key):
+    o={};bd=defaultdict(list)
+    for r in s:bd[r['run']].append(r)
+    arr={}
+    vals=np.array([r[key]for r in s]);run=[r['run']for r in s]
+    z=np.zeros(len(s))
+    for rr in set(run):
+        idx=[i for i,x in enumerate(run) if x==rr];v=vals[idx];m=v.mean();sd=v.std() or 1
+        for i in idx:z[i]=(vals[i]-m)/sd
+    return z
+for m in ['dyad','tri','tet']:
+    s=sub(m);cz=wz(s,'cpp');lz=wz(s,'meanlen');b=np.polyfit(lz,cz,1)[0];res=cz-b*lz
+    md=np.array([r['model']for r in s])
+    print(f"  {m} (length slope {b:+.2f}):")
+    for mod in ["gpt-oss","Qwen","GLM-4","Mag","Gemma"]:
+        mm=md==mod
+        if mm.sum():print(f"     {mod:8s} raw {cz[mm].mean():+.2f}  len-adj {res[mm].mean():+.2f}")

data/MANIFEST.md

@@ -0,0 +1,251 @@
+# Data Manifest — divsim paper runs
+
+Reference data for all valid dyadic, triadic, and four-way runs used in the paper.
+DBs live under `$RUNS_DIR` (dyadic/triadic as `sweep_*.db`; four-way under `$RUNS_DIR/tetradic/`).
+They are **not** included in this bundle due to size (~200 GB total).
+
+**Validity criteria:**
+- Dyadic: ≥ 18 distinct commenter agents, ≥ 200 total comments
+- Triadic: ≥ 26 distinct commenter agents, ≥ 200 total comments
+- Four-way: 40 agents (10 per model), ≥ 200 comments, all four of {gpt-oss, Qwen, Magistral, GLM-4} present
+
+**Run counts (current):** 100 dyadic + 89 triadic (five-model pool) + 24 four-way = 213 valid runs.
+
+**Engagement metric:** the variance decomposition and content->engagement analyses use **comments per post**
+(CPP = in-degree / number of posts), which removes the posting-volume exposure confound that inflates raw
+in-degree. Analysis scripts use whichever runs are present under `$RUNS_DIR`.
+
+---
+
+## Dyadic runs
+**Total valid runs: 100**
+
+| Filename | Pair | Seed | n_comments | n_agents | size_bytes | mtime |
+|----------|------|------|-----------|---------|------------|-------|
+| `sweep_gem_gem_glm_s137.db` | GLM-4 × Gemma | 137 | 545 | 20 | 59256832 | 1779256940 |
+| `sweep_gem_gem_glm_s271.db` | GLM-4 × Gemma | 271 | 564 | 20 | 67678208 | 1779259415 |
+| `sweep_gem_gem_glm_s314.db` | GLM-4 × Gemma | 314 | 556 | 20 | 62390272 | 1779262424 |
+| `sweep_gem_gem_glm_s42.db` | GLM-4 × Gemma | 42 | 561 | 20 | 65548288 | 1779253891 |
+| `sweep_gem_gem_glm_s999.db` | GLM-4 × Gemma | 999 | 561 | 20 | 57278464 | 1779262942 |
+| `sweep_gem_gem_mag_s137.db` | Gemma × Mag | 137 | 563 | 20 | 66887680 | 1779237487 |
+| `sweep_gem_gem_mag_s271.db` | Gemma × Mag | 271 | 573 | 20 | 69795840 | 1779237563 |
+| `sweep_gem_gem_mag_s314.db` | Gemma × Mag | 314 | 573 | 20 | 72994816 | 1779240779 |
+| `sweep_gem_gem_mag_s42.db` | Gemma × Mag | 42 | 202 | 20 | 20865024 | 1779233607 |
+| `sweep_gem_gem_mag_s999.db` | Gemma × Mag | 999 | 568 | 20 | 70995968 | 1779241344 |
+| `sweep_gem_gem_oss_s137.db` | Gemma × gpt-oss | 137 | 558 | 20 | 81575936 | 1779289803 |
+| `sweep_gem_gem_oss_s271.db` | Gemma × gpt-oss | 271 | 560 | 20 | 87035904 | 1779292575 |
+| `sweep_gem_gem_oss_s314.db` | Gemma × gpt-oss | 314 | 565 | 20 | 84631552 | 1779292556 |
+| `sweep_gem_gem_oss_s42.db` | Gemma × gpt-oss | 42 | 561 | 20 | 91570176 | 1779289808 |
+| `sweep_gem_gem_oss_s999.db` | Gemma × gpt-oss | 999 | 550 | 20 | 77602816 | 1779296057 |
+| `sweep_gem_gem_qwe_s137.db` | Gemma × Qwen | 137 | 536 | 20 | 56975360 | 1779238651 |
+| `sweep_gem_gem_qwe_s271.db` | Gemma × Qwen | 271 | 566 | 20 | 60739584 | 1779242852 |
+| `sweep_gem_gem_qwe_s314.db` | Gemma × Qwen | 314 | 554 | 20 | 58511360 | 1779244264 |
+| `sweep_gem_gem_qwe_s42.db` | Gemma × Qwen | 42 | 568 | 20 | 61599744 | 1779238533 |
+| `sweep_gem_gem_qwe_s999.db` | Gemma × Qwen | 999 | 560 | 20 | 63430656 | 1779247673 |
+| `sweep_gem_glm_gem_s137.db` | GLM-4 × Gemma | 137 | 554 | 20 | 71245824 | 1779265322 |
+| `sweep_gem_glm_gem_s271.db` | GLM-4 × Gemma | 271 | 560 | 20 | 66015232 | 1779267644 |
+| `sweep_gem_glm_gem_s314.db` | GLM-4 × Gemma | 314 | 569 | 20 | 65216512 | 1779269154 |
+| `sweep_gem_glm_gem_s42.db` | GLM-4 × Gemma | 42 | 568 | 20 | 64397312 | 1779264496 |
+| `sweep_gem_glm_gem_s999.db` | GLM-4 × Gemma | 999 | 570 | 20 | 70668288 | 1779270025 |
+| `sweep_gem_mag_gem_s137.db` | Gemma × Mag | 137 | 576 | 20 | 67174400 | 1779244801 |
+| `sweep_gem_mag_gem_s271.db` | Gemma × Mag | 271 | 557 | 20 | 64151552 | 1779248268 |
+| `sweep_gem_mag_gem_s314.db` | Gemma × Mag | 314 | 569 | 20 | 70443008 | 1779248674 |
+| `sweep_gem_mag_gem_s42.db` | Gemma × Mag | 42 | 576 | 20 | 71020544 | 1779244365 |
+| `sweep_gem_mag_gem_s999.db` | Gemma × Mag | 999 | 571 | 20 | 68837376 | 1779252081 |
+| `sweep_gem_oss_gem_s137.db` | Gemma × gpt-oss | 137 | 550 | 20 | 72888320 | 1779702718 |
+| `sweep_gem_oss_gem_s271.db` | Gemma × gpt-oss | 271 | 538 | 20 | 75186176 | 1779703920 |
+| `sweep_gem_oss_gem_s314.db` | Gemma × gpt-oss | 314 | 570 | 20 | 86704128 | 1779702754 |
+| `sweep_gem_oss_gem_s42.db` | Gemma × gpt-oss | 42 | 564 | 20 | 92504064 | 1779296113 |
+| `sweep_gem_oss_gem_s999.db` | Gemma × gpt-oss | 999 | 563 | 20 | 76296192 | 1779702748 |
+| `sweep_gem_qwe_gem_s137.db` | Gemma × Qwen | 137 | 562 | 20 | 60616704 | 1779252242 |
+| `sweep_gem_qwe_gem_s271.db` | Gemma × Qwen | 271 | 555 | 20 | 54685696 | 1779252843 |
+| `sweep_gem_qwe_gem_s314.db` | Gemma × Qwen | 314 | 569 | 20 | 62332928 | 1779257273 |
+| `sweep_gem_qwe_gem_s42.db` | Gemma × Qwen | 42 | 568 | 20 | 63574016 | 1779248639 |
+| `sweep_gem_qwe_gem_s999.db` | Gemma × Qwen | 999 | 562 | 20 | 60620800 | 1779257045 |
+| `sweep_glm_mag_AB_s137.db` | GLM-4 × Mag | 137 | 568 | 20 | 66908160 | 1779153376 |
+| `sweep_glm_mag_AB_s271.db` | GLM-4 × Mag | 271 | 576 | 20 | 69083136 | 1779153711 |
+| `sweep_glm_mag_AB_s314.db` | GLM-4 × Mag | 314 | 561 | 20 | 70963200 | 1779152748 |
+| `sweep_glm_mag_AB_s42.db` | GLM-4 × Mag | 42 | 569 | 20 | 70332416 | 1779151835 |
+| `sweep_glm_mag_AB_s999.db` | GLM-4 × Mag | 999 | 575 | 20 | 64864256 | 1779153345 |
+| `sweep_glm_mag_BA_s137.db` | GLM-4 × Mag | 137 | 566 | 20 | 66088960 | 1779153390 |
+| `sweep_glm_mag_BA_s271.db` | GLM-4 × Mag | 271 | 564 | 20 | 65060864 | 1779153084 |
+| `sweep_glm_mag_BA_s314.db` | GLM-4 × Mag | 314 | 569 | 20 | 64892928 | 1779153443 |
+| `sweep_glm_mag_BA_s42.db` | GLM-4 × Mag | 42 | 560 | 20 | 62205952 | 1779151252 |
+| `sweep_glm_mag_BA_s999.db` | GLM-4 × Mag | 999 | 576 | 20 | 64098304 | 1779152861 |
+| `sweep_glm_oss_AB_s137.db` | GLM-4 × gpt-oss | 137 | 538 | 20 | 68145152 | 1779125984 |
+| `sweep_glm_oss_AB_s271.db` | GLM-4 × gpt-oss | 271 | 528 | 20 | 65155072 | 1779131809 |
+| `sweep_glm_oss_AB_s314.db` | GLM-4 × gpt-oss | 314 | 499 | 20 | 58146816 | 1779132567 |
+| `sweep_glm_oss_AB_s42.db` | GLM-4 × gpt-oss | 42 | 518 | 20 | 72134656 | 1779121310 |
+| `sweep_glm_oss_AB_s999.db` | GLM-4 × gpt-oss | 999 | 532 | 20 | 60399616 | 1779141456 |
+| `sweep_glm_oss_BA_s137.db` | GLM-4 × gpt-oss | 137 | 488 | 20 | 57929728 | 1779125732 |
+| `sweep_glm_oss_BA_s271.db` | GLM-4 × gpt-oss | 271 | 542 | 20 | 71491584 | 1779130457 |
+| `sweep_glm_oss_BA_s314.db` | GLM-4 × gpt-oss | 314 | 523 | 20 | 60743680 | 1779136288 |
+| `sweep_glm_oss_BA_s42.db` | GLM-4 × gpt-oss | 42 | 521 | 20 | 65347584 | 1779120938 |
+| `sweep_glm_oss_BA_s999.db` | GLM-4 × gpt-oss | 999 | 516 | 20 | 57565184 | 1779141325 |
+| `sweep_glm_qwen_AB_s137.db` | GLM-4 × Qwen | 137 | 493 | 20 | 50180096 | 1779134514 |
+| `sweep_glm_qwen_AB_s271.db` | GLM-4 × Qwen | 271 | 487 | 20 | 50466816 | 1779148018 |
+| `sweep_glm_qwen_AB_s314.db` | GLM-4 × Qwen | 314 | 504 | 20 | 49885184 | 1779160411 |
+| `sweep_glm_qwen_AB_s42.db` | GLM-4 × Qwen | 42 | 480 | 20 | 48644096 | 1779123126 |
+| `sweep_glm_qwen_AB_s999.db` | GLM-4 × Qwen | 999 | 484 | 20 | 46813184 | 1779116576 |
+| `sweep_glm_qwen_BA_s137.db` | GLM-4 × Qwen | 137 | 515 | 20 | 58732544 | 1779139938 |
+| `sweep_glm_qwen_BA_s271.db` | GLM-4 × Qwen | 271 | 503 | 20 | 44761088 | 1779159052 |
+| `sweep_glm_qwen_BA_s314.db` | GLM-4 × Qwen | 314 | 494 | 20 | 41005056 | 1779158811 |
+| `sweep_glm_qwen_BA_s42.db` | GLM-4 × Qwen | 42 | 430 | 20 | 51204096 | 1779129622 |
+| `sweep_glm_qwen_BA_s999.db` | GLM-4 × Qwen | 999 | 465 | 20 | 47808512 | 1779116069 |
+| `sweep_gpt_mag_s137.db` | Mag × gpt-oss | 137 | 544 | 20 | 81920000 | 1779099209 |
+| `sweep_gpt_mag_s271.db` | Mag × gpt-oss | 271 | 547 | 20 | 84930560 | 1779100844 |
+| `sweep_gpt_mag_s314.db` | Mag × gpt-oss | 314 | 572 | 20 | 85561344 | 1779101218 |
+| `sweep_gpt_mag_s42.db` | Mag × gpt-oss | 42 | 574 | 20 | 91918336 | 1779099281 |
+| `sweep_gpt_mag_s999.db` | Mag × gpt-oss | 999 | 581 | 20 | 74018816 | 1779102413 |
+| `sweep_gpt_qwe_s137.db` | Qwen × gpt-oss | 137 | 543 | 20 | 68038656 | 1779080909 |
+| `sweep_gpt_qwe_s271.db` | Qwen × gpt-oss | 271 | 531 | 20 | 56549376 | 1779085792 |
+| `sweep_gpt_qwe_s314.db` | Qwen × gpt-oss | 314 | 532 | 20 | 62742528 | 1779091564 |
+| `sweep_gpt_qwe_s42.db` | Qwen × gpt-oss | 42 | 529 | 20 | 69840896 | 1779075601 |
+| `sweep_gpt_qwe_s999.db` | Qwen × gpt-oss | 999 | 530 | 20 | 49586176 | 1779097052 |
+| `sweep_mag_gpt_s137.db` | Mag × gpt-oss | 137 | 554 | 20 | 80723968 | 1779104432 |
+| `sweep_mag_gpt_s271.db` | Mag × gpt-oss | 271 | 555 | 20 | 70488064 | 1779104670 |
+| `sweep_mag_gpt_s314.db` | Mag × gpt-oss | 314 | 559 | 20 | 81272832 | 1779106080 |
+| `sweep_mag_gpt_s42.db` | Mag × gpt-oss | 42 | 545 | 20 | 88379392 | 1779102897 |
+| `sweep_mag_gpt_s999.db` | Mag × gpt-oss | 999 | 566 | 20 | 81620992 | 1779106413 |
+| `sweep_mag_qwe_s137.db` | Mag × Qwen | 137 | 576 | 20 | 62140416 | 1779091491 |
+| `sweep_mag_qwe_s271.db` | Mag × Qwen | 271 | 568 | 20 | 66150400 | 1779091847 |
+| `sweep_mag_qwe_s314.db` | Mag × Qwen | 314 | 584 | 20 | 66252800 | 1779096942 |
+| `sweep_mag_qwe_s42.db` | Mag × Qwen | 42 | 585 | 20 | 60993536 | 1779085988 |
+| `sweep_mag_qwe_s999.db` | Mag × Qwen | 999 | 582 | 20 | 64733184 | 1779097088 |
+| `sweep_qwe_gpt_s137.db` | Qwen × gpt-oss | 137 | 521 | 20 | 56729600 | 1779080901 |
+| `sweep_qwe_gpt_s271.db` | Qwen × gpt-oss | 271 | 526 | 20 | 55017472 | 1779086001 |
+| `sweep_qwe_gpt_s314.db` | Qwen × gpt-oss | 314 | 531 | 20 | 58732544 | 1779091698 |
+| `sweep_qwe_gpt_s42.db` | Qwen × gpt-oss | 42 | 538 | 20 | 72736768 | 1779075498 |
+| `sweep_qwe_gpt_s999.db` | Qwen × gpt-oss | 999 | 539 | 20 | 66531328 | 1779097026 |
+| `sweep_qwe_mag_s137.db` | Mag × Qwen | 137 | 576 | 20 | 66981888 | 1779075592 |
+| `sweep_qwe_mag_s271.db` | Mag × Qwen | 271 | 581 | 20 | 64507904 | 1779080944 |
+| `sweep_qwe_mag_s314.db` | Mag × Qwen | 314 | 574 | 20 | 66420736 | 1779080997 |
+| `sweep_qwe_mag_s42.db` | Mag × Qwen | 42 | 586 | 20 | 75513856 | 1779075559 |
+| `sweep_qwe_mag_s999.db` | Mag × Qwen | 999 | 577 | 20 | 62619648 | 1779085857 |
+
+## Triadic runs
+**Total valid runs: 89**
+
+| Filename | Triplet | Seed | n_comments | n_agents | size_bytes | mtime |
+|----------|---------|------|-----------|---------|------------|-------|
+| `sweep_tri_gem_mag_glm_s271.db` | GLM-4 + Gemma + Mag | 271 | 927 | 30 | 107360256 | 1779741352 |
+| `sweep_tri_gem_mag_glm_s42.db` | GLM-4 + Gemma + Mag | 42 | 851 | 30 | 93626368 | 1779738907 |
+| `sweep_tri_gem_mag_glm_s999.db` | GLM-4 + Gemma + Mag | 999 | 914 | 30 | 98635776 | 1779740176 |
+| `sweep_tri_gem_oss_glm_s271.db` | GLM-4 + Gemma + gpt-oss | 271 | 853 | 30 | 112611328 | 1779679559 |
+| `sweep_tri_gem_oss_glm_s42.db` | GLM-4 + Gemma + gpt-oss | 42 | 835 | 30 | 111042560 | 1779679853 |
+| `sweep_tri_gem_oss_glm_s999.db` | GLM-4 + Gemma + gpt-oss | 999 | 836 | 30 | 104181760 | 1779681507 |
+| `sweep_tri_gem_oss_mag_s271.db` | Gemma + Mag + gpt-oss | 271 | 860 | 30 | 116637696 | 1779740304 |
+| `sweep_tri_gem_oss_mag_s42.db` | Gemma + Mag + gpt-oss | 42 | 857 | 30 | 118136832 | 1779735837 |
+| `sweep_tri_gem_oss_mag_s999.db` | Gemma + Mag + gpt-oss | 999 | 865 | 30 | 113467392 | 1779740150 |
+| `sweep_tri_gem_qwe_glm_s271.db` | GLM-4 + Gemma + Qwen | 271 | 851 | 30 | 88444928 | 1779663231 |
+| `sweep_tri_gem_qwe_glm_s999.db` | GLM-4 + Gemma + Qwen | 999 | 829 | 30 | 87187456 | 1779662986 |
+| `sweep_tri_gem_qwe_mag_s271.db` | Gemma + Mag + Qwen | 271 | 866 | 30 | 95408128 | 1779707852 |
+| `sweep_tri_gem_qwe_mag_s42.db` | Gemma + Mag + Qwen | 42 | 846 | 30 | 84951040 | 1779705394 |
+| `sweep_tri_gem_qwe_mag_s999.db` | Gemma + Mag + Qwen | 999 | 837 | 30 | 91226112 | 1779708400 |
+| `sweep_tri_gem_qwe_oss_s271.db` | Gemma + Qwen + gpt-oss | 271 | 866 | 30 | 101412864 | 1779615407 |
+| `sweep_tri_gem_qwe_oss_s42.db` | Gemma + Qwen + gpt-oss | 42 | 838 | 30 | 98525184 | 1779611501 |
+| `sweep_tri_gem_qwe_oss_s999.db` | Gemma + Qwen + gpt-oss | 999 | 858 | 30 | 112046080 | 1779615839 |
+| `sweep_tri_glm_mag_gem_s271.db` | GLM-4 + Gemma + Mag | 271 | 846 | 30 | 93204480 | 1779729956 |
+| `sweep_tri_glm_mag_gem_s42.db` | GLM-4 + Gemma + Mag | 42 | 865 | 30 | 102367232 | 1779731904 |
+| `sweep_tri_glm_mag_gem_s999.db` | GLM-4 + Gemma + Mag | 999 | 840 | 30 | 93835264 | 1779731115 |
+| `sweep_tri_glm_oss_gem_s271.db` | GLM-4 + Gemma + gpt-oss | 271 | 862 | 30 | 108032000 | 1779672097 |
+| `sweep_tri_glm_oss_gem_s42.db` | GLM-4 + Gemma + gpt-oss | 42 | 853 | 30 | 112455680 | 1779671509 |
+| `sweep_tri_glm_oss_gem_s999.db` | GLM-4 + Gemma + gpt-oss | 999 | 850 | 30 | 113049600 | 1779674662 |
+| `sweep_tri_glm_oss_mag_s271.db` | GLM-4 + Mag + gpt-oss | 271 | 836 | 30 | 96997376 | 1779583162 |
+| `sweep_tri_glm_oss_mag_s42.db` | GLM-4 + Mag + gpt-oss | 42 | 850 | 30 | 105680896 | 1779576950 |
+| `sweep_tri_glm_oss_mag_s999.db` | GLM-4 + Mag + gpt-oss | 999 | 842 | 30 | 97931264 | 1779584320 |
+| `sweep_tri_glm_qwe_gem_s271.db` | GLM-4 + Gemma + Qwen | 271 | 670 | 30 | 67776512 | 1779633689 |
+| `sweep_tri_glm_qwe_gem_s42.db` | GLM-4 + Gemma + Qwen | 42 | 813 | 30 | 76480512 | 1779631257 |
+| `sweep_tri_glm_qwe_gem_s999.db` | GLM-4 + Gemma + Qwen | 999 | 799 | 30 | 85442560 | 1779633695 |
+| `sweep_tri_glm_qwe_mag_s271.db` | GLM-4 + Mag + Qwen | 271 | 799 | 30 | 87195648 | 1779224711 |
+| `sweep_tri_glm_qwe_mag_s42.db` | GLM-4 + Mag + Qwen | 42 | 833 | 30 | 106655744 | 1779219949 |
+| `sweep_tri_glm_qwe_mag_s999.db` | GLM-4 + Mag + Qwen | 999 | 811 | 30 | 84738048 | 1779225552 |
+| `sweep_tri_glm_qwe_oss_s271.db` | GLM-4 + Qwen + gpt-oss | 271 | 760 | 30 | 85078016 | 1779196637 |
+| `sweep_tri_glm_qwe_oss_s42.db` | GLM-4 + Qwen + gpt-oss | 42 | 716 | 30 | 79732736 | 1779196192 |
+| `sweep_tri_glm_qwe_oss_s999.db` | GLM-4 + Qwen + gpt-oss | 999 | 774 | 30 | 91947008 | 1779202782 |
+| `sweep_tri_mag_glm_gem_s271.db` | GLM-4 + Gemma + Mag | 271 | 849 | 30 | 94908416 | 1779722016 |
+| `sweep_tri_mag_glm_gem_s42.db` | GLM-4 + Gemma + Mag | 42 | 827 | 30 | 88150016 | 1779721920 |
+| `sweep_tri_mag_glm_gem_s999.db` | GLM-4 + Gemma + Mag | 999 | 846 | 30 | 92332032 | 1779722279 |
+| `sweep_tri_mag_oss_gem_s271.db` | Gemma + Mag + gpt-oss | 271 | 848 | 30 | 124346368 | 1779736648 |
+| `sweep_tri_mag_oss_gem_s42.db` | Gemma + Mag + gpt-oss | 42 | 826 | 30 | 104566784 | 1779713437 |
+| `sweep_tri_mag_oss_gem_s999.db` | Gemma + Mag + gpt-oss | 999 | 837 | 30 | 106917888 | 1779735944 |
+| `sweep_tri_mag_oss_glm_s271.db` | GLM-4 + Mag + gpt-oss | 271 | 295 | 30 | 32628736 | 1779593348 |
+| `sweep_tri_mag_oss_glm_s42.db` | GLM-4 + Mag + gpt-oss | 42 | 813 | 30 | 106270720 | 1779296502 |
+| `sweep_tri_mag_oss_glm_s999.db` | GLM-4 + Mag + gpt-oss | 999 | 864 | 30 | 118476800 | 1779575944 |
+| `sweep_tri_mag_qwe_gem_s271.db` | Gemma + Mag + Qwen | 271 | 868 | 30 | 102752256 | 1779700441 |
+| `sweep_tri_mag_qwe_gem_s42.db` | Gemma + Mag + Qwen | 42 | 864 | 30 | 110419968 | 1779698791 |
+| `sweep_tri_mag_qwe_gem_s999.db` | Gemma + Mag + Qwen | 999 | 866 | 30 | 104988672 | 1779701696 |
+| `sweep_tri_mag_qwe_glm_s271.db` | GLM-4 + Mag + Qwen | 271 | 848 | 30 | 97263616 | 1779214062 |
+| `sweep_tri_mag_qwe_glm_s42.db` | GLM-4 + Mag + Qwen | 42 | 822 | 30 | 91475968 | 1779214653 |
+| `sweep_tri_mag_qwe_glm_s999.db` | GLM-4 + Mag + Qwen | 999 | 853 | 30 | 89014272 | 1779219381 |
+| `sweep_tri_mag_qwe_oss_s271.db` | Mag + Qwen + gpt-oss | 271 | 794 | 30 | 100130816 | 1779170054 |
+| `sweep_tri_mag_qwe_oss_s42.db` | Mag + Qwen + gpt-oss | 42 | 845 | 30 | 113418240 | 1779168353 |
+| `sweep_tri_mag_qwe_oss_s999.db` | Mag + Qwen + gpt-oss | 999 | 824 | 30 | 94769152 | 1779172581 |
+| `sweep_tri_oss_glm_gem_s271.db` | GLM-4 + Gemma + gpt-oss | 271 | 855 | 30 | 119349248 | 1779666150 |
+| `sweep_tri_oss_glm_gem_s42.db` | GLM-4 + Gemma + gpt-oss | 42 | 834 | 30 | 102146048 | 1779664702 |
+| `sweep_tri_oss_glm_gem_s999.db` | GLM-4 + Gemma + gpt-oss | 999 | 851 | 30 | 109056000 | 1779664188 |
+| `sweep_tri_oss_mag_gem_s271.db` | Gemma + Mag + gpt-oss | 271 | 848 | 30 | 124026880 | 1779712359 |
+| `sweep_tri_oss_mag_gem_s42.db` | Gemma + Mag + gpt-oss | 42 | 856 | 30 | 116924416 | 1779709320 |
+| `sweep_tri_oss_mag_gem_s999.db` | Gemma + Mag + gpt-oss | 999 | 849 | 30 | 102916096 | 1779712561 |
+| `sweep_tri_oss_mag_glm_s271.db` | GLM-4 + Mag + gpt-oss | 271 | 858 | 30 | 102461440 | 1779291369 |
+| `sweep_tri_oss_mag_glm_s42.db` | GLM-4 + Mag + gpt-oss | 42 | 851 | 30 | 99733504 | 1779291731 |
+| `sweep_tri_oss_mag_glm_s999.db` | GLM-4 + Mag + gpt-oss | 999 | 796 | 30 | 106704896 | 1779295866 |
+| `sweep_tri_oss_qwe_gem_s271.db` | Gemma + Qwen + gpt-oss | 271 | 855 | 30 | 138854400 | 1779607702 |
+| `sweep_tri_oss_qwe_gem_s42.db` | Gemma + Qwen + gpt-oss | 42 | 866 | 30 | 117444608 | 1779610048 |
+| `sweep_tri_oss_qwe_gem_s999.db` | Gemma + Qwen + gpt-oss | 999 | 848 | 30 | 113299456 | 1779609179 |
+| `sweep_tri_oss_qwe_glm_s271.db` | GLM-4 + Qwen + gpt-oss | 271 | 712 | 30 | 79577088 | 1779188985 |
+| `sweep_tri_oss_qwe_glm_s42.db` | GLM-4 + Qwen + gpt-oss | 42 | 769 | 30 | 86376448 | 1779184057 |
+| `sweep_tri_oss_qwe_glm_s999.db` | GLM-4 + Qwen + gpt-oss | 999 | 730 | 30 | 85274624 | 1779190791 |
+| `sweep_tri_oss_qwe_mag_s271.db` | Mag + Qwen + gpt-oss | 271 | 854 | 30 | 109309952 | 1779164927 |
+| `sweep_tri_oss_qwe_mag_s42.db` | Mag + Qwen + gpt-oss | 42 | 852 | 30 | 108691456 | 1779160752 |
+| `sweep_tri_oss_qwe_mag_s999.db` | Mag + Qwen + gpt-oss | 999 | 859 | 30 | 102883328 | 1779166217 |
+| `sweep_tri_qwe_glm_gem_s271.db` | GLM-4 + Gemma + Qwen | 271 | 829 | 30 | 94613504 | 1779625369 |
+| `sweep_tri_qwe_glm_gem_s42.db` | GLM-4 + Gemma + Qwen | 42 | 818 | 30 | 73973760 | 1779621704 |
+| `sweep_tri_qwe_glm_gem_s999.db` | GLM-4 + Gemma + Qwen | 999 | 830 | 30 | 81612800 | 1779625082 |
+| `sweep_tri_qwe_mag_gem_s271.db` | Gemma + Mag + Qwen | 271 | 826 | 30 | 109219840 | 1779691521 |
+| `sweep_tri_qwe_mag_gem_s42.db` | Gemma + Mag + Qwen | 42 | 845 | 30 | 100605952 | 1779692886 |
+| `sweep_tri_qwe_mag_gem_s999.db` | Gemma + Mag + Qwen | 999 | 845 | 30 | 98328576 | 1779692494 |
+| `sweep_tri_qwe_mag_glm_s271.db` | GLM-4 + Mag + Qwen | 271 | 834 | 30 | 81764352 | 1779208380 |
+| `sweep_tri_qwe_mag_glm_s42.db` | GLM-4 + Mag + Qwen | 42 | 826 | 30 | 87134208 | 1779202593 |
+| `sweep_tri_qwe_mag_glm_s999.db` | GLM-4 + Mag + Qwen | 999 | 825 | 30 | 89001984 | 1779208467 |
+| `sweep_tri_qwe_oss_gem_s271.db` | Gemma + Qwen + gpt-oss | 271 | 842 | 30 | 102461440 | 1779598329 |
+| `sweep_tri_qwe_oss_gem_s42.db` | Gemma + Qwen + gpt-oss | 42 | 861 | 30 | 116256768 | 1779599659 |
+| `sweep_tri_qwe_oss_gem_s999.db` | Gemma + Qwen + gpt-oss | 999 | 844 | 30 | 107937792 | 1779610777 |
+| `sweep_tri_qwe_oss_glm_s271.db` | GLM-4 + Qwen + gpt-oss | 271 | 767 | 30 | 88920064 | 1779177738 |
+| `sweep_tri_qwe_oss_glm_s42.db` | GLM-4 + Qwen + gpt-oss | 42 | 736 | 30 | 82784256 | 1779176350 |
+| `sweep_tri_qwe_oss_glm_s999.db` | GLM-4 + Qwen + gpt-oss | 999 | 765 | 30 | 98025472 | 1779181875 |
+| `sweep_tri_qwe_oss_mag_s271.db` | Mag + Qwen + gpt-oss | 271 | 801 | 30 | 88059904 | 1779156383 |
+| `sweep_tri_qwe_oss_mag_s42.db` | Mag + Qwen + gpt-oss | 42 | 863 | 30 | 127578112 | 1779156355 |
+| `sweep_tri_qwe_oss_mag_s999.db` | Mag + Qwen + gpt-oss | 999 | 816 | 30 | 100204544 | 1779161905 |
+
+---
+
+## Four-way (tetradic) runs
+**Total valid runs: 24** (2 seeds x 12 model->block rotations of {gpt-oss, Qwen, Magistral, GLM-4}; 40 agents, 10 per model). Stored under `$RUNS_DIR/tetradic/`.
+
+| Filename | Seed | Rotation | n_comments | n_agents |
+|----------|------|----------|-----------|---------|
+| `tetra_s42_r1.db` | 42 | r1 | 1067 | 40 |
+| `tetra_s42_r2.db` | 42 | r2 | 1088 | 40 |
+| `tetra_s42_r3.db` | 42 | r3 | 1088 | 40 |
+| `tetra_s42_r4.db` | 42 | r4 | 1090 | 40 |
+| `tetra_s42_r5.db` | 42 | r5 | 1086 | 40 |
+| `tetra_s42_r6.db` | 42 | r6 | 1023 | 40 |
+| `tetra_s42_r7.db` | 42 | r7 | 1101 | 40 |
+| `tetra_s42_r8.db` | 42 | r8 | 1016 | 40 |
+| `tetra_s42_r9.db` | 42 | r9 | 1095 | 40 |
+| `tetra_s42_r10.db` | 42 | r10 | 1080 | 40 |
+| `tetra_s42_r11.db` | 42 | r11 | 1048 | 40 |
+| `tetra_s42_r12.db` | 42 | r12 | 1076 | 40 |
+| `tetra_s271_r1.db` | 271 | r1 | 1057 | 40 |
+| `tetra_s271_r2.db` | 271 | r2 | 1029 | 40 |
+| `tetra_s271_r3.db` | 271 | r3 | 1055 | 40 |
+| `tetra_s271_r4.db` | 271 | r4 | 1249 | 40 |
+| `tetra_s271_r5.db` | 271 | r5 | 1067 | 40 |
+| `tetra_s271_r6.db` | 271 | r6 | 1082 | 40 |
+| `tetra_s271_r7.db` | 271 | r7 | 1101 | 40 |
+| `tetra_s271_r8.db` | 271 | r8 | 1102 | 40 |
+| `tetra_s271_r9.db` | 271 | r9 | 1060 | 40 |
+| `tetra_s271_r10.db` | 271 | r10 | 1079 | 40 |
+| `tetra_s271_r11.db` | 271 | r11 | 1072 | 40 |
+| `tetra_s271_r12.db` | 271 | r12 | 1113 | 40 |

docs/EXPERIMENT_PROTOCOL.md

@@ -0,0 +1,229 @@
+# Experiment Protocol: Disentangling Models from Personas in LLM Social Simulations
+
+## Overview
+
+This document is the canonical reproducibility narrative for the dyadic, triadic,
+and four-way (tetradic) sweep experiments and the lexical/content analyses reported
+in the paper. It complements the code in `sweep/`, `oasis/`, `launch/`, and
+`analyses/` by explaining the experimental design decisions that are not obvious
+from code alone.
+
+---
+
+## Simulator
+
+We adapt the OASIS simulator (v0.2.5, https://github.com/camel-ai/oasis) to
+support heterogeneous multi-model populations. The key modifications are in
+`oasis/run_v9.py`:
+
+- `hetero` mode: 2 model families, 10 agents each
+- `hetero3` mode: 3 model families, 10 agents each
+- Plackett-Luce feed ranking with Gumbel noise (T=5.0)
+- Post-share balancer: prevents one model family from dominating posts
+- Warm-up phase: all agents post once before the main loop; any run where a
+  family has < 50% participation is aborted
+- SIGTERM-safe checkpoint/resume for preemptible SLURM allocations
+
+---
+
+## Models
+
+Five models are tested. All are served via vLLM 0.19.0 on 8× NVIDIA L40S 48 GB.
+See `env/vllm_version.md` for exact launch parameters.
+
+| Model | HF ID | TP | Port |
+|-------|-------|----|------|
+| Qwen | Qwen/Qwen3-32B | 2 | 8002 |
+| gpt-oss | openai/gpt-oss-20b | 1 | 8003 |
+| Magistral | mistralai/Magistral-Small-2509 | 2 | 8004 |
+| GLM-4 | zai-org/GLM-4-32B-0414 | 2 | 8007 |
+| Gemma | google/gemma-4-31B-it | 2 | 8009 |
+
+---
+
+## Persona initialization
+
+Personas are sampled from the Moltbook community archive (HF dataset). The
+seed database (`oasis/seed_db/hf-zero-50.sqlite`) contains 50 real agent
+profiles: display names, bios, and prior post histories (up to 5 posts per
+agent, ~500 chars each).
+
+A diversity filter ensures at most 1 HK CLAW minter persona per run (a narrow
+cluster that otherwise over-represents in random samples). The filter is
+deterministic given the RNG seed.
+
+Each seed value produces a different persona sample. Seeds: [42, 137, 271, 314, 999]
+for dyadic runs; [42, 271, 999] for triadic runs.
+
+---
+
+## Rotating assignments
+
+For **dyadic** runs: 20 agents (10 per family), two orderings per seed (A=X,B=Y
+and A=Y,B=X). This gives 2 × C(5,2) × 5 = 100 runs.
+
+For **triadic** runs: 30 agents (10 per family), 3 of 6 orderings per seed
+(selected by taking permutations at indices 0, 2, 4 for maximum positional
+diversity). This gives 3 × C(5,3) × 3 = 90 runs.
+
+---
+
+## Simulation parameters
+
+| Parameter | Value |
+|-----------|-------|
+| Steps | 100 |
+| Activation probability | 0.3 per agent per step |
+| Feed size (K) | 20 |
+| Gumbel noise temperature | T=5.0 |
+| Post-share tolerance | δ=0.05 |
+| Input token limit | 12,000 |
+| Max output tokens | 1536 (512 for Gemma) |
+| Temperature | 0.85 |
+| Max tool-call attempts per turn | 6 |
+
+---
+
+## Metrics
+
+### Directed pairwise engagement homophily (H)
+
+For families X and Y:
+
+```
+H_{X→Y} = obs(X→Y) / exp(X→Y) - 1
+```
+
+where `obs(X→Y)` = fraction of all directed comment edges from X to Y, and
+`exp(X→Y)` = null expectation under random mixing proportional to group sizes.
+
+Two edge types are counted:
+1. commenter → post_author
+2. replier → parent_comment_author (threaded replies)
+
+Positive H = X engages with Y more than random; negative = avoidance.
+Diagonal (X=X) = in-group self-preference.
+
+### Swap stability
+
+For dyadic runs: mean |H_{X→Y}^(AB) - H_{X→Y}^(BA)| across seeds.
+For triadic runs: mean max-|ΔH| across the 3 orderings per (triplet, seed).
+Lower = more stable across persona-to-model assignment rotations.
+
+---
+
+## Validity criteria
+
+A run is included in the paper analysis if:
+
+- **Dyadic**: ≥ 18 distinct agents commented, ≥ 200 total comments
+- **Triadic**: ≥ 26 distinct agents commented, ≥ 200 total comments
+
+These thresholds filter out runs that were aborted (e.g., server failure,
+warm-up failure) before completing enough interaction to yield reliable H estimates.
+
+Note: The H-matrix figure scripts (`analyses/plot_matrices.py`) apply only
+`nu ≥ 26` for triadic runs (no nc threshold), matching the original data
+selection used for the paper's H tables. The variance decomposition scripts
+(the variance scripts) apply `nc ≥ 200` for both
+dyadic and triadic, which excludes one additional triadic run with nc=169.
+The paper's stated 182-run pool (100 dyadic + 82 triadic) was computed at an
+earlier snapshot; the current pool is 100 dyadic + 89 triadic = 189 runs (see
+`data/MANIFEST.md`).
+
+---
+
+## Run identification convention
+
+Database file names encode the run configuration:
+
+```
+sweep_{modelA[:3]}_{modelB[:3]}_s{seed}.db       # dyadic
+sweep_tri_{A[:3]}_{B[:3]}_{C[:3]}_s{seed}.db     # triadic
+```
+
+Each `.db` file has a corresponding `.metadata.json` sidecar with the
+agent-to-model mapping, and `.metadata.json` + `_chats.jsonl` + `_reasoning.jsonl`
+side-car files.
+
+---
+
+## Variance decomposition methodology
+
+The variance decomposition (Appendix D) uses **comments per post** (CPP =
+in-degree / number of posts) as the dependent variable, restricted to agents with
+at least two posts. Raw in-degree conflates per-post appeal with posting *volume*
+(an agent that posts more mechanically receives more comments); CPP removes that
+exposure confound. Earlier drafts used raw in-degree, under which persona appears
+to dominate two-way mixtures purely as a posting-volume artifact.
+
+| Script | What it produces |
+|--------|-----------------|
+| `analyses/variance_cpp.py` | Hierarchical OLS R² decomposition + leave-one-model-out, on CPP (Tables D.1–D.2) |
+| `analyses/absolute_variance.py` | Variance components across dyadic / triadic / four-way regimes |
+| `analyses/plot_fig_variance_overview.py` | Figure: proportional CPP variance (model vs persona) + per-model H by mixture size |
+
+Model selection is the agent's own base model plus the unordered partner-pair
+(the other models present). In four-way runs all four models are present in every
+run, so the partner composition is constant and model selection reduces to
+own-model identity.
+
+---
+
+## Reproducibility notes
+
+1. **Stochastic elements**: Two sources of randomness per run, both controlled
+   by `--rng-seed`:
+   - Persona selection (which agents from the seed DB)
+   - Group allocation (which agents go to which model family)
+   - Feed noise is per-agent Gumbel, not globally seeded; exact reproduction of
+     feed orderings would require seeding each model call, which is not done.
+
+2. **Model-side non-determinism**: vLLM with temperature=0.85 is stochastic.
+   Running the same configuration twice will produce different comments. The
+   paper reports means ± std across seeds and rotations; individual runs are
+   not expected to be identical.
+
+3. **Checkpoint/resume**: Partial DBs can be resumed with `--resume`. The
+   `_checkpoint.json` sidecar records the exact last completed step.
+
+4. **Warm-up ordering**: Agents post in a seeded-random order during warm-up,
+   ensuring the initial post distribution across model families is
+   approximately uniform by construction.
+
+---
+
+## Four-way (tetradic) runs
+
+The four-way sweep uses the pool {gpt-oss, Qwen, Magistral, GLM-4}, 40 agents
+(10 per family), 100 steps, post-share balancer on, activation prob 0.3
+(`run_v9.py --mode hetero4`). Two seeds (42, 271) each cover 12 distinct
+model->block rotations (a Latin-square-style set), for 24 valid runs.
+
+- **Validity:** >= 200 comments and all four models present.
+- **Run identification:** `tetradic/tetra_s{seed}_r{rotation}.db`.
+- **Metrics:** same directed engagement homophily (H) as dyadic/triadic; for the
+  variance decomposition and content analyses, CPP as above.
+
+Driver: `launch/run_tetradic.sh`. Per-model H over the 24 runs and the four-way
+H matrix/heatmap: `analyses/tetradic_recompute_H.py`, `analyses/tetradic_results.py`.
+
+---
+
+## Content analysis
+
+Finding 3 analyzes the text agents produce. Build the corpus once with
+`analyses/extract_texts.py` (-> `data/texts.jsonl`: one row per post/comment with
+its model and persona). Then:
+
+- `analyses/lexical_table.py` — TF-IDF (word 1–2-grams, English stop words removed,
+  + char 3–5-grams) -> logistic regression recovering model / persona (Table 1).
+- `analyses/svd_axes.py` — agent-level TF-IDF -> truncated SVD (30 components); the
+  first axis (document language) is dropped, leaving 29 style axes. Reports per-axis
+  top terms from V^T.
+- `analyses/content_engagement.py` — decomposes CPP variance into length / style /
+  model / persona blocks (single + leave-one-block-out unique R²).
+- `analyses/style_geometry.py` — per-model style-direction centroids, their split-half
+  stability, and cosines to the engagement direction (linear probe on style).
+- `analyses/cluster_model_persona.py`, `analyses/length_regimes.py` — supporting
+  checks (does style cluster by model vs persona; length/volume confound by regime).

env/requirements.txt

@@ -0,0 +1,26 @@
+# divsim reproducibility bundle — Python dependencies
+# Tested on Python 3.12, Linux (RHEL 9)
+
+# ── OASIS / CAMEL core ────────────────────────────────────────────────────────
+camel-ai>=0.1.6
+pandas==2.2.2
+igraph==0.11.6
+cairocffi==1.7.1
+
+# ── vLLM (model serving) ──────────────────────────────────────────────────────
+# Pin to 0.19.0 — the exact version used in all paper experiments.
+# Later versions may change scheduler behavior; see env/vllm_version.md.
+vllm==0.19.0
+
+# ── HuggingFace model download ────────────────────────────────────────────────
+huggingface-hub>=0.23.0
+transformers>=4.47.0
+
+# ── Analysis scripts ──────────────────────────────────────────────────────────
+numpy>=1.26.0
+matplotlib>=3.9.0
+scikit-learn>=1.5.0     # classifiers + SVD (content analyses, variance_cpp)
+scipy>=1.13.0           # sparse TF-IDF matrices (lexical_table.py, etc.)
+
+# ── Utilities ─────────────────────────────────────────────────────────────────
+requests>=2.32.0

env/vllm_version.md

@@ -0,0 +1,72 @@
+# vLLM Version and Per-Model Launch Notes
+
+**Version used in paper:** vLLM 0.19.0
+
+All five models are served via `vllm.entrypoints.openai.api_server`. Common
+defaults across all models:
+
+| Parameter | Value |
+|-----------|-------|
+| `--max-model-len` | 16384 |
+| `--gpu-memory-utilization` | 0.90 |
+| `--enable-auto-tool-choice` | (flag) |
+| `--no-scheduler-reserve-full-isl` | (flag, required — avoids a vLLM 0.19.0 scheduler deadlock under sustained multi-agent load) |
+| Input context cap | 12,000 tokens (set in runner via `_input_token_limit`) |
+| Max output tokens | 1536 (512 for Gemma) |
+| Temperature | 0.85 |
+| BF16 weights | default |
+
+---
+
+## Per-model deviations
+
+### Qwen/Qwen3-32B
+- TP=2 (GPUs 0-1)
+- `--tool-call-parser hermes`
+- `tool_choice=required`
+- Thinking suppressed via `chat_template_kwargs = {"enable_thinking": False}`
+
+### openai/gpt-oss-20b
+- TP=1 (GPU 2); mxfp4 quantized weights fit in ~40 GB
+- `--tool-call-parser openai`
+- `--reasoning-parser openai_gptoss`
+- `tool_choice=required`
+
+### mistralai/Magistral-Small-2509
+- TP=2 (GPUs 3-4)
+- `--tokenizer-mode mistral --config-format mistral --load-format mistral`
+  (Mistral models require their own loader; standard HuggingFace format fails)
+- `--tool-call-parser mistral`
+- `--reasoning-parser mistral`
+- `tool_choice=auto` — **Magistral returns empty `tool_calls` with `required`**;
+  `auto` is the correct setting
+
+### zai-org/GLM-4-32B-0414
+- TP=2 (GPUs 5-6)
+- `--tool-call-parser hermes`
+- `tool_choice=required` — **GLM-4 silently returns plain text with `auto`**;
+  this was discovered when warm-up showed only 1/10 agents posting per run
+
+### google/gemma-4-31B-it
+- TP=2 (GPUs 0-1 or 3-4 depending on node configuration)
+- `--tool-call-parser gemma4`
+- `--chat-template oasis/tool_chat_template_gemma4.jinja` (custom template, required)
+- `tool_choice=auto` — same symptom as Magistral with `required`
+- `--max-num-seqs 64` — tuned to avoid KV-cache saturation under concurrent load
+- `max_tokens=512` (runner-side cap, lower than other models)
+- **Note:** There is a discrepancy between the paper appendix (max_num_seqs=64)
+  and an earlier production launch script (max_num_seqs=8). The appendix value
+  (64) is the final setting used in paper runs.
+
+---
+
+## Known issues in vLLM 0.19.0
+
+- **Scheduler deadlock**: Under sustained multi-agent load, the scheduler can
+  deadlock. Mitigated by `--no-scheduler-reserve-full-isl` on all models.
+- **Gemma KV-cache saturation**: Default scheduling settings cause OOM-like
+  behavior under concurrent requests. `--max-num-seqs 64` and ensuring
+  `--gpu-memory-utilization 0.90` resolves this.
+- **Magistral/Gemma tool_choice=required**: Both models return empty
+  `tool_calls` lists when `tool_choice=required`; the runner uses `auto` and
+  handles non-tool responses with prose-to-action scaffolding.

launch/run_tetradic.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+# Four-way (tetradic) rotation sweep: 2 seeds x 12 distinct model->block permutations.
+# Pool {gpt-oss, Qwen, Magistral, GLM-4}, n=40 agents (10/model), 100 steps,
+# post-share balancer on, activation prob 0.3, run_v9 --mode hetero4.
+# Serves all four models concurrently on one node (7 GPUs), runs two rotations in parallel.
+# Resume-safe: completed DBs are skipped, partial ones (with a *_checkpoint.json) resume.
+#
+# Required env:
+#   SAFEMASS_VENV   venv with vLLM serving stack (CUDA torch, transformers)
+#   OASIS_VENV      venv with the OASIS client deps (run_v9.py)
+#   HF_HUB_CACHE    HuggingFace model cache
+#   RUNS_DIR        output dir for run DBs
+#   SEEDS           (optional) space-separated seeds; default "42 271"
+set -uo pipefail
+SEEDS="${SEEDS:-42 271}"
+: "${SAFEMASS_VENV:?set SAFEMASS_VENV}"; : "${OASIS_VENV:?set OASIS_VENV}"
+: "${HF_HUB_CACHE:?set HF_HUB_CACHE}"; export HF_HUB_CACHE
+RUNS="${RUNS_DIR:?set RUNS_DIR}"
+EXP="${RUNS}/tetradic"; LOGS="${EXP}/logs"; mkdir -p "$EXP" "$LOGS"
+exec >> "${LOGS}/rotations.log" 2>&1
+echo "==== tetradic rotations start $(date -Is)  seeds=[$SEEDS] x12 ===="
+
+wait_health(){ for i in $(seq 1 360); do curl -fsS "http://127.0.0.1:$1/health">/dev/null 2>&1&&return 0; sleep 5; done; return 1; }
+
+# --- serve the four models (see launch/vllm_*.sh for per-model flag rationale) ---
+CUDA_VISIBLE_DEVICES=0 "${SAFEMASS_VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+  --model openai/gpt-oss-20b --served-model-name openai/gpt-oss-20b --tensor-parallel-size 1 --max-model-len 16384 \
+  --port 8003 --gpu-memory-utilization 0.90 --host 127.0.0.1 --trust-remote-code \
+  --enable-auto-tool-choice --tool-call-parser openai --reasoning-parser openai_gptoss >>"${LOGS}/vllm_oss.log" 2>&1 &
+CUDA_VISIBLE_DEVICES=1,2 "${SAFEMASS_VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+  --model Qwen/Qwen3-32B --served-model-name Qwen/Qwen3-32B --tensor-parallel-size 2 --max-model-len 16384 \
+  --port 8002 --gpu-memory-utilization 0.90 --host 127.0.0.1 --trust-remote-code \
+  --enable-auto-tool-choice --tool-call-parser hermes >>"${LOGS}/vllm_qwen.log" 2>&1 &
+CUDA_VISIBLE_DEVICES=3,4 "${SAFEMASS_VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+  --model mistralai/Magistral-Small-2509 --tensor-parallel-size 2 --max-model-len 16384 --port 8004 \
+  --gpu-memory-utilization 0.90 --host 127.0.0.1 --trust-remote-code --tokenizer-mode mistral \
+  --load-format mistral --config-format mistral --enable-auto-tool-choice --tool-call-parser mistral \
+  --reasoning-parser mistral >>"${LOGS}/vllm_mag.log" 2>&1 &
+CUDA_VISIBLE_DEVICES=5,6 "${SAFEMASS_VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+  --model zai-org/GLM-4-32B-0414 --tensor-parallel-size 2 --max-model-len 16384 --port 8007 \
+  --gpu-memory-utilization 0.90 --host 127.0.0.1 --trust-remote-code \
+  --enable-auto-tool-choice --tool-call-parser hermes >>"${LOGS}/vllm_glm.log" 2>&1 &
+for p in 8003 8002 8004 8007; do wait_health $p||{ echo "FATAL vllm $p"; pkill -9 -f vllm.entrypoints; exit 1; }; done
+echo "[fleet] up $(date -Is)"
+
+PY="${OASIS_VENV}/bin/python3"; cd "$RUNS"
+url(){ case $1 in O)echo http://localhost:8003/v1;; Q)echo http://localhost:8002/v1;; M)echo http://localhost:8004/v1;; G)echo http://localhost:8007/v1;; esac; }
+mdl(){ case $1 in O)echo openai/gpt-oss-20b;; Q)echo Qwen/Qwen3-32B;; M)echo mistralai/Magistral-Small-2509;; G)echo zai-org/GLM-4-32B-0414;; esac; }
+
+# 12 distinct permutations of [gpt-oss, Qwen, Magistral, GLM-4] across blocks A B C D.
+PERMS=( "O Q M G" "Q M G O" "M G O Q" "G O Q M" \
+        "O G M Q" "G M Q O" "M Q O G" "Q O G M" \
+        "O Q G M" "Q O M G" "M G Q O" "G M O Q" )
+
+run_one(){ # <db> <seed> <permstring>
+  local db="$1" sd="$2"; read -r a b c d <<< "$3"
+  local name=$(basename "$db" .db); local ckpt="${db%.db}_checkpoint.json"
+  if [ -f "$db" ] && [ ! -f "$ckpt" ]; then echo "  == $name complete, skip"; return 0; fi
+  local res=""; [ -f "$ckpt" ] && res="--resume"
+  VLLM_URL_A="$(url $a)" MODEL_NAME_A="$(mdl $a)" VLLM_URL_B="$(url $b)" MODEL_NAME_B="$(mdl $b)" \
+  VLLM_URL_C="$(url $c)" MODEL_NAME_C="$(mdl $c)" VLLM_URL_D="$(url $d)" MODEL_NAME_D="$(mdl $d)" POST_SHARE_TOL=0.05 \
+  $PY run_v9.py --mode hetero4 --steps 100 --agents 40 --seed-posts 0 --activate-prob 0.3 \
+     --rng-seed "$sd" --db "$db" $res >>"${LOGS}/${name}.log" 2>&1
+  echo "  <<< $name rc=$? $(date -Is)"
+}
+
+for sd in $SEEDS; do
+  echo "==== seed $sd $(date -Is) ===="
+  i=0
+  while [ $i -lt ${#PERMS[@]} ]; do
+    run_one "$EXP/tetra_s${sd}_r$((i+1)).db" $sd "${PERMS[$i]}" & p1=$!
+    p2=""; if [ $((i+1)) -lt ${#PERMS[@]} ]; then run_one "$EXP/tetra_s${sd}_r$((i+2)).db" $sd "${PERMS[$((i+1))]}" & p2=$!; fi
+    wait $p1 ${p2:-}
+    i=$((i+2))
+  done
+done
+echo "==== tetradic rotations done $(date -Is) ===="

launch/vllm_gemma.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Launch vLLM server for google/gemma-4-31B-it.
+#
+# Hardware: 2× L40S 48GB (TP=2). Note: Gemma shares the same GPU pair (0-1 by
+# default here) as Magistral in the paper's triadic-sweep node layout. They
+# cannot run simultaneously; stop one before starting the other.
+# Default port: 8009. Override with PORT env var.
+#
+# Key settings:
+#   --tool-call-parser gemma4   — requires the custom jinja chat template
+#   --chat-template             — path to tool_chat_template_gemma4.jinja
+#   tool_choice=auto            — Gemma 4 returns empty tool_calls with 'required'
+#   --max-num-seqs 64           — tuned to avoid KV-cache saturation under
+#                                 concurrent multi-agent load
+#   --no-scheduler-reserve-full-isl — avoids a vLLM 0.19.0 scheduler deadlock
+#
+# Note on max_tokens: Gemma 4 output is capped at 512 tokens in the runner
+# (compared to 1536 for other models) to limit KV-cache pressure.
+
+set -euo pipefail
+
+HF_HUB_CACHE="${HF_HUB_CACHE:-/data/hf_cache/hub}"
+export HF_HUB_CACHE
+
+VENV="${SAFEMASS_VENV:-$(dirname "$0")/../.venv}"
+PORT="${PORT:-8009}"
+LOGS="${LOGS_DIR:-/tmp/vllm_logs}"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+TEMPLATE="${GEMMA_CHAT_TEMPLATE:-${SCRIPT_DIR}/../oasis/tool_chat_template_gemma4.jinja}"
+mkdir -p "$LOGS"
+
+if [[ ! -f "$TEMPLATE" ]]; then
+    echo "ERROR: Gemma chat template not found at: $TEMPLATE" >&2
+    echo "Set GEMMA_CHAT_TEMPLATE env var or ensure oasis/tool_chat_template_gemma4.jinja exists." >&2
+    exit 1
+fi
+
+CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1}" \
+    "${VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+    --model google/gemma-4-31B-it \
+    --served-model-name google/gemma-4-31B-it \
+    --tensor-parallel-size 2 \
+    --max-model-len 16384 \
+    --gpu-memory-utilization 0.90 \
+    --port "$PORT" \
+    --host 127.0.0.1 \
+    --trust-remote-code \
+    --enable-auto-tool-choice \
+    --tool-call-parser gemma4 \
+    --chat-template "$TEMPLATE" \
+    --max-num-seqs 64 \
+    --no-scheduler-reserve-full-isl \
+    >> "${LOGS}/vllm_gemma_${PORT}.log" 2>&1

launch/vllm_glm4.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Launch vLLM server for zai-org/GLM-4-32B-0414.
+#
+# Hardware: 2× L40S 48GB (TP=2).
+# Default port: 8007. Override with PORT env var.
+#
+# Key settings:
+#   --tool-call-parser hermes   — GLM-4-32B-0414 uses the Hermes tool schema
+#   tool_choice=required        — GLM-4 returns plain text with 'auto';
+#                                 'required' is necessary for reliable tool calls
+#
+# Warm-up check: the simulation runner verifies ≥50% of GLM-4 agents post in
+# warm-up. If this check fails, the most likely cause is the server not being
+# ready or returning malformed tool calls.
+
+set -euo pipefail
+
+HF_HUB_CACHE="${HF_HUB_CACHE:-/data/hf_cache/hub}"
+export HF_HUB_CACHE
+
+VENV="${SAFEMASS_VENV:-$(dirname "$0")/../.venv}"
+PORT="${PORT:-8007}"
+LOGS="${LOGS_DIR:-/tmp/vllm_logs}"
+mkdir -p "$LOGS"
+
+CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-5,6}" \
+    "${VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+    --model zai-org/GLM-4-32B-0414 \
+    --tensor-parallel-size 2 \
+    --max-model-len 16384 \
+    --gpu-memory-utilization 0.90 \
+    --port "$PORT" \
+    --host 127.0.0.1 \
+    --trust-remote-code \
+    --enable-auto-tool-choice \
+    --tool-call-parser hermes \
+    --no-scheduler-reserve-full-isl \
+    >> "${LOGS}/vllm_glm4_${PORT}.log" 2>&1

launch/vllm_gpt_oss.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Launch vLLM server for openai/gpt-oss-20b.
+#
+# Hardware: 1× L40S 48GB (TP=1). The mxfp4 quantized weights fit in ~40 GB.
+# Default port: 8003. Override with PORT env var.
+#
+# Key settings:
+#   --tool-call-parser openai        — gpt-oss uses the OpenAI tool schema
+#   --reasoning-parser openai_gptoss — strips thinking tokens from output
+#   tool_choice=required             — gpt-oss reliably complies with required
+
+set -euo pipefail
+
+HF_HUB_CACHE="${HF_HUB_CACHE:-/data/hf_cache/hub}"
+export HF_HUB_CACHE
+
+VENV="${SAFEMASS_VENV:-$(dirname "$0")/../.venv}"
+PORT="${PORT:-8003}"
+LOGS="${LOGS_DIR:-/tmp/vllm_logs}"
+mkdir -p "$LOGS"
+
+CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-2}" \
+    "${VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+    --model openai/gpt-oss-20b \
+    --tensor-parallel-size 1 \
+    --max-model-len 16384 \
+    --gpu-memory-utilization 0.90 \
+    --port "$PORT" \
+    --host 127.0.0.1 \
+    --trust-remote-code \
+    --enable-auto-tool-choice \
+    --tool-call-parser openai \
+    --reasoning-parser openai_gptoss \
+    --no-scheduler-reserve-full-isl \
+    >> "${LOGS}/vllm_gptoss_${PORT}.log" 2>&1

launch/vllm_magistral.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Launch vLLM server for mistralai/Magistral-Small-2509.
+#
+# Hardware: 2× L40S 48GB (TP=2).
+# Default port: 8004. Override with PORT env var.
+#
+# Key settings:
+#   --tokenizer-mode mistral   \
+#   --config-format mistral    \
+#   --load-format mistral      — Mistral models require their own tokenizer/loader
+#   --tool-call-parser mistral — uses Mistral tool-call format
+#   --reasoning-parser mistral — strips Magistral thinking tokens
+#   tool_choice=auto           — Magistral returns empty tool_calls with 'required';
+#                                'auto' is the correct setting for this model
+
+set -euo pipefail
+
+HF_HUB_CACHE="${HF_HUB_CACHE:-/data/hf_cache/hub}"
+export HF_HUB_CACHE
+
+VENV="${SAFEMASS_VENV:-$(dirname "$0")/../.venv}"
+PORT="${PORT:-8004}"
+LOGS="${LOGS_DIR:-/tmp/vllm_logs}"
+mkdir -p "$LOGS"
+
+CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-3,4}" \
+    "${VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+    --model mistralai/Magistral-Small-2509 \
+    --tensor-parallel-size 2 \
+    --max-model-len 16384 \
+    --gpu-memory-utilization 0.90 \
+    --port "$PORT" \
+    --host 127.0.0.1 \
+    --trust-remote-code \
+    --tokenizer-mode mistral \
+    --config-format mistral \
+    --load-format mistral \
+    --enable-auto-tool-choice \
+    --tool-call-parser mistral \
+    --reasoning-parser mistral \
+    --no-scheduler-reserve-full-isl \
+    >> "${LOGS}/vllm_magistral_${PORT}.log" 2>&1

launch/vllm_qwen.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Launch vLLM server for Qwen/Qwen3-32B.
+#
+# Hardware: 2× L40S 48GB (TP=2), GPUs selectable via CUDA_VISIBLE_DEVICES.
+# Default port: 8002. Override with PORT env var.
+#
+# Key settings:
+#   --tool-call-parser hermes        — Qwen3-32B uses the Hermes tool schema
+#   chat_template_kwargs enable_thinking=False — suppress reasoning prefix tokens;
+#     Qwen3 is a hybrid reasoning model but we want action output only
+#   tool_choice=required             — Qwen reliably complies; forced to prevent
+#     plain-text fallback
+
+set -euo pipefail
+
+HF_HUB_CACHE="${HF_HUB_CACHE:-/data/hf_cache/hub}"
+export HF_HUB_CACHE
+
+VENV="${SAFEMASS_VENV:-$(dirname "$0")/../.venv}"
+PORT="${PORT:-8002}"
+LOGS="${LOGS_DIR:-/tmp/vllm_logs}"
+mkdir -p "$LOGS"
+
+CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1}" \
+    "${VENV}/bin/python3" -m vllm.entrypoints.openai.api_server \
+    --model Qwen/Qwen3-32B \
+    --tensor-parallel-size 2 \
+    --max-model-len 16384 \
+    --gpu-memory-utilization 0.90 \
+    --port "$PORT" \
+    --host 127.0.0.1 \
+    --trust-remote-code \
+    --enable-auto-tool-choice \
+    --tool-call-parser hermes \
+    --no-scheduler-reserve-full-isl \
+    >> "${LOGS}/vllm_qwen_${PORT}.log" 2>&1

oasis/NOTICE

@@ -0,0 +1,17 @@
+OASIS — Open Agent Social Interaction Simulations
+Copyright (c) CAMEL-AI.org
+Licensed under the Apache License, Version 2.0.
+
+The code in this directory is adapted from:
+  https://github.com/camel-ai/oasis
+  Version: 0.2.5
+
+Modifications by Dani Roytburg (droytbur@andrew.cmu.edu):
+  - Added heterogeneous multi-model support (hetero / hetero3 modes)
+  - Added Plackett-Luce feed temperature (FEED_TEMPERATURE)
+  - Added post-share balancer, warm-up phase, per-agent recap
+  - Added SIGTERM handler for SLURM preemption checkpointing
+  - Added chat log + reasoning trace output
+
+The full Apache-2.0 license text is available at:
+  https://www.apache.org/licenses/LICENSE-2.0

oasis/run_v9.py

@@ -0,0 +1,1371 @@
+"""
+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 = "/data/user_data/droytbur/oasis/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())

oasis/seed_db/hf-zero-50.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f22354cbdfa1ee2003913a4be09991ad29e61e04752869fa1fded768d5ba7ac4
+size 1417216

oasis/tool_chat_template_gemma4.jinja

@@ -0,0 +1,354 @@
+{%- macro format_parameters(properties, required, filter_keys=false) -%}
+    {%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}
+    {%- set ns = namespace(found_first=false) -%}
+    {%- for key, value in properties | dictsort -%}
+        {%- set add_comma = false -%}
+        {%- if not filter_keys or key not in standard_keys -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {{ key }}:{
+            {%- if value['description'] -%}
+                description:<|"|>{{ value['description'] }}<|"|>
+                {%- set add_comma = true -%}
+            {%- endif -%}
+            {%- if value['type'] | upper == 'STRING' -%}
+                {%- if value['enum'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    enum:{{ format_argument(value['enum']) }}
+                {%- endif -%}
+            {%- elif value['type'] | upper == 'ARRAY' -%}
+                {%- if value['items'] is mapping and value['items'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    items:{
+                    {%- set ns_items = namespace(found_first=false) -%}
+                    {%- for item_key, item_value in value['items'] | dictsort -%}
+                        {%- if item_value is not none -%}
+                            {%- if ns_items.found_first %},{% endif -%}
+                            {%- set ns_items.found_first = true -%}
+                            {%- if item_key == 'properties' -%}
+                                properties:{
+                                {%- if item_value is mapping -%}
+                                    {{- format_parameters(item_value, value['items']['required'] | default([])) -}}
+                                {%- endif -%}
+                                }
+                            {%- elif item_key == 'required' -%}
+                                required:[
+                                {%- for req_item in item_value -%}
+                                    <|"|>{{- req_item -}}<|"|>
+                                    {%- if not loop.last %},{% endif -%}
+                                {%- endfor -%}
+                                ]
+                            {%- elif item_key == 'type' -%}
+                                {%- if item_value is string -%}
+                                    type:{{ format_argument(item_value | upper) }}
+                                {%- else -%}
+                                    type:{{ format_argument(item_value | map('upper') | list) }}
+                                {%- endif -%}
+                            {%- else -%}
+                                {{ item_key }}:{{ format_argument(item_value) }}
+                            {%- endif -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    }
+                {%- endif -%}
+            {%- endif -%}
+            {%- if value['nullable'] %}
+                {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                nullable:true
+            {%- endif -%}
+            {%- if value['type'] | upper == 'OBJECT' -%}
+                {%- if value['properties'] is defined and value['properties'] is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value['properties'], value['required'] | default([])) -}}
+                    }
+                {%- elif value is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value, value['required'] | default([]), filter_keys=true) -}}
+                    }
+                {%- endif -%}
+                {%- if value['required'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    required:[
+                    {%- for item in value['required'] | default([]) -%}
+                        <|"|>{{- item -}}<|"|>
+                        {%- if not loop.last %},{% endif -%}
+                    {%- endfor -%}
+                    ]
+                {%- endif -%}
+            {%- endif -%}
+            {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+            type:<|"|>{{ value['type'] | upper }}<|"|>}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endmacro -%}
+{%- macro format_function_declaration(tool_data) -%}
+    declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>
+    {%- set params = tool_data['function']['parameters'] -%}
+    {%- if params -%}
+        ,parameters:{
+        {%- if params['properties'] -%}
+            properties:{ {{- format_parameters(params['properties'], params['required']) -}} },
+        {%- endif -%}
+        {%- if params['required'] -%}
+            required:[
+            {%- for item in params['required'] -%}
+                <|"|>{{- item -}}<|"|>
+                {{- ',' if not loop.last -}}
+            {%- endfor -%}
+            ],
+        {%- endif -%}
+        {%- if params['type'] -%}
+            type:<|"|>{{- params['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if 'response' in tool_data['function'] -%}
+        {%- set response_declaration = tool_data['function']['response'] -%}
+        ,response:{
+        {%- if response_declaration['description'] -%}
+            description:<|"|>{{- response_declaration['description'] -}}<|"|>,
+        {%- endif -%}
+        {%- if response_declaration['type'] | upper == 'OBJECT' -%}
+            type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    }
+{%- endmacro -%}
+{%- macro format_argument(argument, escape_keys=True) -%}
+    {%- if argument is string -%}
+        {{- '<|"|>' + argument + '<|"|>' -}}
+    {%- elif argument is boolean -%}
+        {{- 'true' if argument else 'false' -}}
+    {%- elif argument is mapping -%}
+        {{- '{' -}}
+        {%- set ns = namespace(found_first=false) -%}
+        {%- for key, value in argument | dictsort -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {%- if escape_keys -%}
+                {{- '<|"|>' + key + '<|"|>' -}}
+            {%- else -%}
+                {{- key -}}
+            {%- endif -%}
+            :{{- format_argument(value, escape_keys=escape_keys) -}}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- elif argument is sequence -%}
+        {{- '[' -}}
+        {%- for item in argument -%}
+            {{- format_argument(item, escape_keys=escape_keys) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- ']' -}}
+    {%- else -%}
+        {{- argument -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro strip_thinking(text) -%}
+    {%- set ns = namespace(result='') -%}
+    {%- for part in text.split('<channel|>') -%}
+        {%- if '<|channel>' in part -%}
+            {%- set ns.result = ns.result + part.split('<|channel>')[0] -%}
+        {%- else -%}
+            {%- set ns.result = ns.result + part -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- ns.result | trim -}}
+{%- endmacro -%}
+
+{%- macro format_tool_response_block(tool_name, response) -%}
+    {{- '<|tool_response>' -}}
+    {%- if response is mapping -%}
+        {{- 'response:' + tool_name + '{' -}}
+        {%- for key, value in response | dictsort -%}
+            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- else -%}
+        {{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}
+    {%- endif -%}
+    {{- '<tool_response|>' -}}
+{%- endmacro -%}
+
+{%- set ns = namespace(prev_message_type=None) -%}
+{%- set loop_messages = messages -%}
+{{- bos_token -}}
+{#- Handle System/Tool Definitions Block -#}
+{%- if (enable_thinking is defined and enable_thinking) or tools or messages[0]['role'] in ['system', 'developer'] -%}
+    {{- '<|turn>system\n' -}}
+    {#- Inject Thinking token at the very top of the FIRST system turn -#}
+    {%- if enable_thinking is defined and enable_thinking -%}
+        {{- '<|think|>\n' -}}
+        {%- set ns.prev_message_type = 'think' -%}
+    {%- endif -%}
+    {%- if messages[0]['role'] in ['system', 'developer'] -%}
+        {%- if messages[0]['content'] is string -%}
+            {{- messages[0]['content'] | trim -}}
+        {%- elif messages[0]['content'] is sequence -%}
+            {%- for item in messages[0]['content'] -%}
+                {{- item['text'] | trim + ' '-}}
+            {%- endfor -%}
+        {%- endif -%}
+        {%- set loop_messages = messages[1:] -%}
+    {%- endif -%}
+    {%- if tools -%}
+        {%- for tool in tools %}
+            {{- '<|tool>' -}}
+            {{- format_function_declaration(tool) | trim -}}
+            {{- '<tool|>' -}}
+        {%- endfor %}
+        {%- set ns.prev_message_type = 'tool' -%}
+    {%- endif -%}
+    {{- '<turn|>\n' -}}
+{%- endif %}
+
+{#- Pre-scan: find last user message index for reasoning guard -#}
+{%- set ns_turn = namespace(last_user_idx=-1) -%}
+{%- for i in range(loop_messages | length) -%}
+    {%- if loop_messages[i]['role'] == 'user' -%}
+        {%- set ns_turn.last_user_idx = i -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Loop through messages -#}
+{%- for message in loop_messages -%}
+    {%- if message['role'] != 'tool' -%}
+    {%- set ns.prev_message_type = None -%}
+    {%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}
+    {#- Detect continuation: suppress duplicate <|turn>model when previous non-tool message was also assistant -#}
+    {%- set prev_nt = namespace(role=None, found=false) -%}
+    {%- if loop.index0 > 0 -%}
+        {%- for j in range(loop.index0 - 1, -1, -1) -%}
+            {%- if not prev_nt.found -%}
+                {%- if loop_messages[j]['role'] != 'tool' -%}
+                    {%- set prev_nt.role = loop_messages[j]['role'] -%}
+                    {%- set prev_nt.found = true -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+    {%- set continue_same_model_turn = (role == 'model' and prev_nt.role == 'assistant') -%}
+    {%- if not continue_same_model_turn -%}
+        {{- '<|turn>' + role + '\n' }}
+    {%- endif -%}
+
+    {#- Render reasoning/reasoning_content as thinking channel -#}
+    {%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}
+    {%- if thinking_text and loop.index0 > ns_turn.last_user_idx and message.get('tool_calls') -%}
+        {{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}
+    {%- endif -%}
+
+            {%- if message['tool_calls'] -%}
+                {%- for tool_call in message['tool_calls'] -%}
+                    {%- set function = tool_call['function'] -%}
+                    {{- '<|tool_call>call:' + function['name'] + '{' -}}
+                    {%- if function['arguments'] is mapping -%}
+                        {%- set ns_args = namespace(found_first=false) -%}
+                        {%- for key, value in function['arguments'] | dictsort -%}
+                            {%- if ns_args.found_first %},{% endif -%}
+                            {%- set ns_args.found_first = true -%}
+                            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+                        {%- endfor -%}
+                    {%- elif function['arguments'] is string -%}
+                        {{- function['arguments'] -}}
+                    {%- endif -%}
+                    {{- '}<tool_call|>' -}}
+                {%- endfor -%}
+                {%- set ns.prev_message_type = 'tool_call' -%}
+            {%- endif -%}
+
+            {%- set ns_tr_out = namespace(flag=false) -%}
+            {%- if message.get('tool_responses') -%}
+                {#- Legacy: tool_responses embedded on the assistant message (Google/Gemma native) -#}
+                {%- for tool_response in message['tool_responses'] -%}
+                    {{- format_tool_response_block(tool_response['name'] | default('unknown', true), tool_response['response']) -}}
+                    {%- set ns_tr_out.flag = true -%}
+                    {%- set ns.prev_message_type = 'tool_response' -%}
+                {%- endfor -%}
+            {%- elif message.get('tool_calls') -%}
+                {#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}
+                {%- set ns_tool_scan = namespace(stopped=false) -%}
+                {%- for k in range(loop.index0 + 1, loop_messages | length) -%}
+                    {%- if ns_tool_scan.stopped -%}
+                    {%- elif loop_messages[k]['role'] != 'tool' -%}
+                        {%- set ns_tool_scan.stopped = true -%}
+                    {%- else -%}
+                        {%- set follow = loop_messages[k] -%}
+                        {#- Resolve tool_call_id to function name -#}
+                        {%- set ns_tname = namespace(name=follow.get('name') | default('unknown', true)) -%}
+                        {%- for tc in message['tool_calls'] -%}
+                            {%- if tc.get('id') == follow.get('tool_call_id') -%}
+                                {%- set ns_tname.name = tc['function']['name'] -%}
+                            {%- endif -%}
+                        {%- endfor -%}
+                        {#- Handle content as string or content-parts array -#}
+                        {%- set tool_body = follow.get('content') -%}
+                        {%- if tool_body is string -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- elif tool_body is sequence and tool_body is not string -%}
+                            {%- set ns_txt = namespace(s='') -%}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'text' -%}
+                                    {%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}
+                                {%- endif -%}
+                            {%- endfor -%}
+                            {{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}
+                        {%- else -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- endif -%}
+                        {%- set ns_tr_out.flag = true -%}
+                        {%- set ns.prev_message_type = 'tool_response' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+            {%- set captured_content -%}
+            {%- if message['content'] is string -%}
+                {%- if role == 'model' -%}
+                    {{- strip_thinking(message['content']) -}}
+                {%- else -%}
+                    {{- message['content'] | trim -}}
+                {%- endif -%}
+            {%- elif message['content'] is sequence -%}
+                {%- for item in message['content'] -%}
+                    {%- if item['type'] == 'text' -%}
+                        {%- if role == 'model' -%}
+                            {{- strip_thinking(item['text']) -}}
+                        {%- else -%}
+                            {{- item['text'] | trim -}}
+                        {%- endif -%}
+                    {%- elif item['type'] == 'image' -%}
+                        {{- '<|image|>' -}}
+                        {%- set ns.prev_message_type = 'image' -%}
+                    {%- elif item['type'] == 'audio' -%}
+                        {{- '<|audio|>' -}}
+                        {%- set ns.prev_message_type = 'audio' -%}
+                    {%- elif item['type'] == 'video' -%}
+                        {{- '<|video|>' -}}
+                        {%- set ns.prev_message_type = 'video' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+            {%- endset -%}
+
+            {{- captured_content -}}
+            {%- set has_content = captured_content | trim | length > 0 -%}
+
+        {%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}
+            {{- '<|tool_response>' -}}
+        {%- elif not (ns_tr_out.flag and not has_content) -%}
+            {{- '<turn|>\n' -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}
+        {{- '<|turn>model\n' -}}
+        {%- if not enable_thinking | default(false) -%}
+            {{- '<|channel>thought\n<channel|>' -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endif -%}

smoke_test/assert_h_matrix.py

@@ -0,0 +1,170 @@
+"""
+Smoke-test assertions for a completed divsim run.
+
+Checks:
+  1. The DB file exists and is non-empty.
+  2. metadata.json sidecar exists and has an agent_model_map.
+  3. Both model families have ≥1 comment.
+  4. Total cross-family comments > 5.
+  5. H matrix is computable, is a dict, and has finite values for all
+     (src, dst) pairs covering both families.
+
+Usage:
+    python assert_h_matrix.py --db /path/to/sweep_*.db
+    python assert_h_matrix.py --db /path/to/sweep_*.db --min-cross 5
+"""
+
+import argparse
+import json
+import math
+import os
+import sqlite3
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+SHORT = {
+    'Qwen/Qwen3-32B':                 'Qwen',
+    'openai/gpt-oss-20b':             'gpt-oss',
+    'mistralai/Magistral-Small-2509': 'Mag',
+    'zai-org/GLM-4-32B-0414':         'GLM-4',
+    'google/gemma-4-31B-it':          'Gemma',
+}
+
+
+def compute_h(db_path: str) -> dict:
+    """Compute directed pairwise H matrix from a run DB."""
+    meta_path = db_path.replace('.db', '.metadata.json')
+    if not os.path.exists(meta_path):
+        raise FileNotFoundError(f"metadata.json not found: {meta_path}")
+    with open(meta_path) as f:
+        meta = json.load(f)
+    amm = meta.get('agent_model_map', {})
+    if not amm:
+        raise ValueError("agent_model_map is empty in metadata.json")
+
+    uf = {int(k)+1: SHORT.get(v['model'], v['model'][:8]) for k, v in amm.items()}
+    fc = defaultdict(int)
+    for fam in uf.values():
+        fc[fam] += 1
+    n = sum(fc.values())
+
+    conn     = sqlite3.connect(db_path)
+    comments = conn.execute(
+        'SELECT c.user_id, p.user_id FROM comment c '
+        'JOIN post p ON c.post_id=p.post_id WHERE c.user_id!=p.user_id'
+    ).fetchall()
+    conn.close()
+
+    ec    = defaultdict(int)
+    for cu, pu in comments:
+        sf, df = uf.get(cu), uf.get(pu)
+        if sf and df:
+            ec[(sf, df)] += 1
+
+    total = sum(ec.values())
+    if total == 0:
+        raise ValueError("No cross-family comment edges found.")
+
+    H = {}
+    for s in fc:
+        for d in fc:
+            obs = ec.get((s, d), 0) / total
+            exp = (fc[s]/n) * ((fc[d] - (1 if s == d else 0)) / (n-1))
+            if exp > 0:
+                H[(s, d)] = obs/exp - 1
+    return H, ec, fc
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--db',        required=True, help='Path to sweep_*.db file.')
+    parser.add_argument('--min-cross', type=int, default=5,
+                        help='Minimum total cross-family comments required (default: 5).')
+    args = parser.parse_args()
+
+    db_path = args.db
+    failures = []
+
+    # 1. DB exists and is non-empty
+    if not os.path.exists(db_path):
+        print(f"FAIL: DB file does not exist: {db_path}")
+        sys.exit(1)
+    if os.path.getsize(db_path) < 1000:
+        failures.append(f"DB file is too small ({os.path.getsize(db_path)} bytes)")
+
+    # 2. Metadata exists
+    meta_path = db_path.replace('.db', '.metadata.json')
+    if not os.path.exists(meta_path):
+        failures.append(f"metadata.json not found: {meta_path}")
+    else:
+        with open(meta_path) as f:
+            meta = json.load(f)
+        if not meta.get('agent_model_map'):
+            failures.append("agent_model_map is missing or empty in metadata.json")
+
+    if failures:
+        for f in failures:
+            print(f"FAIL: {f}")
+        sys.exit(1)
+
+    try:
+        H, ec, fc = compute_h(db_path)
+    except Exception as e:
+        print(f"FAIL: H matrix computation failed: {e}")
+        sys.exit(1)
+
+    families = list(fc.keys())
+    print(f"  Families: {families}")
+    print(f"  Family sizes: {dict(fc)}")
+
+    # 3. Both families have ≥1 comment
+    comments_per_family = defaultdict(int)
+    conn = sqlite3.connect(db_path)
+    comments_all = conn.execute('SELECT user_id FROM comment').fetchall()
+    conn.close()
+    amm = meta.get('agent_model_map', {})
+    uf  = {int(k)+1: SHORT.get(v['model'], v['model'][:8]) for k, v in amm.items()}
+    for (uid,) in comments_all:
+        fam = uf.get(uid)
+        if fam:
+            comments_per_family[fam] += 1
+
+    for fam in families:
+        cnt = comments_per_family.get(fam, 0)
+        if cnt < 1:
+            failures.append(f"Family '{fam}' has 0 comments")
+        else:
+            print(f"  Family '{fam}': {cnt} comments emitted — OK")
+
+    # 4. Cross-family comments > min_cross
+    cross_total = sum(v for (s, d), v in ec.items() if s != d)
+    print(f"  Cross-family comments: {cross_total} (min required: {args.min_cross})")
+    if cross_total <= args.min_cross:
+        failures.append(f"Cross-family comments {cross_total} ≤ {args.min_cross}")
+
+    # 5. H matrix has finite values for all pairs
+    print(f"  H matrix entries: {len(H)}")
+    for pair, h in H.items():
+        if not math.isfinite(h):
+            failures.append(f"H[{pair}] is not finite: {h}")
+        else:
+            print(f"    H[{pair[0]}->{pair[1]}] = {h:+.4f}")
+
+    if len(H) < len(families) * (len(families) - 1):
+        failures.append(f"H matrix has fewer entries than expected "
+                        f"({len(H)} < {len(families)*(len(families)-1)})")
+
+    if failures:
+        print("\nFAILED:")
+        for f in failures:
+            print(f"  - {f}")
+        sys.exit(1)
+    else:
+        print("\nAll assertions passed.")
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

smoke_test/run_smoke.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# Smoke test: run one short dyadic simulation and verify basic outputs.
+#
+# Spec: 1 dyad (Qwen + Magistral), 20 steps, 4 agents total (2 per family).
+# Expected runtime: < 5 minutes on 2× L40S GPUs.
+#
+# Required env vars:
+#   VLLM_URL_A   — Qwen3-32B server URL (default: http://localhost:8002/v1)
+#   VLLM_URL_B   — Magistral server URL (default: http://localhost:8004/v1)
+#   SAFEMASS_VENV — path to Python venv
+#   SEED_DB       — path to hf-zero-50.sqlite (default: ../oasis/seed_db/hf-zero-50.sqlite)
+#
+# After the run, assert_h_matrix.py is called to verify the output.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+VENV="${SAFEMASS_VENV:-${ROOT_DIR}/.venv}"
+RUNNER="${OASIS_RUNNER:-${ROOT_DIR}/oasis/run_v9.py}"
+SEED_DB="${SEED_DB:-${ROOT_DIR}/oasis/seed_db/hf-zero-50.sqlite}"
+RUNS_DIR="${RUNS_DIR:-/tmp/divsim_smoke_runs}"
+LOGS_DIR="${LOGS_DIR:-/tmp/divsim_smoke_logs}"
+
+mkdir -p "${RUNS_DIR}" "${LOGS_DIR}"
+
+export SEED_DB
+export MODEL_NAME_A="${MODEL_NAME_A:-Qwen/Qwen3-32B}"
+export MODEL_NAME_B="${MODEL_NAME_B:-mistralai/Magistral-Small-2509}"
+export VLLM_URL_A="${VLLM_URL_A:-http://localhost:8002/v1}"
+export VLLM_URL_B="${VLLM_URL_B:-http://localhost:8004/v1}"
+
+DB="${RUNS_DIR}/smoke_qwen_mag_s42.db"
+export OASIS_DB_PATH="${DB}"
+
+echo "[smoke] Starting dyadic smoke run"
+echo "  A: ${MODEL_NAME_A} @ ${VLLM_URL_A}"
+echo "  B: ${MODEL_NAME_B} @ ${VLLM_URL_B}"
+echo "  db: ${DB}"
+echo "  steps=20  agents=4  seed=42"
+
+"${VENV}/bin/python3" "${RUNNER}" \
+    --mode hetero \
+    --steps 20 \
+    --agents 4 \
+    --seed-posts 4 \
+    --activate-prob 0.5 \
+    --rng-seed 42 \
+    --db "${DB}" \
+    2>&1 | tee "${LOGS_DIR}/smoke_run.log"
+
+echo ""
+echo "[smoke] Run complete. Running assertions..."
+"${VENV}/bin/python3" "${SCRIPT_DIR}/assert_h_matrix.py" --db "${DB}"
+echo "[smoke] All assertions passed."

sweep/sweep_dyadic.py

@@ -0,0 +1,153 @@
+"""
+Dyadic (2-model) combinatorial sweep for the divsim paper.
+
+Enumerates all ordered pairs from the 5 paper models, crossed with 5 persona seeds,
+for a total of C(5,2)×2×5 = 100 configurations. Each configuration launches one
+run of the OASIS simulator in hetero mode.
+
+Configuration is read from environment variables:
+    RUNS_DIR    — output directory for .db files (required)
+    VENV_PATH   — path to the Python venv with oasis installed
+    OASIS_RUNNER — path to run_v9.py (defaults to <this_dir>/../oasis/run_v9.py)
+    LOGS_DIR    — directory for per-run log files
+
+Usage:
+    python sweep_dyadic.py --dry-run              # print all configs, no launch
+    python sweep_dyadic.py --mode 2model          # all 2-model runs (default)
+    python sweep_dyadic.py --max-parallel 2       # limit concurrent runs
+    python sweep_dyadic.py --skip-existing        # skip runs whose DB already exists
+"""
+
+import argparse
+import itertools
+import os
+import subprocess
+import time
+from pathlib import Path
+
+
+RUNS_DIR = Path(os.environ.get("RUNS_DIR", "./runs"))
+VENV     = os.environ.get("VENV_PATH", str(Path(__file__).parent.parent / ".venv"))
+RUNNER   = Path(os.environ.get("OASIS_RUNNER",
+                               str(Path(__file__).parent.parent / "oasis" / "run_v9.py")))
+LOGS_DIR = Path(os.environ.get("LOGS_DIR", "./logs/sweep"))
+
+MODELS = {
+    "qwen":   ("Qwen/Qwen3-32B",                   "http://localhost:8002/v1"),
+    "oss":    ("openai/gpt-oss-20b",               "http://localhost:8003/v1"),
+    "mag":    ("mistralai/Magistral-Small-2509",    "http://localhost:8004/v1"),
+    "glm":    ("zai-org/GLM-4-32B-0414",           "http://localhost:8007/v1"),
+    "gem":    ("google/gemma-4-31B-it",             "http://localhost:8009/v1"),
+}
+
+MODEL_KEYS = list(MODELS.keys())
+SEEDS  = [42, 137, 271, 314, 999]
+STEPS  = 100
+N_AGENTS = 20  # 10 per group
+
+
+def run_id(a: str, b: str, seed: int) -> str:
+    return f"sweep_{a[:3]}_{b[:3]}_s{seed}"
+
+
+def db_is_valid(db: Path) -> bool:
+    """Return True if the DB has enough data to be considered a complete run."""
+    if not db.exists():
+        return False
+    try:
+        import sqlite3
+        conn = sqlite3.connect(db)
+        nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
+        nc = conn.execute("SELECT COUNT(*) FROM comment").fetchone()[0]
+        conn.close()
+        return nu >= 18 and nc >= 200
+    except Exception:
+        return False
+
+
+def launch(a: str, b: str, seed: int, dry_run: bool) -> dict:
+    rid = run_id(a, b, seed)
+    db  = RUNS_DIR / f"{rid}.db"
+    log = LOGS_DIR / f"{rid}.log"
+    ma, mb = MODELS[a], MODELS[b]
+
+    env = {
+        **os.environ,
+        "VLLM_URL_A":   ma[1], "MODEL_NAME_A": ma[0],
+        "VLLM_URL_B":   mb[1], "MODEL_NAME_B": mb[0],
+        "OASIS_DB_PATH": str(db),
+    }
+    cmd = [
+        f"{VENV}/bin/python3", str(RUNNER),
+        "--mode",         "hetero",
+        "--steps",        str(STEPS),
+        "--agents",       str(N_AGENTS),
+        "--seed-posts",   str(N_AGENTS),
+        "--activate-prob", "0.3",
+        "--rng-seed",     str(seed),
+        "--db",           str(db),
+    ]
+
+    if dry_run:
+        print(f"  [DRY] {rid}  A={a}({ma[0]})  B={b}({mb[0]})  seed={seed}")
+        return {"rid": rid, "proc": None}
+
+    LOGS_DIR.mkdir(parents=True, exist_ok=True)
+    RUNS_DIR.mkdir(parents=True, exist_ok=True)
+    with open(log, "w") as lf:
+        proc = subprocess.Popen(cmd, env=env, stdout=lf, stderr=lf)
+    print(f"  [{rid}] PID={proc.pid}  A={a}  B={b}  seed={seed}")
+    return {"rid": rid, "proc": proc}
+
+
+def all_configs():
+    configs = []
+    for pair in itertools.combinations(MODEL_KEYS, 2):
+        for perm in itertools.permutations(pair):
+            for seed in SEEDS:
+                configs.append((perm[0], perm[1], seed))
+    return configs
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run",      action="store_true",
+                        help="Print configs without launching.")
+    parser.add_argument("--max-parallel", type=int, default=2,
+                        help="Maximum concurrent runs.")
+    parser.add_argument("--skip-existing", action="store_true", default=True,
+                        help="Skip runs whose DB already exists and is valid.")
+    args = parser.parse_args()
+
+    configs = all_configs()
+    print(f"Dyadic sweep: {len(configs)} configs "
+          f"(C(5,2)×2 ordered pairs × {len(SEEDS)} seeds)")
+    print(f"Seeds: {SEEDS}  max_parallel: {args.max_parallel}  "
+          f"dry_run: {args.dry_run}")
+
+    active = []
+    for a, b, seed in configs:
+        active = [r for r in active if r["proc"] and r["proc"].poll() is None]
+        while len(active) >= args.max_parallel:
+            time.sleep(10)
+            active = [r for r in active if r["proc"] and r["proc"].poll() is None]
+
+        if args.skip_existing:
+            db = RUNS_DIR / f"{run_id(a, b, seed)}.db"
+            if db_is_valid(db):
+                print(f"  [skip] {run_id(a, b, seed)} (valid DB exists)")
+                continue
+
+        r = launch(a, b, seed, args.dry_run)
+        if r["proc"]:
+            active.append(r)
+        time.sleep(2)
+
+    for r in active:
+        if r["proc"]:
+            r["proc"].wait()
+    print("All dyadic configs done.")
+
+
+if __name__ == "__main__":
+    main()

sweep/sweep_triadic.py

@@ -0,0 +1,170 @@
+"""
+Triadic (3-model) sweep for the divsim paper, with preemption support.
+
+Enumerates all C(5,3)=10 model triplets, samples 3 of the 6 possible orderings
+per triplet (the 3 with maximum positional diversity), crossed with 3 seeds.
+Total: 10 triplets × 3 orderings × 3 seeds = 90 configurations.
+
+Preemption support: run_v9.py catches SIGTERM and exits cleanly after the
+current step commit. This script checks for partial DBs and resumes them via
+--resume rather than restarting from scratch.
+
+Configuration is read from environment variables:
+    RUNS_DIR    — output directory for .db files (required)
+    VENV_PATH   — path to the Python venv with oasis installed
+    OASIS_RUNNER — path to run_v9.py (defaults to <this_dir>/../oasis/run_v9.py)
+    LOGS_DIR    — directory for per-run log files
+
+Usage:
+    python sweep_triadic.py --dry-run              # print all configs, no launch
+    python sweep_triadic.py --max-parallel 2       # limit concurrent runs
+    python sweep_triadic.py --triplets qwen,oss,mag  # run a specific triplet only
+"""
+
+import argparse
+import itertools
+import os
+import subprocess
+import time
+from pathlib import Path
+
+
+RUNS_DIR = Path(os.environ.get("RUNS_DIR", "./runs"))
+VENV     = os.environ.get("VENV_PATH", str(Path(__file__).parent.parent / ".venv"))
+RUNNER   = Path(os.environ.get("OASIS_RUNNER",
+                               str(Path(__file__).parent.parent / "oasis" / "run_v9.py")))
+LOGS_DIR = Path(os.environ.get("LOGS_DIR", "./logs/sweep"))
+
+MODELS = {
+    "qwen":   ("Qwen/Qwen3-32B",                   "http://localhost:8002/v1"),
+    "oss":    ("openai/gpt-oss-20b",               "http://localhost:8003/v1"),
+    "mag":    ("mistralai/Magistral-Small-2509",    "http://localhost:8004/v1"),
+    "glm":    ("zai-org/GLM-4-32B-0414",           "http://localhost:8007/v1"),
+    "gem":    ("google/gemma-4-31B-it",             "http://localhost:8009/v1"),
+}
+
+SEEDS   = [42, 271, 999]
+STEPS   = 100
+N_AGENTS = 30  # 10 per group
+
+
+def sampled_orderings(triplet: tuple) -> list:
+    """Return 3 of the 6 possible permutations, evenly spaced for positional diversity."""
+    perms = list(itertools.permutations(triplet))
+    return [perms[0], perms[2], perms[4]]
+
+
+def run_id(perm: tuple, seed: int) -> str:
+    return f"sweep_tri_{'_'.join(m[:3] for m in perm)}_s{seed}"
+
+
+def db_is_valid(db: Path) -> bool:
+    """Return True if the DB has enough active agents to be a complete triadic run."""
+    if not db.exists():
+        return False
+    try:
+        import sqlite3
+        conn = sqlite3.connect(db)
+        nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0]
+        conn.close()
+        return nu >= 26
+    except Exception:
+        return False
+
+
+def launch(perm: tuple, seed: int, dry_run: bool) -> dict | None:
+    rid = run_id(perm, seed)
+    db  = RUNS_DIR / f"{rid}.db"
+    log = LOGS_DIR / f"{rid}.log"
+
+    if db_is_valid(db):
+        print(f"  [skip] {rid} (valid DB exists)")
+        return None
+
+    resume = db.exists() and db.stat().st_size > 50_000
+
+    ma, mb, mc = MODELS[perm[0]], MODELS[perm[1]], MODELS[perm[2]]
+    env = {
+        **os.environ,
+        "VLLM_URL_A":   ma[1], "MODEL_NAME_A": ma[0],
+        "VLLM_URL_B":   mb[1], "MODEL_NAME_B": mb[0],
+        "VLLM_URL_C":   mc[1], "MODEL_NAME_C": mc[0],
+        "OASIS_DB_PATH": str(db),
+    }
+    cmd = [
+        f"{VENV}/bin/python3", str(RUNNER),
+        "--mode",         "hetero3",
+        "--steps",        str(STEPS),
+        "--agents",       str(N_AGENTS),
+        "--seed-posts",   str(N_AGENTS),
+        "--activate-prob", "0.3",
+        "--rng-seed",     str(seed),
+        "--db",           str(db),
+    ]
+    if resume:
+        cmd.append("--resume")
+
+    status = "[resume]" if resume else "[run]   "
+    print(f"  {status} {rid}")
+
+    if dry_run:
+        print(f"           A={perm[0]}  B={perm[1]}  C={perm[2]}  seed={seed}")
+        return None
+
+    LOGS_DIR.mkdir(parents=True, exist_ok=True)
+    RUNS_DIR.mkdir(parents=True, exist_ok=True)
+    with open(log, "a") as lf:
+        proc = subprocess.Popen(cmd, env=env, stdout=lf, stderr=lf)
+    return {"rid": rid, "proc": proc}
+
+
+def all_triplets():
+    return list(itertools.combinations(MODELS.keys(), 3))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dry-run",      action="store_true",
+                        help="Print configs without launching.")
+    parser.add_argument("--max-parallel", type=int, default=2,
+                        help="Maximum concurrent runs.")
+    parser.add_argument("--triplets",     nargs="*",
+                        help="Restrict to specific triplets, e.g. qwen,oss,mag")
+    args = parser.parse_args()
+
+    triplets = all_triplets()
+    if args.triplets:
+        triplets = [tuple(t.split(",")) for t in args.triplets]
+
+    configs = [
+        (perm, seed)
+        for triplet in triplets
+        for perm in sampled_orderings(triplet)
+        for seed in SEEDS
+    ]
+
+    print(f"Triadic sweep: {len(triplets)} triplets × 3 orderings × "
+          f"{len(SEEDS)} seeds = {len(configs)} configs")
+    print(f"Triplets: {['+'.join(t) for t in triplets]}")
+    print()
+
+    active = []
+    for perm, seed in configs:
+        active = [r for r in active if r["proc"].poll() is None]
+        while len(active) >= args.max_parallel:
+            time.sleep(15)
+            active = [r for r in active if r["proc"].poll() is None]
+
+        r = launch(perm, seed, args.dry_run)
+        if r:
+            active.append(r)
+        if not args.dry_run:
+            time.sleep(2)
+
+    for r in active:
+        r["proc"].wait()
+    print("All triadic configs done.")
+
+
+if __name__ == "__main__":
+    main()