Add divdata build scripts (build_divdata.py, build_trajectories.py); document consolidated dataset; replace absolute paths with $RUNS_DIR / OASIS_ROOT / SEED_DB env vars

README.md

@@ -193,13 +193,32 @@ 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
+$RUNS_DIR/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`.
 
+### Consolidated dataset (`divdata`)
+
+Every run is also released as one Parquet dataset indexed by `run_id` and `step`
+(`anonymousfileupload/divdata` on the Hub): posts, comments, agents, impressions (the feed
+each agent saw, with slate position), actions, and **trajectories** — one row per agent
+activation including passive ones, with the tool call the model emitted, its stated
+deliberation / reasoning where the family exposes one, and wall-clock timestamps. The two
+scripts that build it from the run databases are in `data/`:
+
+```bash
+export OASIS_ROOT=/path/containing/runs        # directory that holds runs/*.db + sidecars
+python data/build_divdata.py       --out divdata/                        # 6 core tables
+python data/build_trajectories.py  --out divdata/ --workers 16 --patch-steps  # trajectories + step back-fill
+```
+
+`step` is not stored by the simulator; both scripts reconstruct it from the per-run chat
+sidecar and document exactly where the alignment is exact and where it is left NULL. See
+the dataset's `README.md` and `BUILD_LOG.md` for the details and for the 2026-09-09 erratum.
+
 ---
 
 ## Repository layout
@@ -235,7 +254,9 @@ divsim_publish/
 │   ├── 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
+│   ├── MANIFEST.md              # DB paths, SHA-256, size, (pair/triplet, seed) labels
+│   ├── build_divdata.py         # run DBs -> divdata Parquet (runs/agents/posts/comments/impressions/actions)
+│   └── build_trajectories.py    # + trajectories.parquet (every activation, passive included) and step back-fill
 ├── 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

data/build_divdata.py

@@ -0,0 +1,211 @@
+"""Consolidate every OASIS run into one Parquet dataset indexed by run_id and step.
+
+Each simulation currently lives as <run>.db + <run>.metadata.json + <run>_chats.jsonl.
+Step is NOT stored in the database; it lives only in the chat sidecar, one row per agent
+activation. Validated on every run: the agent's k-th status='ok' activation corresponds to
+its k-th action in `trace` ordered by time, so step is recovered EXACTLY (not inferred).
+Runs where that alignment fails are still emitted, with step = NULL and a flag, rather than
+silently guessed.
+
+Impressions are normalised. In the raw databases each `trace.refresh` event embeds the full
+text of all 20 slate posts, which is ~48% of every file (17.9 MB of a 37.6 MB run). Here an
+impression is just (run_id, step, viewer_agent_id, post_id); post text is stored once in
+`posts`. That is a ~150x reduction on the largest table.
+
+Tables written (one Parquet file each):
+  runs        run_id, experiment_type, model_default, n_agents, n_initial, steps, join_step,
+              created_at, source_path, step_alignment_ok, step_coverage
+  agents      run_id, agent_id, user_id, model, persona, join_step
+  posts       run_id, post_id, agent_id, model, step, created_at, content
+  comments    run_id, comment_id, post_id, agent_id, model, step, created_at, content,
+              is_cross_model
+  impressions run_id, step, viewer_agent_id, post_id, slot (0-based position in the 20-slot slate)
+  actions     run_id, agent_id, step, action, created_at
+"""
+import sqlite3, glob, os, re, json, argparse, collections
+import pandas as pd
+
+ROOT = os.environ.get("OASIS_ROOT", ".")   # directory holding runs/ (and attractor_rl/eval_runs*/)
+
+
+def agent_models(meta_path):
+    try:
+        j = json.load(open(meta_path))
+    except Exception:
+        return None, {}
+    am = j.get("agent_model_map") or {}
+    out = {}
+    for k, v in am.items():
+        try: k = int(k)
+        except Exception: pass
+        if isinstance(v, dict):
+            out[k] = (v.get("model", "").split("/")[-1], v.get("join_step"))
+        else:
+            out[k] = (str(v).split("/")[-1], None)
+    return j, out
+
+
+def steps_for(db, u2a):
+    """Two per-agent step sequences from the chat sidecar, in file order:
+      ok   -- steps of status='ok' activations (incl. step 0). The k-th one is the
+              agent's k-th ACTION (post or comment) in time order.
+      ref  -- steps of every activation with step > 0, any status. The k-th one is the
+              agent's k-th `refresh` row in trace: exhausted activations still refresh,
+              and the step-0 intro post is written without a refresh.
+    Returns (ok, ref) or None if there is no sidecar."""
+    ch = db.replace(".db", "_chats.jsonl")
+    if not os.path.exists(ch):
+        return None
+    ok = collections.defaultdict(list); ref = collections.defaultdict(list)
+    try:
+        for line in open(ch):
+            try: d = json.loads(line)
+            except Exception: continue
+            ag = d.get("agent_id"); st = d.get("step")
+            if d.get("status") == "ok":
+                ok[ag].append(st)
+            try:
+                if int(st) > 0: ref[ag].append(st)
+            except Exception:
+                pass
+    except Exception:
+        return None
+    return ok, ref
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="divdata")
+    ap.add_argument("--limit", type=int, default=0)
+    a = ap.parse_args()
+    os.makedirs(a.out, exist_ok=True)
+
+    dbs = sorted(glob.glob(os.path.join(ROOT, "runs/**/*.db"), recursive=True)) + \
+          sorted(glob.glob(os.path.join(ROOT, "attractor_rl/eval_runs*/**/*.db"), recursive=True))
+    if a.limit: dbs = dbs[:a.limit]
+
+    R, A, P, C, I, X = [], [], [], [], [], []
+    aligned = misaligned = skipped = 0
+
+    for idx, db in enumerate(dbs):
+        if os.path.exists(db.replace(".db", "_checkpoint.json")): skipped += 1; continue
+        meta_p = db.replace(".db", ".metadata.json")
+        if not os.path.exists(meta_p): skipped += 1; continue
+        meta, am = agent_models(meta_p)
+        if not am: skipped += 1; continue
+        run_id = os.path.relpath(db, ROOT)[:-3].replace("/", "__")
+        try:
+            c = sqlite3.connect(db)
+            users = list(c.execute("SELECT user_id, agent_id, user_name FROM user"))
+            u2a = {u: ag for u, ag, _ in users}
+            a2u = {ag: u for u, ag, _ in users}
+            persona = {ag: nm for _, ag, nm in users}
+
+            _sq = steps_for(db, u2a)
+            seq, rseq = (_sq if _sq else (None, None))
+            trace = list(c.execute(
+                "SELECT user_id, action, created_at FROM trace "
+                "WHERE action IN ('create_post','create_comment') ORDER BY created_at, rowid"))
+            per_agent_actions = collections.defaultdict(list)
+            for uid, act, ts in trace:
+                ag = u2a.get(uid)
+                if ag is not None: per_agent_actions[ag].append((act, ts))
+
+            # PER-AGENT alignment. An agent's k-th successful activation is its k-th
+            # action in time order, so when the two counts agree the step is EXACT. A
+            # single stray action (seen in ~half the older sweeps: one agent off by one,
+            # e.g. 380 activations vs 379 actions) must not discard the other 19 agents,
+            # so alignment is decided per agent and unalignable agents get step = NULL.
+            step_of = {}
+            n_ok = n_tot = 0
+            for ag, acts in per_agent_actions.items():
+                s_ag = (seq or {}).get(ag, [])
+                n_tot += len(acts)
+                if len(s_ag) == len(acts):
+                    n_ok += len(acts)
+                    for i, _ in enumerate(acts):
+                        step_of[(ag, i)] = s_ag[i]
+            ok = n_tot > 0 and n_ok == n_tot
+            aligned += ok; misaligned += (not ok)
+            cover = (n_ok / n_tot) if n_tot else 0.0
+
+            for ag, (model, js) in am.items():
+                A.append(dict(run_id=run_id, agent_id=ag, user_id=a2u.get(ag),
+                              model=model, persona=persona.get(ag), join_step=js))
+
+            # Posts and comments are merged into ONE time-ordered stream per agent before
+            # indexing. (An earlier version indexed all posts, then all comments, which
+            # mis-assigned step for every agent that had both -- see BUILD_LOG.)
+            events = [("post", pid, None, uid, ts, content) for pid, uid, ts, content in c.execute(
+                          "SELECT post_id, user_id, created_at, content FROM post")] + \
+                     [("comment", cid, pid, uid, ts, content) for cid, pid, uid, ts, content in c.execute(
+                          "SELECT comment_id, post_id, user_id, created_at, content FROM comment")]
+            events.sort(key=lambda e: (e[4], e[1]))
+            seen = collections.Counter()
+            owner, ownmodel = {}, {}
+            for kind, _id, pid, uid, ts, content in events:
+                ag = u2a.get(uid); m = am.get(ag, ("", None))[0] if ag is not None else None
+                st = step_of.get((ag, seen[ag]))
+                seen[ag] += 1
+                if kind == "post":
+                    owner[_id] = ag; ownmodel[_id] = m
+                    P.append(dict(run_id=run_id, post_id=_id, agent_id=ag, model=m,
+                                  step=st, created_at=ts, content=content))
+                else:
+                    om = ownmodel.get(pid)
+                    C.append(dict(run_id=run_id, comment_id=_id, post_id=pid, agent_id=ag, model=m,
+                                  step=st, created_at=ts, content=content,
+                                  is_cross_model=(bool(om and m and om != m) if om and m else None)))
+
+            # impressions: normalised out of trace.refresh
+            ref = list(c.execute("SELECT user_id, created_at, info FROM trace WHERE action='refresh' ORDER BY created_at, rowid"))
+            nref = collections.Counter(u2a.get(uid) for uid, _, _ in ref)
+            rseen = collections.Counter()
+            for uid, ts, info in ref:
+                ag = u2a.get(uid)
+                try: d = json.loads(info)
+                except Exception: continue
+                st = None
+                r_ag = (rseq or {}).get(ag, [])
+                k = rseen[ag]
+                if len(r_ag) == nref[ag] and k < len(r_ag): st = r_ag[k]
+                rseen[ag] += 1
+                for slot, p in enumerate(d.get("posts", []) or []):
+                    pid = p.get("post_id")
+                    if pid is not None:
+                        I.append(dict(run_id=run_id, step=st, viewer_agent_id=ag, post_id=pid, slot=slot))
+            aseen = collections.Counter()
+            for uid, act, ts in trace:
+                ag = u2a.get(uid)
+                X.append(dict(run_id=run_id, agent_id=ag, step=step_of.get((ag, aseen[ag])), action=act, created_at=ts))
+                aseen[ag] += 1
+            c.close()
+
+            R.append(dict(run_id=run_id,
+                          experiment_type=(meta or {}).get("experiment_type"),
+                          model_default=(meta or {}).get("model_default"),
+                          n_agents=(meta or {}).get("n_agents"),
+                          n_initial=(meta or {}).get("n_initial"),
+                          steps=(meta or {}).get("steps"),
+                          join_step=(meta or {}).get("join_step"),
+                          created_at=(meta or {}).get("created_at"),
+                          source_path=os.path.relpath(db, ROOT),
+                          step_alignment_ok=bool(ok),
+                          step_coverage=round(cover, 4)))
+        except Exception:
+            skipped += 1
+            continue
+        if (idx + 1) % 100 == 0:
+            print(f"  ...{idx+1}/{len(dbs)}  runs={len(R)} posts={len(P)} comments={len(C)} impressions={len(I)}", flush=True)
+
+    print(f"\n  runs kept={len(R)} skipped={skipped}  step-aligned={aligned} misaligned={misaligned}")
+    for name, rows in (("runs", R), ("agents", A), ("posts", P), ("comments", C),
+                       ("impressions", I), ("actions", X)):
+        df = pd.DataFrame(rows)
+        p = os.path.join(a.out, f"{name}.parquet")
+        df.to_parquet(p, index=False, compression="zstd")
+        print(f"  {name:12s} {len(df):9d} rows  {os.path.getsize(p)/1e6:8.1f} MB")
+
+
+if __name__ == "__main__":
+    main()

data/build_trajectories.py

@@ -0,0 +1,264 @@
+"""Reconstruct per-agent, per-activation trajectories -- INCLUDING passive activations -- for
+every run in divdata, and write `trajectories.parquet`.
+
+Why this exists. `actions.parquet` only contains the two active actions the simulator logs
+(create_post, create_comment). But every activation begins with a `refresh` row in `trace`
+(the feed fetch) that carries a wall-clock timestamp whether or not the agent then acts, so
+the *passive* side of the trajectory -- "agent was activated, looked at the feed, did
+nothing" -- is fully recoverable from the database. Validated on the source runs: every
+refresh window contains at most one action (1196/1200 windows have exactly one; the 4 with
+zero are `status=exhausted` activations where all retries failed to parse).
+
+Alignment to step. `step` is not in the database; it lives in `<run>_chats.jsonl`, one row
+per activation. Step-0 rows have no refresh (the sign-up intro post is written directly), so
+the k-th refresh of an agent is its k-th chats row with step > 0. Where that count matches,
+step is EXACT; where an agent is off by one (seen in ~half the older sweeps) its steps are
+NULL but its timestamps and actions are still emitted. Coverage is reported per run.
+
+Reasoning. Some model families emit a free-text deliberation before the tool call; the
+harness stored it in `<run>_reasoning.jsonl` keyed by (step, agent_id). It is joined on
+where the step aligned. Absent for families that do not expose reasoning.
+
+Decision record. Each activation's attempts in the chat sidecar carry the model's visible
+output (`response_content` -- gemma and Magistral state their deliberation here ~95-99% of
+the time, Qwen3 ~19%, gpt-oss/GLM-4 never), the tool call it chose (name + args, so the
+target post is known even when the action later failed), and the parse error of each failed
+attempt. All three are kept. The prompt is not: the feed it contained is `impressions`.
+
+Row = one activation of one agent:
+  run_id, agent_id, model, activation_idx, step, refreshed_at, status, n_attempts,
+  action ('create_post' | 'create_comment' | 'none'), acted_at, latency_s,
+  post_id (own post for create_post; target post for create_comment), comment_id,
+  tool_name, tool_args (JSON), response_text, reasoning, finish_reason, errors,
+  extra_in_window (True for a 2nd+ action inside one refresh window; see below)
+"""
+import sqlite3, glob, os, json, argparse, collections, sys
+import pandas as pd
+
+ROOT = os.environ.get("OASIS_ROOT", ".")   # directory holding runs/ (and attractor_rl/eval_runs*/)
+sys.path.insert(0, os.path.dirname(__file__))
+from build_divdata import agent_models
+
+
+def decision(d):
+    """The decision record of one activation, from its attempts list: the visible text the
+    model produced (its stated deliberation, where the family emits one), the tool call it
+    chose, and the parse errors of failed attempts. The prompt (user_message) is NOT kept --
+    the feed it contained is already in `impressions`, in slate order."""
+    atts = d.get("attempts") or []
+    last = next((a for a in reversed(atts) if "tool_calls" in a or "response_content" in a), None)
+    errs = [a.get("error") for a in atts if a.get("error")]
+    tc = (last or {}).get("tool_calls") or []
+    tc0 = tc[0] if tc else {}
+    return dict(n_attempts=len(atts),
+                response_text=((last or {}).get("response_content") or None),
+                finish_reason=((last or {}).get("finish_reason") or None),
+                tool_name=tc0.get("name"), tool_args=(json.dumps(tc0.get("args"), ensure_ascii=False) if tc0 else None),
+                errors=(" | ".join(str(e) for e in errs) or None))
+
+
+def load_chats(path):
+    """agent_id -> list of (step, status, decision) in file order, step>0 only; plus the
+    step-0 record per agent (the intro post, written without a refresh)."""
+    seq = collections.defaultdict(list); step0 = {}
+    for line in open(path):
+        try: d = json.loads(line)
+        except Exception: continue
+        try: st = int(d.get("step"))
+        except Exception: continue
+        ag = int(d.get("agent_id"))
+        if st == 0: step0[ag] = decision(d); continue
+        seq[ag].append((st, d.get("status"), decision(d)))
+    return seq, step0
+
+
+def load_reasoning(path):
+    out = {}
+    if not os.path.exists(path): return out
+    for line in open(path):
+        try: d = json.loads(line)
+        except Exception: continue
+        try: out[(int(d["step"]), int(d["agent_id"]))] = d.get("reasoning")
+        except Exception: continue
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="divdata")
+    ap.add_argument("--runs", default="divdata/runs.parquet")
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--workers", type=int, default=8)
+    ap.add_argument("--patch-steps", action="store_true",
+                    help="fill NULL step in posts/comments/actions of --out from the trajectory alignment")
+    a = ap.parse_args()
+
+    runs = pd.read_parquet(a.runs, columns=["run_id", "source_path"])
+    if a.limit: runs = runs.head(a.limit)
+
+    T = []
+    log = dict(runs=0, no_chats=0, agents=0, agents_aligned=0, activations=0, passive=0,
+               windows_multi=0, agents_multi=0, with_reasoning=0, with_response_text=0, with_tool_call=0, status=collections.Counter())
+    from multiprocessing import Pool
+    with Pool(a.workers) as pool:
+        for i, (rows, plog) in enumerate(pool.imap_unordered(one_run, list(zip(runs.run_id, runs.source_path)), chunksize=4)):
+            T.extend(rows)
+            for k, v in plog.items():
+                if k == "status":
+                    for kk, vv in v.items(): log["status"][kk] += vv
+                else: log[k] += v
+            if (i + 1) % 100 == 0:
+                print(f"  ...{i+1}/{len(runs)} activations={len(T)}", flush=True)
+    finish(a, T, log)
+
+
+def one_run(arg):
+    run_id, rel = arg
+    log = dict(runs=0, no_chats=0, agents=0, agents_aligned=0, activations=0, passive=0,
+               windows_multi=0, agents_multi=0, with_reasoning=0, with_response_text=0, with_tool_call=0, status=collections.Counter())
+    T = []
+    if True:
+        db = os.path.join(ROOT, rel)
+        meta_p = db.replace(".db", ".metadata.json")
+        _, am = agent_models(meta_p)
+        ch_p = db.replace(".db", "_chats.jsonl")
+        seq, step0 = load_chats(ch_p) if os.path.exists(ch_p) else (None, {})
+        if seq is None: log["no_chats"] += 1
+        reason = load_reasoning(db.replace(".db", "_reasoning.jsonl"))
+        try:
+            c = sqlite3.connect(db)
+            u2a = {u: g for u, g in c.execute("SELECT user_id, agent_id FROM user")}
+            # trace and post/comment timestamps differ by ~80 ms, so link by per-agent
+            # ordinal instead: the agent's k-th create_post in trace is its k-th post row.
+            posts_of = collections.defaultdict(list); coms_of = collections.defaultdict(list)
+            for pid, u in c.execute("SELECT post_id, user_id FROM post ORDER BY created_at, post_id"):
+                posts_of[u2a.get(u)].append(pid)
+            for cid, pid, u in c.execute("SELECT comment_id, post_id, user_id FROM comment ORDER BY created_at, comment_id"):
+                coms_of[u2a.get(u)].append((cid, pid))
+            tr = c.execute("SELECT user_id, created_at, action FROM trace WHERE action IN ('refresh','create_post','create_comment') "
+                           "ORDER BY created_at, rowid").fetchall()
+            c.close()
+        except Exception:
+            return T, log
+        log["runs"] += 1
+        per = collections.defaultdict(list)
+        for u, ts, act in tr:
+            ag = u2a.get(u)
+            if ag is not None: per[ag].append((ts, act))
+
+        for ag, events in per.items():
+            model = am.get(ag, ("", None))[0] if am else None
+            s_ag = (seq or {}).get(ag, [])
+            n_ref = sum(1 for _, act in events if act == "refresh")
+            aligned = (seq is not None) and (len(s_ag) == n_ref)
+            log["agents"] += 1; log["agents_aligned"] += aligned
+            # walk windows
+            k = -1; cur = None; kp = kc = 0; multi = False
+            rows = []
+            for ts, act in events:
+                if act == "refresh":
+                    if cur: rows.append(cur)
+                    k += 1
+                    st, status, dec = (s_ag[k] if aligned else (None, None, {}))
+                    cur = dict(run_id=run_id, agent_id=ag, model=model, activation_idx=k, step=st,
+                               refreshed_at=ts, status=status, action="none",
+                               acted_at=None, post_id=None, comment_id=None, **dec,
+                               reasoning=(reason.get((st, ag)) if st is not None else None))
+                else:
+                    if cur is None:
+                        # step-0 intro post: no refresh precedes it
+                        rows.append(dict(run_id=run_id, agent_id=ag, model=model, activation_idx=-1, step=0,
+                                         refreshed_at=None, status="ok", action=act, **step0.get(ag, {}),
+                                         acted_at=ts, post_id=(posts_of[ag][kp] if kp < len(posts_of[ag]) else None),
+                                         comment_id=None, reasoning=reason.get((0, ag))))
+                        kp += 1
+                        continue
+                    if cur["action"] != "none":
+                        # A second action inside one refresh window. 16 runs (one old v9
+                        # hetero_late archive run accounts for 2,468 of 3,247 such actions)
+                        # violate the one-action-per-activation assumption, so the refresh
+                        # alignment is not trustworthy for this agent: the extra action gets
+                        # its own row (same activation_idx, extra_in_window=True) and the
+                        # whole agent's step/decision fields are nulled below.
+                        log["windows_multi"] += 1; multi = True
+                        rows.append(cur)
+                        cur = dict(cur, action="none", acted_at=None, post_id=None, comment_id=None, extra_in_window=True)
+                    cur["action"] = act; cur["acted_at"] = ts
+                    if act == "create_post":
+                        cur["post_id"] = posts_of[ag][kp] if kp < len(posts_of[ag]) else None; kp += 1
+                    else:
+                        cid, pid = coms_of[ag][kc] if kc < len(coms_of[ag]) else (None, None); kc += 1
+                        cur["comment_id"] = cid; cur["post_id"] = pid
+            if cur: rows.append(cur)
+            if multi:
+                log["agents_multi"] += 1
+                for r in rows:
+                    if r["activation_idx"] >= 0:
+                        for f in ("step", "status", "n_attempts", "response_text", "finish_reason",
+                                  "tool_name", "tool_args", "errors", "reasoning"):
+                            r[f] = None
+            for r in rows:
+                r.setdefault("extra_in_window", False)
+                log["activations"] += 1
+                log["passive"] += (r["action"] == "none")
+                log["with_reasoning"] += (r["reasoning"] is not None)
+                log["with_response_text"] += bool(r.get("response_text"))
+                log["with_tool_call"] += bool(r.get("tool_name"))
+                log["status"][r["status"]] += 1
+            T.extend(rows)
+    return T, log
+
+
+def finish(a, T, log):
+    df = pd.DataFrame(T)
+    # older runs wrote second-precision timestamps, newer ones microseconds
+    df["refreshed_at"] = pd.to_datetime(df.refreshed_at, format="mixed"); df["acted_at"] = pd.to_datetime(df.acted_at, format="mixed")
+    df["latency_s"] = (df.acted_at - df.refreshed_at).dt.total_seconds().round(3)
+    df["step"] = df.step.astype("Int64"); df["n_attempts"] = df.n_attempts.astype("Int64")
+    for col in ("response_text", "finish_reason", "tool_name", "tool_args", "errors", "reasoning"):
+        if col not in df: df[col] = None
+    df["post_id"] = df.post_id.astype("Int64"); df["comment_id"] = df.comment_id.astype("Int64")
+    df = df[["run_id", "agent_id", "model", "activation_idx", "step", "refreshed_at", "status", "n_attempts",
+             "action", "acted_at", "latency_s", "post_id", "comment_id",
+             "tool_name", "tool_args", "response_text", "reasoning", "finish_reason", "errors", "extra_in_window"]]
+    p = os.path.join(a.out, "trajectories.parquet")
+    df.to_parquet(p, index=False, compression="zstd")
+    log["status"] = dict(log["status"])
+    log["rows"] = len(df); log["size_mb"] = round(os.path.getsize(p) / 1e6, 1)
+    log["step_coverage"] = round(float(df.step.notna().mean()), 4)
+    log["action_counts"] = df.action.value_counts().to_dict()
+    print(json.dumps(log, indent=1, default=str))
+    if a.patch_steps:
+        patch_steps(a.out, df, log)
+    json.dump(log, open(os.path.join(a.out, "_trajectories_build_log.json"), "w"), indent=1, default=str)
+
+
+def patch_steps(out, t, log):
+    """The refresh-window alignment holds for every agent that has a chat sidecar, whereas
+    build_divdata's action-count alignment fails for an agent whose ok-activation and
+    action counts differ. Where the two agree they agree exactly (verified 100% on every
+    comparable row), so use the window alignment to fill step where build_divdata left NULL.
+    Existing non-null values are never overwritten."""
+    key = t[t.action != "none"].dropna(subset=["step"])
+    for name, on, sub in (("posts", ["run_id", "post_id"], key[key.action == "create_post"]),
+                          ("comments", ["run_id", "comment_id"], key[key.action == "create_comment"]),
+                          ("actions", ["run_id", "agent_id", "created_at"], key.assign(created_at=key.acted_at))):
+        p = os.path.join(out, f"{name}.parquet")
+        if not os.path.exists(p): continue
+        df = pd.read_parquet(p)
+        if name == "actions": df["created_at"] = pd.to_datetime(df.created_at, format="mixed")
+        m = df.merge(sub[on + ["step"]].rename(columns={"step": "_s"}), on=on, how="left")
+        before = df.step.isna().sum()
+        both = m.dropna(subset=["step", "_s"])
+        agree = float((both.step.astype(int) == both._s.astype(int)).mean()) if len(both) else 1.0
+        m["step"] = m.step.where(m.step.notna(), m._s).astype("Int64")
+        m = m.drop(columns="_s")
+        if name == "actions": m["created_at"] = m.created_at.astype(str)
+        m.to_parquet(p, index=False, compression="zstd")
+        log[f"patch_{name}"] = dict(null_before=int(before), null_after=int(m.step.isna().sum()),
+                                    rows=len(m), agreement_on_overlap=round(agree, 5))
+        print(f"  patched {name}: step NULL {before} -> {int(m.step.isna().sum())} of {len(m)}; overlap agreement {agree:.5f}")
+
+
+if __name__ == "__main__":
+    main()

oasis/run_v9.py

@@ -52,7 +52,7 @@ 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"
+SEED_DB = os.environ.get("SEED_DB", "data/mock-dbs/hf-zero-50.sqlite")
 
 
 def write_metadata(db_path: str, mode: str, n_agents: int, n_initial: int,