Initial release: 204,520 agent-step records, 5 conditions, 6 scenarios

README.md

@@ -1,3 +1,247 @@
----
-license: mit
----
+---
+license: mit
+language:
+  - en
+tags:
+  - generative-agents
+  - emotion
+  - multi-agent
+  - simulation
+  - reinforcement-learning
+  - cognitive-science
+  - occ-theory
+  - predictive-processing
+task_categories:
+  - reinforcement-learning
+  - text-classification
+size_categories:
+  - 100K<n<1M
+pretty_name: "Emotion Engine: Emergent Emotional Appraisal in Generative Agents"
+---
+
+# Emotion Engine Dataset
+
+**204,520 agent-step records** from a five-condition controlled experiment on emergent
+emotional appraisal in generative agents.
+
+> Paper: *Emergent Emotional Appraisal in Generative Agents via Predictive World Modeling*
+> Author: Prem Babu Kanaparthi
+> Code: [github.com/YOUR_USERNAME/emotion-engine](https://github.com/YOUR_USERNAME/emotion-engine)
+
+---
+
+## What This Dataset Is
+
+Five emotion-engine architectures were compared in Ghost Town — a 12-agent survival
+simulation across 6 scenario variants and 8 random seeds.
+
+The central finding: **Condition D** (trained only to predict future world events)
+independently rediscovers OCC cognitive appraisal signatures (fear, grief, suspicion)
+with zero emotion rules, labels, or reward shaping.
+
+Each record is one agent at one timestep: the full observation vector, emotion state,
+latent representation, action taken, 12 future-event prediction probabilities,
+and outcome metadata.
+
+---
+
+## Dataset Structure
+
+### Splits
+
+| Split | Condition | Scenario | Seeds | Records |
+|-------|-----------|----------|-------|---------|
+| `baseline` | Baseline (no emotion) | all 6 | 0–7 | 40,907 |
+| `condition_a` | Hand-coded OCC rules | all 6 | 0–7 | 40,921 |
+| `condition_b` | Behavioral cloning | all 6 | 0–7 | 40,838 |
+| `condition_c` | Emotion dynamics model | all 6 | 0–7 | 40,916 |
+| `condition_d` | Predictive world modeling | all 6 | 0–7 | 40,938 |
+
+**Total: 204,520 records**
+
+### Scenarios in Every Split
+
+| Scenario | Primary OCC Signature | Description |
+|----------|-----------------------|-------------|
+| `standard_night` | Fear | 1 ghost per night, standard threat |
+| `high_ghost_pressure` | Fear (extreme) | 3 simultaneous ghosts per night |
+| `storm_scarcity` | Stress + Grief | Food supply reduced 70% by storm |
+| `ally_death` | Grief | June Carter dies at step 1 (scripted) |
+| `betrayal_refusal` | Suspicion | Rival pairs initialized with negative ties |
+| `crowded_shelter` | Fear + Suspicion | Shelter capacity halved (6 slots / 12 agents) |
+
+---
+
+## Fields
+
+Each record contains the following fields:
+
+### Identity
+| Field | Type | Description |
+|-------|------|-------------|
+| `run_id` | string | Unique run identifier, e.g. `condition_d_standard_night_seed0_12-agent` |
+| `step` | int | Timestep within run (0–71, 3 simulated days × 24 steps/day) |
+| `agent_id` | string | Agent name (one of 12 fixed agents) |
+| `condition` | string | `baseline_0`, `condition_a`, `condition_b`, `condition_c`, `condition_d` |
+| `seed` | int | Random seed (0–7) |
+| `scenario` | string | One of the 6 scenario variants |
+
+### Observation (14 dimensions)
+| Field | Type | Description |
+|-------|------|-------------|
+| `obs_visible_ghosts` | int | Number of ghosts within sensor range |
+| `obs_visible_deaths` | int | Number of ally deaths witnessed this step |
+| `obs_nearby_allies` | int | Allies within 5 tiles |
+| `obs_trusted_allies` | int | Allies with positive social tie nearby |
+| `obs_supplies_seen` | int | Supply units visible |
+| `obs_in_shelter` | bool | Agent is inside a safe building |
+| `obs_nearest_refuge_distance` | float | Tiles to closest safe building |
+| `obs_steps_since_ghost_seen` | int | Steps since last ghost sighting (capped at 20) |
+| `obs_steps_since_ally_died` | int | Steps since last witnessed death (capped at 20) |
+| `obs_steps_since_betrayal` | int | Steps since last betrayal received (capped at 20) |
+| `obs_ally_deaths_witnessed` | int | Cumulative ally deaths witnessed |
+| `obs_betrayals_received` | int | Cumulative betrayals received |
+| `obs_average_trust` | float | Mean social tie value across all agents [−1, 1] |
+| `obs_graph_tension` | float | Mean negative tie magnitude |
+
+### Emotion / Affect (Condition D only — zeros for others)
+| Field | Type | Description |
+|-------|------|-------------|
+| `affect_fear` | float | Fear activation [0, 1] |
+| `affect_grief` | float | Grief activation [0, 1] |
+| `affect_trust` | float | Trust activation [0, 1] |
+| `affect_stress` | float | Stress activation [0, 1] |
+| `affect_relief` | float | Relief activation [0, 1] |
+| `affect_suspicion` | float | Suspicion activation [0, 1] |
+
+### Latent Representation (8 dimensions)
+| Field | Type | Description |
+|-------|------|-------------|
+| `latent_0` … `latent_7` | float | Internal learned representation (8-dim) |
+
+### Future-Event Predictions (Condition D only — zeros for others)
+| Field | Type | Description |
+|-------|------|-------------|
+| `pred_ghost_nearby_t3` | float | P(ghost visible in 3 steps) |
+| `pred_my_death_t5` | float | P(this agent dies in 5 steps) |
+| `pred_health_drop_t3` | float | P(health decreases in 3 steps) |
+| `pred_nearby_death_t5` | float | P(an ally dies in 5 steps) |
+| `pred_help_success_t5` | float | P(help action succeeds in 5 steps) |
+| `pred_refusal_received_t5` | float | P(refusal received in 5 steps) |
+| `pred_tie_increase_t5` | float | P(social tie increases in 5 steps) |
+| `pred_shelter_achieved_t2` | float | P(agent in shelter in 2 steps) |
+| `pred_storm_onset_t3` | float | P(storm starts in 3 steps) |
+| `pred_scarcity_t5` | float | P(supply scarcity in 5 steps) |
+| `pred_graph_tension_t3` | float | P(social tension increases in 3 steps) |
+| `pred_valence_t5` | float | P(positive valence in 5 steps) |
+
+### Action & Outcome
+| Field | Type | Description |
+|-------|------|-------------|
+| `action` | string | Action taken: `hide`, `gather_supplies`, `seek_safe_house`, `seek_hospital`, `refuse_help`, `warn`, `patrol` |
+| `goal` | string | Agent goal state at this step |
+| `reward_survival` | float | Survival reward component |
+| `reward_shelter` | float | Shelter reward component |
+| `reward_health` | float | Health reward component |
+| `reward_social` | float | Social reward component |
+| `total_reward` | float | Sum of reward components |
+| `alive` | bool | Agent survived this step |
+| `health` | float | Health percentage (0–100) |
+| `sheltered` | bool | Agent is in a safe building |
+| `time_of_day` | string | `day`, `dusk`, `night`, `dawn` |
+
+---
+
+## Loading the Dataset
+
+### With the `datasets` library (recommended)
+
+```python
+from datasets import load_dataset
+
+# Load a specific condition
+ds = load_dataset("YOUR_USERNAME/emotion-engine", "condition_d")
+
+# Load all conditions
+ds = load_dataset("YOUR_USERNAME/emotion-engine", "all")
+
+# Filter to a specific scenario
+night_only = ds["train"].filter(lambda x: x["scenario"] == "standard_night")
+
+# Filter to ghost-present steps
+threat_steps = ds["train"].filter(lambda x: x["obs_visible_ghosts"] > 0)
+```
+
+### Reproduce the Fear→Shelter result
+
+```python
+from datasets import load_dataset
+import numpy as np
+from scipy.stats import fisher_exact
+
+ds = load_dataset("YOUR_USERNAME/emotion-engine", "condition_d", split="train")
+df = ds.to_pandas()
+
+ghost_present = df[df["obs_visible_ghosts"] > 0]
+ghost_absent  = df[df["obs_visible_ghosts"] == 0]
+
+shelter_given_ghost    = (ghost_present["action"] == "seek_safe_house").mean()
+shelter_given_no_ghost = (ghost_absent["action"]  == "seek_safe_house").mean()
+
+# Contingency table
+a = (ghost_present["action"] == "seek_safe_house").sum()
+b = (ghost_present["action"] != "seek_safe_house").sum()
+c = (ghost_absent["action"]  == "seek_safe_house").sum()
+d = (ghost_absent["action"]  != "seek_safe_house").sum()
+
+_, p = fisher_exact([[a, b], [c, d]])
+print(f"Ghost present  → shelter: {shelter_given_ghost:.1%}")
+print(f"Ghost absent   → shelter: {shelter_given_no_ghost:.1%}")
+print(f"Fisher p = {p:.2e}")
+# Expected: Ghost present → shelter: 99.0%, p = 3.3e-113
+```
+
+### Reproduce the Suspicion Decay result
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("YOUR_USERNAME/emotion-engine", "condition_d", split="train")
+df = ds.to_pandas()
+
+refusals = df[df["action"] == "refuse_help"].copy()
+
+def bucket(steps):
+    if steps <= 5:  return "recent"
+    if steps <= 10: return "fading"
+    return "forgotten"
+
+refusals["bucket"] = refusals["obs_steps_since_betrayal"].apply(bucket)
+all_social = df.copy()
+all_social["bucket"] = all_social["obs_steps_since_betrayal"].apply(bucket)
+
+for b in ["recent", "fading", "forgotten"]:
+    denom = (all_social["bucket"] == b).sum()
+    numer = ((refusals["bucket"] == b)).sum()
+    print(f"{b}: {numer/denom:.1%} refusal rate")
+# Expected: recent 64.6%, fading 4.5%, forgotten 35.2%
+```
+
+---
+
+## Citation
+
+```bibtex
+@article{kanaparthi2026emotion,
+  author  = {Kanaparthi, Prem Babu},
+  title   = {Emergent Emotional Appraisal in Generative Agents
+             via Predictive World Modeling},
+  year    = {2026},
+}
+```
+
+---
+
+## License
+
+MIT License.

data/baseline_0.parquet

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

data/condition_a.parquet

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

data/condition_b.parquet

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

data/condition_c.parquet

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

data/condition_d.parquet

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

emotion_engine.py

@@ -0,0 +1,204 @@
+"""
+emotion_engine.py — HuggingFace Datasets loading script
+
+Registered as the dataset builder for the emotion-engine HF repo.
+Supports loading by condition name or "all" for the full dataset.
+
+Usage:
+    from datasets import load_dataset
+
+    # Single condition
+    ds = load_dataset("YOUR_USERNAME/emotion-engine", "condition_d")
+
+    # All conditions concatenated
+    ds = load_dataset("YOUR_USERNAME/emotion-engine", "all")
+"""
+
+import datasets
+
+_CITATION = """
+@article{kanaparthi2026emotion,
+  author  = {Kanaparthi, Prem Babu},
+  title   = {Emergent Emotional Appraisal in Generative Agents
+             via Predictive World Modeling},
+  year    = {2026},
+}
+"""
+
+_DESCRIPTION = """
+204,520 agent-step records from a five-condition controlled experiment comparing
+emotion-engine architectures in a 12-agent ghost-survival simulation (Ghost Town).
+
+Five conditions:
+  baseline_0  — no emotion system
+  condition_a — hand-coded OCC appraisal rules
+  condition_b — behavioral cloning from condition_a
+  condition_c — emotion dynamics model
+  condition_d — predictive world modeling (proposed)
+
+Six scenarios per condition:
+  standard_night, high_ghost_pressure, storm_scarcity,
+  ally_death, betrayal_refusal, crowded_shelter
+
+8 random seeds per scenario.
+
+Each record contains: full 14-dim observation, 6-dim emotion vector,
+8-dim latent representation, 12 future-event predictions (Condition D),
+action taken, and outcome metadata.
+"""
+
+_HOMEPAGE = "https://github.com/YOUR_USERNAME/emotion-engine"
+_LICENSE  = "MIT"
+
+_CONDITIONS = [
+    "baseline_0",
+    "condition_a",
+    "condition_b",
+    "condition_c",
+    "condition_d",
+]
+
+_FEATURES = datasets.Features({
+    # Identity
+    "run_id":    datasets.Value("string"),
+    "step":      datasets.Value("int32"),
+    "agent_id":  datasets.Value("string"),
+    "condition": datasets.Value("string"),
+    "seed":      datasets.Value("int32"),
+    "scenario":  datasets.Value("string"),
+
+    # Observation (14 dims)
+    "obs_visible_ghosts":          datasets.Value("int32"),
+    "obs_visible_deaths":          datasets.Value("int32"),
+    "obs_nearby_allies":           datasets.Value("int32"),
+    "obs_trusted_allies":          datasets.Value("int32"),
+    "obs_supplies_seen":           datasets.Value("int32"),
+    "obs_in_shelter":              datasets.Value("bool"),
+    "obs_nearest_refuge_distance": datasets.Value("float32"),
+    "obs_steps_since_ghost_seen":  datasets.Value("int32"),
+    "obs_steps_since_ally_died":   datasets.Value("int32"),
+    "obs_steps_since_betrayal":    datasets.Value("int32"),
+    "obs_ally_deaths_witnessed":   datasets.Value("int32"),
+    "obs_betrayals_received":      datasets.Value("int32"),
+    "obs_average_trust":           datasets.Value("float32"),
+    "obs_graph_tension":           datasets.Value("float32"),
+
+    # Affect / emotion
+    "affect_fear":      datasets.Value("float32"),
+    "affect_grief":     datasets.Value("float32"),
+    "affect_trust":     datasets.Value("float32"),
+    "affect_stress":    datasets.Value("float32"),
+    "affect_relief":    datasets.Value("float32"),
+    "affect_suspicion": datasets.Value("float32"),
+
+    # Latent representation (8 dims)
+    "latent_0": datasets.Value("float32"),
+    "latent_1": datasets.Value("float32"),
+    "latent_2": datasets.Value("float32"),
+    "latent_3": datasets.Value("float32"),
+    "latent_4": datasets.Value("float32"),
+    "latent_5": datasets.Value("float32"),
+    "latent_6": datasets.Value("float32"),
+    "latent_7": datasets.Value("float32"),
+
+    # Future-event predictions (Condition D; zero for others)
+    "pred_ghost_nearby_t3":     datasets.Value("float32"),
+    "pred_my_death_t5":         datasets.Value("float32"),
+    "pred_health_drop_t3":      datasets.Value("float32"),
+    "pred_nearby_death_t5":     datasets.Value("float32"),
+    "pred_help_success_t5":     datasets.Value("float32"),
+    "pred_refusal_received_t5": datasets.Value("float32"),
+    "pred_tie_increase_t5":     datasets.Value("float32"),
+    "pred_shelter_achieved_t2": datasets.Value("float32"),
+    "pred_storm_onset_t3":      datasets.Value("float32"),
+    "pred_scarcity_t5":         datasets.Value("float32"),
+    "pred_graph_tension_t3":    datasets.Value("float32"),
+    "pred_valence_t5":          datasets.Value("float32"),
+
+    # Action & outcome
+    "action":          datasets.Value("string"),
+    "goal":            datasets.Value("string"),
+    "reward_survival": datasets.Value("float32"),
+    "reward_shelter":  datasets.Value("float32"),
+    "reward_health":   datasets.Value("float32"),
+    "reward_social":   datasets.Value("float32"),
+    "total_reward":    datasets.Value("float32"),
+    "alive":           datasets.Value("bool"),
+    "health":          datasets.Value("float32"),
+    "sheltered":       datasets.Value("bool"),
+    "time_of_day":     datasets.Value("string"),
+})
+
+
+class EmotionEngineConfig(datasets.BuilderConfig):
+    def __init__(self, condition="all", **kwargs):
+        super().__init__(**kwargs)
+        self.condition = condition
+
+
+class EmotionEngine(datasets.GeneratorBasedBuilder):
+    """Ghost Town emotion engine dataset — 204,520 agent-step records."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIG_CLASS = EmotionEngineConfig
+
+    BUILDER_CONFIGS = [
+        EmotionEngineConfig(
+            name="all",
+            version=VERSION,
+            description="All five conditions concatenated (204,520 records)",
+            condition="all",
+        ),
+    ] + [
+        EmotionEngineConfig(
+            name=c,
+            version=VERSION,
+            description=f"Condition {c} only (~40k records, 6 scenarios, 8 seeds)",
+            condition=c,
+        )
+        for c in _CONDITIONS
+    ]
+
+    DEFAULT_CONFIG_NAME = "condition_d"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=_FEATURES,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        if self.config.condition == "all":
+            files = {
+                c: dl_manager.download(f"data/{c}.parquet")
+                for c in _CONDITIONS
+            }
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={"filepaths": list(files.values())},
+                )
+            ]
+        else:
+            filepath = dl_manager.download(
+                f"data/{self.config.condition}.parquet"
+            )
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={"filepaths": [filepath]},
+                )
+            ]
+
+    def _generate_examples(self, filepaths):
+        import pandas as pd
+        idx = 0
+        for path in filepaths:
+            df = pd.read_parquet(path)
+            for _, row in df.iterrows():
+                yield idx, row.to_dict()
+                idx += 1

export_to_parquet.py

@@ -0,0 +1,185 @@
+"""
+export_to_parquet.py
+====================
+Converts raw Ghost Town simulation outputs into clean Parquet files
+ready for upload to Hugging Face Datasets.
+
+Usage:
+    python export_to_parquet.py \
+        --source path/to/outputs/proof_all_scenarios \
+        --out    path/to/emotion-engine-dataset/data
+
+Output:
+    data/
+        baseline_0.parquet
+        condition_a.parquet
+        condition_b.parquet
+        condition_c.parquet
+        condition_d.parquet
+
+Each Parquet file is one condition split (~40k rows).
+Total size after compression: ~30-50 MB.
+"""
+
+import argparse
+import json
+import os
+import glob
+import pandas as pd
+from pathlib import Path
+
+
+CONDITION_NAMES = [
+    "baseline_0",
+    "condition_a",
+    "condition_b",
+    "condition_c",
+    "condition_d",
+]
+
+
+def flatten_record(r: dict) -> dict:
+    """Flatten one JSONL record into a single-level dict."""
+    obs = r.get("observation", {})
+    sc  = r.get("social_context", {})
+    aff = r.get("affect", r.get("affect_vector", {}))
+    lat = r.get("latent", [0.0] * 8)
+    prd = r.get("predictions", {})
+    rew = r.get("reward_components", {})
+    meta = r.get("metadata", {})
+
+    row = {
+        # Identity
+        "run_id":    r.get("run_id", ""),
+        "step":      int(r.get("step", 0)),
+        "agent_id":  r.get("agent_id", ""),
+        "condition": r.get("condition", ""),
+        "seed":      int(r.get("seed", 0)),
+        "scenario":  meta.get("scenario", r.get("scenario", "")),
+
+        # Observation (14 dims)
+        "obs_visible_ghosts":           int(obs.get("visible_ghosts", 0)),
+        "obs_visible_deaths":           int(obs.get("visible_deaths", 0)),
+        "obs_nearby_allies":            int(obs.get("nearby_allies", 0)),
+        "obs_trusted_allies":           int(obs.get("trusted_allies", 0)),
+        "obs_supplies_seen":            int(obs.get("supplies_seen", 0)),
+        "obs_in_shelter":               bool(obs.get("in_shelter", False)),
+        "obs_nearest_refuge_distance":  float(obs.get("nearest_refuge_distance", 0)),
+        "obs_steps_since_ghost_seen":   int(obs.get("steps_since_ghost_seen", 20)),
+        "obs_steps_since_ally_died":    int(obs.get("steps_since_ally_died", 20)),
+        "obs_steps_since_betrayal":     int(obs.get("steps_since_betrayal", 20)),
+        "obs_ally_deaths_witnessed":    int(obs.get("ally_deaths_witnessed", 0)),
+        "obs_betrayals_received":       int(obs.get("betrayals_received", 0)),
+        "obs_average_trust":            float(sc.get("average_trust", 0.0)),
+        "obs_graph_tension":            float(sc.get("graph_tension", 0.0)),
+
+        # Affect / emotion vector
+        "affect_fear":      float(aff.get("fear",      0.0)),
+        "affect_grief":     float(aff.get("grief",     0.0)),
+        "affect_trust":     float(aff.get("trust",     0.0)),
+        "affect_stress":    float(aff.get("stress",    0.0)),
+        "affect_relief":    float(aff.get("relief",    0.0)),
+        "affect_suspicion": float(aff.get("suspicion", 0.0)),
+
+        # Latent representation (8 dims)
+        **{f"latent_{i}": float(lat[i]) if i < len(lat) else 0.0
+           for i in range(8)},
+
+        # Future-event predictions (Condition D)
+        "pred_ghost_nearby_t3":     float(prd.get("ghost_nearby_t3",        0.0)),
+        "pred_my_death_t5":         float(prd.get("my_death_t5",            0.0)),
+        "pred_health_drop_t3":      float(prd.get("health_drop_t3",         0.0)),
+        "pred_nearby_death_t5":     float(prd.get("nearby_death_t5",        0.0)),
+        "pred_help_success_t5":     float(prd.get("help_success_t5",        0.0)),
+        "pred_refusal_received_t5": float(prd.get("refusal_received_t5",    0.0)),
+        "pred_tie_increase_t5":     float(prd.get("tie_increase_t5",        0.0)),
+        "pred_shelter_achieved_t2": float(prd.get("shelter_achieved_t2",    0.0)),
+        "pred_storm_onset_t3":      float(prd.get("storm_onset_t3",         0.0)),
+        "pred_scarcity_t5":         float(prd.get("scarcity_t5",            0.0)),
+        "pred_graph_tension_t3":    float(prd.get("graph_tension_increase_t3",
+                                                   prd.get("graph_tension_t3", 0.0))),
+        "pred_valence_t5":          float(prd.get("valence_t5",             0.0)),
+
+        # Action & outcome
+        "action":         r.get("action", ""),
+        "goal":           r.get("goal", ""),
+        "reward_survival": float(rew.get("survival", 0.0)),
+        "reward_shelter":  float(rew.get("shelter",  0.0)),
+        "reward_health":   float(rew.get("health",   0.0)),
+        "reward_social":   float(rew.get("social",   0.0)),
+        "total_reward":    float(r.get("total_reward", 0.0)),
+        "alive":           bool(meta.get("alive", True)),
+        "health":          float(meta.get("health", 100.0)),
+        "sheltered":       bool(meta.get("sheltered", False)),
+        "time_of_day":     meta.get("time_of_day", ""),
+    }
+    return row
+
+
+def load_run(jsonl_path: str) -> list[dict]:
+    records = []
+    with open(jsonl_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                records.append(flatten_record(json.loads(line)))
+            except Exception as e:
+                print(f"  Warning: skipped malformed record in {jsonl_path}: {e}")
+    return records
+
+
+def export(source_dir: str, out_dir: str):
+    source_dir = Path(source_dir)
+    out_dir    = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Group run folders by condition
+    all_runs = sorted(source_dir.glob("*/training_records.jsonl"))
+    if not all_runs:
+        raise FileNotFoundError(
+            f"No training_records.jsonl found under {source_dir}.\n"
+            "Make sure --source points to the batch output directory."
+        )
+
+    by_condition: dict[str, list] = {c: [] for c in CONDITION_NAMES}
+
+    for jsonl_path in all_runs:
+        run_name = jsonl_path.parent.name  # e.g. condition_d_standard_night_seed0_12-agent
+        matched = None
+        for cname in CONDITION_NAMES:
+            if run_name.startswith(cname):
+                matched = cname
+                break
+        if matched is None:
+            print(f"  Skipping unrecognised run: {run_name}")
+            continue
+
+        print(f"  Loading {run_name} …", end=" ", flush=True)
+        rows = load_run(str(jsonl_path))
+        by_condition[matched].extend(rows)
+        print(f"{len(rows)} records")
+
+    print()
+    for cname, rows in by_condition.items():
+        if not rows:
+            print(f"  No records for {cname} — skipping")
+            continue
+        df = pd.DataFrame(rows)
+        out_path = out_dir / f"{cname}.parquet"
+        df.to_parquet(out_path, index=False, compression="snappy")
+        size_mb = out_path.stat().st_size / 1e6
+        print(f"  {cname:15s}  {len(df):>7,} records  ->  {out_path.name}  ({size_mb:.1f} MB)")
+
+    print(f"\nAll splits written to {str(out_dir)}/")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Export Ghost Town outputs to Parquet for HuggingFace.")
+    parser.add_argument("--source", required=True,
+                        help="Path to batch output directory (e.g. outputs/proof_all_scenarios)")
+    parser.add_argument("--out", default="data",
+                        help="Output directory for Parquet files (default: data/)")
+    args = parser.parse_args()
+    export(args.source, args.out)