Initial public release: TRACE v1.0.0

.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
+data/splits/train.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,61 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+build/
+dist/
+.eggs/
+.venv/
+venv/
+env/
+
+# Packaging
+*.egg
+*.wheel
+pip-log.txt
+pip-delete-this-directory.txt
+
+# uv lockfile — not committed; runtime deps are spec'd in pyproject.toml +
+# requirements.txt. Anyone running the generator only needs PyYAML, which is
+# stable enough that a pinned lockfile would add noise without value.
+uv.lock
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Type checking
+.mypy_cache/
+.ruff_cache/
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*~
+.DS_Store
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Working artifacts — these are intentionally not committed.
+# `data/splits/` IS committed (the release payload).
+# But if anyone regenerates mid-review, they produce these:
+data/splits/curation_pool.jsonl
+data/splits/curation_pool_original.jsonl
+data/splits/dtt.jsonl
+data/splits/net.jsonl
+data/splits/task_analysis.jsonl
+data/splits/session_interpretation.jsonl
+
+# Curation review artifact (regenerated; not part of the release)
+docs/curation/review.md

CHANGELOG.md

@@ -0,0 +1,30 @@
+# CHANGELOG
+
+All notable changes to TRACE are recorded here, starting with v1.0.0.
+Future releases will follow semantic versioning:
+
+- **Patch** (v1.0.x) — typo fixes, metadata tweaks, no change to the JSONL splits.
+- **Minor** (v1.x.0) — additions to the taxonomy or new teaching methods; existing examples preserved; new examples appended to splits.
+- **Major** (v2.0.0) — schema changes or re-generations that invalidate prior splits; prior versions remain accessible via git tags.
+
+---
+
+## v1.0.0 — 2026-04-25
+
+Initial public release. 2,999 examples split across train (2,549) / valid (149) / test (281) / sanity (20). Paired with the dataset card, datasheet (Gebru et al. 2021), and data statement (Bender & Friedman 2018).
+
+### What's covered
+
+- **Teaching programs** across three methods — DTT (800), NET (500), Task Analysis (500, including toleration programs).
+- **Session interpretations** — 1,200 multi-session behavioral logs across 12 trajectory patterns with 13 target behaviors.
+- **Provenance** — every example carries full `meta.provenance.taxonomy_cells` for auditable traceback.
+- **Reproducibility** — the corpus regenerates byte-identically from `(configs, seed)` on any platform; every `example_id` is verifiable as `sha256(user_content + assistant_content)[:16]` directly from the published JSONL row.
+
+### Known limitations
+
+See the dataset card section 6 and the data statement section H for the full list. Most notable:
+
+- English-only, US clinical register.
+- Pattern frequencies are uniform for learnability rather than epidemiologically weighted.
+- VB-MAPP + AFLS only.
+- Single-reviewer clinical validation.

CITATION.cff

@@ -0,0 +1,43 @@
+cff-version: 1.2.0
+message: "If you use TRACE in your research, please cite it as below."
+title: "TRACE: Taxonomy-Referenced ABA Clinical Examples"
+abstract: >
+  A 2,999-example synthetic instruction-tuning dataset for two clinical tasks
+  in Applied Behavior Analysis — teaching-program generation (DTT, NET,
+  Task Analysis) and multi-session behavioral interpretation (12 trajectory
+  patterns, 13 target behaviors). Every example is generated from a taxonomy
+  grounded in the canonical ABA literature and carries full sampling
+  provenance.
+authors:
+  - family-names: Kahunla
+    given-names: Festus
+    affiliation: "Drexel University; Pombo Labs"
+date-released: 2026-04-25
+version: "1.0.0"
+license: CC-BY-NC-4.0
+repository-code: "https://github.com/Pombo-Labs/TRACE"
+url: "https://huggingface.co/datasets/PomboLabs/TRACE"
+type: dataset
+keywords:
+  - applied-behavior-analysis
+  - ABA
+  - autism
+  - clinical-NLP
+  - synthetic-data
+  - instruction-tuning
+  - small-language-model
+  - taxonomy
+  - provenance
+preferred-citation:
+  type: generic
+  title: >
+    TRACE: Taxonomy-Grounded Synthetic Data for Teaching Program Generation
+    and Session Interpretation in Applied Behavior Analysis
+  authors:
+    - family-names: Kahunla
+      given-names: Festus
+      affiliation: "Drexel University; Pombo Labs"
+  year: 2026
+  publisher:
+    name: "Pombo Labs"
+  url: "https://github.com/Pombo-Labs/TRACE"

LICENSE-CODE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 Pombo Labs
+
+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.
+
+This license applies to all source code, configuration files, and scripts in
+this repository (the contents of `configs/`, `src/`, the top-level `pyproject.toml`,
+and this LICENSE-CODE file itself). The dataset files in `data/splits/` are
+licensed separately under CC BY-NC 4.0 (see LICENSE-DATA).

LICENSE-DATA

@@ -0,0 +1,38 @@
+Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
+
+Copyright (c) 2026 Pombo Labs
+
+The dataset files in `data/splits/` (train.jsonl, valid.jsonl, test.jsonl,
+sanity.jsonl) — and any derivative dataset produced by running the generator
+code in this repository — are licensed under the Creative Commons
+Attribution-NonCommercial 4.0 International License.
+
+You are free to:
+  - Share   — copy and redistribute the material in any medium or format
+  - Adapt   — remix, transform, and build upon the material
+
+Under the following terms:
+  - Attribution — You must give appropriate credit, provide a link to the
+                  license, and indicate if changes were made.
+  - NonCommercial — You may not use the material for commercial purposes.
+
+Attribution should include:
+  - The dataset name (TRACE) and version (v1)
+  - Author: Kahunla, F.
+  - Publisher: Pombo Labs
+  - The repository URL: https://github.com/Pombo-Labs/TRACE
+
+No warranty is given. TRACE is a research artifact and has not been
+clinically validated. It is not a clinical tool. Any use of the dataset,
+or any model derived from it, in a clinical setting is at the sole
+responsibility of the user and their facility. The authors and Pombo Labs
+make no representation of clinical suitability and accept no liability for
+clinical outcomes.
+
+Full license text:
+https://creativecommons.org/licenses/by-nc/4.0/legalcode
+
+Human-readable summary:
+https://creativecommons.org/licenses/by-nc/4.0/
+
+SPDX-License-Identifier: CC-BY-NC-4.0

README.md

@@ -0,0 +1,149 @@
+# TRACE
+
+**T**axonomy-**R**eferenced **A**BA **C**linical **E**xamples
+
+A 2,999-example synthetic instruction-tuning dataset for two clinical tasks in Applied Behavior Analysis: **teaching-program generation** and **behavioral session interpretation**. Every example is generated from a taxonomy grounded in the canonical ABA literature (Cooper, Heron, & Heward 2020; VB-MAPP; AFLS; BACB Ethics Code 2020) and carries full sampling provenance — the exact taxonomy cells that produced it.
+
+| | |
+|---|---|
+| **Version** | v1.0.0 |
+| **Examples** | 2,999 (2,549 train / 149 valid / 281 test / 20 sanity) |
+| **Tasks** | Teaching-program generation (DTT, NET, Task Analysis); behavioral session interpretation (12 patterns, 13 target behaviors) |
+| **Language** | English (US clinical register) |
+| **Data license** | CC BY-NC 4.0 |
+| **Code license** | MIT |
+| **Maintainer** | Pombo Labs — [GitHub](https://github.com/Pombo-Labs) · [Hugging Face](https://huggingface.co/PomboLabs) |
+| **Author** | Festus Kahunla |
+
+---
+
+## What this is for
+
+ABA is a clinical discipline with high documentation workload. Board Certified Behavior Analysts (BCBAs) draft teaching programs and interpret multi-session behavioral logs constantly across their caseloads. TRACE is a **research** dataset for studying whether small language models can learn the structure of those documents well enough to produce useful first-pass drafts. It is a research artifact, not a clinical tool.
+
+Real session data is HIPAA-protected and gated by BACB confidentiality rules; it cannot be reliably de-identified without losing clinical detail. TRACE avoids the constraint by construction: the data never represented a real person.
+
+## What makes TRACE different
+
+1. **Two tasks in one dataset.** Structured teaching-program generation across DTT, NET, and Task Analysis; multi-session interpretation across 12 clinical trajectory patterns.
+2. **Taxonomy-grounded.** Every category in the controlled vocabulary ties to a specific source — Cooper/Heron/Heward chapters, JABA papers, VB-MAPP/AFLS curricula, BACB Ethics Code 2020, ABAI 2010 Position Statement.
+3. **Full provenance per example.** `meta.provenance.taxonomy_cells` records the exact values sampled from every taxonomy dimension that produced the example. This is the property that makes clinical auditing tractable.
+4. **Practitioner-in-the-loop iteration.** Clinical accuracy was refined through targeted taxonomy edits rather than per-example rewrites — each flagged inaccuracy maps to a single cell whose fix then propagates across every example that sampled it.
+
+## Quick start
+
+```bash
+# Load with Hugging Face datasets
+from datasets import load_dataset
+ds = load_dataset("PomboLabs/TRACE")
+print(ds["train"][0])
+```
+
+Or from the raw JSONL splits:
+```python
+import json
+for line in open("data/splits/train.jsonl"):
+    example = json.loads(line)
+    system, user, assistant = example["messages"]
+    gold = example["meta"]["gold_labels"]
+    provenance = example["meta"]["provenance"]["taxonomy_cells"]
+```
+
+### Extend the generator
+
+The taxonomy YAMLs under `configs/` are the fork point — drop in a new teaching method, a new clinical area, or a new behavioral pattern, regenerate, and you have a corpus tailored to your scope.
+
+```bash
+uv pip install -e .
+uv run python src/generate.py --all
+uv run python src/split_data.py
+uv run python src/prepare_curation.py
+uv run python src/compile_curation.py
+```
+
+(Without `uv`: `pip install -r requirements.txt` and drop the `uv run` prefix.)
+
+The pipeline is deterministic, so the same configs + seed produce the same corpus — but the more interesting use is to make your own.
+
+## Repository structure
+
+```
+.
+├── configs/                     # taxonomy YAMLs (controlled vocabulary)
+│   ├── shared/                    # cross-area: learner profiles, mastery states
+│   ├── dtt/                       # DTT taxonomy + template + compatibility
+│   ├── net/                       # NET area
+│   ├── task_analysis/             # chaining (independence + toleration)
+│   └── session_interpretation/    # patterns, behaviors, trajectories, recommendations
+├── src/
+│   ├── generators/                # per-area generator code
+│   ├── generate.py                # orchestrator
+│   ├── split_data.py              # train / valid / curation_pool
+│   ├── prepare_curation.py        # browseable review.md
+│   └── compile_curation.py        # test + sanity splits
+├── data/splits/                 # the released JSONL splits
+└── docs/
+    ├── dataset-card.md          # HF-style user-facing card
+    ├── datasheet.md             # Gebru et al. (2021) template
+    ├── data-statement.md        # Bender & Friedman (2018) template
+    ├── taxonomy-v1.md           # operational definitions + citations
+    ├── schema-v1.md             # wire format + slot specifications
+    ├── references.md            # the focused citation shortlist (~30 papers)
+    └── curation/
+        ├── README.md            # review + compile workflow
+        └── LEGEND.md            # session-log notation reference
+```
+
+## Documentation
+
+| | |
+|---|---|
+| **Dataset card** | [docs/dataset-card.md](docs/dataset-card.md) |
+| **Datasheet** (Gebru et al. 2021) | [docs/datasheet.md](docs/datasheet.md) |
+| **Data statement** (Bender & Friedman 2018) | [docs/data-statement.md](docs/data-statement.md) |
+| **Taxonomy reference** | [docs/taxonomy-v1.md](docs/taxonomy-v1.md) |
+| **Schema reference** | [docs/schema-v1.md](docs/schema-v1.md) |
+| **Curation workflow** | [docs/curation/README.md](docs/curation/README.md) |
+| **Session-log reading guide** | [docs/curation/LEGEND.md](docs/curation/LEGEND.md) |
+
+## Ethics and intended use
+
+- **For:** fine-tuning small models (recommended: Gemma 4 E2B, QLoRA, 4-bit) for on-device drafting assistants, evaluation baselines, research on clinical-NLP data pipelines.
+- **Not for:** autonomous clinical decisions; writing final Behavior Intervention Plans without BCBA review; training models on real client data; medical diagnosis; insurance documentation.
+
+Crisis-plan content is deliberately conservative: physical-intervention procedures are not specified because they vary by jurisdiction, training certification, and learner-specific contraindications. See [docs/dataset-card.md section 6.3](docs/dataset-card.md) for details.
+
+**Responsibility.** TRACE is a research artifact. It is not a clinical tool, has not been clinically validated, and carries no clinical endorsement. Anyone who chooses to deploy TRACE — or any model derived from it — in a clinical setting does so entirely at their own responsibility and under their facility's own oversight. The authors and Pombo Labs make no representation of clinical suitability and accept no liability for clinical outcomes.
+
+## License
+
+- **Data** — JSONL splits under `data/splits/` — Creative Commons Attribution-NonCommercial 4.0 (CC BY-NC 4.0). Research and non-commercial use permitted with attribution. See [LICENSE-DATA](LICENSE-DATA).
+- **Code** — generator, scripts, configs — MIT. See [LICENSE-CODE](LICENSE-CODE).
+
+## Citation
+
+```bibtex
+@dataset{trace_2026,
+  title     = {TRACE: Taxonomy-Referenced ABA Clinical Examples},
+  author    = {Kahunla, Festus},
+  year      = {2026},
+  publisher = {Pombo Labs},
+  url       = {https://github.com/Pombo-Labs/TRACE},
+  note      = {Taxonomy-Grounded Synthetic Data for Teaching Program Generation
+               and Session Interpretation in Applied Behavior Analysis}
+}
+```
+
+Machine-readable metadata in [CITATION.cff](CITATION.cff).
+
+## Contributing
+
+The taxonomy YAMLs under `configs/` are the intended extension surface. Adding a new skill target, a new target behavior, a new mastery criterion, or a new teaching method follows a documented pattern — see `docs/taxonomy-v1.md` for the existing vocabulary and grounding conventions. Pull requests welcome.
+
+For clinical-accuracy corrections, open an issue with the flagged example's `example_id` and a description of the issue; we trace back to the offending taxonomy cell and apply a single-commit fix.
+
+## Scope of v1
+
+2,999 examples covering DTT, NET, and Task Analysis (including toleration programs) for the teaching-program task, and 1,200 multi-session logs across 12 trajectory patterns for the session-interpretation task. What v1 does not cover is documented in the dataset card (section 6.5 Known limitations).
+
+Version history in [CHANGELOG.md](CHANGELOG.md).

configs/dtt/compatibility.yaml

@@ -0,0 +1,41 @@
+# DTT clinical-consistency rules — TRACE v1
+# Enforced by the DTT generator during sampling to avoid clinically-inconsistent combinations.
+
+# Errorless error-correction procedure pairs exclusively with most-to-least prompt hierarchy
+# Citation: CHH Ch. 21 — errorless learning is the errorless most-to-least convention.
+errorless_requires_hierarchy: most_to_least
+
+# Mastery state -> acceptable reinforcement schedule IDs
+# Citation: CHH Ch. 13, 28 — reinforcement thinning follows acquisition -> mastery -> maintenance.
+mastery_to_reinforcement:
+  emerging: [crf]
+  developing: [crf]
+  approaching: [crf, fr2]
+  near: [fr2, vr3]
+  mastered: [fr2, vr3, token_economy]
+  generalization: [vr3, token_economy]
+
+# VB-MAPP level -> compatible learner profile ids
+# Citation: Sundberg 2008 (VB-MAPP manual) — level is anchored to developmental age.
+level_to_learner_profiles:
+  L1: [early]
+  L2: [early, school_age]
+  L3: [school_age, adolescent]
+
+# Level -> array size for stimulus field (DTT-specific)
+array_size_by_level:
+  L1:
+    n: 3
+    text: "field of 3 (target + 2 distractors)"
+  L2:
+    n: 5
+    text: "field of 5 (target + 4 distractors)"
+  L3:
+    n: 6
+    text: "field of 6 (target + 5 distractors, mixed categories)"
+
+# Sampling weights for level selection (DTT biased toward L1/L2 discrete skills)
+level_sampling_weights:
+  L1: 0.45
+  L2: 0.40
+  L3: 0.15

configs/dtt/taxonomy.yaml

@@ -0,0 +1,294 @@
+# DTT taxonomy — TRACE v1
+# Self-contained: everything the DTT generator needs beyond shared primitives.
+# Citation: Lovaas 1987 JCCP; Smith 2001 Focus on Autism; CHH 2020 Chs. 17, 21.
+#
+# DTT fits array-based discrete-response skills. Only VB-MAPP domains where
+# the target is discrete selection / labeling / matching appear here.
+
+method:
+  id: dtt
+  name: Discrete Trial Training
+  short: DTT
+  citation: "Lovaas, O. I. (1987). JCCP, 55(1), 3–9. https://doi.org/10.1037/0022-006X.55.1.3; Smith, T. (2001). Focus on Autism, 16(2), 86–92."
+  when_to_use: >
+    Acquisition of discrete, decontextualized skills (receptive labels, tacts,
+    matching, early imitation) — especially early in instruction when stimulus
+    control must be established.
+
+# VB-MAPP domains appropriate for DTT (array-based discrete-response skills).
+# Other domains (Mand, Echoic, Motor Imitation, Intraverbal, Social, etc.)
+# belong to NET, PRT, or other method taxonomies.
+skill_domains:
+  vbmapp:
+    levels:
+      - id: L1
+        name: Level 1
+        developmental_age: "0–18 months"
+      - id: L2
+        name: Level 2
+        developmental_age: "18–30 months"
+      - id: L3
+        name: Level 3
+        developmental_age: "30–48 months"
+
+    domains:
+      - id: tact
+        name: Tact
+        gloss: Labeling / naming
+        L1:
+          - tacts common objects (ball, cup, shoe)
+          - tacts familiar people by name
+          - tacts common actions (running, eating, sleeping)
+          - tacts body parts
+          - tacts common animals
+        L2:
+          - tacts colors of objects
+          - tacts shapes (circle, square, triangle)
+          - tacts adjectives (big/little, hot/cold)
+          - tacts prepositions (in, on, under)
+          - tacts emotions in self and others
+        L3:
+          - tacts community helpers and their roles
+          - tacts categories (fruits, vehicles, clothing)
+          - tacts features of objects (color, shape, function)
+          - tacts past-tense events
+          - tacts abstract concepts (same/different, first/last)
+
+      - id: listener_responding
+        name: Listener Responding
+        gloss: Receptive language
+        L1:
+          - follows 1-step motor instructions (sit down, stand up)
+          - selects correct item from an array of 2
+          - points to named body parts
+          - points to named common objects
+          - follows instructions involving objects (give me the cup)
+        L2:
+          - selects correct item from array of 4–6
+          - follows 2-step instructions
+          - selects items by feature (find something red)
+          - selects items by function (find something you eat with)
+          - selects items by class (find an animal)
+        L3:
+          - selects items by multiple features simultaneously
+          - follows conditional instructions (if X, then Y)
+          - follows instructions involving temporal concepts (before, after)
+
+      - id: vp_mts
+        name: Visual Perceptual Skills & Matching-to-Sample
+        gloss: VP-MTS
+        L1:
+          - matches identical objects
+          - matches identical pictures
+          - matches colors (identical chips)
+          - matches shapes (identical blocks)
+          - completes simple 3–4 piece puzzles
+        L2:
+          - matches non-identical items by category
+          - sorts items into 2–3 categories
+          - matches quantities (1–5)
+          - matches upper-case letters
+          - completes 8–12 piece puzzles
+        L3:
+          - matches associated items (sock-shoe, cup-plate)
+          - sorts by multiple attributes simultaneously
+          - matches upper to lower case letters
+          - sequences 3–4 step picture sequences
+          - reproduces block designs from model
+
+      - id: lrffc
+        name: LRFFC
+        gloss: Listener Responding by Feature, Function, Class
+        L1:
+          - selects items by function (What do you drink from?)
+          - selects items by feature (What is round?)
+          - selects items by class (Find the animal)
+          - selects by single function from array of 3
+          - selects by single visible feature from array of 3
+        L2:
+          - selects items by function from array of 5–8
+          - selects items by feature from array of 5–8
+          - selects items by class from array of 5–8
+          - selects items by multiple features (round and red)
+          - selects items by function when item not visible
+        L3:
+          - selects items given 2+ features/functions simultaneously
+          - selects items by class with exclusion (animal but not a pet)
+          - selects items by abstract features (something needed when cold)
+          - selects items by comparison (which is heavier)
+          - selects items by negative features (not round, not food)
+
+      - id: reading
+        name: Reading
+        L1:
+          - matches letters to identical letters
+          - identifies own name in print
+          - identifies 5–10 upper-case letters
+          - matches words to identical words
+          - tracks print left to right
+        L2:
+          - identifies all upper-case letters
+          - identifies all lower-case letters
+          - reads 10–20 sight words
+          - sounds out CVC words (cat, dog, run)
+          - reads simple 2–3 word phrases
+        L3:
+          - reads sentences with comprehension
+          - reads short passages and answers questions
+          - phonetic decoding for novel words
+
+      - id: writing
+        name: Writing
+        L1:
+          - traces horizontal and vertical lines
+          - traces basic shapes (circle, cross)
+          - copies basic shapes from model
+          - traces letters of own name
+          - writes own name from model
+        L2:
+          - writes own name independently
+          - copies all upper-case letters from model
+          - writes upper-case letters from dictation
+          - copies simple words from model
+          - writes numbers 1–10
+
+      - id: math
+        name: Math
+        L1:
+          - rote counts to 10
+          - counts objects 1–5 with 1:1 correspondence
+          - identifies numerals 1–5
+          - matches quantities to numerals 1–5
+          - identifies basic shapes in math context
+        L2:
+          - counts objects 1–20 with 1:1 correspondence
+          - identifies numerals 1–20
+          - compares quantities (more/less/same)
+          - solves single-digit addition with manipulatives
+          - identifies coins by name
+        L3:
+          - adds single-digit numbers without manipulatives
+          - subtracts single-digit numbers
+          - identifies place value (ones, tens)
+          - tells time to the hour and half-hour
+          - solves simple word problems
+
+# Prompt hierarchies that can be used in DTT
+prompt_hierarchies:
+  - id: most_to_least
+    name: Most-to-Least (errorless)
+    sequence: [full_physical, partial_physical, gestural, positional, independent]
+    description: "Start with maximum assistance; fade systematically to independence."
+    best_for: "Acquisition, early learners, safety-critical skills."
+
+  - id: least_to_most
+    name: Least-to-Most
+    sequence: [independent, gestural, positional, partial_physical, full_physical]
+    description: "Start with independent attempt; add assistance only as needed."
+    best_for: "Learner with partial repertoire; promotes independence."
+
+  - id: time_delay
+    name: Time Delay (progressive)
+    sequence: [0s_delay, 2s_delay, 4s_delay, 6s_delay, independent]
+    description: "Increase latency between SD and prompt delivery across sessions."
+    best_for: "Prompt-dependency prevention; ideal for fading."
+    citation: "Touchette & Howard 1984 JABA."
+
+  - id: graduated_guidance
+    name: Graduated Guidance
+    sequence: [hand_over_hand_full, hand_over_hand_light, shadow, independent]
+    description: "Hand-over-hand guidance with fading physical pressure."
+    best_for: "Motor skills, self-care chaining."
+
+  - id: stimulus_fading
+    name: Stimulus Fading
+    sequence: [exaggerated_stimulus, moderate_fade, minimal_fade, natural_stimulus]
+    description: "Modify the stimulus itself; fade cue salience over sessions."
+    best_for: "Receptive discrimination, early reading."
+
+  - id: stimulus_shaping
+    name: Stimulus Shaping
+    sequence: [modified_stimulus, intermediate_shape, target_stimulus]
+    description: "Change the stimulus topography to approximate the target."
+    best_for: "Complex visual discriminations."
+
+# Error correction procedures available for DTT
+# Citation: Cooper, Heron, Heward (2020), Ch. 21.
+error_corrections:
+  - id: transfer_trial
+    name: Transfer trial
+    steps: >
+      Re-present SD -> provide effective-level prompt -> reinforce prompted
+      response -> distractor trial -> re-present SD independently.
+
+  - id: four_step
+    name: 4-step error correction
+    steps: >
+      Model correct response -> lead (do together) -> test (independent) ->
+      distractor -> retest.
+
+  - id: backstep
+    name: Backstep
+    steps: >
+      Return to previous prompt level that produced success ->
+      successful response -> re-attempt at target prompt level.
+
+  - id: simple_correction
+    name: Simple correction
+    steps: >
+      "No, watch me" -> model -> re-present SD -> differential reinforcement
+      for correct response.
+
+  - id: errorless
+    name: Errorless (preventive)
+    steps: >
+      Prevent errors by using high prompts from the start; fade gradually.
+      Paired with most-to-least prompt hierarchy.
+
+# Reinforcement schedules relevant for DTT (acquisition and thinning)
+# Citation: CHH (2020) Ch. 13, 22.
+# Note: DRO/DRA/DRI are behavior-reduction schedules handled in FCT taxonomy.
+reinforcement_schedules:
+  - id: crf
+    name: CRF (continuous reinforcement)
+    description: "Every correct response reinforced."
+    typical_phase: "Acquisition."
+
+  - id: fr2
+    name: FR-2 (fixed ratio 2)
+    description: "Every 2nd correct response reinforced."
+    typical_phase: "Thinning as accuracy stabilizes."
+
+  - id: vr3
+    name: VR-3 (variable ratio 3)
+    description: "Average of every 3rd correct response reinforced."
+    typical_phase: "Maintenance, resistance to extinction."
+
+  - id: token_economy
+    name: Token economy
+    description: "Tokens delivered per correct response; exchanged at session end for a back-up reinforcer appropriate to the learner (for children: candy, cookies, brief leisure-time access, preferred activity, screen time, or a favorite sensory item)."
+    typical_phase: "Group / classroom settings, mastered / generalization phase."
+
+# Mastery criteria common for DTT programs
+# Citation: CHH (2020) Ch. 28.
+mastery_criteria:
+  - id: mc_80_2sessions
+    text: "80% accuracy across 2 consecutive sessions with at least 10 trials each."
+
+  - id: mc_90_3sessions
+    text: "90% accuracy across 3 consecutive sessions."
+
+  - id: mc_80_generalization
+    text: "80% accuracy with 2 different therapists and 2 different settings."
+
+  - id: mc_80_independent
+    text: "80% accuracy at independent prompt level across 3 sessions."
+
+  - id: mc_90_first_trial
+    text: "90% first-trial-correct across 5 consecutive sessions."
+
+  - id: mc_fluency
+    text: "Fluency criterion: correct responses within 3-second latency at 90% accuracy."
+
+  - id: mc_natural_env
+    text: "Demonstrated use in natural environment across 3 independent instances."

configs/dtt/template.yaml

@@ -0,0 +1,90 @@
+# DTT teaching program template — TRACE v1
+# Filled by src/generate.py with values sampled from taxonomy.
+
+template_id: task1_dtt_v1
+task_type: teaching_program
+method_id: dtt
+
+# System prompt used for this task type
+system_prompt: |
+  You are an expert ABA (Applied Behavior Analysis) clinical assistant. You help
+  Board Certified Behavior Analysts and staff design teaching programs for
+  individuals with autism. Your responses are clinically accurate, individualized
+  to the learner profile, follow BACB ethical guidelines, and reference no real
+  client data. Select the appropriate teaching method (DTT, NET, Task Analysis,
+  FCT, BST, PRT) based on the skill target and learner profile.
+
+# User message template variants — one is sampled per example for phrasing diversity
+user_variants:
+  - |
+    Generate a teaching program for the following target.
+
+    Skill Target: {skill_target}
+    Curriculum Reference: {curriculum_ref}
+    Learner Profile: {learner_profile_name}
+    Current Mastery: {mastery_state_name}
+    Teaching Method: DTT
+
+    Provide the full program structure appropriate to the selected method.
+
+  - |
+    I need a DTT program for this skill.
+
+    Target: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner: {learner_profile_name}
+    Mastery Status: {mastery_state_name}
+
+    Please include the SD, prompt hierarchy, stimulus array, error correction procedure, reinforcement schedule, and mastery criteria.
+
+  - |
+    Design a Discrete Trial Training program for the following.
+
+    Skill: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner Level: {learner_profile_name}
+    Baseline: {mastery_state_name}
+
+    Include the full DTT trial structure.
+
+# Assistant message template — filled by generator
+# All slots in {braces} are computed by the generator from taxonomy values
+assistant_template: |
+  ## Program Overview
+  - Target skill: {skill_target}
+  - Curriculum: {curriculum_ref}
+  - Learner: {learner_profile_name}
+  - Current mastery: {mastery_state_name}
+
+  This DTT program establishes stimulus control over the target skill through structured discrete trials with a defined prompt hierarchy, stimulus array, and systematic error-correction procedure.
+
+  ## Discriminative Stimulus (SD)
+  Primary SD: "{primary_sd}"
+  Variations: {sd_variations}
+  Presentation: {sd_presentation}
+
+  ## Prompt Hierarchy
+  Strategy: {prompt_hierarchy_name}
+  Sequence: {prompt_sequence}
+  Current prompt level: At the {mastery_state_short} stage, {current_prompt_guidance}
+
+  ## Stimulus Array
+  Array size: {array_size}
+  Target stimuli: {target_stimuli}
+  {distractor_block}
+  Rotation: Randomize position of target across trials to prevent position bias.
+
+  ## Error Correction Procedure
+  {error_correction_steps}
+
+  ## Reinforcement Schedule
+  {reinforcement_schedule_name} — {reinforcement_description}. Provide differential reinforcement: higher-quality reinforcement for independent correct responses than for prompted correct responses.
+
+  ## Mastery Criteria
+  {mastery_criterion_text}
+
+  ## Data Collection
+  Trial-by-trial data recording prompt level and response accuracy. IOA scheduled every {ioa_frequency} sessions minimum; target agreement ≥ 80%.
+
+  ## Generalization & Maintenance Plan
+  Post-mastery: probe with novel stimuli, across {n_generalization_therapists} additional therapists, and in at least {n_generalization_settings} natural contexts. Maintenance probes weekly for 4 weeks, then monthly.

configs/generation.yaml

@@ -0,0 +1,44 @@
+# TRACE data generation config
+# Controls per-area example counts, split ratios, and the global seed.
+
+seed: 42
+output_dir: data/splits
+
+# Per-area generation counts and enabled flags.
+# Total target: ~3,500 examples (train + valid + curation-pool sums).
+areas:
+  dtt:
+    enabled: true
+    n: 800
+    description: "DTT teaching programs — array-based discrete-response skills."
+  net:
+    enabled: true
+    n: 500
+    description: "NET teaching programs — motivation-based naturalistic teaching."
+  task_analysis:
+    enabled: true
+    n: 500
+    description: "Task Analysis / Chaining — multi-step routines (AFLS)."
+  fct:
+    enabled: false
+    n: 300
+    description: "FCT — replacement-behavior programs paired with deceleration targets."
+  bst:
+    enabled: false
+    n: 200
+    description: "BST — staff-facing training programs."
+  prt:
+    enabled: false
+    n: 300
+    description: "PRT — pivotal-behavior programs."
+  session_interpretation:
+    enabled: true
+    n: 1200
+    description: "Task 2 — behavioral session interpretation (paper's innovation task)."
+
+# Split ratios applied after all enabled areas generate
+# test + sanity are NOT generated here — they're curated by the user from curation_pool
+splits:
+  train: 0.85
+  valid: 0.05
+  curation_pool: 0.10    # user reviews this pool and curates test.jsonl + sanity.jsonl

configs/net/compatibility.yaml

@@ -0,0 +1,51 @@
+# NET clinical-consistency rules — TRACE v1
+
+# VB-MAPP level -> compatible learner profiles
+level_to_learner_profiles:
+  L1: [early]
+  L2: [early, school_age]
+  L3: [school_age, adolescent]
+
+# Sampling weights for level selection
+# NET is used at all levels but slightly biased toward L2/L3 where mands grow
+level_sampling_weights:
+  L1: 0.30
+  L2: 0.40
+  L3: 0.30
+
+# Skill keyword -> MO category mapping
+# Used to select the appropriate MO arrangement for a sampled skill.
+skill_to_mo_category:
+  - keywords: [mand, item, preferred, 2-word]
+    category: mand_item
+  - keywords: [missing]
+    category: mand_missing
+  - keywords: [help]
+    category: mand_help
+  - keywords: [break]
+    category: mand_break
+  - keywords: ["all done", finished, completion]
+    category: mand_completion
+  - keywords: ["what"]
+    category: mand_info_what
+  - keywords: ["where"]
+    category: mand_info_where
+  - keywords: [attention, peers]
+    category: mand_attention
+  - keywords: [action]
+    category: mand_action
+  - keywords: [greet]
+    category: spontaneous_greeting
+  - keywords: [comment, describe, narrate, story]
+    category: spontaneous_comment
+  - keywords: [conversation, reciprocal, multi-turn]
+    category: intraverbal_multi_turn
+  - keywords: [turn-taking, turn]
+    category: social_turn_taking
+  - keywords: [initiate, peer]
+    category: social_initiation
+  - keywords: [routine]
+    category: intraverbal_routine
+
+# Default category when no keyword matches
+default_mo_category: mand_item

configs/net/taxonomy.yaml

@@ -0,0 +1,230 @@
+# NET (Natural Environment Teaching) taxonomy — TRACE v1
+# Self-contained: skills + MOs + natural contexts for naturalistic teaching.
+# Citation: Hart & Risley 1975 JABA; McGee, Krantz, McClannahan 1985 JABA.
+
+method:
+  id: net
+  name: Natural Environment Teaching
+  short: NET
+  citation: "Hart, B. & Risley, T. R. (1975). JABA, 8(4), 411–420. https://doi.org/10.1901/jaba.1975.8-411; McGee, G. G., Krantz, P. J., & McClannahan, L. E. (1985). JABA, 18(1), 17–31."
+  when_to_use: >
+    Mand / requesting; generalization phase; when motivation is the limiting
+    factor; when the skill's natural occasion is ecologically predictable
+    (e.g., requesting food during snack time).
+
+# VB-MAPP domains appropriate for NET (motivation-driven skills).
+skill_domains:
+  vbmapp:
+    levels:
+      - id: L1
+        name: Level 1
+        developmental_age: "0–18 months"
+      - id: L2
+        name: Level 2
+        developmental_age: "18–30 months"
+      - id: L3
+        name: Level 3
+        developmental_age: "30–48 months"
+
+    domains:
+      - id: mand
+        name: Mand
+        gloss: Requesting
+        L1:
+          - single-word mands for preferred items
+          - mands for missing items needed to complete an activity
+          - mands for actions
+          - mands for help
+          - mands using 2-word phrases
+          - mands for a break (e.g., "break please", AAC "I need a break")
+          - mands for activity completion ("all done", "finished")
+          - mands to use the bathroom (e.g., "bathroom", "potty", "I need to go", AAC bathroom icon)
+        L2:
+          - mands for information using "what"
+          - mands for information using "where"
+          - mands using adjectives (big, little, more)
+          - mands for attention from peers
+          - mands for others to stop an action
+          - mands for a break during a non-preferred task ("break please, I need a break")
+          - mands to indicate completion of a step or activity ("all done with this one")
+        L3:
+          - mands for information using "why"
+          - mands for information using "when"
+          - mands using complete sentences with correct grammar
+          - mands for future events or items not present
+          - mands using polite social conventions
+          - mands for a break with reason ("I need a break, I'm frustrated")
+          - mands to indicate completion in context ("I'm all done with math, can I start reading?")
+
+      - id: social
+        name: Social Behavior & Social Play
+        L1:
+          - makes eye contact during interactions
+          - responds to own name
+          - engages in social games (peek-a-boo, tickle)
+          - shows items to others spontaneously
+          - tolerates proximity of peers during parallel play
+        L2:
+          - initiates social interactions with peers
+          - takes turns during structured activities
+          - shares materials with peers when prompted
+          - engages in cooperative play with one peer
+          - responds to peer initiations appropriately
+        L3:
+          - maintains reciprocal conversations with peers
+          - demonstrates empathy and perspective-taking
+          - negotiates and compromises during group activities
+          - joins ongoing peer activities appropriately
+          - maintains friendships over time
+
+      - id: spontaneous_vocal
+        name: Spontaneous Vocal Behavior
+        L1:
+          - spontaneously vocalizes during preferred activities
+          - spontaneously names items in the environment
+          - spontaneously requests desired items without prompts
+          - spontaneously greets familiar people
+          - spontaneously comments on events
+        L2:
+          - spontaneously describes ongoing activities
+          - spontaneously asks questions about the environment
+          - spontaneously reports past events
+          - spontaneously uses social phrases appropriately
+          - spontaneously initiates conversation with peers
+        L3:
+          - spontaneously tells stories or narratives
+          - spontaneously makes relevant comments in conversations
+          - spontaneously adjusts language to different listeners
+          - spontaneously uses humor appropriately
+          - spontaneously provides explanations and reasons
+
+      - id: intraverbal
+        name: Intraverbal
+        gloss: Contextualized verbal-to-verbal responding
+        L2:
+          - answers WH-questions about familiar topics
+          - describes function of common objects
+          - names items in categories when given the category
+          - answers social questions (How are you?)
+          - describes recent events in sequence
+        L3:
+          - answers why- and how-questions
+          - engages in multi-turn conversations on a topic
+          - makes inferences from given information
+          - provides definitions of words
+          - answers hypothetical questions
+
+# MO (Motivating Operation) arrangement templates by skill-type category.
+# The generator picks one based on the skill target keywords.
+mo_arrangements:
+  - id: deprivation_preferred_item
+    applies_to: [mand_item, mand_action]
+    text: "Briefly withhold or restrict access to the target preferred item/activity for 30–60 seconds to establish motivation before the teaching opportunity."
+    context_examples: [snack time, free play, leisure time]
+
+  - id: missing_item_completion
+    applies_to: [mand_help, mand_missing]
+    text: "Arrange an activity that requires a specific item to complete, then omit that item from the available materials. Wait for the learner to notice the gap."
+    context_examples: [art activity, snack preparation, puzzle]
+
+  - id: break_opportunity
+    applies_to: [mand_break]
+    text: "Present a brief non-preferred task or demand at a level the learner can tolerate but may wish to pause. Wait for a request-for-break topography; honor the request immediately on first acquisition (CRF), thin later."
+    context_examples: [work time, tabletop task, academic period]
+
+  - id: completion_opportunity
+    applies_to: [mand_completion]
+    text: "Set up a clearly-bounded activity with a visible endpoint (e.g., a worksheet, a puzzle, a sorting task). Wait for the learner to indicate completion verbally or via AAC; honor the indication immediately."
+    context_examples: [worksheet, puzzle, sorting task, meal]
+
+  - id: bathroom_opportunity
+    applies_to: [mand_bathroom]
+    text: "Arrange a scheduled toileting window (typically 30–60 minutes after fluid intake) and observe for pre-toileting signs (body position, vocalization, squirming). Model the mand topography (vocal, sign, or AAC icon) at the first sign of need; reinforce any approximation with immediate escort to the bathroom. Do not prompt after an accident has started."
+    context_examples: [post-snack window, post-drink window, scheduled mid-morning check, end-of-activity transition]
+
+  - id: unexpected_change
+    applies_to: [mand_info_what, mand_info_where, spontaneous_comment]
+    text: "Create a small environmental change (new item, familiar item in new location, surprise event) that invites a verbal comment or question."
+    context_examples: [morning greeting, room transition, activity setup]
+
+  - id: peer_presence
+    applies_to: [social_initiation, social_turn_taking, peer_mand]
+    text: "Arrange a shared activity with one or more peers where the target response is naturally occasioned (turn-taking game, shared snack, collaborative task)."
+    context_examples: [peer play, circle time, shared snack]
+
+  - id: reciprocal_conversation
+    applies_to: [intraverbal_multi_turn, social_reciprocal, spontaneous_narrative]
+    text: "Engage the learner in a naturalistic conversation on a topic of demonstrated interest. Pause at natural turn boundaries to invite the target response."
+    context_examples: [transition conversation, post-activity debrief, leisure chat]
+
+  - id: routine_lead_in
+    applies_to: [spontaneous_greeting, intraverbal_routine]
+    text: "Use the natural beginning/ending of an established routine (morning arrival, mealtime, departure) as the moment for the target response."
+    context_examples: [arrival, snack, departure]
+
+# Natural-context examples drawn into prompts for variation
+natural_contexts:
+  - snack time
+  - free play with preferred materials
+  - transition between activities
+  - morning arrival routine
+  - peer group game
+  - art / craft activity
+  - leisure / sensory break
+  - outdoor play
+  - shared meal preparation
+  - departure routine
+
+# Prompt strategies used in NET (subset of full hierarchy — naturalistic)
+prompt_strategies:
+  - id: time_delay
+    name: Time Delay
+    description: "Wait a brief interval (0->2->4 s) for independent response before delivering a model or verbal prompt."
+    best_for: "Most NET mand and spontaneous vocal targets."
+
+  - id: model_then_fade
+    name: Model + immediate fade
+    description: "Deliver a vocal/gestural model if no response within the motivated moment; fade to expectant look over sessions."
+    best_for: "Acquisition of new mand topographies."
+
+  - id: expectant_look
+    name: Expectant look (pause)
+    description: "Deliver no prompt — maintain eye contact and hold the preferred item until the learner responds."
+    best_for: "Established mands; fading teacher-delivered prompts."
+
+  - id: verbal_fill_in
+    name: Verbal fill-in
+    description: "Deliver a partial phrase and pause; learner completes the vocal response."
+    best_for: "Song, rhyme, or scripted social-phrase targets."
+
+# Natural reinforcers — always the functional outcome of the target response
+natural_reinforcer_examples:
+  mand_item: "immediate access to the requested item for 30–60 seconds."
+  mand_action: "performance of the requested action."
+  mand_help: "adult delivers the requested help, task completed together."
+  mand_missing: "the missing item is provided, activity can continue."
+  mand_break: "immediate brief escape from the demand (30–60 seconds) to a neutral or preferred activity."
+  mand_completion: "the activity ends immediately and the learner transitions to the next preferred activity."
+  mand_bathroom: "immediate escort to the bathroom; the learner is not required to complete the current task before going. Pairing the mand with timely bathroom access is what teaches the learner that requesting works."
+  mand_info_what: "adult answers the question informatively."
+  mand_info_where: "adult answers the question or provides location."
+  mand_attention: "adult attends to the learner and engages briefly."
+  social_initiation: "peer engages back; activity continues with both."
+  social_turn_taking: "turn is delivered; game continues."
+  spontaneous_comment: "adult attends to the comment with matching affect."
+  spontaneous_greeting: "adult returns the greeting warmly."
+  intraverbal_multi_turn: "conversation continues with adult's naturally matched reply."
+  default: "natural social or tangible consequence matching the function of the response."
+
+# Mastery criteria for NET programs (slightly different emphasis than DTT)
+mastery_criteria:
+  - id: mc_indep_natural_env
+    text: "Independent use of target response across 3 natural opportunities per day for 3 consecutive days."
+  - id: mc_generalize_multi_therapist
+    text: "Independent use across 3 different adults and 2 different settings within 2 weeks."
+  - id: mc_peer_initiation
+    text: "Independent use with a peer in unstructured free play across 2 consecutive sessions."
+  - id: mc_spontaneous_rate
+    text: "Average rate of ≥ 3 spontaneous responses per 30-minute session across 3 consecutive sessions."
+  - id: mc_fluent_exchange
+    text: "Fluent exchange (response within 3 s of MO / opportunity) with appropriate topography, 80% of opportunities across 3 sessions."

configs/net/template.yaml

@@ -0,0 +1,84 @@
+# NET teaching program template — TRACE v1
+
+template_id: task1_net_v1
+task_type: teaching_program
+method_id: net
+
+system_prompt: |
+  You are an expert ABA (Applied Behavior Analysis) clinical assistant. You help
+  Board Certified Behavior Analysts and staff design teaching programs for
+  individuals with autism. Your responses are clinically accurate, individualized
+  to the learner profile, follow BACB ethical guidelines, and reference no real
+  client data. Select the appropriate teaching method (DTT, NET, Task Analysis,
+  FCT, BST, PRT) based on the skill target and learner profile.
+
+user_variants:
+  - |
+    Generate a teaching program for the following target.
+
+    Skill Target: {skill_target}
+    Curriculum Reference: {curriculum_ref}
+    Learner Profile: {learner_profile_name}
+    Current Mastery: {mastery_state_name}
+    Teaching Method: NET (Natural Environment Teaching)
+
+    Provide the full program structure appropriate to the selected method.
+
+  - |
+    I need a NET program for this skill.
+
+    Target: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner: {learner_profile_name}
+    Mastery Status: {mastery_state_name}
+
+    Please include the MO arrangement, natural opportunity, prompt strategy, natural reinforcer, generalization tactics, and mastery criteria.
+
+  - |
+    Design a Natural Environment Teaching program for the following.
+
+    Skill: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner Level: {learner_profile_name}
+    Baseline: {mastery_state_name}
+
+    Include the full naturalistic teaching structure.
+
+assistant_template: |
+  ## Program Overview
+  - Target skill: {skill_target}
+  - Curriculum: {curriculum_ref}
+  - Learner: {learner_profile_name}
+  - Current mastery: {mastery_state_name}
+
+  This NET program teaches the target skill through naturalistic embedding — capturing motivated moments within the learner's routine rather than using contrived massed trials.
+
+  ## Motivating Operation (MO) Arrangement
+  {mo_arrangement_text}
+  Primary natural context: {primary_natural_context}.
+
+  ## Natural Opportunity
+  {natural_opportunity_text}
+
+  ## Prompt Strategy
+  Strategy: {prompt_strategy_name}
+  {prompt_strategy_description}
+  Current prompt level: At the {mastery_state_short} stage, {current_prompt_guidance}
+
+  ## Natural Reinforcer
+  {natural_reinforcer_text}
+  Avoid contrived consequences — the functional outcome IS the reinforcer.
+
+  ## Generalization Tactics
+  - Program multiple exemplars across {n_exemplars} different stimuli or peers.
+  - Rotate between {n_settings} different natural settings.
+  - Rotate across {n_therapists} different adults during the teaching phase.
+
+  ## Mastery Criteria
+  {mastery_criterion_text}
+
+  ## Data Collection
+  Opportunity-based data recording: each naturally-occasioned trial is scored for independence and topography. IOA scheduled every {ioa_frequency} sessions minimum; target agreement ≥ 80%.
+
+  ## Generalization & Maintenance Plan
+  Post-mastery: probe across novel peers, settings, and materials. Maintenance probes weekly for 4 weeks, then monthly. Fade adult-delivered prompts before declaring mastery.

configs/session_interpretation/compatibility.yaml

@@ -0,0 +1,90 @@
+# Session Interpretation compatibility rules — TRACE v1
+
+# Pattern -> how many target behaviors are typically present in logs of this pattern
+pattern_behavior_count_ranges:
+  mastery_progression: [0, 1]
+  regression: [1, 2]
+  plateau: [0, 1]
+  frustration_pattern: [1, 2]
+  variable_performance: [0, 2]
+  prompt_dependency: [0, 1]
+  rapid_acquisition: [0, 0]
+  generalization_failure: [0, 1]
+  extinction_burst: [1, 2]
+  skill_loss_after_break: [0, 1]
+  motivating_operation_shift: [0, 1]
+  setting_event_trigger: [0, 2]
+
+# Pattern -> likely behavior functions when behavior is present
+pattern_function_bias:
+  frustration_pattern: [escape, escape, attention]      # escape dominant
+  extinction_burst: [escape, attention, tangible]        # depends on what's being extinguished
+  regression: [escape, attention, automatic]
+  variable_performance: [escape, attention, tangible, automatic]
+  plateau: [escape, automatic]
+  generalization_failure: [escape, attention]
+  setting_event_trigger: [escape, automatic, attention]
+  motivating_operation_shift: [tangible, automatic]
+  prompt_dependency: [attention, escape]
+  skill_loss_after_break: [escape, automatic]
+  mastery_progression: [automatic]                       # if any behavior present, likely automatic/low-stakes
+  rapid_acquisition: []                                  # no behaviors
+
+# Pattern -> behavioral indicator cluster to sample from when log includes indicators
+pattern_behavioral_indicator_cluster:
+  frustration_pattern: frustration
+  regression: frustration
+  extinction_burst: frustration
+  variable_performance: disengagement
+  plateau: disengagement
+  prompt_dependency: disengagement
+  generalization_failure: disengagement
+  setting_event_trigger: disengagement
+  motivating_operation_shift: disengagement
+  mastery_progression: engagement
+  rapid_acquisition: engagement
+  skill_loss_after_break: disengagement
+
+# Escalation rules — raise above pattern default when severe behaviors present
+# Behaviors with typical_severity "high" escalate one level (capped at 4).
+escalation_rules:
+  severe_behavior_ids: [sib, aggression, pica, elopement, fecal_smearing]
+  severe_behavior_escalation_bump: 1
+  safety_immediate_threshold_behaviors: [sib]            # SIB at high frequency triggers 4
+  safety_immediate_sib_rate_per_session: 8               # freq >= this in final 2 sessions -> escalation 4
+
+# Confidence inference rules
+confidence_rules:
+  min_sessions_for_moderate: 5
+  min_sessions_for_high: 8
+  ioa_required_for_high: true
+  variance_threshold_low: 0.25                           # if accuracy SD > this, cap at moderate
+
+# Log length by pattern
+log_length_by_pattern:
+  mastery_progression: [8, 12]
+  regression: [8, 12]
+  plateau: [8, 12]
+  frustration_pattern: [8, 12]
+  variable_performance: [8, 12]
+  prompt_dependency: [8, 12]
+  rapid_acquisition: [5, 8]
+  generalization_failure: [8, 12]
+  extinction_burst: [6, 10]
+  skill_loss_after_break: [6, 10]
+  motivating_operation_shift: [8, 12]
+  setting_event_trigger: [8, 12]
+
+# ABC and IOA presence (fractions are probabilities)
+abc_inclusion_probability: 0.3
+ioa_inclusion_probability: 0.25
+ioa_agreement_range: [0.82, 0.97]
+ioa_low_probability: 0.05                                # small chance of below-80% IOA
+ioa_low_range: [0.68, 0.79]
+
+# Sessions per log — max + min + typical duration
+session_duration_minutes_range: [30, 60]
+trials_per_program_per_session_range: [8, 15]
+
+# Sampling of programs per log
+programs_per_log_range: [3, 6]

configs/session_interpretation/recommendations.yaml

@@ -0,0 +1,155 @@
+# Per-pattern recommendation template pools — TRACE v1
+# Sampled by the generator to compose the "Programming Recommendations" section.
+# Each pattern has bullets grouped under BIP-shaped sub-sections:
+#   antecedent / replacement / consequence / crisis
+# Replacement and crisis sections only appear when target behaviors are in the log.
+#
+# Crisis-plan bullets are grounded in:
+# - BACB Ethics Code for Behavior Analysts (2020), Section 3.05 (restrictive
+#   procedures) and Section 2.13 (referrals / coordination of services)
+# - ABAI Position Statement on Restraint and Seclusion (2010)
+# - Widely-used facility crisis-prevention training frameworks as examples only
+#   (Safety-Care, CPI, PMT, Therapeutic Crisis Intervention)
+# Procedure specifics are intentionally left to the facility's training program
+# because restraint / seclusion protocols vary by jurisdiction, training
+# certification, and facility policy.
+
+patterns:
+  mastery_progression:
+    antecedent:
+      - "Continue current teaching procedure — it is effective for this learner."
+      - "Maintain current stimulus arrangement; begin planning next skill in sequence."
+    replacement: []
+    consequence:
+      - "Begin thinning reinforcement from CRF to FR-2 as accuracy stabilizes above 85%."
+      - "Continue differential reinforcement for independent responses."
+    crisis: []
+
+  regression:
+    antecedent:
+      - "Conduct reinforcer assessment to identify current high-preference items."
+      - "Review recent environmental or schedule changes that may be affecting performance."
+      - "Return temporarily to a previously-mastered prompt level and re-fade systematically."
+    replacement:
+      - "If problem behavior accompanies regression, strengthen replacement-behavior training for the hypothesized function."
+    consequence:
+      - "Increase reinforcement magnitude and schedule temporarily (return to CRF if needed)."
+      - "Implement more frequent maintenance probes (at least weekly) after re-mastery."
+    crisis:
+      - "If regression co-occurs with severe behavior (SIB, aggression, property destruction) reaching the learner's safety threshold: pause all skill-acquisition programming, implement environmental safety measures (clear the area of hazards, move peers to safe distance), and contact the supervising BCBA."
+      - "Staff should first attempt verbal de-escalation and least-restrictive strategies; physical intervention is used only as a last resort and only by staff currently certified in the facility's crisis-prevention framework (e.g., Safety-Care, CPI, or equivalent)."
+      - "Physical intervention is applied only when specifically authorized in this learner's BIP. Many learners have contraindications (medical conditions, developmental or age-related factors, trauma history, or explicit BIP restrictions) that rule out restrictive procedures — in those cases the crisis plan defaults to verbal de-escalation, environmental safety measures, and immediate supervisor / emergency contact without physical intervention."
+      - "Document the incident per facility and BACB (Ethics Code 2020, Section 3.05) requirements within 24 hours; conduct post-incident debrief with all staff involved before resuming programming."
+
+  plateau:
+    antecedent:
+      - "Modify teaching procedure — switch prompt type (e.g., from most-to-least to time delay)."
+      - "Conduct preference assessment and update reinforcer menu."
+      - "Break the current skill into smaller component steps if possible."
+      - "Increase practice opportunities by embedding targets in natural-environment training."
+    replacement: []
+    consequence:
+      - "Check for inadvertent reinforcement of near-misses; tighten differential reinforcement."
+    crisis: []
+
+  frustration_pattern:
+    antecedent:
+      - "**Immediately** reduce task difficulty — drop back 1–2 prompt levels or present previously-mastered targets."
+      - "Intersperse easy (mastered) tasks with acquisition targets at a 3:1 or 4:1 ratio."
+      - "Shorten session length and increase break frequency."
+    replacement:
+      - "Teach a replacement response ('break please', 'wait please', 'all done') and reinforce it at the function of the problem behavior."
+      - "Pair the replacement response with short, predictable escape windows."
+    consequence:
+      - "Do NOT remove demand contingent on tantrum / escape behavior — this reinforces the escape function."
+      - "Provide brief break contingent on independent replacement response instead."
+    crisis:
+      - "If aggression toward staff, peer aggression, SIB, or property destruction exceeds the learner's safety threshold: first use verbal de-escalation and environmental safety measures (clear the area, move peers to safe distance, remove hazards)."
+      - "If behavior continues to pose imminent risk, follow the facility's tiered crisis-intervention protocol — only staff currently certified in the facility's training (e.g., Safety-Care, CPI, PMT, or equivalent) may implement physical intervention, and the least-restrictive option appropriate to the risk level is used. Physical intervention is applied only when specifically authorized in this learner's BIP; for learners with contraindications (medical, developmental, trauma history, or explicit BIP restrictions), the plan stops at de-escalation + environmental safety + supervisor contact."
+      - "Notify the supervising BCBA immediately; pause the skill-acquisition program until the BIP is reviewed. Document the incident (antecedent, topography, duration, staff response, post-incident state) per facility and BACB Ethics Code (2020, Section 3.05) requirements."
+      - "Conduct a post-incident debrief with all staff involved to review what worked, what did not, and whether the BIP needs revision."
+
+  variable_performance:
+    antecedent:
+      - "Check for environmental variables that differ across sessions (time of day, therapist, setting)."
+      - "Standardize session structure and reinforcement delivery across therapists."
+    replacement: []
+    consequence:
+      - "Implement inter-observer agreement probes to rule out measurement inconsistency."
+    crisis: []
+
+  prompt_dependency:
+    antecedent:
+      - "Switch to a time-delay procedure (0s -> 2s -> 4s -> 6s) to encourage independent responding."
+      - "Avoid inadvertent prompt delivery (therapist gaze, body positioning) that may function as a prompt."
+    replacement: []
+    consequence:
+      - "Ensure differential reinforcement — independent responses receive higher-quality reinforcement than prompted responses."
+      - "Consider stimulus fading instead of response prompting for this skill."
+    crisis: []
+
+  rapid_acquisition:
+    antecedent:
+      - "Advance to next skill in the sequence immediately."
+      - "Begin generalization probes across people, settings, and materials."
+    replacement: []
+    consequence:
+      - "Move to maintenance schedule (probe monthly) and redirect session time to acquisition targets."
+    crisis: []
+
+  generalization_failure:
+    antecedent:
+      - "Implement structured generalization training: vary therapists, settings, and materials systematically."
+      - "Use multiple-exemplar training — teach with 3–5 different stimulus sets."
+      - "Program common stimuli across training and generalization settings."
+    replacement: []
+    consequence:
+      - "Consider natural-environment training (NET) to supplement DTT for this skill."
+    crisis: []
+
+  extinction_burst:
+    antecedent:
+      - "Maintain current antecedent arrangements — do not add extra demand."
+    replacement:
+      - "Ensure replacement response is available and reinforced at high magnitude during the burst."
+    consequence:
+      - "**Maintain current protocol** — consistency during extinction bursts is critical."
+      - "Ensure all team members are trained on the procedure."
+    crisis:
+      - "If problem-behavior intensity or topography exceeds the learner's baseline safety threshold (SIB causing tissue damage, aggression causing injury, imminent elopement into hazard): pause the extinction procedure and implement the facility's tiered crisis-prevention protocol (e.g., Safety-Care, CPI, or equivalent)."
+      - "De-escalation and environmental safety first; physical intervention is last resort and only by staff currently certified in the facility's framework. Least-restrictive option appropriate to the risk level applies at every step. Physical intervention is used only when specifically authorized for this learner in the BIP — contraindications (medical, developmental, trauma history) may restrict the procedures available, in which case the plan is de-escalation + environmental safety + supervisor contact only."
+      - "Contact the supervising BCBA immediately; do not resume the extinction procedure without BCBA review. Document duration, intensity, antecedent, staff response, and post-incident state."
+      - "Conduct a post-incident debrief with staff. If the burst exceeds the BIP's anticipated duration or intensity, the BIP should be re-reviewed before resuming."
+
+  skill_loss_after_break:
+    antecedent:
+      - "Implement booster sessions at the most-recently-effective prompt level."
+      - "Increase session frequency temporarily until pre-break levels are recovered."
+    replacement: []
+    consequence:
+      - "Review and strengthen the maintenance schedule to prevent future skill loss."
+      - "Consider sending practice materials home during extended breaks."
+    crisis: []
+
+  motivating_operation_shift:
+    antecedent:
+      - "Conduct preference assessment to identify a currently-valued reinforcer."
+      - "Program MO-establishing operations (deprivation for target reinforcer) before teaching sessions."
+      - "Rotate reinforcers to prevent satiation."
+    replacement: []
+    consequence:
+      - "Adjust reinforcement density to match current MO level."
+    crisis: []
+
+  setting_event_trigger:
+    antecedent:
+      - "Identify and document the setting event (sleep, illness, schedule change, medication)."
+      - "Modify programming demand on days when setting event is present."
+      - "Coordinate with caregivers / medical team on setting-event factors outside the program."
+    replacement: []
+    consequence:
+      - "Track setting events alongside performance data to quantify their effect."
+    crisis:
+      - "If the setting event involves a medical concern (seizure-like activity, injury, illness): stop the program immediately, follow the facility's medical-incident protocol, and refer to the appropriate medical professional. Medical events are NOT behavioral targets and must not be treated as ABA programming issues."
+      - "If behavior escalates during the setting-event window: use verbal de-escalation and environmental safety first; do not add demand. Only staff currently certified in the facility's crisis-prevention framework may use physical intervention, and only if imminent safety risk warrants it AND the learner's BIP specifically authorizes it (contraindications and BIP restrictions may rule it out)."
+      - "Coordinate with caregivers, the medical team, and the supervising BCBA; document the setting event and the associated behavior for pattern analysis. Review the BIP in light of the setting-event data."

configs/session_interpretation/taxonomy.yaml

@@ -0,0 +1,318 @@
+# Session Interpretation taxonomy — TRACE v1
+# The controlled vocabulary the Task 2 generator draws from. Self-contained.
+#
+# Citations for underlying concepts: see taxonomy-v1.md.
+
+task:
+  id: session_interpretation
+  name: Behavioral Session Interpretation
+  citation: >
+    Multi-session interpretation framework is TRACE's operationalization.
+    Underlying concepts grounded in CHH (2020) Ch. 6–7 (analyzing behavior change),
+    Iwata 1982/1994 (functional analysis), Hanley-Iwata-McCord 2003 (FBA review),
+    Bijou-Peterson-Ault 1968 (ABC recording), Michael 1993 (MOs).
+
+# 12 session patterns (each drives trajectory + interpretation)
+patterns:
+  - id: mastery_progression
+    name: Mastery progression
+    description: "Steady improvement toward mastery criteria."
+    trend: ascending
+    concern_level: none
+    default_escalation: 1
+    citation: "CHH Ch. 6."
+
+  - id: regression
+    name: Regression
+    description: "Decline in performance after previous mastery or near-mastery."
+    trend: descending
+    concern_level: high
+    default_escalation: 3
+    citation: "CHH Ch. 26 (maintenance)."
+
+  - id: plateau
+    name: Plateau
+    description: "Accuracy stable but below mastery criteria for extended period."
+    trend: flat
+    concern_level: moderate
+    default_escalation: 2
+    citation: "CHH Ch. 7."
+
+  - id: frustration_pattern
+    name: Frustration pattern
+    description: "Declining accuracy accompanied by behavioral indicators of frustration and escape-maintained responding."
+    trend: descending
+    concern_level: high
+    default_escalation: 3
+    citation: "Iwata 1994 (escape function); CHH Ch. 27."
+
+  - id: variable_performance
+    name: Variable performance
+    description: "Inconsistent accuracy across sessions with no clear trend."
+    trend: variable
+    concern_level: moderate
+    default_escalation: 2
+    citation: "CHH Ch. 5 (measurement reliability)."
+
+  - id: prompt_dependency
+    name: Prompt dependency
+    description: "High accuracy with prompts but failure at independent level."
+    trend: flat_high_prompted
+    concern_level: moderate
+    default_escalation: 2
+    citation: "Touchette & Howard 1984 JABA (time delay)."
+
+  - id: rapid_acquisition
+    name: Rapid acquisition
+    description: "Quick skill acquisition exceeding expected timeline."
+    trend: sharply_ascending
+    concern_level: none
+    default_escalation: 1
+    citation: "CHH Ch. 6."
+
+  - id: generalization_failure
+    name: Generalization failure
+    description: "Strong performance in training but failure to generalize to novel conditions."
+    trend: context_dependent
+    concern_level: moderate
+    default_escalation: 2
+    citation: "Stokes & Baer 1977 JABA; CHH Ch. 26."
+
+  - id: extinction_burst
+    name: Extinction burst
+    description: "Temporary increase in problem behavior during behavior reduction."
+    trend: temporary_spike
+    concern_level: expected
+    default_escalation: 2
+    citation: "CHH Ch. 24."
+
+  - id: skill_loss_after_break
+    name: Skill loss after break
+    description: "Performance decline following extended absence or break, with recovery."
+    trend: drop_then_recovery
+    concern_level: moderate
+    default_escalation: 2
+    citation: "CHH Ch. 26 (maintenance)."
+
+  - id: motivating_operation_shift
+    name: Motivating operation shift
+    description: "Responding drops when MO changes (e.g., satiation); recovers when MO restored."
+    trend: mo_dip
+    concern_level: moderate
+    default_escalation: 2
+    citation: "Michael 1993 JEAB; CHH Ch. 16."
+
+  - id: setting_event_trigger
+    name: Setting event trigger
+    description: "Accuracy or behavior changes correlated with an external setting event (illness, sleep, schedule change)."
+    trend: setting_event
+    concern_level: moderate
+    default_escalation: 2
+    citation: "Smith & Iwata 1997 JABA; Bijou & Baer 1961."
+
+# Behavior functions
+functions:
+  - id: escape
+    name: escape
+    reinforcer: "Termination or avoidance of an aversive stimulus (demand, task, interaction)."
+    typical_antecedents: [demand presentation, difficult task, non-preferred activity, transition to work]
+    typical_consequences: [task removed, demand withdrawn, redirected to preferred activity]
+  - id: attention
+    name: attention
+    reinforcer: "Attention from others (adult or peer)."
+    typical_antecedents: [adult attention diverted, peer interaction, low-attention period]
+    typical_consequences: [adult attends, reprimand delivered, peer interaction initiated]
+  - id: tangible
+    name: tangible
+    reinforcer: "Access to an item or activity."
+    typical_antecedents: [preferred item removed, restricted access, another peer has item]
+    typical_consequences: [item returned, access granted, activity restored]
+  - id: automatic
+    name: automatic
+    reinforcer: "Self-produced reinforcement (sensory, proprioceptive)."
+    typical_antecedents: [low-stimulation period, alone time, waiting]
+    typical_consequences: [no social mediation; behavior self-terminates or continues]
+  - id: unknown
+    name: unknown
+    reinforcer: "Insufficient data to determine function."
+
+# Target behaviors (deceleration targets)
+# For full operational definitions + citations see taxonomy-v1.md.
+# Used when the generator samples 0–3 behaviors per log.
+target_behaviors:
+  - id: tantrum
+    name: Tantrum
+    operational: "Co-occurring cluster of two or more of: crying/screaming, dropping to floor, kicking, hitting, throwing objects, lasting ≥ 3 s."
+    plausible_functions: [escape, attention, tangible]
+    typical_severity: moderate
+  - id: aggression
+    name: Aggression
+    operational: "Attempted or completed forceful contact directed toward another person (hit, kick, bite, scratch, pinch, throw-at)."
+    plausible_functions: [escape, tangible, attention]
+    typical_severity: high
+  - id: sib
+    name: Self-injurious behavior (SIB)
+    operational: "Any response that produces tissue damage or has potential to (head-hit, self-bite, face-slap, head-bang, skin-pick, self-pinch)."
+    plausible_functions: [automatic, attention, escape]
+    typical_severity: high
+  - id: elopement
+    name: Elopement
+    operational: "Full body crossing a designated boundary without adult approval."
+    plausible_functions: [escape, tangible, automatic]
+    typical_severity: high
+  - id: property_destruction
+    name: Property destruction
+    operational: "Hitting/kicking furniture or walls; throwing objects not meant to be thrown; tearing clothing, books, materials."
+    plausible_functions: [escape, attention, tangible]
+    typical_severity: moderate
+  - id: motor_stereotypy
+    name: Motor stereotypy
+    operational: "Repetitive non-functional motor movements (hand-flap, body-rock, finger-flick, spin)."
+    plausible_functions: [automatic]
+    typical_severity: low
+  - id: vocal_stereotypy
+    name: Vocal stereotypy
+    operational: "Non-contextual, non-communicative vocalizations outside appropriate conversational context."
+    plausible_functions: [automatic]
+    typical_severity: low
+  - id: non_compliance
+    name: Non-compliance
+    operational: "Failure to initiate a requested response within 5 s of an instructional prompt, OR active refusal."
+    plausible_functions: [escape]
+    typical_severity: low
+  - id: mouthing
+    name: Mouthing
+    operational: "Placing hand, fingers, or non-food object into the mouth outside scheduled meal/snack times."
+    plausible_functions: [automatic]
+    typical_severity: low
+  - id: pica
+    name: Pica
+    operational: "Placement of any inedible item past the plane of the lips, including ingestion."
+    plausible_functions: [automatic, attention]
+    typical_severity: high
+  - id: verbal_aggression
+    name: Verbal aggression
+    operational: "Yelling, cursing, name-calling, or verbal threats toward another person."
+    plausible_functions: [attention, escape]
+    typical_severity: moderate
+  - id: fecal_smearing
+    name: Fecal smearing (scatolia)
+    operational: "Reaching into diaper, pull-up, or pants to retrieve feces and/or spreading feces onto skin, clothing, walls, furniture, or other surfaces."
+    plausible_functions: [automatic, attention]
+    typical_severity: high
+    citation: "Piazza et al. 1996 JABA; Matson et al. 2008 (scatolia in ASD)."
+  - id: toileting_accident
+    name: Toileting accident (urine or bowel)
+    operational: "Session toileting data tracks both successful voids in the toilet (urine and BM) and accidents (voiding outside the toilet onto self, clothing, furniture, or floor). The deceleration target is accident frequency; in-toilet voids are recorded as context for toileting progress. Medical rule-out required before treating accidents behaviorally."
+    plausible_functions: [automatic, escape]
+    typical_severity: moderate
+    citation: "Azrin & Foxx 1971 JABA; Cicero & Pfadt 2002; LeBlanc et al. 2005."
+
+# Measurement types used in session logs
+measurement_types:
+  - id: accuracy_pct
+    short: "accuracy"
+    description: "Trial-based percentage correct (X/N)."
+    used_for: [skill acquisition]
+  - id: frequency
+    short: "freq"
+    description: "Raw count per session."
+    used_for: [discrete behaviors, target behaviors]
+  - id: rate
+    short: "rate"
+    description: "Count per minute or hour."
+    used_for: [target behaviors]
+  - id: duration
+    short: "duration"
+    description: "Total elapsed time behavior occurred."
+    used_for: [tantrum, on-task engagement]
+  - id: latency
+    short: "latency"
+    description: "Time from SD to response initiation."
+    used_for: [skill responsivity]
+  - id: partial_interval
+    short: "PIR"
+    description: "Proportion of intervals in which behavior occurred at any point."
+    used_for: [stereotypy, low-intensity behavior]
+  - id: momentary_time_sampling
+    short: "MTS"
+    description: "Behavior sampled at end of each interval."
+    used_for: [group observation]
+
+# Escalation levels (safety-critical structured label)
+escalation_levels:
+  - id: 1
+    label: "Continue monitoring"
+    description: "Current programming is effective; no changes."
+  - id: 2
+    label: "Adjust next session"
+    description: "Implement a specific programming change at the next session."
+  - id: 3
+    label: "Supervisor review"
+    description: "Elevate to supervising BCBA within 24–48 hours."
+  - id: 4
+    label: "Safety immediate"
+    description: "Stop program; contact supervisor / family; consider crisis-plan activation."
+
+# Confidence levels (calibration signal)
+confidence_levels:
+  - id: high
+    label: high
+    description: "Pattern and recommendation well-supported by log data."
+  - id: moderate
+    label: moderate
+    description: "Data supports the hypothesis but alternatives cannot be fully ruled out."
+  - id: low
+    label: low
+    description: "Insufficient data to rule in a specific pattern; recommend data collection before programming changes."
+
+# Behavioral indicator phrases (pasted verbatim into session logs)
+# Organized by cluster; Task 2 generator samples from here.
+behavioral_indicators:
+  frustration:
+    - "Increased response latency (3–5× baseline)"
+    - "Pushing materials away from the work area"
+    - "Turning away from task or staff"
+    - "Vocal refusal ('no', 'I don't want to')"
+    - "Self-stimulatory behavior increase during demand periods"
+    - "Crying during demand presentation"
+    - "Elopement from the work area"
+    - "Attempts at property destruction (throwing materials, swiping items off the surface)"
+    - "Aggression attempt directed at staff (hit, kick, or scratch toward adult)"
+    - "Peer aggression (hitting or pushing peers during group activities)"
+    - "Self-injurious behavior onset during task difficulty (self-biting, hair-pulling, head-hitting)"
+  engagement:
+    - "Eye contact maintained throughout trials"
+    - "Quick response latency (within 2–3 seconds)"
+    - "Reaching for materials proactively"
+    - "Smiling during reinforcement delivery"
+    - "Requesting more trials verbally"
+    - "Appropriate sitting posture maintained"
+  disengagement:
+    - "Looking away during SD presentation"
+    - "Delayed responding (>5 seconds consistently)"
+    - "Stereotypic behavior during inter-trial intervals"
+    - "Leaving seat without permission"
+    - "Playing with non-task materials"
+    - "Echolalic responding (repeating SD rather than answering)"
+
+# Teaching method metadata (for referencing methods in log programs)
+teaching_methods:
+  - id: dtt
+    name: DTT
+    default_structure: "structured discrete trials, massed"
+  - id: net
+    name: NET
+    default_structure: "natural-environment embedded opportunities"
+  - id: task_analysis
+    name: Task Analysis
+    default_structure: "multi-step chaining, {chain_type}"
+  - id: fct
+    name: FCT
+    default_structure: "functional communication training, replacement response = {replacement}"
+  - id: prt
+    name: PRT
+    default_structure: "pivotal response training, child-choice, attempt reinforcement"
+  - id: bst
+    name: BST
+    default_structure: "staff-facing training program"

configs/session_interpretation/template.yaml

@@ -0,0 +1,68 @@
+# Session Interpretation template — TRACE v1
+# Task 2 — given a multi-session behavioral log, produce structured interpretation.
+
+template_id: task2_session_interp_v1
+task_type: session_interpretation
+
+system_prompt: |
+  You are an expert ABA (Applied Behavior Analysis) clinical assistant. You
+  analyze multi-session behavioral session logs for individuals with autism and
+  produce structured clinical interpretations that identify patterns, hypothesize
+  behavior functions when applicable, and recommend programming adjustments
+  structured along BIP lines (antecedent strategies, replacement behaviors,
+  consequence strategies, crisis plan). Your interpretation also includes an
+  escalation level and a confidence expression. Every recommendation is grounded
+  in the data provided. Follow BACB ethical guidelines and reference no real
+  client data.
+
+# User message variants — one is sampled per example to vary phrasing
+user_variants:
+  - |
+    Interpret the following behavioral session log. Provide clinical concerns, pattern classification, behavior function hypothesis (if applicable), programming recommendations (antecedent / replacement / consequence / crisis), escalation level, confidence, and data-supported rationale.
+
+    {session_log}
+
+  - |
+    Review this session log and produce a structured clinical interpretation.
+
+    {session_log}
+
+    Please include: (1) clinical concerns, (2) pattern classification, (3) function hypothesis for any target behaviors, (4) recommendations structured as antecedent / replacement / consequence / crisis, (5) escalation level and confidence, (6) data-supported rationale.
+
+  - |
+    Here is a multi-session behavioral log for a learner. Analyze it and provide your clinical interpretation using the structured format.
+
+    {session_log}
+
+# Assistant template — filled section-by-section by the generator.
+# Conditional sections (function hypothesis, replacement, crisis plan) are
+# pre-computed by the generator as strings, possibly empty.
+assistant_template: |
+  ## Clinical Concerns
+  {clinical_concerns_bullets}
+
+  ## Pattern Classification
+  {pattern_class}
+
+  {pattern_explanation}
+  {function_hypothesis_section}
+  ## Programming Recommendations
+
+  ### Antecedent strategies
+  {antecedent_bullets}
+  {replacement_section}
+  ### Consequence strategies
+  {consequence_bullets}
+  {crisis_section}
+  ## Escalation Level
+  {escalation_level} — {escalation_label}
+
+  {escalation_justification}
+
+  ## Confidence
+  {confidence_level}
+
+  {confidence_justification}
+
+  ## Data-Supported Rationale
+  {rationale_bullets}

configs/session_interpretation/trajectory_rules.yaml

@@ -0,0 +1,137 @@
+# Per-pattern trajectory rules — TRACE v1
+# Parameters that drive per-session accuracy and behavior-frequency generation.
+# Each pattern ID matches configs/session_interpretation/taxonomy.yaml.
+#
+# Interpretation of fields:
+#   base_range: uniform-sample initial accuracy
+#   delta_per_session_range: per-session delta applied cumulatively
+#   noise: uniform ±noise added per session
+#   behavior_trajectory: how target-behavior frequencies evolve (optional)
+#     "stable_low" / "ascending" / "descending" / "spike" / etc.
+
+rules:
+  mastery_progression:
+    accuracy:
+      base_range: [0.30, 0.50]
+      delta_per_session_range: [0.04, 0.08]
+      noise: 0.05
+      cap: 0.95
+    behavior_trajectory: stable_low
+
+  regression:
+    accuracy:
+      base_range: [0.70, 0.85]
+      delta_per_session_range: [-0.08, -0.04]
+      noise: 0.05
+      floor: 0.10
+    behavior_trajectory: ascending_moderate
+
+  plateau:
+    accuracy:
+      base_range: [0.45, 0.65]
+      delta_per_session_range: [-0.02, 0.02]
+      noise: 0.08
+    behavior_trajectory: stable_low
+
+  frustration_pattern:
+    accuracy:
+      base_range: [0.70, 0.85]
+      delta_per_session_range: [-0.08, -0.04]
+      noise: 0.05
+      floor: 0.10
+    behavior_trajectory: ascending_strong
+    behavioral_indicators: frustration
+
+  variable_performance:
+    accuracy:
+      base_range: [0.40, 0.70]
+      delta_per_session_range: [0.0, 0.0]
+      noise: 0.20
+    behavior_trajectory: variable
+
+  prompt_dependency:
+    accuracy:
+      base_range: [0.75, 0.95]      # high but prompted
+      delta_per_session_range: [-0.02, 0.02]
+      noise: 0.04
+    behavior_trajectory: stable_low
+    prompted_share: [0.70, 0.90]      # share of trials that are prompted (not independent)
+
+  rapid_acquisition:
+    accuracy:
+      base_range: [0.20, 0.40]
+      delta_per_session_range: [0.08, 0.12]
+      noise: 0.03
+      cap: 0.97
+    behavior_trajectory: stable_low
+
+  generalization_failure:
+    accuracy:
+      alternating:
+        training_range: [0.75, 0.90]
+        novel_range: [0.25, 0.45]
+        noise: 0.05
+    behavior_trajectory: stable_low
+
+  extinction_burst:
+    accuracy:
+      base_range: [0.50, 0.70]
+      delta_per_session_range: [0.0, 0.03]
+      noise: 0.05
+    behavior_trajectory: temporary_spike
+    burst_start_fraction: 0.33         # spike starts ~1/3 through log
+    burst_duration_sessions: 2
+    burst_magnitude: [2.0, 3.5]        # multiplier on baseline frequency
+
+  skill_loss_after_break:
+    accuracy:
+      base_range: [0.70, 0.85]
+      initial_drop: [0.25, 0.40]
+      recovery_per_session_range: [0.05, 0.10]
+      noise: 0.03
+    behavior_trajectory: stable_low
+
+  motivating_operation_shift:
+    accuracy:
+      base_range: [0.70, 0.85]
+      mo_dip_sessions: [2, 4]          # how many consecutive sessions show the dip
+      mo_dip_magnitude: [0.25, 0.40]   # drop depth
+      recovery_per_session_range: [0.05, 0.08]
+      noise: 0.04
+    behavior_trajectory: stable_low
+
+  setting_event_trigger:
+    accuracy:
+      base_range: [0.55, 0.75]
+      setting_event_session_fraction: 0.40   # where the setting event hits
+      setting_event_magnitude: [0.20, 0.35]
+      recovery_per_session_range: [0.04, 0.08]
+      noise: 0.05
+    behavior_trajectory: coincident_spike
+
+# Behavior-trajectory shorthand -> what it produces for frequency per session
+behavior_trajectory_library:
+  stable_low:
+    base_freq_range: [0, 3]
+    delta_per_session: 0.0
+    noise: 1.0
+  ascending_moderate:
+    base_freq_range: [1, 3]
+    delta_per_session: 0.3
+    noise: 1.0
+  ascending_strong:
+    base_freq_range: [1, 3]
+    delta_per_session: 0.6
+    noise: 1.0
+  variable:
+    base_freq_range: [1, 5]
+    delta_per_session: 0.0
+    noise: 3.0
+  temporary_spike:
+    base_freq_range: [1, 3]
+    spike_multiplier_range: [2.5, 4.0]
+    noise: 1.0
+  coincident_spike:
+    base_freq_range: [1, 3]
+    spike_multiplier_range: [2.0, 3.5]
+    noise: 1.0

configs/shared/learner_profiles.yaml

@@ -0,0 +1,34 @@
+# Learner profile taxonomy — TRACE v1
+# Groups learners by developmental + chronological age + curriculum scope.
+
+profiles:
+  - id: early
+    name: Early Learner
+    developmental_age: "0–48 months"
+    curricula: [vbmapp]
+    typical_vbmapp_levels: [L1, L2]
+    note: "Foundational skills; discrete + naturalistic teaching appropriate."
+
+  - id: school_age
+    name: School-Age Learner
+    developmental_age: "varies; often 24–60 months equivalent"
+    chronological_age: "6–12 years"
+    curricula: [vbmapp, afls]
+    typical_vbmapp_levels: [L2, L3]
+    typical_afls_modules: [school]
+    note: "Classroom skills + pre-academic + continuing language."
+
+  - id: adolescent
+    name: Adolescent Learner
+    chronological_age: "13–17 years"
+    curricula: [afls, vbmapp]
+    typical_vbmapp_levels: [L3]
+    typical_afls_modules: [basic_living, home, community, school, vocational]
+    note: "Functional-living + vocational focus; residual language gaps addressed."
+
+  - id: adult
+    name: Adult Learner
+    chronological_age: "18+ years"
+    curricula: [afls]
+    typical_afls_modules: [basic_living, home, community, vocational, independent_living]
+    note: "Independent-living + vocational focus; residential/day-program setting."

configs/shared/mastery_states.yaml

@@ -0,0 +1,46 @@
+# Mastery states taxonomy — TRACE v1
+# Where a skill sits in its learning trajectory.
+# Citation: Cooper, Heron, Heward (2020), Ch. 26, Ch. 28.
+
+states:
+  - id: emerging
+    name: Emerging
+    short: emerging
+    accuracy_range: [0.00, 0.30]
+    description: "Skill not yet acquired; high prompt levels needed."
+    prompt_level_guidance: "Begin at higher prompt levels (full physical / partial physical)."
+
+  - id: developing
+    name: Developing
+    short: developing
+    accuracy_range: [0.30, 0.50]
+    description: "Responding established; stimulus control unstable."
+    prompt_level_guidance: "Partial physical or modeling prompt with systematic fading."
+
+  - id: approaching
+    name: Approaching mastery
+    short: approaching mastery
+    accuracy_range: [0.50, 0.70]
+    description: "Moving toward independence; prompt fading in progress."
+    prompt_level_guidance: "Gestural or positional prompts; plan fade to independence."
+
+  - id: near
+    name: Near mastery
+    short: near mastery
+    accuracy_range: [0.70, 0.85]
+    description: "Stimulus control solid; occasional errors on complex stimuli."
+    prompt_level_guidance: "Minimal prompts; increase expectations for independence."
+
+  - id: mastered
+    name: Mastered at current level
+    short: mastered
+    accuracy_range: [0.85, 1.00]
+    description: "Meets mastery criterion for current step."
+    prompt_level_guidance: "Independent responding; move to generalization."
+
+  - id: generalization
+    name: Generalization phase
+    short: generalization
+    accuracy_range: [0.85, 1.00]
+    description: "Mastered in training; extending to novel settings / materials / therapists."
+    prompt_level_guidance: "NET-style opportunities; multiple exemplar probing."

configs/shared/prompt_types.yaml

@@ -0,0 +1,46 @@
+# Canonical prompt types — TRACE shared taxonomy
+# Citation: Cooper, Heron, & Heward (2020), Ch. 21 ("Prompting and Fading").
+#
+# Used across any teaching method that has a prompt hierarchy (DTT, Task Analysis, etc.).
+# Each method's own taxonomy references these by id.
+
+prompt_types:
+  - id: full_physical
+    short: FP
+    name: Full physical
+    description: "Hand-over-hand / complete manual guidance through the movement."
+
+  - id: partial_physical
+    short: PP
+    name: Partial physical
+    description: "Light guidance at a distal body part (elbow, shoulder)."
+
+  - id: model
+    short: M
+    name: Modeling
+    description: "Demonstrate the response; learner copies."
+
+  - id: gestural
+    short: G
+    name: Gestural
+    description: "Pointing or indicating without physical contact."
+
+  - id: verbal
+    short: V
+    name: Verbal
+    description: "Spoken hint or instruction."
+
+  - id: positional
+    short: Pos
+    name: Positional
+    description: "Target stimulus arranged closer to learner or more prominent."
+
+  - id: visual
+    short: Vis
+    name: Visual
+    description: "Pictures, arrows, written cues placed for learner to see."
+
+  - id: independent
+    short: I
+    name: Independent
+    description: "No prompt; learner responds without assistance."

configs/task_analysis/compatibility.yaml

@@ -0,0 +1,38 @@
+# Task Analysis clinical-consistency rules — TRACE v1
+
+# Module -> typical learner profiles (some modules only fit older learners)
+module_to_learner_profiles:
+  basic_living: [school_age, adolescent, adult]
+  home: [adolescent, adult]
+  community: [adolescent, adult]
+  vocational: [adolescent, adult]
+  independent_living: [adult]
+
+# Mastery state -> acceptable reinforcement schedules (chaining-specific)
+mastery_to_reinforcement:
+  emerging: [crf_per_step]
+  developing: [crf_per_step]
+  approaching: [crf_per_step, differential_per_step]
+  near: [differential_per_step, token_economy]
+  mastered: [terminal_reinforcement, token_economy]
+  generalization: [terminal_reinforcement]
+
+# Chain type tends to follow skill preference; fallback is total_task
+use_preferred_chain_type_probability: 0.75
+
+# Sampling across modules (weighted toward typical clinical frequency)
+module_sampling_weights:
+  basic_living: 0.35
+  home: 0.20
+  community: 0.15
+  vocational: 0.15
+  independent_living: 0.15
+
+# Prompt strategy bias by mastery state
+mastery_to_prompt_strategies:
+  emerging: [graduated_guidance, most_to_least]
+  developing: [graduated_guidance, most_to_least]
+  approaching: [most_to_least, least_to_most]
+  near: [least_to_most]
+  mastered: [least_to_most]
+  generalization: [least_to_most]

configs/task_analysis/taxonomy.yaml

@@ -0,0 +1,413 @@
+# Task Analysis / Chaining taxonomy — TRACE v1
+# Self-contained: AFLS skills broken into step lists, chain types, prompting.
+# Citation: CHH 2020 Ch. 23; Slocum & Tiger 2011 JABA; Partington & Mueller 2012.
+
+method:
+  id: task_analysis
+  name: Task Analysis / Chaining
+  short: Task Analysis
+  citation: "Cooper, Heron, Heward (2020) Applied Behavior Analysis (3rd ed.), Ch. 23; Slocum, S. K. & Tiger, J. H. (2011). JABA, 44(4), 793–805; Partington & Mueller 2012 (AFLS)."
+  when_to_use: >
+    Multi-step skills with a natural sequence — toileting, handwashing,
+    dressing, cooking, cleaning, classroom routines, community tasks,
+    vocational routines.
+
+# Chain types
+chain_types:
+  - id: forward
+    name: Forward chaining
+    description: "Teach step 1 to mastery, then 1->2, then 1->2->3, progressively adding later steps."
+    best_for: "Skills where early steps are simple and the chain grows in complexity."
+  - id: backward
+    name: Backward chaining
+    description: "Complete all steps for the learner except the last; teach the last step first, then work backward. The final reinforcer (task completion) is always present for the learner."
+    best_for: "Skills where the terminal reinforcer is salient (bathing, dressing, meal cleanup)."
+  - id: total_task
+    name: Total-task presentation
+    description: "Prompt the learner through the entire chain every trial; fade prompts across all steps simultaneously."
+    best_for: "Skills with few steps, or when all steps are similar in difficulty."
+
+# Prompt hierarchies commonly used in chaining
+prompt_hierarchies:
+  - id: graduated_guidance
+    name: Graduated Guidance
+    description: "Hand-over-hand physical guidance with fading pressure; move to shadow, then independent."
+    best_for: "Self-care and motor-dominant chains."
+  - id: most_to_least
+    name: Most-to-Least
+    description: "Start with full-physical prompt at each step; fade to partial physical, gestural, verbal, independent."
+    best_for: "Acquisition phase; new chains."
+  - id: least_to_most
+    name: Least-to-Most
+    description: "Allow independent attempt; add progressively more intrusive prompts only if learner does not initiate."
+    best_for: "Partial-repertoire chains; promoting independence."
+
+# Error correction procedures appropriate for chaining
+error_corrections:
+  - id: back_to_previous_step
+    name: Back-step + re-approach
+    steps: "Return to the previously-mastered step; re-execute that step correctly; then re-attempt the missed step with one prompt level above the last independent level."
+  - id: model_prompt_fade
+    name: Model -> prompt -> fade
+    steps: "Demonstrate the correct step; provide physical or gestural prompt as needed; fade prompt across subsequent trials."
+  - id: task_reset
+    name: Task reset
+    steps: "Pause the chain; reset environmental stimuli; restart the chain from the beginning with full prompts at the previously-missed step."
+
+# Reinforcement schedules for chaining
+reinforcement_schedules:
+  - id: crf_per_step
+    name: CRF per step (acquisition)
+    description: "Continuous reinforcement for each correctly-completed step during acquisition."
+  - id: terminal_reinforcement
+    name: Terminal reinforcement (mastered)
+    description: "Reinforcement delivered only at chain completion; no per-step reinforcement."
+  - id: differential_per_step
+    name: Differential per-step + terminal
+    description: "Small per-step reinforcement for independent responses; larger reinforcer at chain completion."
+  - id: token_economy
+    name: Token economy
+    description: "One token per correctly-completed step; token exchange at chain completion."
+
+# Mastery criteria for chains (independence) vs toleration programs.
+# Generator filters by applies_to when picking a criterion.
+mastery_criteria:
+  - id: mc_all_steps_independent
+    applies_to: independence
+    text: "100% of steps completed independently (no prompts) across 3 consecutive trials of the full chain."
+  - id: mc_fluent_chain
+    applies_to: independence
+    text: "Full chain completed within {fluency_seconds}s across 3 consecutive sessions with independent responding on all steps."
+  - id: mc_generalization
+    applies_to: independence
+    text: "Full chain completed independently with 2 different adults in 2 different settings across 2 consecutive days."
+  - id: mc_self_initiation
+    applies_to: independence
+    text: "Chain self-initiated from the appropriate antecedent (no verbal prompt to begin) across 3 consecutive opportunities."
+  - id: mc_toleration_full_duration
+    applies_to: toleration
+    text: "End-goal duration tolerated across 3 consecutive sessions with no safety behaviors (refusal, crying, SIB, aggression, property destruction)."
+  - id: mc_toleration_caregivers
+    applies_to: toleration
+    text: "End-goal activity tolerated with 2 different caregivers (primary caregiver + one other) across 2 consecutive weeks."
+  - id: mc_toleration_settings
+    applies_to: toleration
+    text: "End-goal activity tolerated across 2 different settings (e.g., home and clinic) across 2 consecutive weeks without safety behaviors."
+
+# AFLS skill domains — learner profile + module + skill + step definitions
+afls:
+  modules:
+    - id: basic_living
+      name: Basic Living Skills
+      learner_profiles: [school_age, adolescent, adult]
+      # Two kinds of programs in this module:
+      #   - "steps" field = independence-focused chaining (learner performs the skill with
+      #     graduated prompts)
+      #   - "shaping_steps" field = toleration program (learner allows staff or caregiver
+      #     to perform the skill; duration-based shaping of tolerance)
+      # Some real skills have BOTH variants depending on learner profile and history.
+      skills:
+        - name: washing hands
+          chain_type_preferred: total_task
+          steps:
+            - Walk to the sink.
+            - Turn on the water.
+            - Wet hands under the water.
+            - Apply soap to hands.
+            - Rub hands together for 15–20 seconds, covering fronts, backs, and between fingers.
+            - Rinse hands thoroughly under the water.
+            - Turn off the water.
+            - Dry hands with a towel.
+        - name: brushing teeth
+          chain_type_preferred: total_task
+          steps:
+            - Collect toothbrush and toothpaste.
+            - Wet the toothbrush under water.
+            - Apply a pea-sized amount of toothpaste.
+            - Brush upper-front teeth in small circles for 30 seconds.
+            - Brush lower-front teeth in small circles for 30 seconds.
+            - Brush upper-back teeth (left and right).
+            - Brush lower-back teeth (left and right).
+            - Spit into the sink and rinse mouth.
+            - Rinse the toothbrush and return it to the holder.
+        - name: putting on a shirt (pullover)
+          chain_type_preferred: backward
+          steps:
+            - Hold the shirt with the front facing away.
+            - Place both arms into the sleeves.
+            - Pull the opening over the head.
+            - Push arms through the sleeves fully.
+            - Pull the bottom of the shirt down to straighten it.
+        - name: putting on pants
+          chain_type_preferred: backward
+          steps:
+            - Sit or stand securely.
+            - Hold pants with the front facing away.
+            - Place one leg into the corresponding pant leg.
+            - Place the other leg into the other pant leg.
+            - Pull pants up to the waist.
+            - Fasten the button / zipper / velcro.
+        - name: showering
+          chain_type_preferred: backward
+          steps:
+            - Enter the shower and close the curtain.
+            - Turn on the water and adjust temperature.
+            - Wet body completely.
+            - Apply soap to a washcloth.
+            - Wash body systematically (face -> torso -> arms -> legs -> feet).
+            - Rinse all soap off.
+            - Apply shampoo and rub into hair.
+            - Rinse hair completely.
+            - Turn off the water.
+            - Exit the shower and dry off with a towel.
+        - name: toileting routine
+          chain_type_preferred: forward
+          steps:
+            - Recognize the need and walk to the bathroom.
+            - Close the door for privacy.
+            - Lower clothing appropriately.
+            - Sit on the toilet.
+            - Complete the elimination.
+            - Use toilet paper correctly.
+            - Stand and pull clothing up.
+            - Flush the toilet.
+            - Wash hands.
+
+        # Toleration programs
+        # For learners who do not tolerate the activity being performed on them.
+        # Goal is NOT to do it independently — goal is to allow caregiver/staff to
+        # complete the activity without refusal, crying, SIB, or aggression, with
+        # duration shaped incrementally.
+        - name: tolerating tooth brushing by caregiver
+          program_type: toleration
+          target_activity: tooth brushing performed by caregiver
+          end_goal_description: "full 2-minute tooth-brushing routine completed by caregiver without refusal, crying, SIB, or aggression"
+          shaping_steps:
+            - "1-second toothbrush contact with teeth"
+            - "3 seconds of brushing"
+            - "5 seconds of brushing"
+            - "15 seconds of brushing"
+            - "30 seconds of brushing"
+            - "60 seconds of brushing"
+            - "Full 2-minute brushing routine"
+
+        - name: tolerating hair washing by caregiver
+          program_type: toleration
+          target_activity: hair washing / shampooing performed by caregiver
+          end_goal_description: "full hair-washing routine completed by caregiver without refusal or safety behaviors"
+          shaping_steps:
+            - "5 seconds of water on hair"
+            - "15 seconds of water on hair"
+            - "Shampoo applied without lathering"
+            - "30 seconds of gentle lathering"
+            - "60 seconds of lathering"
+            - "Full rinse"
+            - "Full routine: wet -> shampoo -> lather -> rinse"
+
+        - name: tolerating nail clipping
+          program_type: toleration
+          target_activity: nail clipping performed by caregiver
+          end_goal_description: "all 10 fingernails (and optionally toenails) clipped by caregiver without refusal, pulling hand away, or safety behaviors"
+          shaping_steps:
+            - "1 fingernail clipped"
+            - "2 fingernails clipped in one sitting"
+            - "5 fingernails clipped (one hand)"
+            - "All 10 fingernails clipped"
+            - "All 10 fingernails + 10 toenails clipped"
+
+        - name: tolerating haircut
+          program_type: toleration
+          target_activity: haircut by caregiver or stylist
+          end_goal_description: "full haircut (10+ minutes) completed without refusal, leaving the chair, or safety behaviors"
+          shaping_steps:
+            - "Sit in the chair with cape on for 30 seconds"
+            - "Tolerate 1 minute of quiet sitting with cape"
+            - "Tolerate 2 minutes of brief clipping"
+            - "Tolerate 5 minutes of clipping"
+            - "Tolerate 10 minutes of clipping"
+            - "Tolerate full haircut routine"
+
+        - name: tolerating showering assistance
+          program_type: toleration
+          target_activity: showering / bathing performed with caregiver assistance
+          end_goal_description: "full assisted shower routine completed without refusal, exiting the shower, or safety behaviors"
+          shaping_steps:
+            - "Stand in shower for 30 seconds with water off"
+            - "Tolerate 10 seconds of water on body"
+            - "Tolerate 30 seconds of water on body"
+            - "Tolerate soap application to torso"
+            - "Tolerate full body wash by caregiver"
+            - "Full assisted shower routine"
+
+        - name: tolerating medical exam
+          program_type: toleration
+          target_activity: routine medical exam by clinician
+          end_goal_description: "full routine exam (stethoscope, blood pressure cuff, otoscope, temperature) completed without refusal or safety behaviors"
+          shaping_steps:
+            - "Enter and sit in the exam room"
+            - "Tolerate stethoscope contact for 5 seconds"
+            - "Tolerate blood pressure cuff on arm"
+            - "Tolerate otoscope in ear"
+            - "Tolerate temperature reading"
+            - "Tolerate full routine exam"
+
+    - id: home
+      name: Home Skills
+      learner_profiles: [adolescent, adult]
+      skills:
+        - name: making the bed
+          chain_type_preferred: forward
+          steps:
+            - Strip any disheveled linens and lay them flat.
+            - Straighten the bottom sheet across the mattress.
+            - Place the top sheet evenly over the mattress.
+            - Tuck the top sheet in at the foot of the bed.
+            - Place the comforter over the top sheet.
+            - Place pillows at the head of the bed.
+            - Smooth the comforter surface.
+        - name: meal cleanup
+          chain_type_preferred: forward
+          steps:
+            - Stack used dishes on one side of the table.
+            - Carry dishes to the sink or dishwasher.
+            - Rinse food residue into the trash or disposal.
+            - Load dishes into the dishwasher (or wash by hand).
+            - Wipe the table with a damp cloth.
+            - Put away any leftover food into containers.
+            - Place containers in the refrigerator.
+        - name: dishwashing by hand
+          chain_type_preferred: forward
+          steps:
+            - Scrape food residue into the trash.
+            - Fill the sink with warm, soapy water.
+            - Wash each dish systematically with a sponge.
+            - Rinse each dish under clean water.
+            - Place each dish on the drying rack.
+            - Drain the sink and wipe it down.
+        - name: operating the dishwasher
+          chain_type_preferred: forward
+          steps:
+            - Collect dirty dishes from the table and sink area.
+            - Scrape any solid food residue into the trash.
+            - Rinse dishes briefly under water.
+            - Open the dishwasher door.
+            - Load plates and bowls into the bottom rack.
+            - Load cups, glasses, and small items into the top rack.
+            - Place utensils handle-down in the utensil basket.
+            - Add detergent to the detergent dispenser.
+            - Close the dishwasher door.
+            - Select the appropriate wash cycle and press Start.
+        - name: unloading the dishwasher
+          chain_type_preferred: forward
+          steps:
+            - Open the dishwasher once the cycle is complete.
+            - Unload the top rack first (cups, glasses, small items).
+            - Put cups and glasses away in the correct cabinet.
+            - Unload the utensil basket.
+            - Put utensils away in the drawer.
+            - Unload the bottom rack (plates, bowls, larger items).
+            - Put plates and bowls away in the correct cabinet.
+            - Close the dishwasher door.
+        - name: doing laundry
+          chain_type_preferred: total_task
+          steps:
+            - Sort laundry by color (lights / darks / whites).
+            - Load the washing machine with one color group.
+            - Add detergent according to instructions.
+            - Select the correct wash cycle and start the machine.
+            - When complete, move clothes to the dryer.
+            - Start the dryer on the correct cycle.
+            - When dry, fold clothes by category.
+            - Put folded clothes away in drawers or closet.
+        - name: simple meal preparation (sandwich)
+          chain_type_preferred: total_task
+          steps:
+            - Collect all ingredients (bread, filling, spread).
+            - Place two slices of bread on the plate.
+            - Apply spread to one slice.
+            - Place filling on the spread slice.
+            - Place the second slice on top.
+            - Cut the sandwich in half if desired.
+            - Place on a plate to serve.
+
+    - id: community
+      name: Community Participation Skills
+      learner_profiles: [adolescent, adult]
+      skills:
+        - name: crossing a street safely
+          chain_type_preferred: total_task
+          steps:
+            - Approach the crosswalk and stop at the curb.
+            - Look left, look right, look left again.
+            - Identify the walk signal or absence of traffic.
+            - Begin to cross while continuing to scan for vehicles.
+            - Cross directly to the opposite curb.
+            - Step up onto the sidewalk.
+        - name: ordering in a restaurant
+          chain_type_preferred: total_task
+          steps:
+            - Approach the counter or wait to be seated.
+            - Review the menu.
+            - Decide on a choice.
+            - Place the order verbally (or with an AAC device).
+            - Respond to clarifying questions.
+            - Pay using money or a card.
+            - Wait for the order and collect it.
+        - name: using public transportation
+          chain_type_preferred: forward
+          steps:
+            - Confirm the correct stop or station.
+            - Purchase or have the fare ready.
+            - Wait at the designated boarding area.
+            - Board the vehicle when it arrives.
+            - Pay the fare or present the pass.
+            - Sit or stand safely.
+            - Monitor the route for the correct stop.
+            - Exit at the correct stop.
+
+    - id: vocational
+      name: Vocational Skills
+      learner_profiles: [adolescent, adult]
+      skills:
+        - name: clocking in at start of shift
+          chain_type_preferred: total_task
+          steps:
+            - Arrive at the workplace by the scheduled time.
+            - Locate the time clock or digital system.
+            - Enter identification (ID card / badge / code).
+            - Confirm the clock-in timestamp.
+            - Notify the supervisor or check the day's task list.
+            - Proceed to the assigned workstation.
+        - name: completing assigned tasks in order
+          chain_type_preferred: forward
+          steps:
+            - Review the task list for the shift.
+            - Gather needed materials for the first task.
+            - Complete the first task to the specified standard.
+            - Mark the first task complete on the list.
+            - Return materials to storage.
+            - Move to the next task on the list and repeat.
+
+    - id: independent_living
+      name: Independent Living Skills
+      learner_profiles: [adult]
+      skills:
+        - name: taking medication as prescribed
+          chain_type_preferred: total_task
+          steps:
+            - Check the medication schedule at the scheduled time.
+            - Collect the correct medication bottle.
+            - Confirm the dose against the label.
+            - Measure or count the correct dose.
+            - Take the medication with water.
+            - Log the dose in the medication tracker.
+            - Return the bottle to its storage location.
+        - name: scheduling a medical appointment
+          chain_type_preferred: forward
+          steps:
+            - Identify the reason for the appointment.
+            - Locate the provider's contact information.
+            - Call or use the online system.
+            - Provide name, date of birth, and insurance information.
+            - Request an available appointment time.
+            - Confirm the appointment and save it to the calendar.

configs/task_analysis/template.yaml

@@ -0,0 +1,82 @@
+# Task Analysis teaching program template — TRACE v1
+
+template_id: task1_task_analysis_v1
+task_type: teaching_program
+method_id: task_analysis
+
+system_prompt: |
+  You are an expert ABA (Applied Behavior Analysis) clinical assistant. You help
+  Board Certified Behavior Analysts and staff design teaching programs for
+  individuals with autism. Your responses are clinically accurate, individualized
+  to the learner profile, follow BACB ethical guidelines, and reference no real
+  client data. Select the appropriate teaching method (DTT, NET, Task Analysis,
+  FCT, BST, PRT) based on the skill target and learner profile.
+
+user_variants:
+  - |
+    Generate a teaching program for the following target.
+
+    Skill Target: {skill_target}
+    Curriculum Reference: {curriculum_ref}
+    Learner Profile: {learner_profile_name}
+    Current Mastery: {mastery_state_name}
+    Teaching Method: Task Analysis / Chaining
+
+    Provide the full program structure appropriate to the selected method.
+
+  - |
+    I need a Task Analysis program for this multi-step skill.
+
+    Target: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner: {learner_profile_name}
+    Mastery Status: {mastery_state_name}
+
+    Please include the task analysis (numbered steps), chain type, prompt strategy per step, error correction, reinforcement, and mastery criteria.
+
+  - |
+    Design a chaining program for the following.
+
+    Skill: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner Level: {learner_profile_name}
+    Baseline: {mastery_state_name}
+
+    Include the full Task Analysis structure.
+
+assistant_template: |
+  ## Program Overview
+  - Target skill: {skill_target}
+  - Curriculum: {curriculum_ref}
+  - Learner: {learner_profile_name}
+  - Current mastery: {mastery_state_name}
+
+  This Task Analysis program teaches the target skill as a chain of discrete steps, each taught and reinforced until the learner can complete the full sequence independently.
+
+  ## Task Analysis
+  Chain type: {chain_type_name}
+  {chain_type_description}
+
+  Steps:
+  {step_list}
+
+  ## Prompt Strategy Per Step
+  Strategy: {prompt_strategy_name}
+  {prompt_strategy_description}
+  Current prompt level: At the {mastery_state_short} stage, {current_prompt_guidance}
+
+  ## Error Correction Procedure
+  {error_correction_name}: {error_correction_steps}
+
+  ## Reinforcement
+  {reinforcement_schedule_name} — {reinforcement_description}.
+  Pair the terminal reinforcer with the natural consequence of the completed task (e.g., clean hands, clean dishes, completed routine).
+
+  ## Mastery Criteria
+  {mastery_criterion_text}
+
+  ## Data Collection
+  Per-step data: each step is scored for independence / prompt level on every trial. IOA scheduled every {ioa_frequency} sessions minimum; target agreement ≥ 80%.
+
+  ## Generalization & Maintenance Plan
+  Post-mastery: probe the full chain across {n_generalization_settings} different settings and with {n_generalization_therapists} different adults. Maintenance probes weekly for 4 weeks, then monthly.

configs/task_analysis/template_toleration.yaml

@@ -0,0 +1,91 @@
+# Toleration / Systematic-Desensitization program template — TRACE v1
+# Used for skills where the goal is NOT learner independence but rather the
+# learner *allowing* caregiver/staff to perform the activity, with duration
+# shaped incrementally across trials.
+
+template_id: task1_toleration_v1
+task_type: teaching_program
+method_id: task_analysis     # Administratively in the task_analysis area; clinically distinct approach
+
+system_prompt: |
+  You are an expert ABA (Applied Behavior Analysis) clinical assistant. You help
+  Board Certified Behavior Analysts and staff design teaching programs for
+  individuals with autism. Your responses are clinically accurate, individualized
+  to the learner profile, follow BACB ethical guidelines, and reference no real
+  client data. Select the appropriate teaching method (DTT, NET, Task Analysis,
+  FCT, BST, PRT) based on the skill target and learner profile.
+
+user_variants:
+  - |
+    Generate a teaching program for the following target.
+
+    Skill Target: {skill_target}
+    Curriculum Reference: {curriculum_ref}
+    Learner Profile: {learner_profile_name}
+    Current Mastery: {mastery_state_name}
+    Teaching Method: Toleration / Systematic Desensitization
+
+    The goal is for the learner to allow the activity to be performed (not to perform it independently). Provide the full program structure including shaping steps and refusal/safety procedures.
+
+  - |
+    I need a toleration program for this self-care / medical / caregiver-delivered skill.
+
+    Target: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner: {learner_profile_name}
+    Mastery Status: {mastery_state_name}
+
+    Please include the toleration end goal, shaping progression, antecedent strategies, reinforcement plan, refusal / safety procedures, and mastery criteria.
+
+  - |
+    Design a systematic desensitization / toleration program for the following.
+
+    Skill: {skill_target}
+    Curriculum: {curriculum_ref}
+    Learner Level: {learner_profile_name}
+    Baseline: {mastery_state_name}
+
+    The learner currently refuses or exhibits safety behaviors during the activity; the program should build tolerance gradually.
+
+assistant_template: |
+  ## Program Overview
+  - Target skill: {skill_target}
+  - Curriculum: {curriculum_ref}
+  - Learner: {learner_profile_name}
+  - Current mastery: {mastery_state_name}
+  - Approach: Toleration / systematic desensitization (caregiver-delivered activity)
+
+  This program builds tolerance for {target_activity} through systematic shaping. The learner is not being taught to perform the skill independently — the goal is to allow the caregiver or staff to perform it across an incrementally increasing duration, without refusal, crying, self-injurious behavior, or aggression.
+
+  ## Toleration End Goal
+  {end_goal_description}
+
+  ## Shaping Progression
+  Teach by moving through these shaping steps in order. Advance to the next step only when the current step is tolerated for 3 consecutive sessions without safety behaviors.
+
+  {shaping_step_list}
+
+  Current shaping step: At the {mastery_state_short} stage, {current_step_guidance}
+
+  ## Antecedent Strategies
+  - Pre-warn the learner before the activity begins (verbal or visual schedule).
+  - Offer a preferred item or sensory tool to hold during the activity.
+  - Where possible, offer a choice of position, location, or starting point.
+  - Keep the environment calm and predictable; avoid other demands immediately before or after.
+
+  ## Reinforcement
+  Deliver high-magnitude, high-preference reinforcement contingent on successful toleration of the target duration. Pair with effusive praise. Reinforcement is continuous (CRF) during acquisition of each shaping step.
+
+  ## Refusal and Safety Procedures
+  - If the learner refuses or turns away: pause briefly (5–10 seconds), re-present the activity at the current or previous shaping step.
+  - If problem behavior (crying, property destruction, SIB, aggression, peer aggression) emerges: stop the activity immediately, implement the facility crisis plan, and document the incident.
+  - Do NOT remove the activity contingent on safety behaviors in a way that establishes an escape-maintained pattern — consult supervising BCBA for the specific escape-extinction protocol appropriate to this learner.
+
+  ## Mastery Criteria
+  {mastery_criterion_text}
+
+  ## Data Collection
+  Per-trial: duration tolerated before refusal, presence / absence of safety behaviors (crying, property destruction, SIB, aggression), staff support level, and shaping step attempted. IOA scheduled every {ioa_frequency} sessions minimum; target agreement ≥ 80%.
+
+  ## Generalization & Maintenance Plan
+  Post-mastery: probe the full routine across {n_generalization_settings} different settings and with {n_generalization_therapists} different adults (including the primary caregiver if relevant). Maintenance probes weekly for 4 weeks, then monthly.

data/splits/train.jsonl

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

docs/curation/LEGEND.md

@@ -0,0 +1,177 @@
+# Session-Log Reading Guide
+
+Reference for reading Task 2 (session-interpretation) examples. Keep this
+open in a side pane while browsing `review.md`.
+
+---
+
+## Session header line
+
+```
+Session 3 — 2026-10-10 — 45 min — 1 observer
+```
+
+Or, for inter-observer agreement sessions:
+
+```
+Session 5 — 2026-10-14 — IOA SESSION — 2 observers
+```
+
+| Piece | Meaning |
+|---|---|
+| `Session N` | Nth observation session in this log |
+| `2026-10-10` | Synthetic date (always in 2026 range) |
+| `45 min` | Session duration |
+| `1 observer` / `2 observers` | Single observer (primary) or IOA session |
+| `IOA SESSION` | (If present) agreement check; behavior lines in this session show a trailing `IOA X% agreement` |
+
+---
+
+## Skill data line (acquisition programs)
+
+```
+ordering in a restaurant: 9/13 correct (67%); latency 3.1s; prompts 5
+```
+
+| Piece | Meaning |
+|---|---|
+| `9/13 correct` | Correct trials / total trials |
+| `67%` | Accuracy |
+| `latency 3.1s` | Mean response latency after SD presentation |
+| `prompts 5` | Number of trials on which any prompt was delivered |
+
+---
+
+## Behavior data lines
+
+Each target behavior gets its own measurement format matched to the
+behavior's clinical shape. Generic `freq` lines apply to most behaviors;
+behaviors with clinically distinctive shapes have behavior-specific
+measurements.
+
+### Generic frequency behaviors
+
+```
+Aggression: freq 3
+Elopement: freq 2
+SIB: freq 5
+Property destruction: freq 1
+Non-compliance: freq 4
+Verbal aggression: freq 2
+```
+
+`freq N` = N occurrences this session.
+
+### Tantrum (includes duration)
+
+```
+Tantrum: freq 2, duration 7m total
+```
+
+### Stereotypy and mouthing (include partial-interval recording)
+
+```
+Motor stereotypy: freq 8; PIR 18%
+Vocal stereotypy: freq 5; PIR 12%
+Mouthing: freq 6; PIR 15%
+```
+
+`PIR X%` = partial-interval recording: % of intervals in which the behavior
+occurred at any point.
+
+### Pica (attempts vs successful ingestion)
+
+```
+Pica: attempts 3 (2 unsuccessful — staff retrieved item before ingestion; 1 successful — item ingested)
+```
+
+Staff often intercept pica attempts; tracking attempts / successful
+separately preserves the severity signal that a raw frequency loses.
+
+### Fecal smearing / scatolia (attempts vs completed smearing)
+
+```
+Fecal smearing (scatolia): attempts 2 (1 intercepted — staff redirected before smearing; 1 completed — feces transferred to skin, clothing, or surface)
+```
+
+Same intercepted / completed split as pica — clinically critical because
+staff responsiveness directly shapes outcome severity.
+
+### Toileting (four-count voiding log)
+
+```
+Toileting accident (urine or bowel): urine: 3 in-toilet / 2 accidents; BM: 0 in-toilet / 1 accidents
+```
+
+Mirrors a standard clinical voiding log. The deceleration target is
+**accidents** (urine + BM), but successful in-toilet voids are tracked
+alongside for context:
+
+- `urine: X in-toilet / Y accidents` — successful urinations vs. urine accidents
+- `BM: P in-toilet / Q accidents` — successful bowel movements vs. BM accidents
+
+### IOA annotation
+
+On sessions marked `IOA SESSION`, each behavior line ends with `; IOA X% agreement`:
+
+```
+Aggression: freq 3; IOA 88% agreement
+```
+
+---
+
+## ABC line
+
+```
+ABC (elopement): A = peer took toy; B = ran from room; C = staff retrieved learner
+```
+
+- `A` = Antecedent (what happened immediately before the behavior)
+- `B` = Behavior (operational description)
+- `C` = Consequence (what happened immediately after)
+
+ABC evidence feeds the behavior-function hypothesis in the assistant's
+response (escape / attention / tangible / automatic, per Iwata et al. 1994
+and Hanley, Iwata, & McCord 2003).
+
+---
+
+## Function-hypothesis line (log header)
+
+Near the top of a log you'll see one line per tracked behavior:
+
+```
+1. Fecal smearing (scatolia) — function hypothesized: automatic
+2. Aggression — function hypothesized: escape
+```
+
+These are the sampled (gold) functions that the interpretation response
+should corroborate with the evidence in the log.
+
+---
+
+## Program list
+
+```
+Programs tracked this session block:
+1. ordering in a restaurant (AFLS Community) — task_analysis
+2. mands for a break (VB-MAPP Mand L1) — net
+3. tacts colors of objects (VB-MAPP Tact L2) — dtt
+```
+
+Each entry names the skill target, its curriculum location, and the
+teaching method.
+
+---
+
+## Behavioral indicator block (across sessions)
+
+```
+BEHAVIORAL OBSERVATIONS (across sessions)
+- Increased response latency (3–5× baseline)
+- Pushing materials away from the work area
+- Vocal refusal ("no", "I don't want to")
+```
+
+These are pattern-specific indicator clusters (frustration, engagement, or
+disengagement) sampled from `the `behavioral_indicators` block in configs/session_interpretation/taxonomy.yaml`.

docs/curation/README.md

@@ -0,0 +1,93 @@
+# Curation Workflow
+
+The curation step turns the pipeline-held-out `curation_pool.jsonl` into the
+two evaluation files shipped in `data/splits/`:
+
+- **`test.jsonl`** — evaluation set. The paper's headline metrics come from this set.
+- **`sanity.jsonl`** — 20-example smoke-test set for development.
+
+In TRACE v1 the whole curation pool is promoted as the test corpus (no hand
+curation). The **review + compile** scripts are still part of the pipeline
+because (a) regenerating the test and sanity splits is deterministic from the
+pool, and (b) anyone adapting TRACE to a new clinical domain can reuse the
+same workflow with their own taxonomy.
+
+---
+
+## Two scripts
+
+| Script | What it does |
+|---|---|
+| `src/prepare_curation.py` | Renders `curation_pool.jsonl` as a browseable Markdown document in `docs/curation/review.md` — one candidate per section, grouped by task × category, with gold labels and provenance visible. |
+| `src/compile_curation.py` | Splits the curation pool into `data/splits/test.jsonl` (the remainder) and `data/splits/sanity.jsonl` (20 examples, largest-remainder stratified by category). Deterministic under `--seed`. |
+
+---
+
+## Commands
+
+```bash
+# Regenerate the browseable review document.
+uv run python src/prepare_curation.py
+
+# Compile the test + sanity splits from the pool.
+uv run python src/compile_curation.py
+
+# Override the sanity size (default 20) or seed (default 42).
+uv run python src/compile_curation.py --sanity-n 20 --seed 42
+```
+
+After `compile_curation.py` runs you'll have:
+- `data/splits/test.jsonl` — the evaluation set
+- `data/splits/sanity.jsonl` — the smoke-test set
+
+---
+
+## Reading `review.md`
+
+`review.md` renders each candidate with:
+- A heading showing the task type, category, and `example_id`.
+- Gold labels inline (method, domain, level, learner profile, mastery state;
+  or pattern class, behavior functions, escalation, confidence, crisis-plan flag).
+- A short provenance line (for session interpretation: number of sessions,
+  number of behaviors, whether IOA is included, whether ABC is included).
+- The full user message (the teaching-program prompt or the session log).
+- The full assistant message (the structured response).
+
+Use `LEGEND.md` as a side-pane reference for the session-log notation in
+Task 2 examples.
+
+---
+
+## Flagging issues for re-generation
+
+If you spot a clinical inaccuracy while browsing `review.md`:
+
+1. Note the candidate's `example_id` (shown in its heading).
+2. Look up the candidate's `meta.provenance.taxonomy_cells` in the JSONL to
+   identify which taxonomy dimension produced the issue.
+3. Edit the relevant YAML under `configs/` (or the renderer in `src/generators/`
+   if it's a rendering-logic issue) — *never* hand-edit individual JSONL
+   entries, because the fix should propagate to every example that sampled
+   the same cells.
+4. Regenerate the corpus with `src/generate.py --all`, re-split with
+   `src/split_data.py`, and re-compile with `src/compile_curation.py`.
+
+Every clinical-review flag during v1 development landed as a single
+targeted taxonomy edit plus a full regeneration — never a hand-edit of
+the JSONL. This is the invariant the pipeline relies on: fixes must
+propagate through the taxonomy to be systematic across the corpus.
+
+---
+
+## Adapting the workflow to a new clinical domain
+
+The scripts are domain-agnostic. To port to a different dataset:
+
+- `prepare_curation.py` just reads `data/splits/curation_pool.jsonl` and
+  renders it. Works on any JSONL with the same envelope shape.
+- `compile_curation.py` stratifies on `category_of(example)` — a small
+  function near the top of the script. Change its logic to use whichever
+  field best represents your category (the `method` field for TRACE's
+  teaching programs; the `pattern_class` field for session interpretation).
+- Everything else — largest-remainder allocation, deterministic splitting,
+  provenance preservation — carries over unchanged.

docs/data-statement.md

@@ -0,0 +1,126 @@
+# Data Statement for TRACE (v1)
+
+**TRACE** — **T**axonomy-**R**eferenced **A**BA **C**linical **E**xamples
+
+Template: Bender, E. M., & Friedman, B. (2018). *Data Statements for Natural Language Processing: Toward Mitigating System Bias and Enabling Better Science.* Transactions of the Association for Computational Linguistics. https://aclanthology.org/Q18-1041/
+
+---
+
+## A. Curation Rationale
+
+### Why this data, and why this composition?
+Applied Behavior Analysis (ABA) is a clinical discipline with high documentation workload — BCBAs produce teaching programs and interpret multi-session behavioral logs continuously across their caseloads. Existing general-purpose language assistants are both unspecialized to ABA's structured conventions (operational definitions, VB-MAPP / AFLS curricula, functional-analysis frameworks) and unvetted against its clinical standards (BACB Ethics Code 2020; ABAI 2010 Position Statement on Restraint). This dataset was curated to support fine-tuning a small on-device language model (Gemma 4 E2B) specifically for **drafting** — i.e., producing first-pass teaching programs and session interpretations that a BCBA then reviews and revises — without any ingestion of real client data.
+
+Two tasks are represented because they are the two highest-frequency authorial tasks in an ABA clinical team's week: (1) drafting teaching programs for new or evolving skill targets, and (2) interpreting session-by-session behavioral data to adjust programming. They share a taxonomy (learner profiles, mastery states, teaching methods, target behaviors) but diverge in structure (teaching-program responses are single-program documents; session-interpretation responses are diagnostic summaries).
+
+### Why synthetic?
+Real ABA session data contains 45 CFR 164 protected health information (PHI) under HIPAA and is additionally subject to BACB Ethics Code confidentiality rules (section 2.03, section 2.05). Any public dataset drawn from real client data would require individual consent, facility release, and de-identification that cannot reliably preserve the clinical detail required for training. Synthetic generation avoids these constraints by construction: the data never represented a real person in the first place. The trade-off — distributions may not match any one real caseload — is made explicit in the dataset card (section 6.5) and flagged to users.
+
+---
+
+## B. Language Variety
+
+All text is in **English (en-US)**, written in standard American clinical register. The authorial style follows the conventions of:
+- **Peer-reviewed ABA literature** — *Journal of Applied Behavior Analysis* (JABA), *Behavior Analysis in Practice* (BAP).
+- **Reference textbook** — Cooper, Heron, & Heward (2020), *Applied Behavior Analysis* (3rd ed.).
+- **Professional documentation** — BACB Ethics Code (2020), ABAI Position Statements.
+
+Within that register, the dataset covers:
+- **Teaching-program language** — imperative instructional prose (stimulus control description, prompt hierarchy specification, reinforcement-schedule specification, error-correction procedure, mastery criterion).
+- **Session-log language** — telegraphic data-sheet notation (`accuracy 6/10 (60%); freq 2; duration 3m; IOA 88%`) mixed with ABC-entry prose.
+- **Clinical-interpretation language** — structured prose matching the assistant template's headings (Clinical Concerns, Pattern Classification, Behavior Function Hypothesis, Programming Recommendations, Crisis Plan when applicable, Confidence).
+
+There is no dialectal variation, no code-switching, no second-language speaker voice. Generalization to non-US clinical conventions (BCBA-D vs. international RBT frameworks, different curricula) is explicitly out of scope for v1.
+
+---
+
+## C. Speaker Demographic
+
+**Not applicable.** The dataset has no speakers. All content is programmatically generated from taxonomy configs written by a single author with ABA domain fluency. The written conventions inherit from the sources listed in section B.
+
+---
+
+## D. Annotator Demographic
+
+**Not applicable in the conventional sense.** No human annotators labeled instances after generation. Gold labels are emitted at generation time from the same taxonomy cells that produced the example — they are by-construction the ground truth of the sampling step.
+
+**Quasi-annotator role: clinical-accuracy reviewer.** One individual (the dataset author) performed ad-hoc clinical-accuracy review of generated candidates during iteration. This reviewer:
+
+- Has practitioner-adjacent exposure to ABA clinical settings (not a BCBA; not a BCaBA; not an RBT in active practice).
+- Is a native English speaker, fluent in the English clinical-documentation register.
+- Performed review by browsing full-text candidate renderings and flagging clinical implausibilities against published sources (CHH 2020; BACB Ethics Code 2020; JABA papers for operational definitions).
+
+**What this means for the dataset:**
+- Clinical-accuracy review was grounded in published sources, not in one reviewer's clinical judgment alone. Where a reviewer uncertainty could not be resolved from a source, the item was retained with a flag rather than decided by individual preference.
+- Full BCBA-level clinical validation (multi-reviewer, κ-scored) was not performed on v1.
+- Bias from the reviewer's particular exposure (specific facility types, specific learner age ranges, specific behavioral topographies) is possible. The taxonomy's grounding in CHH and JABA is the mitigating control.
+
+---
+
+## E. Speech Situation
+
+**Not applicable** (no speech). The imagined reader/user for the generated text:
+- **Teaching programs** — a BCBA or behavior technician reading a first-pass program draft for clinical review, before it is finalized and implemented with a learner.
+- **Session interpretations** — a BCBA or supervising analyst reading a summary of the most recent N sessions of a learner's data, as a decision-support document for programming adjustments.
+
+The modality is written documentation, asynchronous, read in quiet clinical-office settings. The register is clinical-professional.
+
+---
+
+## F. Text Characteristics
+
+### Genre
+- Clinical documentation (teaching programs, behavioral session interpretations).
+- Instructional prose interleaved with structured data-sheet notation.
+
+### Structural Conventions
+- Teaching programs follow a fixed section layout (Program Overview, Stimulus Control, Prompt Hierarchy, Reinforcement, Error Correction, Mastery Criteria, Generalization & Maintenance Plan). Variants exist for DTT, NET, and Task Analysis; Task Analysis has a distinct toleration-program layout.
+- Session logs are rendered as pseudo-data-sheet blocks, one block per session, with per-program accuracy lines, per-behavior measurement lines, and optional ABC / IOA entries.
+- Session interpretations follow a fixed layout (Clinical Concerns, Pattern Classification, Behavior Function Hypothesis, Programming Recommendations, Crisis Plan, Confidence).
+
+### Domain-specific notation
+- ABA abbreviations used freely: SD (discriminative stimulus), MO (motivating operation), ABC (antecedent-behavior-consequence), IOA (interobserver agreement), PIR (partial-interval recording), CRF (continuous reinforcement), FR-2, VR-3, etc.
+- Measurement notation follows the schema in `schema-v1.md section 2.3`.
+
+### Distribution characteristics
+- Target behaviors: sampled per pattern (0–3 per log).
+- Accuracy trajectories: driven by pattern-specific generators (ascending for mastery_progression, descending for regression, etc.).
+- Behavior frequencies: pattern-trajectory-driven; bounded.
+- Severity: per-behavior `typical_severity` flag (low/moderate/high) feeds escalation logic.
+
+### What the dataset *does not* contain
+- Personal names.
+- Real identifiers.
+- Dates outside 2026-01-01 to 2026-12-31.
+- Non-English text.
+- Informal register (chat-style, SMS, social media).
+- Off-topic content.
+- Adversarial or jailbreak examples.
+- Real session notes or documentation.
+
+---
+
+## G. Recording Quality
+
+**Not applicable** (no recording).
+
+---
+
+## H. Other
+
+### Provenance guarantee
+Every example carries full sampling provenance in `meta.provenance.taxonomy_cells`. This is the artifact that makes clinical auditing tractable: when a reviewer flags an implausible example, they can trace it to the exact cells that generated it and propose a taxonomy or compatibility-rule fix. This is a property of the dataset we consider essential and want future versions to preserve.
+
+### Known biases
+- **Caseload-distribution bias.** Pattern frequencies are uniform across the 12 session-interpretation patterns for learnability, whereas real caseloads skew toward mastery_progression. Users training epidemiological models should reweight.
+- **Curriculum bias.** VB-MAPP and AFLS are the only curricula covered. Practitioners using ABLLS-R, Essential for Living, PEAK, or other curricula should adapt.
+- **Register bias.** All text is US clinical-professional. Non-US or non-clinical register is not represented.
+- **Reviewer-exposure bias.** Clinical review was performed by a single reviewer. See section D.
+- **Synthetic-distribution bias.** Sampling weights reflect clinical frequency where known but are approximate.
+
+### Transparency commitments
+- Full generator code is public in the repository.
+- Full taxonomy configs are public in the repository.
+- Dataset regeneration from `(configs, seed)` is deterministic.
+- Every version of the dataset is pinned to a specific repository commit hash.
+- All citations used to ground taxonomy content are enumerated in `docs/research/citations-to-use.md`.

docs/dataset-card.md

@@ -0,0 +1,358 @@
+---
+pretty_name: "TRACE — Taxonomy-Referenced ABA Clinical Examples"
+license: cc-by-nc-4.0
+language:
+  - en
+size_categories:
+  - 1K<n<10K
+task_categories:
+  - text-generation
+tags:
+  - clinical
+  - applied-behavior-analysis
+  - autism
+  - small-language-model
+  - synthetic
+  - instruction-tuning
+  - taxonomy
+  - provenance
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/splits/train.jsonl
+      - split: validation
+        path: data/splits/valid.jsonl
+      - split: test
+        path: data/splits/test.jsonl
+      - split: sanity
+        path: data/splits/sanity.jsonl
+---
+
+# TRACE Dataset Card (v1)
+
+**Name:** **TRACE** — **T**axonomy-**R**eferenced **A**BA **C**linical **E**xamples
+**Version:** v1.0.0
+**Date:** 2026-04-25
+**Primary language:** English
+**License (data):** CC BY-NC 4.0 · **License (code):** MIT
+**Total examples:** 2,999
+**Tasks:** 2 — (1) ABA teaching program generation, (2) behavioral session interpretation.
+**Author:** Festus Kahunla (Drexel University).
+**Publisher / maintained by:** [Pombo Labs](https://github.com/Pombo-Labs).
+**Repository:** https://github.com/Pombo-Labs/TRACE
+
+---
+
+## 1. TL;DR
+
+TRACE is a **synthetic instruction-tuning dataset** for two clinical tasks in Applied Behavior Analysis (ABA):
+
+1. **Teaching program generation** — given a learner profile and a skill target, produce a structured teaching program (DTT, NET, or Task Analysis/chaining) covering stimulus control, prompt hierarchy, reinforcement schedule, error correction, mastery criterion, and generalization plan.
+2. **Behavioral session interpretation** — given a multi-session behavioral log (accuracies, target behaviors with measurements, optional ABC and IOA data), produce clinical concerns, a pattern classification, a function hypothesis, programming recommendations, and (when applicable) a crisis plan.
+
+The dataset was produced by a **taxonomy-driven generator** whose controlled vocabulary is grounded in the canonical ABA literature (Cooper, Heron, & Heward 2020; VB-MAPP; AFLS; key JABA papers). Every example carries full **provenance metadata** — the exact taxonomy cells that were sampled to produce it. Clinical accuracy was iterated via practitioner-in-the-loop ad-hoc review.
+
+**Intended use.** Research. TRACE is designed for fine-tuning small language models (e.g., 4-bit Gemma 4 E2B with QLoRA) on ABA-flavored instruction-following, as a substrate for research into clinical-NLP data pipelines, taxonomy-driven synthetic generation, and small-LM evaluation.
+
+**Not for:** autonomous clinical decisions; training on or combining with real client data; medical diagnosis; legal or insurance documentation. TRACE has not been clinically validated and is not a clinical tool. See section 6 for the responsibility disclaimer.
+
+---
+
+## 2. Dataset Composition
+
+### 2.1 Splits
+
+| Split | Examples | Fraction | Purpose |
+|---|---:|---:|---|
+| `train.jsonl` | 2,549 | 85.0% | LoRA fine-tuning |
+| `valid.jsonl` | 149 | 4.97% | Periodic validation loss during training |
+| `test.jsonl` | 281 | 9.37% | Held-out evaluation (headline metrics) |
+| `sanity.jsonl` | 20 | 0.67% | Training smoke-test (tiny stratified subset) |
+| **Total** | **2,999** | 100% | |
+
+Splits are **stratified by task × category** (method for teaching programs; pattern_class for session interpretation) so each split mirrors the corpus distribution. The test set is the full curation pool minus a 20-example stratified sanity carveout.
+
+### 2.2 Per-area breakdown
+
+| Area | Count | Task type | Primary source |
+|---|---:|---|---|
+| DTT | 800 | teaching_program | VB-MAPP (array-based discrete-response domains) |
+| NET | 500 | teaching_program | VB-MAPP (mand, social, spontaneous vocal, intraverbal) |
+| Task Analysis | 500 | teaching_program | AFLS (basic_living, home, community, vocational, independent_living) |
+| Session Interpretation | 1,200 | session_interpretation | 12 clinical trajectory patterns |
+
+### 2.3 DTT skill-domain distribution (800 total)
+
+| VB-MAPP domain | Count |
+|---|---:|
+| Reading | 131 |
+| LRFFC (Listener Responding by Feature/Function/Class) | 126 |
+| Math | 120 |
+| Visual Perceptual / Matching-to-Sample | 115 |
+| Listener Responding | 111 |
+| Tact | 106 |
+| Writing | 91 |
+
+Sampled across VB-MAPP Levels 1 (≈45%), 2 (≈40%), and 3 (≈15%).
+
+### 2.4 NET skill-domain distribution (500 total)
+
+| VB-MAPP domain | Count |
+|---|---:|
+| Spontaneous Vocal | 143 |
+| Mand (including bathroom, break, all-done) | 141 |
+| Social Behavior & Play | 131 |
+| Intraverbal | 85 |
+
+Each NET program carries a Motivating Operation arrangement matched to the skill (deprivation, missing-item, break opportunity, completion opportunity, bathroom opportunity, peer presence, reciprocal conversation, routine lead-in) and is embedded in a natural context (snack, free play, transition, arrival, etc.).
+
+### 2.5 Task Analysis distribution (500 total)
+
+| AFLS module | Count | | Program type | Count |
+|---|---:|---|---|---:|
+| Basic Living | 172 | | Independence | 413 |
+| Home | 96 | | Toleration (systematic desensitization) | 87 |
+| Community | 94 | | | |
+| Vocational | 76 | | | |
+| Independent Living | 62 | | | |
+
+**Toleration programs** are a distinct program type for learners whose clinical goal is to *allow* a caregiver-delivered routine (tooth brushing, hair washing, nail clipping, haircuts, showering, medical exam) rather than to perform it independently. They use a shaping progression with duration targets rather than a step chain.
+
+### 2.6 Session Interpretation distribution (1,200 total)
+
+Twelve trajectory patterns, roughly uniform (84–113 each):
+
+| Pattern | Count |
+|---|---:|
+| regression | 113 |
+| prompt_dependency | 109 |
+| setting_event_trigger | 107 |
+| rapid_acquisition | 106 |
+| motivating_operation_shift | 104 |
+| generalization_failure | 103 |
+| mastery_progression | 100 |
+| skill_loss_after_break | 100 |
+| plateau | 96 |
+| frustration_pattern | 91 |
+| variable_performance | 87 |
+| extinction_burst | 84 |
+
+**Target behaviors** sampled into logs (presence per log; a log carries 0–3 behaviors):
+
+| Behavior | Logs | Measurement shape |
+|---|---:|---|
+| Aggression | 95 | freq |
+| Toileting (urine + BM, in-toilet + accidents) | 89 | `urine: X in-toilet / Y accidents; BM: P in-toilet / Q accidents` |
+| Pica | 81 | `attempts N (X unsuccessful; Y successful)` |
+| Self-Injurious Behavior (SIB) | 79 | freq |
+| Verbal Aggression | 79 | freq |
+| Fecal Smearing (scatolia) | 78 | `attempts N (X intercepted; Y completed)` |
+| Property Destruction | 75 | freq |
+| Elopement | 75 | freq |
+| Non-compliance | 70 | freq |
+| Tantrum | 66 | `freq N, duration Mm total` |
+| Mouthing | 56 | `freq N; PIR P%` |
+| Motor Stereotypy | 50 | `freq N; PIR P%` |
+| Vocal Stereotypy | 48 | `freq N; PIR P%` |
+
+---
+
+## 3. Data Format
+
+### 3.1 Wire format
+
+Each example is one JSONL line:
+
+```json
+{
+  "messages": [
+    {"role": "system",    "content": "<ABA clinical-assistant system prompt>"},
+    {"role": "user",      "content": "<task-specific prompt>"},
+    {"role": "assistant", "content": "<structured clinical response>"}
+  ],
+  "meta": {
+    "task_type":    "teaching_program" | "session_interpretation",
+    "example_id":   "<deterministic hash, 16-hex>",
+    "gold_labels":  { ... task-specific labels ... },
+    "provenance":   {
+      "layer": 1,
+      "area":  "dtt" | "net" | "task_analysis" | "session_interpretation",
+      "template_id": "...",
+      "taxonomy_cells": { ... exact sampled values ... },
+      "teacher_model": null,
+      "seed_tag": "...",
+      "generated_at": "..."
+    }
+  }
+}
+```
+
+Only `messages` is used for training (mask_prompt: true). `meta` is preserved for evaluation and provenance tracking.
+
+### 3.2 Gold labels per task
+
+**Teaching program:**
+```
+{
+  "method":          "dtt" | "net" | "task_analysis",
+  "domain":          "VB-MAPP.<domain>" | "AFLS.<module>",
+  "level":           "L1" | "L2" | "L3" | ...,     # VB-MAPP only
+  "learner_profile": "early" | "school_age" | "adolescent" | "adult",
+  "mastery_state":   "emerging" | "developing" | "approaching" | "near" | "mastered" | "generalization",
+  "program_type":    "independence" | "toleration",  # Task Analysis only
+  "chain_type":      "forward" | "backward" | "total_task"  # Task Analysis only
+}
+```
+
+**Session interpretation:**
+```
+{
+  "pattern_class":        "<one of 12 patterns>",
+  "behavior_functions":   { "<behavior_name>": "escape"|"attention"|"tangible"|"automatic"|"unknown" },
+  "escalation_level":     1 | 2 | 3 | 4,
+  "confidence":           "high" | "moderate" | "low",
+  "crisis_plan_required": true | false
+}
+```
+
+### 3.3 Provenance
+
+Every sampled choice is recorded in `meta.provenance.taxonomy_cells`. For teaching programs this includes the skill target, prompt hierarchy, reinforcement schedule, error correction, and mastery criterion. For session interpretation it includes the pattern, number of sessions, behaviors sampled, functions inferred, and whether IOA and ABC data are present. This enables:
+
+- **Traceability:** any clinical issue in a generated example can be traced back to the exact taxonomy cell that produced it.
+- **Reproducibility:** the dataset can be regenerated deterministically from the configs and seed.
+- **Stratification:** splits can be regenerated with different stratification keys without regenerating the corpus.
+- **Ablation:** subsets can be constructed by filtering on provenance cells.
+
+---
+
+## 4. How It Was Built
+
+### 4.1 Architecture
+
+```
+configs/
+├── shared/                          # cross-area primitives (learner profiles, mastery states, prompt types)
+├── dtt/                             # DTT area: taxonomy + template + compatibility
+├── net/                             # NET area
+├── task_analysis/                   # Chaining area (independence + toleration templates)
+└── session_interpretation/          # Session interp area:
+                                     #   taxonomy + compatibility + trajectory_rules
+                                     #   + recommendations (per-pattern bullets) + template
+src/generators/
+├── aba_dtt.py                       # per-area generator
+├── aba_net.py
+├── aba_task_analysis.py
+└── aba_session_interp.py
+src/generate.py                      # orchestrator
+```
+
+### 4.2 Generation loop
+
+For each example:
+1. Sample a clinical configuration from the taxonomy, weighted by realistic clinical frequency (level weights, module weights, pattern weights).
+2. Apply compatibility rules (e.g., DTT errorless error correction pairs only with most-to-least prompting; certain patterns have bias toward certain behavior functions).
+3. Compute template slots — current-prompt-level guidance from mastery state; MO arrangement from skill keywords; mastery criterion; reinforcement schedule.
+4. Render `user_content` from a random user-variant.
+5. Render `assistant_content` by filling `{slots}` in the assistant template.
+6. Stamp `meta.gold_labels` and `meta.provenance`.
+7. Write as one JSONL line.
+
+### 4.3 Grounding
+
+- **Skill curricula** — VB-MAPP milestones (Sundberg 2008) for verbal-behavior domains; AFLS (Partington & Mueller) for adaptive-living domains.
+- **Teaching methods** — DTT (Lovaas 1987; Smith 2001); NET (Hart & Risley 1975 in CHH Ch. 18); Task Analysis / chaining (CHH Ch. 20).
+- **Operational definitions of target behaviors** — Cooper/Heron/Heward Ch. 3, 27; key JABA papers (Iwata et al. 1994 for SIB and functional analysis; Carr & Durand 1985 for FCT; Hanley, Iwata, & McCord 2003 for FBA).
+- **Session patterns** — derived from CHH Ch. 6–7 (analyzing behavior change) and Stokes & Baer 1977 (generalization).
+- **Crisis plans** — BACB Ethics Code (2020) section 3.05; ABAI Position Statement on Restraint and Seclusion (2010). Physical-intervention procedures are left vague on purpose because they vary by training program (Safety-Care, CPI, PMT, TCI) and jurisdiction; the dataset emphasizes verbal de-escalation, environmental safety, BIP authorization, and contraindications.
+
+### 4.4 Clinical-accuracy pipeline
+
+Initial generation produced the structural skeleton. The corpus was then iterated via **practitioner-in-the-loop review** — a full-text render of the held-out candidate pool was browsed by a reviewer with ABA practitioner exposure, and each flagged clinical inaccuracy was traced to the responsible taxonomy cell and fixed with a single targeted edit plus a full regeneration. Because every example records its sampling provenance, a single cell-level edit propagates to every example that sampled the affected cells — so flagging one example systematically corrects a class of examples.
+
+---
+
+## 5. Intended Uses
+
+### 5.1 Direct use
+- Instruction-tuning a small language model (recommended: Gemma 4 E2B 4-bit with QLoRA) to draft ABA teaching programs and interpret session logs.
+- Evaluation of task-specific competencies using the held-out `test.jsonl` (281 examples).
+- Research on taxonomy-driven synthetic data generation for clinical decision support.
+
+### 5.2 Downstream use
+- Research on small-LM drafting assistants in structured clinical-documentation domains.
+- Comparison baselines for future ABA-specific LLM work (Kumar et al. 2024 "Personalized-ABA" is the closest direct predecessor; the present dataset extends to structured program generation and session-log interpretation).
+
+### 5.3 Out-of-scope (do NOT use for)
+- Autonomous clinical decisions.
+- Writing final Behavior Intervention Plans without BCBA review.
+- Training models on or combined with real client records (the pipeline and schema are explicitly designed to avoid this).
+- Legal or insurance documentation.
+- Medical diagnosis.
+
+---
+
+## 6. Ethics & Risks
+
+### 6.1 Provenance
+Every example is synthetic. No real client data, no real session notes, no real identifiers were used at any step. Learner references use synthetic IDs (`SYN-####`); dates fall in the range 2026-01-01 to 2026-12-31.
+
+### 6.2 Clinical-risk framing
+The dataset is designed around a **draft-and-review** authoring pattern. Assistant responses are structured so that a reviewer can quickly see the method, the stimulus arrangement, the prompt hierarchy, the reinforcement plan, the error-correction procedure, the mastery criterion, and the generalization plan — each as a distinct, scannable section. Session-interpretation responses surface a confidence level (high / moderate / low) and an escalation level (1–4) as structured fields. These are design choices that support auditability; they are not clinical advice, and TRACE's responsibility disclaimer applies.
+
+### 6.3 Crisis-plan sensitivity
+Crisis plans were written against the ABAI 2010 Position Statement on Restraint and Seclusion and BACB Ethics Code 2020 section 3.05. The dataset references facility crisis-prevention frameworks (Safety-Care, CPI, PMT, TCI) only as examples and **deliberately avoids specifying restraint procedures** because those procedures are (a) jurisdiction-dependent, (b) training-certification-gated, and (c) learner-specific (many learners have contraindications). The dataset embeds explicit text in every crisis-plan bullet that physical intervention is used only when specifically authorized in the learner's BIP and only by staff currently certified in the facility's training program.
+
+### 6.4 Population representation
+Learner profiles are intentionally abstract (early / school-age / adolescent / adult). The dataset does not encode demographic categories (race, socioeconomic status, gender identity) and does not attempt to characterize clinical presentations by such categories. This is a deliberate choice for a first release; future versions may add representation if grounded in published demographic work.
+
+### 6.5 Known limitations
+- **English only.** Teaching method terminology, curriculum targets, and session-log conventions are rendered in English.
+- **Synthetic distributions.** Pattern frequencies are approximately uniform for learnability; real clinical practice has different frequencies (mastery-progression is far more common than frustration-pattern in a healthy caseload). The dataset is explicitly a teaching set, not an epidemiological sample.
+- **VB-MAPP + AFLS only.** Other curricula (ABLLS-R, Essential for Living, PEAK) are not covered. Practitioners using those curricula should adapt.
+- **No longitudinal data.** Sessions within a log are temporally ordered but the pipeline does not model real continuity over months or years.
+- **Toleration covers hygiene only.** Other toleration programs (e.g., wearing glasses, riding in a car seat) are not represented.
+- **Toilet-training acquisition is out of scope.** Accidents are tracked in session logs and bathroom-requesting is taught as a NET mand, but the full Azrin & Foxx 1971 rapid toilet-training acquisition protocol is not included as a task-analysis program.
+
+### 6.6 License
+**Data:** CC BY-NC 4.0 — research and non-commercial use with attribution. **Code:** MIT.
+
+**Responsibility.** TRACE is a research artifact. It is not a clinical tool, has not been clinically validated, and carries no clinical endorsement. Anyone who chooses to deploy TRACE — or any model derived from it — in a clinical setting does so entirely at their own responsibility and under their facility's own oversight. The authors and Pombo Labs make no representation of clinical suitability and accept no liability for clinical outcomes.
+
+---
+
+## 7. Reproducibility
+
+The corpus is regenerated deterministically from:
+- `configs/` (all YAMLs)
+- `configs/generation.yaml` (seed and per-area counts)
+- `src/generators/*.py` (generator code)
+
+```bash
+uv run python src/generate.py --all                  # regenerate 3000 examples
+uv run python src/split_data.py                      # stratified split
+uv run python src/prepare_curation.py                # browseable review.md
+uv run python src/compile_curation.py                # test.jsonl + sanity.jsonl
+```
+
+The dataset version is `v1.0.0`; the matching git tag pins the exact configs and generator code that produced the published JSONL splits.
+
+---
+
+## 8. Citation
+
+Please cite as:
+
+> Kahunla, F. (2026). *TRACE: Taxonomy-Grounded Synthetic Data for Teaching Program Generation and Session Interpretation in Applied Behavior Analysis.* Pombo Labs. https://github.com/Pombo-Labs/TRACE
+
+Machine-readable metadata: `CITATION.cff`.
+
+---
+
+## 9. Appendices
+
+- **Datasheet** (Gebru et al. 2021 format): `datasheet.md`
+- **Data statement** (Bender & Friedman 2018 format): `data-statement.md`
+- **Taxonomy reference** (operational definitions + citations): `taxonomy-v1.md`
+- **Schema reference** (wire format + slot specifications): `schema-v1.md`

docs/datasheet.md

@@ -0,0 +1,220 @@
+# Datasheet for TRACE (v1)
+
+**TRACE** — **T**axonomy-**R**eferenced **A**BA **C**linical **E**xamples
+
+Template: Gebru, T., Morgenstern, J., Vecchione, B., Wortman Vaughan, J., Wallach, H., Daumé III, H., & Crawford, K. (2021). *Datasheets for Datasets.* Communications of the ACM. https://arxiv.org/abs/1803.09010
+
+---
+
+## Motivation
+
+### Why was the dataset created?
+To provide the first public, open-access synthetic instruction-tuning dataset for two tasks in Applied Behavior Analysis (ABA): (1) teaching program generation and (2) multi-session behavioral interpretation. Board Certified Behavior Analysts (BCBAs) draft large numbers of these documents weekly; current LLM assistants are both unspecialized to ABA and unvetted against its clinical standards. The dataset supports fine-tuning a small, on-device language model (Gemma 4 E2B at 2B parameters) for drafting support, preserving clinical oversight at the point of deployment.
+
+### Who funded the creation of the dataset?
+No external funding. Authored by Festus Kahunla (Drexel University) and released publicly under the **Pombo Labs** organization (https://github.com/Pombo-Labs).
+
+### Any other comments?
+The dataset's primary novelty is its **taxonomy-driven construction with complete provenance**: every example can be traced back to a specific set of taxonomy cells that produced it. This is a deliberate choice to make clinical validity auditable.
+
+---
+
+## Composition
+
+### What do the instances represent?
+Two instance types:
+
+1. **Teaching-program instances** (1,800 total) — a user message describes a learner profile and a skill target; an assistant message produces a structured teaching program. Covers three methods: Discrete Trial Training (DTT, 800), Natural Environment Teaching (NET, 500), Task Analysis / chaining (500).
+
+2. **Session-interpretation instances** (1,200 total) — a user message contains a multi-session behavioral log (5–12 sessions, with per-session accuracies, target behaviors with measurements, and optional ABC and IOA data); an assistant message produces clinical concerns, a pattern classification, a function hypothesis, recommendations, and when applicable a crisis plan.
+
+### How many instances are there in total?
+2,999.
+
+### Does the dataset contain all possible instances or is it a sample?
+The dataset is a **programmatic sample** from a combinatorial space defined by the taxonomy. The space is formally enumerable (domains × levels × learner profiles × mastery states × prompt hierarchies × reinforcement schedules × error corrections × mastery criteria) but is far larger than 2,999 examples. Sampling weights reflect approximate clinical frequency where known (e.g., VB-MAPP Level 1 is sampled more heavily than Level 3 for DTT because early learners dominate the data space in practice).
+
+### What data does each instance consist of?
+See `schema-v1.md` and `dataset-card.md section 3`. Each instance is one JSONL line with two top-level keys:
+- `messages` — a three-message chat triple (system, user, assistant) that the fine-tuner trains on.
+- `meta` — task type, example ID, gold labels, and full sampling provenance (ignored during training).
+
+### Is there a label or target associated with each instance?
+Yes, stored in `meta.gold_labels`. For teaching programs: method, domain, level, learner profile, mastery state. For session interpretation: pattern class, behavior functions, escalation level, confidence, crisis-plan requirement.
+
+### Is any information missing from individual instances?
+Some instances have optional data by design:
+- **Task Analysis / toleration programs** have `shaping_steps` instead of `steps` and no `chain_type` (not applicable).
+- **Session logs** carry ABC data on approximately 30% of sessions when behaviors are present; IOA data on approximately 25% of logs; behavioral-indicator clusters per pattern. Absence of these is intentional, not missingness.
+
+### Are relationships between individual instances made explicit?
+Instances are independent by construction. No implicit links between examples.
+
+### Are there recommended data splits?
+Yes. The dataset ships with four split files:
+
+| Split | Count | Fraction | Purpose |
+|---|---:|---:|---|
+| `train.jsonl` | 2,549 | 85% | LoRA fine-tuning |
+| `valid.jsonl` | 149 | 5% | Validation during training |
+| `test.jsonl` | 281 | 9.4% | Held-out evaluation |
+| `sanity.jsonl` | 20 | 0.7% | Training smoke-test |
+
+All splits are stratified by area × category to preserve the corpus distribution.
+
+### Are there errors, sources of noise, or redundancies?
+- **Template repetition.** Assistant responses follow a structured template; lexical patterns recur by design. This is an intentional trade-off for learnability.
+- **Sampling drift.** Because the generator samples independently per example, some combinations of cells can land improbable but not impossible (e.g., a "mastered" skill still running an error-correction procedure). Compatibility rules reduce this; ad-hoc practitioner review catches the rest.
+- **Clinical accuracy.** Every example passed at least a syntactic quality check. A subset underwent ad-hoc practitioner review during iteration; not every example has been individually inspected.
+
+### Does the dataset contain data that might be considered confidential?
+No. All data is synthetic. No real client information. No real session notes. No real names, dates, or IDs. Synthetic IDs use the `SYN-####` pattern from a fixed range; synthetic dates fall in 2026-01-01 to 2026-12-31.
+
+### Does the dataset contain data that might be offensive, insulting, threatening, or otherwise cause anxiety?
+The session logs describe challenging behavior (aggression, self-injury, property destruction, pica, elopement, fecal smearing, toileting accidents, tantrum). These descriptions are clinical in register and grounded in the operational definitions used in the peer-reviewed JABA literature. They may be distressing to readers unfamiliar with ABA. Target behaviors appear only in the context of a session log being interpreted — they are never endorsed, glorified, or represented outside clinical framing.
+
+### Does the dataset relate to people?
+Indirectly. Instances describe synthetic learners in clinical scenarios. No real people are identifiable. No real demographic distributions are encoded.
+
+### Does the dataset identify any sub-populations?
+Learner profiles are:
+- **Early Learner** (≈3–5 years; VB-MAPP L1 or L2 depending on skill)
+- **School-Age** (≈6–10 years; VB-MAPP L2–L3, AFLS basic_living and home)
+- **Adolescent** (≈11–17 years; AFLS community, vocational)
+- **Adult** (≈18+ years; AFLS independent_living primary)
+
+These are developmentally anchored; they do not encode race, ethnicity, socioeconomic status, or gender identity. No sub-populations are characterized on those axes.
+
+### Is it possible to identify individuals from the dataset?
+No. The dataset is synthetic.
+
+### Does the dataset contain data that might be considered sensitive?
+The subject matter is sensitive — autism-related clinical challenges, problem behavior, restraint-related crisis planning. The data itself is not sensitive because it is synthetic. Care was taken in the crisis-plan content to cite authoritative sources (BACB Ethics Code 2020 section 3.05; ABAI 2010 Position Statement) and to avoid prescribing restraint procedures directly.
+
+---
+
+## Collection Process
+
+### How was the data associated with each instance acquired?
+Programmatic generation. The pipeline is a deterministic function of (a) the YAML taxonomy configs and (b) a random seed. Inputs to the generator come from published curricula (VB-MAPP; AFLS) and textbook / JABA / BACB Ethics Code content that was manually encoded into the taxonomy YAMLs by the authors. **No web scraping. No ingestion of patient records. No use of real session notes.**
+
+### What mechanisms or procedures were used?
+Python scripts under `src/generators/` with taxonomy YAMLs under `configs/`. See `dataset-card.md section 4`.
+
+### If sampled, what was the sampling strategy?
+Weighted random sampling on each taxonomy dimension, with compatibility rules applied afterward to reject clinically inconsistent combinations. Weights are human-specified (in `compatibility.yaml` files) to approximate clinical frequency.
+
+### Who was involved in the data collection process?
+Festus Kahunla (Drexel; Pombo Labs) wrote the generator and the taxonomy, conducted clinical-accuracy review, and authored the dataset docs.
+
+### Over what timeframe was the data collected?
+January 2026 to April 2026. The early months covered taxonomy research, literature grounding, and pipeline design; the corpus itself was generated and iterated in April 2026.
+
+### Were any ethical review processes conducted?
+No IRB required — the dataset is entirely synthetic. The generator architecture is explicitly designed so no real client data can enter the pipeline. Clinical scope (what counts as a reasonable teaching program, what crisis procedures are appropriate) was grounded in published sources (BACB Ethics Code 2020; ABAI 2010 Position Statement; Cooper, Heron, & Heward 2020) rather than personal clinical experience.
+
+### Does the dataset relate to people? If so, did you collect data from them directly or from a third-party?
+The dataset does not relate to any real person. No data was collected from any person.
+
+### Were the individuals in question notified about data collection?
+Not applicable (no real individuals).
+
+### Did the individuals in question consent to data collection?
+Not applicable (no real individuals).
+
+### If consent was obtained, were they given a mechanism to revoke consent?
+Not applicable.
+
+### Has an analysis of the potential impact of the dataset and its use on data subjects been conducted?
+The dataset has no data subjects. The intended model users (BCBAs and ABA technicians) are discussed in section 6.2 of the dataset card (clinical-risk framing) and section 6.3 (crisis-plan sensitivity).
+
+---
+
+## Preprocessing / Cleaning / Labeling
+
+### Was any preprocessing / cleaning / labeling of the data done?
+- **Labeling.** Gold labels are emitted at generation time from the same taxonomy cells that produced the example. No post-hoc annotation. Labels are therefore by-construction correct for the taxonomy; they are only as valid as the taxonomy is (see section 4.3 of the dataset card for grounding).
+- **Deduplication.** Example IDs are deterministic hashes of the message content; duplicates (same user + assistant content) would be detected across generations, but in practice duplicates do not occur because every render draws fresh random values for the slots.
+- **Filtering.** Compatibility rules reject clinically inconsistent samples before rendering. No post-rendering filter is applied.
+
+### Was the "raw" data saved in addition to the preprocessed data?
+The generator is a deterministic function of (configs, seed) and produces the same data on every run. There is no separate "raw" stage — every artifact is reproducible from source.
+
+### Is the software used to preprocess / clean / label the data available?
+Yes, in the repository: `src/generators/`, `src/prepare_data.py`, `src/split_data.py`, `src/prepare_curation.py`, `src/compile_curation.py`.
+
+---
+
+## Uses
+
+### Has the dataset been used for any tasks already?
+At time of v1 release, the dataset has been used for the associated research paper and for Pombo Labs's on-device small-LM fine-tuning experiments. Downstream fine-tuning + evaluation results will be referenced from this dataset card as they are published.
+
+### Is there a repository that links to any or all papers or systems that use the dataset?
+Repository: https://github.com/Pombo-Labs/TRACE (v1 pinned to the initial release commit). Downstream artifacts — training logs, evaluation results, and any derived models — will be released separately and referenced from this dataset card as they become available.
+
+### What other tasks could the dataset be used for?
+- Evaluation baselines for future ABA-specific LLM work.
+- Research on taxonomy-driven synthetic data generation (the pipeline is domain-agnostic; only the configs are ABA-specific).
+- Research on provenance-traceable data and auditable clinical AI.
+
+### Is there anything about the composition of the dataset or the way it was collected and preprocessed / cleaned / labeled that might impact future uses?
+- **Pattern frequencies are uniform for learnability.** Real clinical caseloads are skewed toward mastery-progression; users who care about epidemiological plausibility should reweight.
+- **The dataset is English-only and US-clinical-context-only.** Users in other jurisdictions or languages will need to adapt.
+- **Target-behavior presence in logs is bounded** (0–3 per log by pattern); real logs may have more or fewer.
+- **Crisis plans are deliberately vague on physical-intervention procedures** because those procedures are training- and jurisdiction-specific. Users building systems that need to recommend specific restraint procedures will need additional data curated to their jurisdiction.
+
+### Are there tasks for which the dataset should not be used?
+TRACE is a research artifact and is not a clinical tool. Any clinical use is at the user's own risk. See dataset card section 5.3 for the full framing. Summarized:
+
+- Not for autonomous clinical decisions.
+- Not for final BIP writing without BCBA review.
+- Not to be combined with real client data during training or inference.
+- Not for medical diagnosis, legal documentation, or insurance reimbursement.
+
+---
+
+## Distribution
+
+### Will the dataset be distributed to third parties outside of the entity on behalf of which it was created?
+Yes — intended for open release under a research license (CC BY-NC 4.0 recommended, pending finalization).
+
+### How will the dataset be distributed?
+Public GitHub repository and Hugging Face Hub.
+
+### When will the dataset be distributed?
+2026-04-25 for the v1 release.
+
+### Will the dataset be distributed under a copyright or intellectual property license?
+Data: CC BY-NC 4.0. Code: MIT. TRACE is a research artifact; it has not been clinically validated and is not a clinical tool. Any use in a clinical setting is at the sole responsibility of the user and their facility.
+
+### Have any third parties imposed IP-based or other restrictions?
+No third-party IP is embedded. Curriculum references are to published frameworks (VB-MAPP, AFLS); no proprietary items are reproduced. Citation-based references to the Cooper/Heron/Heward textbook and JABA papers are just that — citations, not text reproductions.
+
+### Do any export controls or other regulatory restrictions apply?
+No.
+
+---
+
+## Maintenance
+
+### Who will be supporting / hosting / maintaining the dataset?
+**Pombo Labs** (https://github.com/Pombo-Labs) is the release maintainer. Festus Kahunla is the primary author and active maintainer of the dataset.
+
+### How can the owner / curator / manager of the dataset be contacted?
+Via the GitHub repository issue tracker.
+
+### Is there an erratum?
+A CHANGELOG will be maintained in the repository for each dataset version.
+
+### Will the dataset be updated?
+Yes, as ongoing research warrants. Future versions will be released as new git tags (semantic versioning) with full CHANGELOG entries. No public roadmap is committed to at v1.
+
+### If the dataset relates to people, are there applicable limits on retention?
+Not applicable (no real people).
+
+### Will older versions continue to be supported?
+Yes. Each dataset version is pinned to a specific commit hash; old versions remain reproducible from the corresponding configs and generator code.
+
+### If others want to extend / augment / build on / contribute to the dataset, is there a mechanism for them to do so?
+Yes. The taxonomy YAMLs are the intended extension surface. Adding a new skill target, a new target behavior, a new mastery criterion, or a new teaching method follows a documented pattern (see `configs/` for structure). Pull requests to the repository are the intended contribution mechanism.

docs/references.md

@@ -0,0 +1,142 @@
+# Citations to use — the focused shortlist
+
+**Principle:** The paper's References section is lean and earned, not a literature dump. This shortlist is the ~30 papers we actually cite across the paper and the dataset documentation (dataset card, datasheet, data statement, taxonomy reference).
+
+---
+
+## A. ABA × NLP — direct predecessors and positioning (6)
+
+1. **Kumar, A., et al. (2024). Personalized-ABA.** *NLP4Science @ ACL.* https://aclanthology.org/2024.nlp4science-1.16/
+   *How we cite:* direct predecessor; benchmark to beat.
+
+2. **Cox, D. J., & Jennings, A. M. (2024). Promises and possibilities of AI in behavior analytic services.** *Behavior Analysis in Practice, 17*, 123–136. https://pmc.ncbi.nlm.nih.gov/articles/PMC10890993/
+   *How we cite:* motivates the application space, especially "NLP on session notes."
+
+3. **Jennings, A. M., & Cox, D. J. (2024). Starting the conversation around the ethical use of AI in ABA.** *Behavior Analysis in Practice, 17*, 107–122. https://pmc.ncbi.nlm.nih.gov/articles/PMC10891004/
+   *How we cite:* ethics spine — BACB 2.03/2.05, HIPAA, explainability criteria our stack satisfies by construction.
+
+4. **Peck, S., O'Brien, C., Bourret, J., & Agostinelli, D. (2025). ChatGPT versus clinician responses to questions in ABA.** *JABA.* https://onlinelibrary.wiley.com/doi/10.1002/jaba.70029
+   *How we cite:* BCBAs already prefer LLMs blind — raises hallucination stakes.
+
+5. **Garg, M., Raza, S., Rayana, S., Liu, X., & Sohn, S. (2025). The rise of small language models in healthcare: A comprehensive survey.** arXiv:2504.17119. https://arxiv.org/abs/2504.17119
+   *How we cite:* positions our work in SLM-clinical field; ABA is a named white-space in their taxonomy.
+
+6. **Gao, L. et al. (2025). Generative AI for assessment and treatment of autism spectrum disorders: A scoping review.** *Frontiers in Psychiatry.* https://pmc.ncbi.nlm.nih.gov/articles/PMC12322814/
+   *How we cite:* none of the 10 studies surveyed cover BCBA workflow / session logs / on-device — directly positions our contribution.
+
+## B. Stack precedents — small clinical on-device LMs (3)
+
+7. **Zhang, T., et al. (2025). Menta: On-device SLM for mental health.** arXiv:2512.02716. https://arxiv.org/abs/2512.02716
+   *How we cite:* direct recipe precedent (4B + LoRA r=16 α=32 + 4-bit on iPhone, beats 13B).
+
+8. **MedGemma Team, Google DeepMind (2025). MedGemma Technical Report.** arXiv:2507.05201. https://arxiv.org/abs/2507.05201
+   *How we cite:* Gemma family at 4B is clinically competent — direct stack-choice precedent.
+
+9. **Dettmers, T., et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs.** *NeurIPS.* https://arxiv.org/abs/2305.14314
+   *How we cite:* foundational method for our QLoRA fine-tuning.
+
+## C. Data methodology (4)
+
+10. **Wang, Y., et al. (2023). Self-Instruct.** *ACL.* https://arxiv.org/abs/2212.10560
+    *How we cite:* foundational instruction-bootstrapping pipeline; source of ROUGE-L<0.7 dedup.
+
+11. **Zhang, X., et al. (2023). AlpaCare.** arXiv:2310.14558. https://arxiv.org/abs/2310.14558
+    *How we cite:* clinician-seeded stratification recipe — the key quality lever for medical instruction tuning.
+
+12. **Gekhman, Z., et al. (2024). Does Fine-Tuning LLMs on New Knowledge Encourage Hallucinations?** *EMNLP.* https://arxiv.org/abs/2405.05904
+    *How we cite:* grounds our "teach format, not new facts" design.
+
+13. **Patel, M., et al. (2025). How to Design, Create, and Evaluate an Instruction-Tuning Dataset in Health Care.** *JMIR.* https://www.jmir.org/2025/1/e70481
+    *How we cite:* our validation protocol (4-dim rubric, κ with cooldown) follows this tutorial directly.
+
+## D. Evaluation methodology (7)
+
+14. **Singhal, K., et al. (2025). Toward expert-level medical question answering with LLMs (Med-PaLM 2).** *Nature Medicine.* https://www.nature.com/articles/s41591-024-03423-7
+    *How we cite:* rubric design (9 axes, pairwise ranking) — the clinical-NLG gold standard.
+
+15. **Arora, R. K., et al. (2025). HealthBench.** arXiv:2505.08775. https://arxiv.org/abs/2505.08775
+    *How we cite:* justifies our 3-point rubric scale over Likert-5/7.
+
+16. **Kim, S., et al. (2024). Prometheus 2.** arXiv:2405.01535. https://arxiv.org/abs/2405.01535
+    *How we cite:* the open, local LLM judge we run alongside GPT-4.1 and Claude.
+
+17. **Zheng, L., et al. (2024). Judging LLM-as-a-Judge (MT-Bench).** *NeurIPS 2023.* https://arxiv.org/abs/2306.05685
+    *How we cite:* sources of position / verbosity / self-enhancement bias; justifies our swap-augmentation and panel diversity.
+
+18. **Kulkarni et al. (2025). TN-Eval: Behavioral therapy note rubrics.** arXiv:2503.20648. https://arxiv.org/abs/2503.20648
+    *How we cite:* closest adjacent rubric; faithfulness warning (therapists preferred hallucinated notes).
+
+19. **Manakul, P., et al. (2023). SelfCheckGPT.** arXiv:2303.08896. https://arxiv.org/abs/2303.08896
+    *How we cite:* our zero-resource hallucination metric.
+
+20. **Reiter, E. (2018). A Structured Review of the Validity of BLEU.** *Computational Linguistics, 44*(3), 393–401. https://direct.mit.edu/coli/article/44/3/393/
+    *How we cite:* justifies NOT using BLEU as a primary metric (negation matters in evaluation claims).
+
+## E. Statistical grounding (3)
+
+21. **Cohen, J. (1968). Weighted kappa.** *Psychological Bulletin, 70*(4).
+    *How we cite:* quadratic-weighted κ for our ordinal escalation-level classifier.
+
+22. **Chicco, D., & Jurman, G. (2020). Advantages of MCC over F1 and accuracy.** *BMC Genomics.* https://link.springer.com/article/10.1186/s12864-019-6413-7
+    *How we cite:* justifies reporting MCC alongside macro-F1 on imbalanced classification heads.
+
+23. **Guo, C., et al. (2017). On Calibration of Modern Neural Networks.** *ICML.* https://arxiv.org/abs/1706.04599
+    *How we cite:* source of ECE + temperature-scaling for our confidence calibration.
+
+## F. ABA foundation (5)
+
+24. **Cooper, J. O., Heron, T. E., & Heward, W. L. (2020). *Applied Behavior Analysis* (3rd ed.).** Pearson. ISBN 978-0134752556.
+    *How we cite:* canonical ABA reference — chapter citations for DTT, task analysis, measurement, IOA, FBA, BIP components.
+
+25. **Iwata, B. A., Dorsey, M. F., Slifer, K. J., Bauman, K. E., & Richman, G. S. (1982/1994). Toward a functional analysis of self-injury.** *JABA, 27*(2), 197–209. https://doi.org/10.1901/jaba.1994.27-197
+    *How we cite:* bedrock of the four-function taxonomy we encode.
+
+26. **Carr, E. G., & Durand, V. M. (1985). Reducing behavior problems through functional communication training.** *JABA, 18*(2), 111–126. https://doi.org/10.1901/jaba.1985.18-111
+    *How we cite:* origin of FCT; replacement-behavior framework.
+
+27. **Hanley, G. P., Iwata, B. A., & McCord, B. E. (2003). Functional analysis of problem behavior: A review.** *JABA, 36*(2), 147–185. https://doi.org/10.1901/jaba.2003.36-147
+    *How we cite:* definitive FBA review, finalization of four-function taxonomy.
+
+28. **Lovaas, O. I. (1987). Behavioral treatment and normal educational and intellectual functioning in young autistic children.** *JCCP, 55*(1), 3–9. https://doi.org/10.1037/0022-006X.55.1.3
+    *How we cite:* DTT / EIBI historical origin.
+
+## G. Dataset documentation (2)
+
+29. **Gebru, T., et al. (2021). Datasheets for Datasets.** *CACM.* https://arxiv.org/abs/1803.09010
+    *How we cite:* template for our dataset's datasheet appendix.
+
+30. **Bender, E., & Friedman, B. (2018). Data Statements for NLP.** *TACL.* https://aclanthology.org/Q18-1041/
+    *How we cite:* NLP-specific data disclosure — complements Gebru datasheet.
+
+---
+
+## What was intentionally dropped (and why)
+
+Comprehensive background is in `literature-foundation.md`. The following categories do **not** earn spots in the paper's References:
+
+- **Target-behavior JABA papers** (Kodak elopement, Piazza pica, Marcus aggression, Rapp & Vollmer stereotypy, etc.) — These ground the dataset's operational definitions and belong in the **dataset card / datasheet**, not the main paper. They'll appear in a supplementary `taxonomy-v1.md`.
+- **Curriculum primary sources beyond VB-MAPP** (AFLS, ABLLS-R, Essential for Living, PEAK) — cite only if we actually use them as data sources. Current pipeline uses VB-MAPP only; others stay in background reading.
+- **Secondary synthetic-data papers** (phi-1, Orca, LIMA, Baize, MedAlpaca, Clinical Camel, Persona Hub, Evol-Instruct, LAB, DataDreamer) — Self-Instruct + AlpaCare + Gekhman + Patel cover our method grounding. The rest are design inspiration, not required citations.
+- **Secondary evaluation papers** (GPTScore, JudgeLM, BARTScore, Med-HALT, MedHallu, HELM critiques, Abacha MEDIQA, G-Eval) — Prometheus 2 + MT-Bench + TN-Eval + SelfCheckGPT + Reiter + Med-PaLM 2 cover our method grounding.
+- **Older measurement / IOA JABA papers** (Powell 1975, Harrop & Daniels 1986, Kazdin 1977) — covered by Cooper/Heron/Heward textbook chapters.
+- **Teaching-method origins beyond DTT** (Hart & Risley 1975 NET, Koegel 1987 PRT, Parsons 2012 BST, Tiger 2008 FCT review, Slocum & Tiger 2011 chaining) — covered by CHH textbook chapter citations. Only cite these JABA papers individually if our paper makes a specific claim about that teaching method.
+- **Neuromnia blog / Meta-AI press** — not citable in an academic venue; mention in passing without reference.
+- **Lanovaz & Hranchuk 2021** — different task (visual-inspection binary classification from graphs); only cite if we explicitly contrast against it. Likely drop.
+- **Dataset documentation meta-papers** (Bender 2023 Data Statements v2, HF dataset card docs, NeurIPS 2025 D&B CfP, Giuffrè 2023 synthetic health, Pezoulas 2025 privacy, Mozilla/AI-Alliance 2024) — cite only where directly relevant in the datasheet, not in the main paper.
+
+---
+
+## Summary
+
+| Category | Count |
+|---|---|
+| ABA × NLP | 6 |
+| Stack precedents | 3 |
+| Data methodology | 4 |
+| Evaluation methodology | 7 |
+| Statistical grounding | 3 |
+| ABA foundation | 5 |
+| Dataset documentation | 2 |
+| **Total** | **30** |
+
+Appropriate for a 4-page ACL paper (typical range 20–40 citations) plus a NeurIPS D&B dataset paper appendix. Add more only when the text actually needs them.

docs/schema-v1.md

@@ -0,0 +1,756 @@
+# TRACE Dataset Schema v1
+
+**Purpose.** This document defines the **wire format** for TRACE training examples — the precise shape each JSONL line takes, the structure of user messages and assistant responses, and the metadata fields used for evaluation label extraction.
+
+**Scope.** Two tasks, each with its own input/output conventions but sharing a common chat-format wrapper. Every taxonomy category from `taxonomy-v1.md` maps to a field or sampling decision here.
+
+**Status.** Version 1, 2026-04-23. Breaking changes require a version bump.
+
+**Companion documents.**
+- `taxonomy-v1.md` — the controlled vocabulary (what categories exist)
+- `schema-v1.md` — this document (how examples are shaped)
+- `datasheet.md` (pending) — dataset card
+- `src/prepare_data.py` (pending rewrite) — implements this schema
+
+---
+
+## 0. Overview
+
+Two tasks:
+
+| Task | Input | Output | MLX-LM role mapping |
+|---|---|---|---|
+| **1. Teaching Program Generation** | Learner profile + skill target + method + context | Structured teaching program with method-specific fields | user -> assistant |
+| **2. Behavioral Session Interpretation** | Multi-session behavioral log (8–12 sessions typical) | Structured clinical interpretation (concerns + pattern + function + recommendations + escalation + confidence + rationale) | user -> assistant |
+
+Each training example is one JSONL line with:
+- `messages` — the chat-format messages the model trains on (system + user + assistant)
+- `meta` — evaluation metadata (gold labels, provenance) that is *not* shown to the model during training but is used by `src/evaluate.py` for metric computation
+
+---
+
+## 1. Wire format
+
+### 1.1 MLX-LM chat format
+
+MLX-LM's `--data` expects JSONL files where each line has a `"messages"` array. Each message is `{"role": "system"|"user"|"assistant", "content": "..."}`. When `mask_prompt: true`, loss is computed only on assistant tokens.
+
+### 1.2 TRACE extended format
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "..."},
+    {"role": "user", "content": "..."},
+    {"role": "assistant", "content": "..."}
+  ],
+  "meta": {
+    "task_type": "teaching_program" | "session_interpretation",
+    "example_id": "<sha256-hex-prefix-16-chars>",
+    "gold_labels": { ... task-specific ... },
+    "provenance": {
+      "layer": 1 | 2 | 3,
+      "template_id": "<string>",
+      "taxonomy_cells": { ... sampled values ... },
+      "teacher_model": "<string or null>",
+      "seed": <int>,
+      "generated_at": "<ISO-8601>"
+    }
+  }
+}
+```
+
+The `meta` field is ignored by MLX-LM during training but preserved for evaluation and provenance tracking. `example_id` is a deterministic hash of the user + assistant content so that duplicates can be detected across generations.
+
+### 1.3 Splits
+
+Train / valid / test splits live in `data/splits/`:
+- `train.jsonl` — 85% (used for LoRA training)
+- `valid.jsonl` — 10% (used by MLX-LM for periodic validation loss)
+- `test.jsonl` — 5% (held out; only used for final evaluation)
+
+Stratified by `meta.task_type` and by `meta.gold_labels.pattern_class` (task 2) so each split is balanced.
+
+---
+
+## 2. Common conventions
+
+### 2.1 Synthetic identifiers
+
+Every learner referenced in any example has a synthetic ID: `SYN-####` where `####` is a 4-digit number from a fixed range (1000–9999). Generator uses `random.Random(seed)` to draw these deterministically. **No real-world ID patterns, no initials, no names.**
+
+### 2.2 Dates
+
+Synthetic dates always fall in the range `2026-01-01` -> `2026-12-31` (stable, non-leaking). Format: `YYYY-MM-DD`. Session timestamps within a day are not included (unnecessary detail).
+
+### 2.3 Measurement notation (within session logs)
+
+| Measurement | Abbreviation / format |
+|---|---|
+| Accuracy (trial-based) | `X/N correct (PP%)` e.g., `6/10 correct (60%)` |
+| Frequency (count) | `freq = N` |
+| Rate | `rate N.NN/min` |
+| Duration | `Nm` or `N m Ns` |
+| Latency | `latency N.Ns` |
+| Partial-interval | `PIR PP% of intervals` |
+| Whole-interval | `WIR PP% of intervals` |
+| Momentary time sampling | `MTS PP%` |
+| Episode-based | `N episodes, mean duration Nm Ns` |
+| IOA | `IOA PP%` (with "session marked IOA" header) |
+
+### 2.4 Prompt-level shorthand
+
+Used inside session logs to describe trial-level prompting distribution:
+
+- `FP` — full physical
+- `PP` — partial physical
+- `M` — model
+- `G` — gestural
+- `V` — verbal
+- `Pos` — positional
+- `Vis` — visual
+- `I` — independent
+
+Example: `prompts: FP×3, PP×2, G×1, I×4` means 3 full-physical, 2 partial-physical, 1 gestural, 4 independent trials.
+
+### 2.5 Markdown conventions (assistant output)
+
+All assistant outputs use GitHub-flavored markdown. Section headers use `##` for top-level fields and `###` for sub-fields. Structured labels (pattern class, escalation, confidence) appear under their own `##` headers and contain a single canonical value in the first paragraph for regex extraction.
+
+---
+
+## 3. Task 1 — Teaching Program Generation
+
+### 3.1 System prompt (task 1)
+
+```
+You are an expert ABA (Applied Behavior Analysis) clinical assistant. You help
+Board Certified Behavior Analysts and staff design teaching programs for
+individuals with autism. Your responses are clinically accurate, individualized
+to the learner profile, follow BACB ethical guidelines, and reference no real
+client data. Select the appropriate teaching method (DTT, NET, Task Analysis,
+FCT, BST, PRT) based on the skill target and learner profile.
+```
+
+### 3.2 User message format (task 1)
+
+Seven required fields filled from the taxonomy. The generator samples valid combinations per section 14 of `taxonomy-v1.md`.
+
+```
+Generate a teaching program for the following target.
+
+Skill Target: {skill_name}
+Curriculum Reference: {vbmapp_domain or afls_module} — {level or none}
+Learner Profile: {early | school-age | adolescent | adult}
+Current Mastery: {emerging | developing | approaching | near | mastered | generalization | maintenance}
+Teaching Method: {dtt | net | task_analysis | fct | bst | prt}
+Program Context: {D | R | Both}
+
+Provide the full program structure appropriate to the selected method.
+```
+
+Template variations (~5 paraphrases) are sampled per Self-Instruct convention to avoid canonical-form overfitting.
+
+### 3.3 Assistant message format (method-agnostic sections)
+
+Every task-1 output contains these top-level sections in order:
+
+```markdown
+## Program Overview
+{1-2 sentence summary of what is being taught and to whom}
+
+## {method-specific sections — see section 3.4}
+
+## Mastery Criteria
+{which of the 7 mastery conventions from taxonomy section 11.1}
+
+## Data Collection
+{what measurement types will be used; when IOA will be scheduled}
+
+## Generalization & Maintenance Plan
+{when to probe across therapists / settings / materials; maintenance schedule}
+```
+
+### 3.4 Method-specific output variants
+
+The middle section of the output varies by method. Each has a fixed field structure.
+
+#### 3.4.1 DTT
+
+```markdown
+## Discriminative Stimulus (SD)
+Primary SD: "{sd_text}"
+Variations: {list}
+Presentation: {how stimulus is presented}
+
+## Prompt Hierarchy
+Strategy: {most-to-least | least-to-most | time-delay | graduated-guidance | stimulus-fading | stimulus-shaping}
+Sequence: {ordered prompt-level levels}
+Current prompt level: {based on mastery state}
+
+## Stimulus Array
+Array size: {field of N or no-array}
+Target stimuli: {list}
+Distractor stimuli: {list or N/A}
+Rotation: {how position/order is varied}
+
+## Error Correction Procedure
+{one of the 5 procedures from taxonomy section 10}
+
+## Reinforcement Schedule
+{one of the 7 schedules from taxonomy section 9}
+```
+
+#### 3.4.2 NET
+
+```markdown
+## Motivating Operation (MO) Arrangement
+{how the environment is set up to establish value for the target}
+
+## Natural Opportunity
+{when and where in the natural routine the teaching occurs}
+
+## Prompt Strategy
+Strategy: {prompt hierarchy}
+Delivery: {how prompts are embedded naturally}
+
+## Natural Reinforcer
+{the functional reinforcer that follows the target behavior}
+
+## Generalization Tactics
+{multiple exemplar training; programming common stimuli}
+```
+
+#### 3.4.3 Task Analysis / Chaining
+
+```markdown
+## Task Analysis
+Chain type: {forward | backward | total-task}
+Steps:
+1. {step description}
+2. {step description}
+...
+N. {step description}
+
+## Prompt Strategy Per Step
+{prompt level used at each step, fading plan}
+
+## Error Correction
+{procedure for when a step is missed}
+
+## Reinforcement
+Per-step reinforcement: {yes/no, schedule}
+Terminal reinforcement: {on chain completion}
+```
+
+#### 3.4.4 FCT
+
+```markdown
+## Target Behavior (to reduce)
+{operational definition, hypothesized function}
+
+## Replacement Response
+Topography: {vocal phrase | sign | AAC icon | card exchange}
+Training sequence: {how the replacement is taught}
+
+## Extinction Plan
+{how the problem behavior is placed on extinction}
+
+## Reinforcement for Replacement
+Schedule: {initially CRF; thinning plan}
+Magnitude: {quality and duration matched to natural reinforcer for problem behavior}
+
+## Crisis Plan
+{if extinction burst or safety concern, what staff do}
+```
+
+#### 3.4.5 BST (staff-facing)
+
+```markdown
+## Training Target
+{the program or skill the trainee will learn to implement}
+
+## Training Components
+1. Instruction: {what written/verbal instruction is given}
+2. Modeling: {trainer demonstrates; video or live}
+3. Rehearsal: {trainee practices with feedback}
+4. Feedback: {specific, behavior-specific, immediate}
+
+## Fidelity Checklist
+{bulleted items that must be demonstrated, scored yes/no}
+
+## Mastery Criterion (trainee)
+{e.g., 100% fidelity across 2 consecutive role-plays with novel scenarios}
+```
+
+#### 3.4.6 PRT
+
+```markdown
+## Motivation Arrangement
+{how child choice, preferred materials, and interspersal are set up}
+
+## Teaching Opportunities
+{when target is presented; how multiple cues are programmed}
+
+## Reinforcement of Attempts
+{what counts as an attempt; how attempts are reinforced differentially}
+
+## Natural Reinforcer
+{the functional reinforcer for the target response}
+
+## Generalization
+{multiple-exemplar plan; across people / settings}
+```
+
+### 3.5 Metadata fields (task 1)
+
+```json
+"meta": {
+  "task_type": "teaching_program",
+  "example_id": "<sha256 prefix>",
+  "gold_labels": {
+    "method": "dtt",
+    "domain": "VB-MAPP.Tact",
+    "level": "L2",
+    "learner_profile": "early",
+    "mastery_state": "developing",
+    "context": "Both"
+  },
+  "provenance": {
+    "layer": 1,
+    "template_id": "tp-dtt-001",
+    "taxonomy_cells": {
+      "skill_target": "Tacts colors of objects",
+      "prompt_hierarchy": "most-to-least",
+      "reinforcement_schedule": "CRF",
+      "error_correction": "transfer_trial"
+    },
+    "teacher_model": null,
+    "seed": 20260423001,
+    "generated_at": "2026-04-23T14:22:11Z"
+  }
+}
+```
+
+### 3.6 Complete task-1 example (abridged)
+
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "You are an expert ABA clinical assistant..."
+    },
+    {
+      "role": "user",
+      "content": "Generate a teaching program for the following target.\n\nSkill Target: Tacts colors of objects\nCurriculum Reference: VB-MAPP Tact L2\nLearner Profile: early\nCurrent Mastery: developing\nTeaching Method: dtt\nProgram Context: Both\n\nProvide the full program structure appropriate to the selected method."
+    },
+    {
+      "role": "assistant",
+      "content": "## Program Overview\nThis program teaches {learner} to tact (label) the color of presented objects...\n\n## Discriminative Stimulus (SD)\nPrimary SD: \"What color?\"\nVariations: \"Tell me the color\", \"What color is this?\"\nPresentation: ...\n\n## Prompt Hierarchy\nStrategy: most-to-least\nSequence: full physical (hand guidance to point) -> partial physical (touch elbow) -> gestural (point to color) -> positional (color nearest learner) -> independent.\nCurrent prompt level: given current 40% accuracy, begin at partial-physical and fade to gestural across sessions.\n\n## Stimulus Array\nArray size: field of 3 (target + 2 distractors)\nTarget stimuli: red, blue, yellow\nDistractor stimuli: 2 non-target colors per trial\nRotation: randomize position of target across trials.\n\n## Error Correction Procedure\nTransfer trial: re-present SD -> provide effective-level prompt -> reinforce prompted response -> distractor trial -> re-present SD independently.\n\n## Reinforcement Schedule\nCRF (continuous reinforcement) during acquisition; fade to FR-2 once accuracy exceeds 80%.\n\n## Mastery Criteria\n80% accuracy across 2 consecutive sessions with at least 10 trials each.\n\n## Data Collection\nTrial-by-trial data recording prompt level and response accuracy. IOA scheduled every 4th session at minimum.\n\n## Generalization & Maintenance Plan\nPost-mastery: probe with novel color stimuli, across 2 additional therapists, and in at least 2 natural contexts. Maintenance probes weekly for 4 weeks, then monthly."
+    }
+  ],
+  "meta": {
+    "task_type": "teaching_program",
+    "example_id": "a3f2b8d14e9c7a0f",
+    "gold_labels": {
+      "method": "dtt",
+      "domain": "VB-MAPP.Tact",
+      "level": "L2",
+      "learner_profile": "early",
+      "mastery_state": "developing",
+      "context": "Both"
+    },
+    "provenance": {
+      "layer": 1,
+      "template_id": "tp-dtt-001",
+      "taxonomy_cells": {
+        "skill_target": "Tacts colors of objects",
+        "prompt_hierarchy": "most-to-least",
+        "reinforcement_schedule": "CRF",
+        "error_correction": "transfer_trial"
+      },
+      "teacher_model": null,
+      "seed": 20260423001,
+      "generated_at": "2026-04-23T14:22:11Z"
+    }
+  }
+}
+```
+
+---
+
+## 4. Task 2 — Behavioral Session Interpretation
+
+### 4.1 System prompt (task 2)
+
+```
+You are an expert ABA clinical assistant. You analyze multi-session behavioral
+session logs for individuals with autism and produce structured clinical
+interpretations that identify patterns, hypothesize behavior functions when
+applicable, and recommend programming adjustments structured along BIP lines
+(antecedent strategies, replacement behaviors, consequence strategies, crisis
+plan). Your interpretation also includes an escalation level and a confidence
+expression. Every recommendation is grounded in the data provided. Follow BACB
+ethical guidelines and reference no real client data.
+```
+
+### 4.2 User message format — the session log
+
+The session log is a plain-text block with a fixed top-level structure. The generator produces it deterministically from sampled taxonomy values + a hidden pattern label.
+
+#### 4.2.1 Learner profile block
+
+```
+LEARNER PROFILE
+Synthetic ID: SYN-####
+Profile: {Early Learner | School-Age Learner | Adolescent Learner | Adult Learner} ({chronological age} yr)
+Curricula: {VB-MAPP L# | AFLS {module(s)} | combination}
+Primary context: {D | R | Both}
+Date range: Sessions 1–N across M days ({start date} to {end date})
+```
+
+#### 4.2.2 Acceleration programs block
+
+```
+ACCELERATION PROGRAMS
+1. {Skill Target} ({Curriculum Reference})
+   Method: {method}, {method-specific brief, e.g., "backward chaining, 8 steps"}
+   Context: {D | R | Both}
+2. ...
+```
+
+Typically 3–6 acceleration programs per log.
+
+#### 4.2.3 Deceleration targets block
+
+```
+DECELERATION TARGETS
+1. {Target behavior} — function hypothesized: {escape | attention | tangible | automatic | unknown}
+2. ...
+```
+
+Zero to three deceleration targets per log. When present, each has a hypothesized function used by the gold-label generator; the hypothesis may or may not be the correct answer in the interpretation (some examples deliberately encode ambiguity).
+
+#### 4.2.4 Per-session data format
+
+One block per session.
+
+```
+Session {N} — {YYYY-MM-DD} ({context-tag}) — {duration} min — {# observers}
+  {Skill 1 name}: {measurement 1}; {measurement 2}; prompts {prompt distribution}
+  {Skill 2 name}: {measurement}
+  ...
+  {Behavior 1 name}: {measurement}
+  {Behavior 2 name}: {measurement}
+  {optional: ABC(behavior): A = {antecedent}; B = {behavior description}; C = {consequence}}
+```
+
+ABC entries appear in ~30% of logs (taxonomy section 6.1), at a rate of approximately 1 ABC event per session that includes behavior occurrence.
+
+#### 4.2.5 IOA session format
+
+Approximately 25% of logs include one IOA session (sampled uniformly from the middle third of sessions in the log).
+
+```
+Session {N} — IOA SESSION — 2 observers
+  {Skill 1} IOA: {percentage}% agreement
+  {Behavior 1} IOA: {percentage}% agreement
+  ...
+```
+
+Agreements below 80% in generated IOA data are intentional in a minority of examples to test the model's ability to flag reliability concerns.
+
+#### 4.2.6 Cross-session observations block
+
+```
+BEHAVIORAL OBSERVATIONS (across sessions)
+- {narrative observation 1}
+- {narrative observation 2}
+- ...
+```
+
+3–6 bullet observations that summarize trends visible in the session data. Generated deterministically from the hidden pattern label + the behavioral indicator pool from taxonomy section 7.
+
+### 4.3 Assistant message format — structured interpretation
+
+Eight top-level sections in fixed order. Sections marked **required** always appear; sections marked **conditional** appear only when behavior data is present in the log.
+
+```markdown
+## Clinical Concerns          (required — free-form prose)
+
+## Pattern Classification     (required — structured label + 1–2 sentence evidence)
+
+## Behavior Function Hypothesis (conditional — only if deceleration targets observed)
+
+## Programming Recommendations  (required — 4 BIP-structured subsections)
+### Antecedent strategies
+### Replacement behavior       (conditional on behavior presence)
+### Consequence strategies
+### Crisis plan                (conditional — escalation level ≥ 3)
+
+## Escalation Level           (required — structured label + brief justification)
+
+## Confidence                 (required — structured label + brief justification)
+
+## Data-Supported Rationale   (required — numeric grounding)
+```
+
+#### 4.3.1 Clinical Concerns
+
+Free-form prose, 2–5 bullets or short paragraphs. Each concern references specific data from the log (accuracy values, frequencies, trends).
+
+#### 4.3.2 Pattern Classification
+
+First paragraph contains exactly one canonical label (or two labels joined by `+` if co-occurring):
+
+```markdown
+## Pattern Classification
+{pattern_label}
+
+{1–2 sentence explanation of why this pattern was identified}
+```
+
+Pattern labels drawn from taxonomy section 7 (12 patterns):
+`mastery_progression | regression | plateau | frustration_pattern | variable_performance | prompt_dependency | rapid_acquisition | generalization_failure | extinction_burst | skill_loss_after_break | motivating_operation_shift | setting_event_trigger`
+
+Co-occurring example: `regression + frustration_pattern`.
+
+#### 4.3.3 Behavior Function Hypothesis (conditional)
+
+Present only if deceleration targets appear in the log. One sub-entry per target behavior.
+
+```markdown
+## Behavior Function Hypothesis
+{behavior name}: {escape | attention | tangible | automatic | unknown}
+  Evidence: {1–3 sentences grounded in log data, referencing ABC events if present}
+
+{behavior name}: ...
+```
+
+If the log lacks evidence to distinguish functions, the hypothesis is `unknown` and the interpretation notes what data would disambiguate.
+
+#### 4.3.4 Programming Recommendations (BIP-structured)
+
+Four subsections. `### Antecedent strategies` and `### Consequence strategies` are always present; `### Replacement behavior` appears when deceleration targets are present; `### Crisis plan` appears when escalation level ≥ 3.
+
+```markdown
+## Programming Recommendations
+
+### Antecedent strategies
+- {specific, testable recommendation}
+- ...
+
+### Replacement behavior (FCT)
+- {teaching target, function-matched}
+- {reinforcement plan for replacement}
+
+### Consequence strategies
+- {how staff respond to target behavior}
+- {what is reinforced; what is placed on extinction}
+
+### Crisis plan
+- {safety procedures for escalation}
+```
+
+#### 4.3.5 Escalation Level
+
+```markdown
+## Escalation Level
+{1 | 2 | 3 | 4} — {short label}
+
+{1–2 sentence justification}
+```
+
+Labels: `1 — Continue monitoring`, `2 — Adjust next session`, `3 — Supervisor review`, `4 — Safety immediate`.
+
+#### 4.3.6 Confidence
+
+```markdown
+## Confidence
+{high | moderate | low}
+
+{1 sentence explaining the data-quality basis for the confidence level}
+```
+
+#### 4.3.7 Data-Supported Rationale
+
+Numeric grounding for all claims made above. Bulleted list of specific accuracy / frequency / duration / trend statistics drawn from the session log.
+
+### 4.4 Metadata fields (task 2)
+
+```json
+"meta": {
+  "task_type": "session_interpretation",
+  "example_id": "<sha256 prefix>",
+  "gold_labels": {
+    "pattern_class": "regression+frustration_pattern",
+    "behavior_functions": {
+      "Tantrum": "escape",
+      "Mouthing": "automatic"
+    },
+    "escalation_level": 3,
+    "confidence": "moderate",
+    "crisis_plan_required": true
+  },
+  "log_properties": {
+    "n_sessions": 10,
+    "n_acceleration_programs": 4,
+    "n_deceleration_targets": 2,
+    "has_abc_data": true,
+    "has_ioa_session": true,
+    "learner_profile": "adolescent",
+    "context_distribution": {"D": 0.3, "R": 0.7, "Both": 0.0}
+  },
+  "provenance": {
+    "layer": 1,
+    "template_id": "sess-regress-v1",
+    "pattern_seed": 20260423007,
+    "seed": 20260423007,
+    "generated_at": "2026-04-23T14:30:00Z"
+  }
+}
+```
+
+### 4.5 Complete task-2 example (abridged user content, full assistant output)
+
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "You are an expert ABA clinical assistant. You analyze multi-session behavioral session logs..."
+    },
+    {
+      "role": "user",
+      "content": "Interpret the following behavioral session log. Provide clinical concerns, pattern classification, behavior function hypothesis (if applicable), programming recommendations (antecedent / replacement / consequence / crisis), escalation level, confidence, and data-supported rationale.\n\nLEARNER PROFILE\nSynthetic ID: SYN-4721\nProfile: Adolescent Learner (16 yr)\nCurricula: AFLS Basic Living + AFLS Home Skills + VB-MAPP L3 (residual)\nPrimary context: Residential (R), partial Day (D)\nDate range: Sessions 1–10 across 14 days (2026-03-01 to 2026-03-14)\n\nACCELERATION PROGRAMS\n1. Self-Care: Washing Hands (AFLS Basic Living)\n   Method: Task Analysis, backward chaining, 8 steps\n   Context: Both\n2. Requesting with AAC (VB-MAPP Mand L3 adapted)\n   Method: NET\n   Context: Both\n3. Community Safety Signs (AFLS Community)\n   Method: DTT\n   Context: D\n4. Tolerating Denied Access (FCT replacement)\n   Method: FCT, replacement response = \"wait please\"\n   Context: Both\n\nDECELERATION TARGETS\n1. Tantrum — function hypothesized: escape\n2. Mouthing (non-pica) — function hypothesized: automatic\n\nSession 1 — 2026-03-01 (R) — 45 min — 1 observer\n  Washing Hands: 3/8 steps independent (38%); prompts FP×3, PP×2, G×1\n  AAC Requests: freq = 4 (rate 0.09/min); 2 independent, 2 prompted\n  Safety Signs: 6/10 correct (60%); latency 4.2s\n  Tolerating Denied Access: 2/3 trials successful\n  Tantrum: freq 1, duration 4m\n  Mouthing: freq 8; PIR 20%\n  ABC (tantrum): A = iPad removed at 2:15pm; B = screaming + drop-to-floor; C = staff redirected to preferred activity after 4 min\n\nSession 2 — 2026-03-02 (R) — 50 min — 1 observer\n  Washing Hands: 3/8 (38%); prompts FP×3, PP×2, G×1\n  Safety Signs: 5/10 (50%); latency 4.8s\n  Tantrum: freq 2, duration 7m\n  Mouthing: freq 12; PIR 28%\n\n[... Sessions 3–9 ...]\n\nSession 7 — IOA SESSION — 2 observers\n  Washing Hands IOA: 87% agreement\n  Tantrum IOA: 91% agreement\n  AAC Requests IOA: 95% agreement\n\nSession 10 — 2026-03-14 (R) — 45 min — 1 observer\n  Washing Hands: 2/8 (25%); prompts FP×5, PP×2, G×1\n  Safety Signs: 4/10 (40%); latency 6.1s\n  Tolerating: 0/3 success\n  Tantrum: freq 4, duration 12m\n  Mouthing: freq 15; PIR 35%\n  ABC (tantrum, occurrence 2): A = asked to finish worksheet; B = hit table + scream; C = task removed for 5 min, staff attention\n\nBEHAVIORAL OBSERVATIONS\n- Increasing response latency in Safety Signs\n- Increasing tantrum duration\n- Mouthing rate climbing\n- Worksheet and non-preferred tasks consistently precede tantrums"
+    },
+    {
+      "role": "assistant",
+      "content": "## Clinical Concerns\n- Regression pattern in Safety Signs and Washing Hands: accuracy has declined from 60->40% and 38->25% respectively across 10 sessions.\n- Tantrum frequency and duration are increasing, clustered around demand presentation.\n- Mouthing rate is increasing, consistent with automatic function but also temporally correlated with tantrum increases.\n\n## Pattern Classification\nregression + frustration_pattern\n\nConcurrent regression in previously-approaching skills alongside a frustration pattern characterized by escape-indicator behaviors (declining accuracy + increased tantrum duration + demand-triggered occurrences).\n\n## Behavior Function Hypothesis\nTantrum: escape\n  Evidence: both documented ABC events show demand antecedent (iPad removal, worksheet task) followed by task/demand removal or redirection. Tantrum duration increases concurrent with demand difficulty.\nMouthing: automatic\n  Evidence: persists across contexts, no clear social consequence, occurs during low-demand periods and throughout sessions.\n\n## Programming Recommendations\n\n### Antecedent strategies\n- Reduce worksheet task duration by 50% for next 3 sessions; introduce choice between two acceptable non-preferred tasks before any demand.\n- Pre-teach \"wait please\" response before predictable iPad-removal windows.\n- Schedule preferred activity access immediately before (not after) known demand windows to leverage MO.\n\n### Replacement behavior (FCT)\n- Strengthen FCT training for Tolerating Denied Access — current 2->1->0/3 rate across sessions suggests teaching is not yet effective. Consider 0-second time delay prompting and increased reinforcement magnitude for independent \"wait please.\"\n- Pair \"wait please\" with a brief, predictable delay (10–15s) followed by reinforcement access.\n\n### Consequence strategies\n- Do NOT remove demand contingent on tantrum (currently reinforcing escape function).\n- Provide brief (20s) break contingent on independent \"wait please\" or equivalent communication.\n- Place tantrum on escape extinction: continue presenting the task while ensuring learner and staff safety.\n\n### Crisis plan\n- If tantrum exceeds 10 minutes or escalates to property destruction or aggression, follow facility crisis protocol, document the incident, and notify supervising BCBA within 24 hours.\n\n## Escalation Level\n3 — Supervisor review\n\nRegression co-occurring with increasing problem behavior warrants BCBA review within 24–48 hours before implementing proposed FCT and extinction changes.\n\n## Confidence\nmoderate\n\nFunction hypothesis is well-supported by 2/2 documented ABC events, but single-observer sessions limit IOA coverage to one session out of 10. Recommend one additional IOA session before finalizing the intervention plan.\n\n## Data-Supported Rationale\n- Mean Safety Signs accuracy sessions 1–3: 58%; sessions 8–10: 42% (16 percentage point decrement, 27% relative decline).\n- Mean tantrum frequency sessions 1–3: 1.3/session; sessions 8–10: 3.3/session (2.5× increase). Mean duration 4 min -> 12 min.\n- 2/2 documented ABC events show demand antecedent -> tantrum behavior -> task removal consequence, consistent with escape-maintained hypothesis.\n- Mouthing PIR 20% -> 35% across the same period (75% relative increase).\n- IOA data (session 7) — 87–95% agreement — supports data reliability for tantrum and AAC measures; no IOA for Safety Signs or Mouthing."
+    }
+  ],
+  "meta": {
+    "task_type": "session_interpretation",
+    "example_id": "b5c9e2a14f8d7310",
+    "gold_labels": {
+      "pattern_class": "regression+frustration_pattern",
+      "behavior_functions": {
+        "Tantrum": "escape",
+        "Mouthing": "automatic"
+      },
+      "escalation_level": 3,
+      "confidence": "moderate",
+      "crisis_plan_required": true
+    },
+    "log_properties": {
+      "n_sessions": 10,
+      "n_acceleration_programs": 4,
+      "n_deceleration_targets": 2,
+      "has_abc_data": true,
+      "has_ioa_session": true,
+      "learner_profile": "adolescent",
+      "context_distribution": {"D": 0.2, "R": 0.8, "Both": 0.0}
+    },
+    "provenance": {
+      "layer": 1,
+      "template_id": "sess-regress-frust-v1",
+      "pattern_seed": 20260423007,
+      "seed": 20260423007,
+      "generated_at": "2026-04-23T14:30:00Z"
+    }
+  }
+}
+```
+
+---
+
+## 5. Validation and parsing
+
+### 5.1 Required fields
+
+For every example (both tasks):
+- `messages` present with exactly 3 entries: system, user, assistant (in that order)
+- `meta.task_type` in `{teaching_program, session_interpretation}`
+- `meta.example_id` present and non-empty
+- `meta.gold_labels` present with task-specific required keys
+- `meta.provenance.seed` present
+
+### 5.2 Label extraction regex (for evaluator)
+
+After model generation, labels are extracted from the assistant response using deterministic regex. If extraction fails, the example is scored as a parse failure (counts against the model).
+
+**Pattern classification (task 2):**
+```python
+r"##\s*Pattern\s*Classification\s*\n\s*([a-z_+]+)\s*\n"
+```
+
+**Escalation level (task 2):**
+```python
+r"##\s*Escalation\s*Level\s*\n\s*([1-4])\s*—"
+```
+
+**Confidence (task 2):**
+```python
+r"##\s*Confidence\s*\n\s*(high|moderate|low)\s*\n"
+```
+
+**Behavior function (task 2, per behavior):**
+```python
+r"^([A-Z][A-Za-z\s\-\(\)]+):\s*(escape|attention|tangible|automatic|unknown)\s*$"
+```
+
+**Method (task 1, validated against user input):**
+```python
+# No regex needed — method is sampled and stored in gold_labels; evaluator checks
+# whether the assistant output contains the method-specific sections (section 3.4)
+# corresponding to the expected method.
+```
+
+### 5.3 Schema validity checks (pre-training)
+
+`src/prepare_data.py` applies these before writing to splits:
+
+1. All 3 messages present with correct roles
+2. System prompt matches canonical form for the task
+3. Assistant response contains all required section headers for its task
+4. Structured-label sections are regex-extractable
+5. No placeholder strings (`{...}`, `TODO`, empty `Provide:` blocks) in assistant content
+6. User message contains no real-world identifying patterns (regex scan for name-like tokens)
+7. Total length under `max_seq_length` (4096 tokens for training)
+8. No duplicate `example_id` across the full dataset (SimHash + exact-match dedup)
+
+Examples failing any check are written to `data/processed/rejected.jsonl` with a `reason` field.
+
+---
+
+## 6. Extensibility
+
+### 6.1 Adding new session patterns
+
+1. Add entry to `taxonomy-v1.md` section 7 with citation.
+2. Add generator template in `src/prepare_data.py` with trajectory rules.
+3. Add label to regex enum in section 5.2.
+4. Add stratification target in split generator.
+5. Bump schema version.
+
+### 6.2 Adding new teaching methods
+
+1. Add entry to `taxonomy-v1.md` section 1.
+2. Add method-specific output variant to `schema-v1.md` section 3.4.
+3. Add generator template in `src/prepare_data.py`.
+4. Bump schema version.
+
+### 6.3 Versioning
+
+Schema versions follow `major.minor`:
+- **Minor** — additive changes (new pattern, new method, new optional field). Old data remains valid.
+- **Major** — breaking changes (renamed fields, removed sections, changed required structure). Old data requires migration or a new dataset version.
+
+Each generated example records the schema version it was generated under in `meta.provenance.schema_version`.
+
+---
+
+## 7. Changelog
+
+- **v1.0 (2026-04-23)** — initial schema. Two tasks defined. Task 1 covers 6 teaching methods (DTT, NET, Task Analysis, FCT, BST, PRT); Task 2 covers 12 session patterns with structured labels for pattern class, behavior function, escalation level, and confidence.

docs/taxonomy-v1.md

@@ -0,0 +1,608 @@
+# TRACE Dataset Taxonomy v1
+
+**Purpose.** This document is the **controlled vocabulary** for the TRACE synthetic dataset. Every category our data-generation pipeline can draw from is defined here, with an operational definition and a canonical citation. If a category is not in this document, the generator will not produce it — and if it is here, its clinical validity is defensible against a peer-reviewed source.
+
+**Who this serves.**
+- The data-generation pipeline (`src/prepare_data.py`) consumes this taxonomy as its source of truth.
+- The dataset paper's composition table is a direct rendering of this document.
+- Reviewers verifying "no invented clinical categories" can trace each entry -> citation -> CHH chapter / JABA paper / curriculum manual.
+
+**Status.** Version 1, 2026-04-22. Breaking changes require a bumped version and a changelog entry.
+
+**Citation conventions.** Throughout this document:
+- **CHH** = Cooper, Heron, & Heward (2020). *Applied Behavior Analysis* (3rd ed.). Pearson.
+- **JABA** = *Journal of Applied Behavior Analysis*
+- **BAP** = *Behavior Analysis in Practice*
+- DOIs link to the authoritative source wherever possible.
+
+---
+
+## 0.A Program orientation — Acceleration vs Deceleration
+
+Every ABA goal falls into one of two program orientations, a distinction that runs through virtually all clinical data systems:
+
+| Orientation | Purpose | Covers |
+|---|---|---|
+| **Acceleration** | Behaviors / skills to **increase** | Skill-acquisition programs (VB-MAPP, AFLS targets); adaptive behaviors (toileting, communication including AAC); FCT-trained replacement behaviors; independent coping with denied access |
+| **Deceleration** | Behaviors to **decrease** | Target problem behaviors (section 5): SIB, aggression, elopement, tantrum, stereotypy, pica, etc. |
+
+**Citation.** Standard ABA terminology; see CHH Ch. 22 ("Differential Reinforcement" — acceleration via reinforcement of desired behavior) and Ch. 24 ("Extinction") together with Ch. 25 ("Antecedent Interventions") for deceleration.
+
+**Dataset usage.**
+- section 1 teaching methods DTT, NET, Task Analysis, PRT, Incidental Teaching apply to **acceleration** programs.
+- section 1.4 FCT is the acceleration method paired with deceleration — it teaches a replacement behavior while reducing a target behavior.
+- section 1.5 BST is meta-level (trains staff on any program).
+- Task 2 session logs sample across both orientations per session — several acceleration targets and zero or more deceleration behaviors. Exact counts are pipeline hyperparameters.
+
+---
+
+## 0.B How taxonomy dimensions combine
+
+Each **teaching program generation** example is produced by sampling one value from each of these dimensions:
+
+| Dimension | # values | Section |
+|---|---|---|
+| Teaching method | 6 (optionally 8 if video modeling + script fading approved) | section 1 |
+| Skill domain | 16 (VB-MAPP) + 6 (AFLS) = 22 | section 2 |
+| Developmental level | 5 (3 VB-MAPP + 2 AFLS) | section 2 |
+| Skill target | ~250 | section 2 |
+| Mastery state | 7 | section 3 |
+| Prompt hierarchy | 6 | section 8 |
+| Reinforcement schedule | 7 | section 9 |
+| Error correction | 5 | section 10 |
+| Mastery criteria | 7 | section 11 |
+
+Each **behavioral session interpretation** example is produced by sampling:
+
+| Dimension | # values | Section |
+|---|---|---|
+| Session pattern | 12 | section 7 |
+| Primary skills observed | 3–8 per session | section 2 |
+| Target behaviors observed (if any) | 0–3 per session | section 5 |
+| Measurement types used | 2–5 per session | section 6 |
+| Behavior function hypothesis | 4 + "not applicable" | section 4 |
+| Escalation level | 4 | section 12 |
+| Confidence level | 3 | section 13 |
+| BIP component structure | 4 | section 11 |
+
+---
+
+## 1. Teaching methods
+
+The first task (Teaching Program Generation) produces content modality-aware. A "mand" goal is not automatically a DTT program — real clinical practice picks the method that fits the skill and learner. The model must reason about method selection.
+
+### 1.1 Discrete Trial Training (DTT)
+- **Operational definition.** A structured teaching format consisting of clearly defined trial units: *discriminative stimulus (SD) -> learner response -> consequence (reinforcement or correction) -> inter-trial interval (ITI)*. Trials are massed in a contrived setting (usually table-based), with explicit prompt hierarchy and error-correction procedure.
+- **When to use.** Acquisition of discrete, decontextualized skills (receptive labels, tacts, matching, early imitation) especially early in instruction when stimulus control must be established.
+- **Canonical citation.** Lovaas, O. I. (1987). *JCCP, 55*(1), 3–9. https://doi.org/10.1037/0022-006X.55.1.3 — seminal EIBI trial establishing DTT-based programming. Modern definition: Smith, T. (2001). *Focus on Autism, 16*(2), 86–92.
+- **Dataset usage.** Default teaching method for early-learner (VB-MAPP Level 1–2) discrete skills. Output includes explicit SD, prompt hierarchy, stimulus array, error-correction, mastery criteria.
+
+### 1.2 Natural Environment Teaching (NET)
+- **Operational definition.** Teaching that occurs within the learner's natural context, capitalizing on child-initiated motivation and ongoing activities. The teaching opportunity is embedded in the environment, not contrived.
+- **When to use.** Generalization phase, functional communication, requesting (mand) skills, when motivation is the limiting factor, or when the skill's natural occasion is ecologically predictable (e.g., requesting food during snack time).
+- **Canonical citation.** Hart, B. & Risley, T. R. (1975). *JABA, 8*(4), 411–420. https://doi.org/10.1901/jaba.1975.8-411 (origin of incidental teaching). Autism extension: McGee, G. G., Krantz, P. J., & McClannahan, L. E. (1985). *JABA, 18*(1), 17–31.
+- **Dataset usage.** Default teaching method for mand targets and generalization-phase goals. Output emphasizes environmental setup / MO arrangement over contrived SD.
+
+### 1.3 Task Analysis / Chaining
+- **Operational definition.** Decomposition of a complex behavior into sequential component steps, followed by teaching each step and chaining them together. Three chain types:
+  - **Forward chaining** — teach step 1 to mastery, then 1->2, then 1->2->3, etc.
+  - **Backward chaining** — complete all steps except the last; teach last; move backward.
+  - **Total-task presentation** — prompt through entire chain every trial; fade prompts across all steps.
+- **When to use.** Multi-step skills with a natural sequence: toileting, handwashing, dressing, cooking, social routines.
+- **Canonical citation.** CHH Ch. 23 ("Chaining"). Empirical comparison: Slocum, S. K. & Tiger, J. H. (2011). *JABA, 44*(4), 793–805. https://doi.org/10.1901/jaba.2011.44-793
+- **Dataset usage.** Default for self-care (AFLS Basic Living), domestic, community, and vocational domains. Output structure replaces "SD" with "task analysis steps" (numbered list) + chain type + prompt strategy per step.
+
+### 1.4 Functional Communication Training (FCT)
+- **Operational definition.** Procedure for teaching a communication response that serves the *same function* as a target problem behavior, paired with extinction of the problem behavior. Example: a child who tantrums to escape demands is taught to say/sign "break please," which is reinforced; the tantrum is placed on extinction.
+- **When to use.** Any target behavior with a clear social function (escape, attention, tangible). First-line strategy before consequence-based interventions.
+- **Canonical citation.** Carr, E. G. & Durand, V. M. (1985). *JABA, 18*(2), 111–126. https://doi.org/10.1901/jaba.1985.18-111 (seminal). Modern practical review: Tiger, J. H., Hanley, G. P., & Bruzek, J. (2008). *BAP, 1*(1), 16–23.
+- **Dataset usage.** Default teaching method in behavior-intervention-adjacent recommendations (task 2 interpretation output when behavior data is present). Output ties communication response -> hypothesized function -> reinforcement schedule.
+
+### 1.5 Behavior Skills Training (BST)
+- **Operational definition.** Staff/caregiver training procedure with four components in sequence: **(1) Instruction**, **(2) Modeling**, **(3) Rehearsal**, **(4) Feedback**, iterated until the trainee meets mastery criteria on a performance checklist.
+- **When to use.** Training RBTs on a new program, training caregivers on a home procedure, preparing staff for a BIP rollout.
+- **Canonical citation.** Parsons, M. B., Rollyson, J. H., & Reid, D. H. (2012). *BAP, 5*(2), 2–11. https://doi.org/10.1007/BF03391819
+- **Dataset usage.** Used in a minority of task 1 outputs when the target is a staff-facing training program (rather than a learner-facing teaching program). Output structure emphasizes trainer steps and fidelity checklist.
+
+### 1.6 Pivotal Response Training (PRT)
+- **Operational definition.** Naturalistic teaching targeting "pivotal" behaviors that produce widespread collateral gains: **motivation**, **self-initiation**, **responsivity to multiple cues**, **self-management**. Uses child choice, interspersal of mastered/acquisition targets, natural reinforcers, and reinforcement of attempts (not just correct responses).
+- **When to use.** Language acquisition in autism, social initiation, generalization across contexts.
+- **Canonical citation.** Koegel, R. L., O'Dell, M. C., & Koegel, L. K. (1987). *JADD, 17*(2), 187–200. https://doi.org/10.1007/BF01495055 (origin of NLP -> PRT). JABA-indexed: Laski, K. E., Charlop, M. H., & Schreibman, L. (1988). *JABA, 21*(4), 391–400.
+- **Dataset usage.** Used for a minority of early-language targets in naturalistic conditions. Output emphasizes motivation arrangement, child-choice, attempt-reinforcement.
+
+### Method-selection heuristics (encoded as prompt guidance, not hard rules)
+
+| Skill context | Default method | Alternative |
+|---|---|---|
+| Early discrete skills (tacts, receptive labels, matching) | DTT | PRT (if motivation is limiting) |
+| Mand / requesting | NET | FCT (if replacing problem behavior) |
+| Multi-step routines (dressing, handwashing) | Task Analysis | — |
+| Problem-behavior reduction | FCT | — |
+| Generalization phase | NET | PRT |
+| Staff-facing training | BST | — |
+| Social-initiation skills | PRT | NET |
+
+---
+
+## 2. Skill curriculum (Acceleration targets)
+
+All skill domains in this section are **acceleration** targets — goals we want the learner to perform MORE often / more independently. See section 0.A.
+
+Two overlapping curricula are encoded: **VB-MAPP** (early learners, 0–48 months developmental age) and **AFLS** (adolescents / adults and functional living). Together they cover the full learner age span TRACE should handle.
+
+### 2.1 VB-MAPP (Verbal Behavior Milestones Assessment and Placement Program)
+
+**Primary citation.** Sundberg, M. L. (2008). *Verbal Behavior Milestones Assessment and Placement Program*. AVB Press. Validation study: Barnes, C. S., Mellor, J. R., & Rehfeldt, R. A. (2014). *Analysis of Verbal Behavior, 30*(1), 36–47. https://doi.org/10.1007/s40616-013-0004-5
+
+**Developmental levels:**
+- **Level 1** — 0–18 months typical developmental age
+- **Level 2** — 18–30 months
+- **Level 3** — 30–48 months
+
+**16 skill domains**, each expanded to 5 representative targets per developmental level (Sundberg 2008):
+
+**1. Mand** — requesting.
+- L1: single-word mands for preferred items; mands for missing items needed to complete an activity; mands for actions; mands for help; mands using 2-word phrases.
+- L2: mands for information using "what"; mands for information using "where"; mands using adjectives (big, little, more); mands for attention from peers; mands for others to stop an action.
+- L3: mands for information using "why"; mands for information using "when"; mands using complete sentences with correct grammar; mands for future events or items not present; mands using polite social conventions.
+
+**2. Tact** — labeling / naming.
+- L1: common objects (ball, cup, shoe); familiar people by name; common actions (running, eating, sleeping); body parts (nose, eyes, mouth); common animals (dog, cat, bird).
+- L2: colors of objects; shapes (circle, square, triangle); adjectives (big/little, hot/cold); prepositions (in, on, under); emotions in self and others.
+- L3: community helpers and their roles; categories (fruits, vehicles, clothing); features of objects (color, shape, function); past-tense events; abstract concepts (same/different, first/last).
+
+**3. Echoic** — vocal imitation.
+- L1: single vowel sounds; single consonant-vowel combinations; 1–2 syllable words; animal sounds; familiar words on request.
+- L2: 2-word phrases; 3-word phrases; blended consonants; novel words with correct articulation; short sentences.
+- L3: multi-syllable words accurately; full sentences with correct prosody; unfamiliar words from context; phrases with correct intonation patterns; complex instructions verbatim.
+
+**4. Listener Responding** — receptive language.
+- L1: 1-step motor instructions (sit down, stand up); select correct item from an array of 2; point to named body parts; point to named common objects; follow instructions involving objects.
+- L2: select correct item from an array of 4–6; follow 2-step instructions; select items by feature (find something red); select items by function (find something you eat with); select items by class (find an animal).
+- L3: follow multi-step instructions with qualifiers; select items by multiple features simultaneously; follow conditional instructions (if X, then Y); respond to questions about stories read aloud; follow instructions involving temporal concepts (before, after).
+
+**5. Visual Perceptual Skills & Matching-to-Sample (VP-MTS).**
+- L1: match identical objects; match identical pictures; match colors (identical chips); match shapes (identical blocks); complete simple 3–4 piece puzzles.
+- L2: match non-identical items by category; sort items into 2–3 categories; match quantities (1–5); match upper-case letters; complete 8–12 piece puzzles.
+- L3: match associated items (sock-shoe, cup-plate); sort by multiple attributes simultaneously; match upper to lower case letters; sequence 3–4 step picture sequences; reproduce block designs from model.
+
+**6. Motor Imitation.**
+- L1: gross motor actions (clap hands, stomp feet); actions with objects (bang drum, push car); 2-step motor sequences; fine motor actions (pinch, point); facial movements (open mouth, stick out tongue).
+- L2: 3-step motor sequences; novel motor actions on first attempt; actions in songs and finger plays; actions involving bilateral coordination; motor actions after a delay.
+- L3: complex multi-step sequences; motor actions from video models; handwriting strokes and letter forms; craft and art activities; sports-related motor sequences.
+
+**7. Independent Play.**
+- L1: cause-and-effect toys independently; sensory toys for sustained periods; construction toys (blocks, Duplo); vehicles (pushing, rolling); electronic learning toys.
+- L2: simple pretend play sequences; art materials (coloring, playdough); age-appropriate puzzles independently; books independently; simple board or card games.
+- L3: elaborate pretend play with storylines; creative construction activities; rule-based games independently; independently select and transition between activities; hobby / special-interest activities productively.
+
+**8. Social Behavior & Social Play.**
+- L1: eye contact during interactions; responds to own name; social games (peek-a-boo, tickle); shows items to others spontaneously; tolerates proximity of peers during parallel play.
+- L2: initiates social interactions with peers; takes turns during structured activities; shares materials when prompted; cooperative play with one peer; responds to peer initiations appropriately.
+- L3: maintains reciprocal conversations with peers; demonstrates empathy and perspective-taking; negotiates and compromises during group activities; joins ongoing peer activities appropriately; maintains friendships over time.
+
+**9. Intraverbal** — fill-ins, WH answers without visual prompt.
+- L1: fills in words in songs and nursery rhymes; answers "what's your name"; fills in missing words in familiar phrases; answers simple what-questions about visible items; completes verbal routines (ready, set, ___).
+- L2: answers WH-questions about familiar topics; describes function of common objects; names items in categories when given the category; answers social questions (How are you?); describes recent events in sequence.
+- L3: answers why- and how-questions; provides definitions of words; answers hypothetical questions; engages in multi-turn conversations on a topic; makes inferences from given information.
+
+**10. LRFFC** — Listener Responding by Feature, Function, Class.
+- L1: select items by function (What do you drink from?); select items by feature (What is round?); select items by class (Find the animal); select by single function from array of 3; select by single visible feature from array of 3.
+- L2: select items by function from array of 5–8; select items by feature from array of 5–8; select items by class from array of 5–8; select items by multiple features (round and red); select items by function when item not visible.
+- L3: select items given 2+ features/functions simultaneously; select items by class with exclusion (animal but not a pet); select items by abstract features (something needed when cold); select items by comparison (which is heavier); select items by negative features (not round, not food).
+
+**11. Reading.**
+- L1: match letters to identical letters; identify own name in print; identify 5–10 upper-case letters; match words to identical words; track print left to right.
+- L2: identify all upper-case letters; identify all lower-case letters; read 10–20 sight words; sound out CVC words (cat, dog, run); read simple 2–3 word phrases.
+- L3: read sentences with comprehension; read short passages and answer questions; phonetic decoding for novel words; read and follow written instructions; read grade-level text with fluency.
+
+**12. Writing.**
+- L1: trace horizontal and vertical lines; trace basic shapes (circle, cross); copy basic shapes from model; trace letters of own name; write own name from model.
+- L2: write own name independently; copy all upper-case letters from model; write upper-case letters from dictation; copy simple words from model; write numbers 1–10.
+- L3: write words from dictation; write simple sentences with spacing; write answers to questions; write short compositions (3–5 sentences); use basic punctuation and capitalization.
+
+**13. Math.**
+- L1: rote count to 10; count objects 1–5 with 1:1 correspondence; identify numerals 1–5; match quantities to numerals 1–5; identify basic shapes in math context.
+- L2: count objects 1–20 with 1:1 correspondence; identify numerals 1–20; compare quantities (more/less/same); solve single-digit addition with manipulatives; identify coins by name.
+- L3: add single-digit numbers without manipulatives; subtract single-digit numbers; identify place value (ones, tens); tell time to the hour and half-hour; solve simple word problems.
+
+**14. Group & Classroom Skills.**
+- L1: sits in designated area for 2–3 minutes; attends to teacher during group instruction; follows group instructions (everyone stand up); transitions between activities with prompts; waits in line briefly.
+- L2: sits in group for 10–15 minutes; raises hand to request or respond; follows classroom routines independently; works independently at desk for 5–10 minutes; transitions between activities independently.
+- L3: participates in group discussions; follows multi-step classroom instructions; works independently for 15+ minutes; self-monitors behavior using checklist; completes and turns in assignments independently.
+
+**15. Linguistic Structure** — grammar.
+- L1: single words to communicate; combines 2 words (agent + action or action + object); basic noun-verb combinations; simple negation (no, not); basic pronouns (I, me, my).
+- L2: 3–4 word sentences; regular plurals (-s); present progressive (-ing); prepositions in sentences; regular past tense (-ed).
+- L3: complex sentences with conjunctions; irregular past tense correctly; pronouns with correct referents; questions with correct word order; passive voice and embedded clauses.
+
+**16. Spontaneous Vocal Behavior.**
+- L1: spontaneous vocalizations during preferred activities; spontaneous naming of items; spontaneous requests without prompts; spontaneous greetings to familiar people; spontaneous comments on events.
+- L2: spontaneous descriptions of ongoing activities; spontaneous questions about the environment; spontaneous reporting of past events; spontaneous use of social phrases; spontaneous initiation of conversation with peers.
+- L3: spontaneous storytelling / narratives; spontaneous relevant comments in conversations; spontaneous adjustment of language to different listeners; spontaneous use of humor appropriately; spontaneous provision of explanations and reasons.
+
+### 2.2 AFLS (Assessment of Functional Living Skills)
+
+**Primary citation.** Partington, J. W., & Mueller, M. M. (2012). *Assessment of Functional Living Skills*. Behavior Analysts, Inc. / Stimulus Publications.
+
+**Developmental scope.** Late-childhood through adult; skills are functional rather than milestone-bound.
+
+**6 skill modules** (we encode a representative subset of each):
+
+1. **Basic Living Skills** — toileting, eating, dressing, hygiene, bathing (chaining-intensive).
+2. **Home Skills** — meal preparation, cleaning, laundry, bed-making.
+3. **Community Participation Skills** — safety signs, money handling, transportation, shopping, restaurants.
+4. **School Skills** — classroom routines, assignments, social-academic interaction.
+5. **Vocational Skills** — task completion, workplace etiquette, punctuality.
+6. **Independent Living Skills** — budgeting, appointments, medication, self-advocacy.
+
+**Dataset usage.** AFLS targets appear in task 1 examples for older learners (labeled "Adolescent" or "Adult" learner profile) and in task 2 session logs for those learner profiles. Teaching method defaults to **Task Analysis / Chaining**.
+
+### 2.3 Learner-profile age bands
+
+| Profile label | Age band | Curricula |
+|---|---|---|
+| Early Learner | developmental age 0–48 mo | VB-MAPP |
+| School-Age Learner | 6–12 yr chronological, varying developmental | VB-MAPP L2–3 + AFLS School |
+| Adolescent Learner | 13–17 yr chronological, moderate-severe support needs | AFLS + VB-MAPP L3 for residual gaps |
+| Adult Learner | 18+ yr in residential / day program | AFLS + Community + Vocational |
+
+**Dataset usage.** Learner-profile label is a sampling dimension.
+
+**On distribution.** No research source prescribes an ABA-population age-band distribution. The pipeline config sets a balanced default across the four profiles (rather than skewing toward any band) so the model trains on the full lifespan. Real-world caseload distributions vary by facility type (early-intervention centers skew Early; residential programs skew Adult). The exact ratio is a *pipeline hyperparameter*, not a clinical truth.
+
+### 2.4 Gaps explicitly not covered in v1
+
+- **Essential for Living** (McGreevy, Fry, & Cornwall 2014) — skills for adults with severe support needs. Partially covered by AFLS; full EFL integration is not included in v1.
+- **ABLLS-R** (Partington 2010) — heavily overlaps VB-MAPP for early learners; not separately encoded.
+- **PEAK** (Dixon 2014+) — relational frame / advanced cognition; out of scope for baseline dataset.
+
+---
+
+## 3. Mastery states
+
+Seven-state taxonomy describing where a skill is in its learning trajectory. Values are slot values in task 1 user prompts and targets in task 2 interpretation.
+
+| State | Operational criterion | Clinical meaning |
+|---|---|---|
+| **Emerging** | < 30% accuracy across recent sessions | Skill not yet acquired; high prompt levels needed |
+| **Developing** | 30–50% accuracy, inconsistent | Responding established; stimulus control unstable |
+| **Approaching mastery** | 50–70% accuracy, prompt fading in progress | Moving toward independence |
+| **Near mastery** | 70–85% accuracy, occasional errors | Stimulus control solid, complex stimuli still variable |
+| **Mastered (current level)** | ≥ 85% accuracy across 3 consecutive sessions | Meets mastery criterion for current step |
+| **Generalization phase** | Mastered in training but not in novel settings / with novel materials / across therapists | Ready for NET-style generalization probes |
+| **Maintenance** | Previously mastered; periodic probes to check retention | Maintenance schedule (weekly->monthly) |
+
+**Citation.** Mastery-criterion conventions follow CHH Ch. 26 ("Generalization and Maintenance of Behavior Change") and the programmatic mastery-criteria convention in CHH Ch. 28.
+
+**Dataset usage.** Mastery state is a primary slot in every task 1 prompt. In task 2, the narrative "a previously mastered skill has regressed" vs "a developing skill has plateaued" is the basis for pattern detection (section 7).
+
+---
+
+## 4. Behavior functions
+
+The **four-function taxonomy** of problem behavior is the spine of all behavior reasoning in ABA. Iwata's original functional analysis identified three (attention, escape, sensory); Hanley, Iwata & McCord formalized the fourth (tangible) as standard.
+
+| Function | Reinforcer | Example context | Hypothesis test |
+|---|---|---|---|
+| **Escape** (negative reinforcement) | Termination / avoidance of an aversive stimulus (demand, task, interaction) | Child hits when presented with math worksheet -> demand is removed | Elevated rate in demand condition vs control |
+| **Attention** (positive reinforcement, social) | Attention from others (adult or peer) | Child yells when parent on phone -> parent attends | Elevated rate in attention condition vs control |
+| **Tangible** (positive reinforcement, material) | Access to an item or activity | Child tantrums when iPad is taken away -> iPad is returned | Elevated rate when preferred item is restricted |
+| **Automatic** (non-social / sensory) | Self-produced reinforcement (proprioceptive, auditory, visual, gustatory) | Repetitive hand-flapping persists during alone condition | Elevated rate in alone condition; persists across conditions |
+
+**Canonical citations.**
+- Iwata, B. A., Dorsey, M. F., Slifer, K. J., Bauman, K. E., & Richman, G. S. (1982/1994). *JABA, 27*(2), 197–209. https://doi.org/10.1901/jaba.1994.27-197 — THE foundational functional-analysis paper.
+- Hanley, G. P., Iwata, B. A., & McCord, B. E. (2003). *JABA, 36*(2), 147–185. https://doi.org/10.1901/jaba.2003.36-147 — definitive review; formalizes four-function taxonomy including tangible.
+- Pre-FA conceptual roots: Carr, E. G. (1977). *Psychological Bulletin, 84*(4), 800–816.
+- CHH Ch. 27 ("Functional Behavior Assessment").
+
+**Clinical principle.** Same topography can serve different functions across individuals. A "tantrum" in one client may be escape-maintained; in another, attention-maintained. **Interventions must match function**, not topography.
+
+**Dataset usage.**
+- Task 2 interpretation output includes **Function Hypothesis** field when behavior data is present — one of the four functions or "Not Applicable" (skill-only sessions).
+- When present, the hypothesis cites the evidence in the session log (e.g., "elevated rate during demand presentation -> escape-maintained").
+
+---
+
+## 5. Target behaviors — Deceleration targets (with operational definitions)
+
+All behaviors in this section are **deceleration** targets — behaviors we want to reduce. See section 0.A.
+
+Eighteen challenging behaviors with JABA-grounded operational definitions suitable for staff scoring. Behaviors without a canonical operational definition in the literature (e.g., disrobing, grabbing/snatching) are deliberately excluded from v1 rather than invented.
+
+| # | Behavior | Operational definition | Citation |
+|---|---|---|---|
+| 1 | **Self-injurious behavior (SIB)** | Any response that produces tissue damage or has the potential to produce it, including head-hitting, self-biting, face-slapping, head-banging against objects, skin-picking, self-pinching, hair-pulling directed at self. | Iwata et al. 1982/1994 |
+| 2 | **Head-directed SIB** (subtype) | Contact between the individual's hand and head, OR between the head and a stationary object, with audible impact. | Iwata et al. 1982/1994 |
+| 3 | **Aggression** | Attempted or completed forceful contact directed toward another person: hitting, kicking, biting, hair-pulling, scratching, pinching, or throwing objects AT another person. | Marcus, B. A. et al. (2001). *Behavior Modification, 25*(2), 189–213. https://doi.org/10.1177/0145445501252002 |
+| 4 | **Property destruction** | Hitting or kicking furniture/walls; throwing objects not intended to be thrown; tearing clothing, books, or materials; swiping items off surfaces; overturning furniture. | Piazza, C. C., Bowman, L. G., Contrucci, S. A., et al. (1999). *JABA, 32*(4), 437–449. https://doi.org/10.1901/jaba.1999.32-437 |
+| 5 | **Elopement** | Full body (or pre-specified anatomical threshold) crossing a designated boundary (e.g., classroom door, yard fence) without adult approval. | Kodak, T., Grow, L., & Northup, J. (2004). *JABA, 37*(2), 229–232. https://doi.org/10.1901/jaba.2004.37-229; Lang, R. et al. (2010). *JABA, 43*(1), 113–118. |
+| 6 | **Pica** | Placement of any inedible (non-food) item past the plane of the lips, including mouthing and ingestion of objects (paper, dirt, cigarette butts, fabric, small toys, hair). | Piazza, C. C., Fisher, W. W., Hanley, G. P., et al. (1998). *JABA, 31*(2), 165–189. https://doi.org/10.1901/jaba.1998.31-165 |
+| 7 | **Motor stereotypy** | Repetitive, non-functional motor movements (hand-flapping, body-rocking, finger-flicking, spinning) occurring independent of social context and serving no apparent instrumental purpose. | Rapp, J. T. & Vollmer, T. R. (2005). *RIDD, 26*(6), 527–547. https://doi.org/10.1016/j.ridd.2004.11.005 |
+| 8 | **Vocal stereotypy** | Non-contextual, non-communicative vocalization: repetitive sounds, words, phrases, humming, or echolalia outside appropriate conversational context. | Ahearn, W. H., Clark, K. M., MacDonald, R. P. F., & Chung, B. I. (2007). *JABA, 40*(2), 263–275. https://doi.org/10.1901/jaba.2007.30-06 |
+| 9 | **Tantrum** | Co-occurring cluster of two or more of: crying/screaming, dropping to floor, kicking, hitting, throwing objects, lasting ≥ 3 s. Scored from onset of first component topography to 5 s without any component behavior. | Kurtz, P. F. et al. (2003). *JABA, 36*(2), 205–219. https://doi.org/10.1901/jaba.2003.36-205; topography adapted from Carr & Durand 1985. |
+| 10 | **Non-compliance** | Failure to initiate a requested response within 5 s of an instructional prompt (vocal, model, or physical), OR active refusal (verbal "no," walking away). | Wilder, D. A. et al. (2012). *JABA, 45*(1), 121–126. https://doi.org/10.1901/jaba.2012.45-121 |
+| 11 | **Mouthing (non-pica)** | Placement of the hand, fingers, saliva, or non-food object into the mouth past the lip plane, excluding eating/drinking during scheduled meals. | Piazza, C. C., Hanley, G. P., & Fisher, W. W. (1996). *JABA, 29*(4), 437–449. https://doi.org/10.1901/jaba.1996.29-437 |
+| 12 | **Throwing** | Propelling an object through the air with force (excluding task-relevant throwing such as during a game). | Property destruction literature, specifically Piazza et al. 1999 — throwing is often coded as a subtype. |
+| 13 | **Food refusal / selectivity** | Rejection of presented food by turning the head, closing the mouth, batting the utensil away, or expelling food once placed in the mouth. | Piazza, C. C. et al. (2003). *JABA, 36*(2), 187–204 — feeding-disorder literature. |
+| 14 | **Rumination / regurgitation** | Voluntary regurgitation of previously ingested food into the mouth, followed by re-chewing, re-swallowing, or expulsion. Scored per regurgitation episode. | Lyons, E. A., Rue, H. C., Luiselli, J. K., & DiGennaro, F. D. (2007). *JABA, 40*(4), 743–747. https://doi.org/10.1901/jaba.2007.743-747. See also Kahng et al. 2003. |
+| 15 | **Sleep resistance / disruption** | Non-compliance with bedtime routine (refusing to go to bed, leaving bed, repeated requests) OR night waking ≥ 5 min at a time. Scored as instances or total disrupted minutes per night. | Friman, P. C., Hoff, K. E., Schnoes, C., Freeman, K. A., Woods, D. W., & Blum, N. (1999). *JABA, 32*(4), 505–508. https://doi.org/10.1901/jaba.1999.32-505 |
+| 16 | **Verbal aggression / threats** | Yelling, cursing, name-calling, or making verbal threats directed toward another person (e.g., "I'll hit you," "I hate you"). | Kelley, M. E., Lerman, D. C., & Van Camp, C. M. (2002). *JABA, 35*(1), 59–63. See also Hagopian & Boelter 2005. |
+| 17 | **Food stealing** | Taking food items not offered to the individual — from another person's plate, a storage area, or during restricted-access periods — and/or placing such items in the mouth outside designated meal/snack times. | Maglieri, K. A., DeLeon, I. G., Rodriguez-Catter, V., & Sevin, B. M. (2000). Adjunctive delivery of noncontingent reinforcement to treat food stealing during sessions of DRO. *JABA, 33*(4), 615–618. https://doi.org/10.1901/jaba.2000.33-615 |
+| 18 | **Inappropriate sexual behavior (ISB)** | Engagement in sexual self-stimulation (genital contact, rhythmic self-stimulatory movements) in public or semi-public contexts where such behavior is socially or institutionally inappropriate. Scored per episode with onset/offset criteria specified in the program. | Davis, T. N., Machalicek, W., Scalzo, R., Kobylecky, A., Campbell, V., Pinkelman, S., Chan, J., & Sigafoos, J. (2016). A review and treatment selection model for individuals with developmental disabilities who engage in inappropriate sexual behavior. *BAP, 9*(4), 389–402. https://doi.org/10.1007/s40617-016-0149-5. See also Fyffe, C. E., Kahng, S., Fittro, E., & Russell, D. (2004). *JABA, 37*(3), 401–404. |
+
+**Dataset usage.**
+- Task 2 session logs include 0–3 target behaviors per log. Sampling weight biased toward the common behaviors (tantrum, non-compliance, aggression, stereotypy, elopement).
+- Each target behavior in a log has an associated function hypothesis (section 4) that drives the interpretation output.
+
+---
+
+## 6. Measurement types
+
+Real session logs mix measurement types; task 2 inputs must reflect this heterogeneity.
+
+| Type | Operational definition | Use case | Citation |
+|---|---|---|---|
+| **Frequency** (event recording) | Raw count of occurrences of a discrete, quickly-completing behavior during a session. "12 requests this session." | Discrete, countable behaviors with clear onset/offset. | CHH Ch. 4 |
+| **Rate** | Frequency normalized to time: count ÷ session duration. "0.4 requests per minute." | Compare sessions of different durations. | CHH Ch. 4 |
+| **Duration** | Total elapsed time a behavior lasts (sum across instances). "Tantrum total duration: 8 min." | Behaviors with meaningful length (tantrums, on-task engagement, stereotypy). | CHH Ch. 4 |
+| **Latency** | Time from SD to initiation of response. "Mean latency: 3.2 s." | Responsivity / prompt dependency. | CHH Ch. 4 |
+| **Partial-interval recording (PIR)** | Divide session into intervals (e.g., 10 s); mark each interval if behavior occurred *at any point*. Overestimates prevalence. | Hard-to-count behaviors (stereotypy). | Powell, Martindale & Kulp 1975; Harrop & Daniels 1986 |
+| **Whole-interval recording** | Mark interval only if behavior occurred for the *entire* interval. Underestimates. | Behaviors to increase (on-task engagement). | Cooper et al. Ch. 4 |
+| **Momentary time sampling (MTS)** | Check once at the end of each interval whether behavior is occurring. Efficient for groups. Approximates duration. | Multi-client settings; duration estimation. | Powell et al. 1975 |
+
+**Inter-Observer Agreement (IOA).** Two observers independently record the same session; agreement expressed as percent or κ. **Minimum acceptable: ≥ 80%** across 33% of sessions for scientific validity.
+- Citation: CHH Ch. 5 ("Improving and Assessing the Quality of Behavioral Measurement"); Kazdin, A. E. (1977). *JABA, 10*(1), 141–150. https://doi.org/10.1901/jaba.1977.10-141
+
+**Dataset usage.**
+- Every task 2 session log includes at least one **Primary Measurement Type** per target skill or behavior.
+- ~25% of logs include an **IOA subset** (percentage agreement reported) to test the model's ability to interpret reliability.
+- Accuracy % (trial-based correct/total) is the dominant measurement for skill-acquisition programs — this stays.
+
+### 6.1 Antecedent-Behavior-Consequence (ABC) data
+
+ABC recording supplements behavior frequency counts with the immediate environmental context around each occurrence. A subset of task 2 session logs (~30%) include ABC entries for target behaviors, enabling function-hypothesis reasoning beyond what frequency data alone supports.
+
+- **Antecedent** — what was happening immediately before (≤ 10 s) the behavior occurred.
+- **Behavior** — the target behavior as operationally defined (section 5).
+- **Consequence** — what happened immediately after (≤ 10 s), including any staff response.
+
+**Citation.** Bijou, S. W., Peterson, R. F., & Ault, M. H. (1968). A method to integrate descriptive and experimental field studies at the level of data and empirical concepts. *JABA, 1*(2), 175–191. https://doi.org/10.1901/jaba.1968.1-175. See also CHH Ch. 27 ("Functional Behavior Assessment").
+
+The remaining ~70% of logs include frequency-only behavior data, giving the model exposure to both enriched and minimal log formats.
+
+### 6.2 Program execution context
+
+Each acceleration and deceleration program is associated with one or more settings in which it runs:
+
+| Context tag | Setting |
+|---|---|
+| D | Day (school or day habilitation) |
+| R | Residential (home, group home, dormitory) |
+| Both | Runs across settings |
+
+**Dataset usage.** Each synthetic task 1 program and task 2 session log carries a context tag. Default sampling ~40% D, ~30% R, ~30% Both. No research source prescribes exact proportions; this is a pipeline hyperparameter.
+
+---
+
+## 7. Session patterns (for Task 2)
+
+Behavioral session interpretation requires recognizing **patterns across sessions**. Fourteen clinically meaningful patterns are encoded.
+
+| # | Pattern | Signature | Concern level | Extends prepare_data.py? |
+|---|---|---|---|---|
+| 1 | **Mastery progression** | Ascending accuracy, mastery criterion within reach | None | Yes |
+| 2 | **Regression** | Previously mastered skill shows declining accuracy | High | Yes |
+| 3 | **Plateau** | Flat accuracy below mastery for ≥ 5 sessions | Moderate | Yes |
+| 4 | **Frustration pattern** | Declining accuracy + escape-function behavioral indicators | High | Yes |
+| 5 | **Variable performance** | High session-to-session SD, no clear trend | Moderate | Yes |
+| 6 | **Prompt dependency** | High prompted accuracy, low independent accuracy, prolonged | Moderate | Yes |
+| 7 | **Rapid acquisition** | Accelerated mastery beyond expected timeline | None (good) | Yes |
+| 8 | **Generalization failure** | Mastered in training, low accuracy in novel settings/stimuli | Moderate | Yes |
+| 9 | **Extinction burst** | Temporary spike in problem behavior during reduction procedure | Expected | Yes |
+| 10 | **Skill loss after break** | Performance drop after absence, recovering | Moderate | Yes |
+| 11 | **Motivating operation shift** | Responding drops when MO changes (e.g., satiation of reinforcer); recovers when MO restored | Moderate | No — new in v1, grounded in Michael 1993 / CHH Ch.16 |
+| 12 | **Setting event trigger** | Accuracy or behavior changes correlated with an external setting event (illness, sleep disruption, schedule change) | Moderate | No — new in v1, grounded in Smith & Iwata 1997 / Bijou & Baer 1961 |
+
+**Citations.**
+- Patterns 1–10 draw from standard single-case-design interpretation literature (CHH Ch. 6, 7). Specific ones:
+  - Regression / skill loss: CHH Ch. 26 (maintenance).
+  - Extinction burst: CHH Ch. 24.
+  - Prompt dependency: Time-delay literature (Touchette, Touchette 1971; CHH Ch. 21 prompting).
+  - Generalization failure: Stokes & Baer 1977 "An implicit technology of generalization" *JABA, 10*(2); CHH Ch. 26.
+- Patterns 11–12 are TRACE additions with specific literature grounding:
+  - MO shift: CHH Ch. 16 ("Motivating Operations"); Michael, J. (1993). *Journal of the Experimental Analysis of Behavior, 59*(3), 533–552.
+  - Setting event: Bijou & Baer 1961; Smith, R. G. & Iwata, B. A. (1997). *JABA, 30*(2), 343–375.
+
+**Honest framing.** This 12-pattern taxonomy is our *operationalization* for the dataset — no single paper proposes these as a canonical pattern set. Each underlying concept is well-grounded (citations above); the clustering into 12 discrete labels is a design choice that makes session interpretation a tractable classification task.
+
+**Dataset usage.** Each task 2 example is generated from one of these 12 patterns as its hidden label. The interpretation output includes the pattern classification as a structured field (section 12).
+
+---
+
+## 8. Prompt hierarchies
+
+Six prompt-fading strategies used in DTT and related methods.
+
+| # | Strategy | Sequence | When to use |
+|---|---|---|---|
+| 1 | **Most-to-Least (errorless)** | Full physical -> partial physical -> gestural -> positional -> independent | Acquisition, early learner, safety-critical skills |
+| 2 | **Least-to-Most** | Independent -> gestural -> positional -> partial physical -> full physical | Learner already has partial repertoire; promotes independence |
+| 3 | **Graduated Guidance** | Hand-over-hand with fading pressure -> shadow -> independent | Motor skills, self-care chaining |
+| 4 | **Time Delay** (progressive) | 0 s delay -> 2 s -> 4 s -> 6 s -> learner responds independently | Prompt-dependency prevention; ideal for fading |
+| 5 | **Stimulus Fading** | Exaggerated stimulus -> gradually reduce salience -> natural stimulus | Receptive discrimination, early reading |
+| 6 | **Stimulus Shaping** | Modified stimulus -> gradually reshape to target -> natural stimulus | Complex visual discriminations |
+
+**Citations.** CHH Ch. 21 ("Imitation, Shaping, and Prompting") and Ch. 17 ("Stimulus Control"). Time delay: Touchette & Howard 1984 *JABA*.
+
+**Dataset usage.** One of the six sampled per task 1 DTT / Task-Analysis example. Output describes the sequence and current prompt level based on mastery state (section 3).
+
+---
+
+## 9. Reinforcement schedules
+
+Seven reinforcement arrangements — intentional kept to the commonly-used set for cleanliness.
+
+| # | Schedule | Description | Typical use |
+|---|---|---|---|
+| 1 | **CRF** (continuous reinforcement) | Every correct response reinforced | Acquisition phase |
+| 2 | **FR-2** (fixed ratio 2) | Every 2nd correct response reinforced | Thinning as accuracy stabilizes |
+| 3 | **VR-3** (variable ratio 3) | Average of every 3rd correct response | Maintenance, resistance to extinction |
+| 4 | **DRO** (differential reinforcement of other behavior) | Reinforce any behavior *other than* the problem behavior during an interval | Behavior reduction |
+| 5 | **DRA** (differential reinforcement of alternative) | Reinforce a specific alternative behavior, extinguish problem behavior | FCT pairing |
+| 6 | **DRI** (differential reinforcement of incompatible) | Reinforce a behavior physically incompatible with the problem behavior | Stereotypy reduction |
+| 7 | **Token economy** | Tokens delivered per correct response, exchanged later for a back-up reinforcer | Group / classroom settings |
+
+**Citations.** CHH Ch. 13 ("Schedules of Reinforcement"), Ch. 22 ("Differential Reinforcement").
+
+**Dataset usage.** One schedule sampled per task 1 example. Task 2 recommendations may suggest schedule changes (e.g., "thin from CRF to FR-2 as accuracy exceeds 85%").
+
+---
+
+## 10. Error correction procedures
+
+Five error-correction procedures used in DTT and related formats.
+
+| # | Procedure | Steps |
+|---|---|---|
+| 1 | **Transfer trial** | Represent SD -> prompt at effective level -> reinforce prompted response -> distractor trial -> re-present SD independently |
+| 2 | **4-step** | Model -> lead (do together) -> test (independent) -> distractor -> retest |
+| 3 | **Backstep** | Return to previous prompt level that produced success -> successful response -> re-attempt at target prompt level |
+| 4 | **Simple correction** | "No, watch me" -> model -> re-present SD -> differential reinforcement |
+| 5 | **Error-free** | Prevent errors by using high prompts from start; fade gradually (paired with most-to-least) |
+
+**Citations.** CHH Ch. 21. Specific: Heward, W. L. (1994) error-correction comparison.
+
+**Dataset usage.** One procedure sampled per task 1 DTT example.
+
+---
+
+## 11. Mastery criteria options + BIP components
+
+### 11.1 Mastery criteria
+
+Seven mastery criteria conventions common in ABA practice.
+
+1. 80% accuracy across 2 consecutive sessions with ≥ 10 trials each.
+2. 90% accuracy across 3 consecutive sessions.
+3. 80% accuracy with 2 different therapists and 2 different settings (generalization-inclusive).
+4. 80% accuracy at independent prompt level across 3 sessions.
+5. 90% first-trial-correct across 5 consecutive sessions.
+6. Fluency criterion: correct responses within 3-second latency at 90% accuracy.
+7. Demonstrated use in natural environment × 3 independent instances.
+
+**Citation.** CHH Ch. 28 ("Developing Behavior-Change Programs").
+
+### 11.2 BIP components (for task 2 recommendations)
+
+When a target behavior is present in a session log, the task 2 recommendation field is structured along four BIP dimensions.
+
+| Component | Purpose | Example content |
+|---|---|---|
+| **Antecedent strategies** | Prevent the behavior before it occurs by modifying the environment | Shorten tasks; offer choice; pre-teach coping; non-contingent attention; reduce demand difficulty; provide warnings before transitions |
+| **Replacement behavior (teach)** | A skill that produces the same function more appropriately; pair with FCT | Teach "break please" for escape-function tantrums; teach "look at me" for attention-function disruption |
+| **Consequence strategies** | Staff response after the behavior | Do not reinforce (extinction); redirection; blocking; DRA/DRI; differential reinforcement of replacement behavior |
+| **Crisis plan** | Safety procedure if behavior escalates | Staff call-tree; environmental safety (clear hazards); agreed restraint/escape procedures per facility policy; post-incident debrief |
+
+**Citations.**
+- Antecedent strategies: CHH Ch. 25 ("Antecedent Interventions"); Smith, R. G. & Iwata, B. A. (1997). *JABA, 30*(2), 343–375.
+- Replacement behaviors: Carr & Durand 1985 (FCT).
+- Consequence strategies: CHH Ch. 22 (differential reinforcement), Ch. 24 (extinction).
+- Crisis plan: no canonical JABA paper — cite BACB 5th ed. Task List G-15 / H-8 and the BACB *Ethics Code for Behavior Analysts* (2020). Flagged in section 15.
+
+---
+
+## 12. Escalation level (structured output for Task 2)
+
+Every task 2 interpretation emits an **escalation level** as a classification label. This is the safety-critical head.
+
+| Level | Meaning | Trigger examples |
+|---|---|---|
+| **1. Continue monitoring** | Current programming is effective; no changes | Mastery progression; rapid acquisition |
+| **2. Adjust next session** | Implement a specific programming change at next session | Plateau -> change prompt strategy; prompt dependency -> introduce time delay |
+| **3. Supervisor review** | Elevate to supervising BCBA within 24–48 hr | Regression; new emergence of problem behavior; unclear function |
+| **4. Safety — immediate** | Stop program; contact supervisor and/or family immediately; consider crisis-plan activation | SIB escalation; aggression resulting in injury; high-rate elopement; extinction burst exceeding safety threshold |
+
+**Clinical principle.** Escalation level is **ordinal** — mistaking level 4 for level 1 is catastrophically worse than mistaking level 2 for level 1. Evaluation uses quadratic-weighted κ (section 13) to penalize distant mistakes accordingly.
+
+**Dataset usage.** Every task 2 example has a gold-standard escalation level derived deterministically from the pattern (section 7), the target behaviors (section 5), and severity markers.
+
+**On distribution.** No research source prescribes a specific class balance for escalation labels. The pipeline config (not this taxonomy) sets a default that keeps the minority class (level 4 "safety-immediate") present for training representation while reflecting that most sessions do not require immediate safety action. The exact ratio is a *pipeline hyperparameter*, not a clinical truth; see `configs/data-generation.yaml` once implemented.
+
+**Framing as our contribution.** No canonical source specifies this 4-level escalation ordinal. It is TRACE's operationalization, designed to (a) make safety a first-class output and (b) support quadratic-weighted κ evaluation. We cite it as a project design choice, not a clinical taxonomy.
+
+---
+
+## 13. Confidence level (structured output for Task 2)
+
+Three-level confidence expression acknowledging uncertainty.
+
+| Level | Meaning | Example justifications |
+|---|---|---|
+| **High** | Pattern and recommendation well-supported by the data in this log | Multiple sessions of clear data; IOA present and ≥ 80%; single clear pattern |
+| **Moderate** | Data supports the hypothesis but alternatives cannot be fully ruled out | No IOA; few sessions; multiple partially-matching patterns |
+| **Low** | Insufficient data to rule in a specific pattern; recommend data collection before programming changes | < 3 sessions; no IOA; high variability; contradictory signals |
+
+**Citations.** Calibrated uncertainty expression follows general clinical-LM principles (Med-PaLM 2, Singhal et al. 2025). No single ABA-specific source; flagged as project innovation.
+
+**Dataset usage.** Confidence is sampled based on objective data-quality features of the log (number of sessions, IOA presence, variance). Evaluation computes calibration metrics (ECE, Brier — section 13 of `literature-foundation.md`).
+
+---
+
+## 14. Coverage matrix (dimension interactions)
+
+Not every combination is valid. The pipeline enforces these constraints:
+
+| Teaching method | Compatible skill domains | Compatible learner profiles |
+|---|---|---|
+| DTT | All discrete VB-MAPP domains (Mand, Tact, Listener Responding, Echoic, Motor Imitation, VP/MTS, LRFFC, Intraverbal, Math, Reading early) | Early, School-Age |
+| NET | Mand, Tact, Social Behavior, Spontaneous Vocal Behavior, Independent Play | All |
+| Task Analysis | AFLS modules, Writing (multi-step), complex Math, domestic/vocational | School-Age, Adolescent, Adult |
+| FCT | Triggered by target behavior in session log, not by skill domain | All |
+| BST | N/A — staff-facing | Training-program variant |
+| PRT | Mand, Tact, Social Behavior, Spontaneous Vocal Behavior | Early, School-Age |
+
+| Target behavior | Plausible functions | Typical severity / escalation |
+|---|---|---|
+| SIB | All four; most often automatic or escape | L3 – L4 |
+| Aggression | Most often escape or tangible | L3 – L4 |
+| Elopement | Escape, tangible, or automatic | L2 – L4 (depends on environmental risk) |
+| Tantrum | Most often escape or tangible | L2 – L3 |
+| Non-compliance | Primarily escape | L1 – L2 |
+| Stereotypy | Primarily automatic | L1 – L2 (unless interfering with learning) |
+| Pica | Automatic (oral) | L3 – L4 (safety) |
+
+**Dataset usage.** Generators sample valid combinations only. Invalid combinations (e.g., DTT for a multi-step handwashing skill) are not produced, or are produced deliberately as negative-training examples (rare; labeled).
+
+---
+
+## 15. Gaps (explicitly acknowledged)
+
+The following areas in the taxonomy have weaker citation grounding. We cite what exists, note the limitation in the dataset card, and flag them as future-work extensions.
+
+1. **Crisis plan components** — no canonical JABA paper. Cited: BACB 5th ed. Task List G-15 / H-8 and the 2020 Ethics Code. Acceptable because BIP crisis planning is a BACB-regulated practice area.
+2. **Patterns 11–12** (MO shift, setting event) — session-level operationalization is TRACE's contribution; underlying concepts grounded in Michael 1993, Smith & Iwata 1997, Bijou & Baer 1961.
+3. **Disrobing, grabbing/snatching, cascading drift, comorbid skill-behavior** — considered for v1 but excluded because no canonical operational definition exists. We do not invent what the literature has not defined.
+4. **Essential for Living / PEAK / ABLLS-R** — not encoded in v1. VB-MAPP + AFLS provide sufficient coverage for baseline dataset.
+5. **Severity index within target behaviors** — no encoded numeric severity scale. v1 treats severity as implicit in the behavior type + escalation level.
+6. **Multi-function (mixed-function) behaviors** — v1 assigns a single function hypothesis; real clinical reality includes mixed functions. Flagged as a known limitation.
+7. **Cultural / linguistic variation** — v1 is English-only, US/North-American ABA convention. Flagged in dataset card limitations.
+8. **Escalation ordinal (4 levels) and confidence ordinal (3 levels)** — TRACE design choices, not citation-grounded taxonomies. Framed as project contributions; their clinical validity will be evaluated empirically (quadratic-weighted κ vs BCBA raters).
+9. **Class distributions** (escalation levels, learner profiles, pattern frequencies) — no research source prescribes exact proportions. These are pipeline hyperparameters tuned for training balance, not clinical truths.
+
+---
+
+## 16. Changelog
+
+- **v1.0 (2026-04-22)** — initial taxonomy, drawn from VB-MAPP (Sundberg 2008), AFLS (Partington & Mueller 2012), Cooper/Heron/Heward (2020), Iwata (1982/1994), Hanley/Iwata/McCord (2003), Carr & Durand (1985), and supporting JABA operational-definition literature.
+
+---
+
+## 17. How this taxonomy is consumed by the pipeline
+
+- `src/prepare_data.py` imports taxonomy as Python constants generated from this document.
+- Each training example is produced by (a) sampling a valid combination of taxonomy values, (b) running the relevant generation template, (c) applying quality + safety filters.
+- A provenance record is written per example: taxonomy slot values, template ID, teacher model, seed, filter thresholds, timestamp.
+- If this taxonomy changes, the pipeline version and dataset version both bump; old data is preserved as a previous version on HuggingFace.
+
+See `schema-v1.md` (next) for the precise JSON structure of training examples.

pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "trace"
+version = "1.0.0"
+description = "TRACE — Taxonomy-Referenced ABA Clinical Examples. Synthetic dataset + generator for Applied Behavior Analysis teaching-program generation and session interpretation."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Festus Kahunla" },
+]
+maintainers = [
+    { name = "Pombo Labs" },
+]
+keywords = [
+    "applied-behavior-analysis",
+    "aba",
+    "autism",
+    "clinical-nlp",
+    "synthetic-data",
+    "instruction-tuning",
+    "taxonomy",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+dataset-loading = [
+    "datasets>=2.18.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Pombo-Labs/TRACE"
+Repository = "https://github.com/Pombo-Labs/TRACE"
+Documentation = "https://github.com/Pombo-Labs/TRACE#readme"
+Issues = "https://github.com/Pombo-Labs/TRACE/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

requirements.txt

@@ -0,0 +1,9 @@
+# Runtime dependencies for the TRACE generator + dataset loading.
+#
+# Core (required to regenerate the corpus from configs):
+pyyaml>=6.0
+
+# Optional — only needed if you load TRACE via the Hugging Face datasets
+# library (`load_dataset("PomboLabs/TRACE")`). Skip if you only consume the
+# raw JSONL files under data/splits/.
+datasets>=2.18.0

src/compile_curation.py

@@ -0,0 +1,127 @@
+"""Compile test.jsonl + sanity.jsonl from curation_pool.jsonl.
+
+No hand-curation: the whole curation pool is promoted as the
+evaluation corpus. A small stratified slice is carved out for
+sanity.jsonl (training smoke-test); the remainder becomes test.jsonl.
+
+Stratification is by category (method for teaching programs,
+pattern_class for session interpretation) so both splits reflect the
+pool's distribution.
+
+Reads:
+    data/splits/curation_pool.jsonl
+
+Writes:
+    data/splits/test.jsonl
+    data/splits/sanity.jsonl
+
+Usage:
+    uv run python src/compile_curation.py
+    uv run python src/compile_curation.py --sanity-n 20 --seed 42
+"""
+
+import argparse
+import json
+import random
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+POOL_PATH = REPO_ROOT / "data" / "splits" / "curation_pool.jsonl"
+TEST_JSONL = REPO_ROOT / "data" / "splits" / "test.jsonl"
+SANITY_JSONL = REPO_ROOT / "data" / "splits" / "sanity.jsonl"
+
+
+def category_of(example: dict) -> str:
+    gl = example["meta"]["gold_labels"]
+    if example["meta"]["task_type"] == "teaching_program":
+        return gl.get("method", "?")
+    return gl.get("pattern_class", "?")
+
+
+def stratified_sanity_sample(
+    pool: list[dict], sanity_n: int, rng: random.Random
+) -> tuple[list[dict], list[dict]]:
+    """Carve sanity_n stratified examples out of the pool; return (test, sanity)."""
+    by_cat: dict[str, list[dict]] = defaultdict(list)
+    for ex in pool:
+        by_cat[category_of(ex)].append(ex)
+
+    # Largest-remainder method: allocate sanity slots proportional to category size.
+    total = len(pool)
+    raw_quotas = {cat: sanity_n * len(exs) / total for cat, exs in by_cat.items()}
+    floor_quotas = {cat: int(q) for cat, q in raw_quotas.items()}
+    remainder = sanity_n - sum(floor_quotas.values())
+    # Distribute remaining slots by largest fractional part.
+    fractional = sorted(
+        raw_quotas.items(), key=lambda kv: kv[1] - int(kv[1]), reverse=True
+    )
+    for cat, _ in fractional[:remainder]:
+        floor_quotas[cat] += 1
+
+    sanity: list[dict] = []
+    for cat, quota in floor_quotas.items():
+        if quota <= 0:
+            continue
+        picks = rng.sample(by_cat[cat], min(quota, len(by_cat[cat])))
+        sanity.extend(picks)
+
+    sanity_ids = {ex["meta"]["example_id"] for ex in sanity}
+    test = [ex for ex in pool if ex["meta"]["example_id"] not in sanity_ids]
+    return test, sanity
+
+
+def tag_split(example: dict, split_name: str) -> dict:
+    """Deep-copy and stamp the curation split label into meta."""
+    out = json.loads(json.dumps(example))
+    out["meta"]["curation"] = {"target_split": split_name}
+    return out
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--sanity-n", type=int, default=20)
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    if not POOL_PATH.exists():
+        print(f"Curation pool missing: {POOL_PATH}", file=sys.stderr)
+        print("Run `uv run python src/split_data.py` first.", file=sys.stderr)
+        return 1
+
+    pool: list[dict] = []
+    with open(POOL_PATH) as f:
+        for line in f:
+            pool.append(json.loads(line))
+
+    if args.sanity_n >= len(pool):
+        print(
+            f"sanity_n ({args.sanity_n}) must be smaller than pool size ({len(pool)}).",
+            file=sys.stderr,
+        )
+        return 1
+
+    rng = random.Random(args.seed)
+    test, sanity = stratified_sanity_sample(pool, args.sanity_n, rng)
+
+    TEST_JSONL.parent.mkdir(parents=True, exist_ok=True)
+    with open(TEST_JSONL, "w") as f:
+        for ex in test:
+            f.write(json.dumps(tag_split(ex, "test")) + "\n")
+    with open(SANITY_JSONL, "w") as f:
+        for ex in sanity:
+            f.write(json.dumps(tag_split(ex, "sanity")) + "\n")
+
+    def fmt_dist(rows: list[dict]) -> str:
+        c = Counter(category_of(r) for r in rows)
+        return ", ".join(f"{k}={v}" for k, v in sorted(c.items()))
+
+    print(f"Wrote:")
+    print(f"  {TEST_JSONL}   {len(test)} examples  ({fmt_dist(test)})")
+    print(f"  {SANITY_JSONL} {len(sanity)} examples  ({fmt_dist(sanity)})")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/generate.py

@@ -0,0 +1,124 @@
+"""TRACE synthetic data generator — orchestrator.
+
+Routes to per-area generators. Each area is self-contained under configs/<area>/
+with its own taxonomy, template, and compatibility rules.
+
+Usage:
+    # Generate one area (count from generation.yaml)
+    uv run python src/generate.py --area dtt
+
+    # Generate one area with explicit count
+    uv run python src/generate.py --area dtt --n 50
+
+    # Generate all enabled areas
+    uv run python src/generate.py --all
+
+    # Write to a specific file (single-area mode only)
+    uv run python src/generate.py --area dtt --n 10 --out data/samples/dtt-10.jsonl
+"""
+
+import argparse
+import hashlib
+import json
+import random
+import sys
+from pathlib import Path
+
+# Path setup so we can run as a script
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.generators.aba_dtt import DTTGenerator
+from src.generators.aba_net import NETGenerator
+from src.generators.aba_session_interp import SessionInterpretationGenerator
+from src.generators.aba_task_analysis import TaskAnalysisGenerator
+from src.generators.base import load_yaml
+
+CONFIG_DIR = REPO_ROOT / "configs"
+
+# Area registry — add new generators here as they come online.
+GENERATORS = {
+    "dtt": DTTGenerator,
+    "net": NETGenerator,
+    "task_analysis": TaskAnalysisGenerator,
+    "session_interpretation": SessionInterpretationGenerator,
+    # "fct": FCTGenerator,
+    # "bst": BSTGenerator,
+    # "prt": PRTGenerator,
+}
+
+
+def deterministic_area_offset(area: str) -> int:
+    """Stable per-area seed offset.
+
+    Using Python's built-in ``hash()`` here would be non-deterministic across
+    processes (PYTHONHASHSEED randomization), which would make the dataset
+    irreproducible run-to-run. SHA-256 is stable across processes and Python
+    versions.
+    """
+    return int(hashlib.sha256(area.encode()).hexdigest(), 16) % 10000
+
+
+def generate_area(area: str, n: int, seed: int, out_stream) -> int:
+    """Generate `n` examples for `area`; write to `out_stream` as JSONL. Returns count written."""
+    if area not in GENERATORS:
+        raise ValueError(f"Generator for area '{area}' not registered. Available: {list(GENERATORS)}")
+    GenCls = GENERATORS[area]
+    generator = GenCls(CONFIG_DIR)
+    rng = random.Random(seed)
+    for _ in range(n):
+        example = generator.render_example(rng)
+        out_stream.write(json.dumps(example) + "\n")
+    return n
+
+
+def main():
+    parser = argparse.ArgumentParser(description="TRACE per-area generator orchestrator.")
+    parser.add_argument("--area", default=None, help="Generate only this area.")
+    parser.add_argument("--all", action="store_true", help="Generate all enabled areas from generation.yaml.")
+    parser.add_argument("--n", type=int, default=None, help="Override example count.")
+    parser.add_argument("--seed", type=int, default=None, help="Override global seed.")
+    parser.add_argument("--out", type=str, default=None, help="Output JSONL file (single-area mode).")
+    args = parser.parse_args()
+
+    gen_config = load_yaml(CONFIG_DIR / "generation.yaml")
+    seed = args.seed if args.seed is not None else gen_config["seed"]
+
+    if not args.area and not args.all:
+        parser.error("Must specify --area <name> or --all.")
+
+    if args.all:
+        # Multi-area: write one file per area under output_dir
+        output_dir = REPO_ROOT / gen_config["output_dir"]
+        output_dir.mkdir(parents=True, exist_ok=True)
+        total = 0
+        for area, area_cfg in gen_config["areas"].items():
+            if not area_cfg.get("enabled"):
+                print(f"  - {area}: disabled, skipping")
+                continue
+            if area not in GENERATORS:
+                print(f"  - {area}: generator not yet built, skipping")
+                continue
+            n = area_cfg["n"]
+            out_path = output_dir / f"{area}.jsonl"
+            with open(out_path, "w") as f:
+                generate_area(area, n, seed + deterministic_area_offset(area), f)
+            print(f"  - {area}: {n} examples -> {out_path}")
+            total += n
+        print(f"\nTotal generated: {total} examples.")
+    else:
+        # Single-area mode
+        area = args.area
+        n = args.n if args.n is not None else gen_config["areas"][area]["n"]
+        out_stream = open(args.out, "w") if args.out else sys.stdout
+        try:
+            generate_area(area, n, seed, out_stream)
+        finally:
+            if args.out:
+                out_stream.close()
+        if args.out:
+            print(f"Wrote {n} examples to {args.out}")
+
+
+if __name__ == "__main__":
+    main()

src/generators/__init__.py

@@ -0,0 +1 @@
+"""Generator modules for TRACE synthetic data pipeline."""

src/generators/aba_dtt.py

@@ -0,0 +1,293 @@
+"""DTT area generator.
+
+Loads configs/dtt/ + configs/shared/ and produces JSONL examples with
+clinically-consistent combinations sampled from the DTT taxonomy.
+"""
+
+import random
+from pathlib import Path
+
+from .base import (
+    article,
+    load_area,
+    load_shared,
+    render_prompt_sequence,
+    sample_stimuli,
+    strip_trailing_period,
+    make_example_envelope,
+)
+
+# Area identifier + task type
+AREA = "dtt"
+TASK_TYPE = "teaching_program"
+
+
+# SD (Discriminative Stimulus) generation — clinically nuanced
+
+
+def generate_sd(skill_target: str, domain_id: str, rng: random.Random) -> dict:
+    """Generate primary SD, variations, and presentation description.
+
+    Sub-domain aware: Tact-of-colors gets "What color?", not "What is this?".
+    """
+    skill = skill_target.lower()
+
+    if domain_id == "tact":
+        if "color" in skill:
+            return _sd("What color?", '"What color is this?"; "Tell me the color"',
+                       "Present a single-color object and ask while pointing to it.")
+        if "shape" in skill:
+            return _sd("What shape?", '"What shape is this?"; "Tell me the shape"',
+                       "Present a clearly-shaped object or shape card and ask while pointing to it.")
+        if "action" in skill:
+            return _sd("What is he doing?", '"What action?"; "What is she doing?"; "What is happening here?"',
+                       "Present an action picture, video clip, or live demonstration.")
+        if "emotion" in skill or "feeling" in skill:
+            return _sd("How does he feel?", '"What emotion?"; "How is she feeling?"',
+                       "Present a photograph or emoji card depicting the target emotion.")
+        if "body part" in skill:
+            return _sd("What is this?", '"Tell me"; "Name this body part"',
+                       "Point to the target body part (on self, learner, or doll) and ask.")
+        if "animal" in skill:
+            return _sd("What animal is this?", '"What is this?"; "Name this animal"',
+                       "Present an animal picture card and ask while pointing.")
+        if "preposition" in skill:
+            return _sd("Where is it?", '"Where is the {object}?"; "Tell me where"',
+                       "Arrange two objects in a target spatial relation and ask about the position.")
+        if "adjective" in skill:
+            return _sd("What is it like?", '"Describe it"; "Is it big or little?"',
+                       "Present two contrasting items and prompt a comparative description.")
+        if "past" in skill or "event" in skill:
+            return _sd("What happened?", '"What did she do?"; "Tell me what you did"',
+                       "Reference a recently completed action or event familiar to the learner.")
+        if "categor" in skill:
+            return _sd("What category?", '"What group does this belong to?"; "What kind of thing?"',
+                       "Present a clearly categorizable item and prompt the category label.")
+        return _sd("What is this?", '"Tell me what you see"; "What\'s that?"; "Name this"',
+                   "Present the target stimulus within visual field and ask while pointing to it.")
+
+    if domain_id == "vp_mts":
+        return _sd("Match", '"Find the same"; "Put with same"',
+                   "Present the sample stimulus and an array of comparison stimuli simultaneously.")
+
+    if domain_id in {"listener_responding", "lrffc"}:
+        return _sd("Touch [target item]",
+                   '"Point to [target item]"; "Give me [target item]"; "Show me [target item]"',
+                   "Present an array of items on the table and deliver a clear verbal SD.")
+
+    if domain_id == "reading":
+        if "sight word" in skill or "word" in skill:
+            return _sd("What word?", '"Read this word"; "What does it say?"',
+                       "Present the sight-word card and deliver the SD.")
+        if "letter" in skill:
+            return _sd("What letter is this?", '"Read this letter"; "What does this say?"',
+                       "Present the letter flashcard.")
+        if "sentence" in skill or "passage" in skill:
+            return _sd("Read this.", '"Read it aloud"; "What does this sentence say?"',
+                       "Present the written sentence or passage at an appropriate reading level.")
+        return _sd("What letter is this?", '"Read this letter"; "What does this say?"',
+                   "Present the letter or word on a flashcard.")
+
+    if domain_id == "writing":
+        return _sd("Write the target.", '"Trace this"; "Copy this"; "Write {word}"',
+                   "Provide pencil and paper; deliver a clear verbal instruction naming the target letter or word.")
+
+    if domain_id == "math":
+        if "numeral" in skill or "identif" in skill:
+            return _sd("What number is this?", '"Which number?"; "Tell me the number"',
+                       "Present the numeral card.")
+        if "count" in skill:
+            return _sd("How many?", '"Count these"; "How many are there?"',
+                       "Present the set of objects to count.")
+        if "add" in skill or "subtract" in skill:
+            return _sd("Solve this.", '"What is the answer?"; "How much?"',
+                       "Present a written or spoken arithmetic problem at target level.")
+        return _sd("How many?", '"Count these"; "What number is this?"',
+                   "Present the numeral card or a set of objects to count.")
+
+    return _sd("Show me", '"Do this"; "Your turn"',
+               "Present relevant stimuli and deliver a clear verbal SD.")
+
+
+def _sd(primary: str, variations: str, presentation: str) -> dict:
+    return {"primary_sd": primary, "sd_variations": variations, "sd_presentation": presentation}
+
+
+def current_prompt_guidance(mastery_state_id: str) -> str:
+    """Translate mastery state into current-prompt-level guidance."""
+    if mastery_state_id in {"emerging", "developing"}:
+        return "begin at higher prompt levels (full-physical or partial-physical) with systematic fading."
+    if mastery_state_id == "approaching":
+        return "deliver gestural or positional prompts; fade toward independence."
+    if mastery_state_id in {"near", "mastered", "generalization"}:
+        return "use minimal prompts (positional or verbal hint) only when needed; expect independent responding."
+    return "prompt level calibrated to current performance."
+
+
+# DTTGenerator class
+
+
+class DTTGenerator:
+    """Generates teaching-program examples for the DTT area.
+
+    Loads its self-contained taxonomy + template + compatibility rules from
+    configs/dtt/ and uses shared primitives from configs/shared/.
+    """
+
+    def __init__(self, config_dir: Path):
+        self.config_dir = Path(config_dir)
+        self.shared = load_shared(self.config_dir)
+        self.area = load_area(self.config_dir, AREA)
+        self.template = self.area["template"]
+        self.taxonomy = self.area["taxonomy"]
+        self.compat = self.area["compatibility"]
+        self.prompt_types = self.shared["prompt_types"]["prompt_types"]
+
+    # sampling
+
+    def sample_combination(self, rng: random.Random) -> dict:
+        """Sample a clinically-valid DTT combo."""
+        # Sample level with weights from compatibility config
+        level_weights = self.compat["level_sampling_weights"]
+        levels = list(level_weights.keys())
+        weights = [level_weights[k] for k in levels]
+        level_id = rng.choices(levels, weights=weights)[0]
+
+        # Sample domain — filter to only those that define this level (some
+        # domains like Writing don't have L3 in the DTT taxonomy because
+        # long-form writing is Task Analysis territory).
+        all_domains = self.taxonomy["skill_domains"]["vbmapp"]["domains"]
+        domains_with_level = [d for d in all_domains if level_id in d]
+        if not domains_with_level:
+            # Fall back: pick from all domains and re-sample a level they support
+            domain = rng.choice(all_domains)
+            available_levels = [lv for lv in levels if lv in domain]
+            level_id = rng.choice(available_levels)
+        else:
+            domain = rng.choice(domains_with_level)
+        skill_target = rng.choice(domain[level_id])
+
+        # Learner profile filtered by level
+        profiles = self.shared["learner_profiles"]["profiles"]
+        allowed_profile_ids = set(self.compat["level_to_learner_profiles"][level_id])
+        profile = rng.choice([p for p in profiles if p["id"] in allowed_profile_ids])
+
+        mastery_state = rng.choice(self.shared["mastery_states"]["states"])
+
+        # Prompt hierarchy then error-correction (filtered for errorless compat)
+        prompt_hierarchy = rng.choice(self.taxonomy["prompt_hierarchies"])
+        all_ecs = self.taxonomy["error_corrections"]
+        required_hierarchy = self.compat.get("errorless_requires_hierarchy")
+        if prompt_hierarchy["id"] != required_hierarchy:
+            valid_ecs = [ec for ec in all_ecs if ec["id"] != "errorless"]
+        else:
+            valid_ecs = all_ecs
+        error_correction = rng.choice(valid_ecs)
+
+        # Reinforcement schedule filtered by mastery state
+        all_schedules = self.taxonomy["reinforcement_schedules"]
+        allowed_schedule_ids = set(self.compat["mastery_to_reinforcement"][mastery_state["id"]])
+        valid_schedules = [s for s in all_schedules if s["id"] in allowed_schedule_ids]
+        if not valid_schedules:
+            valid_schedules = [s for s in all_schedules if s["id"] == "crf"]
+        reinforcement_schedule = rng.choice(valid_schedules)
+
+        mastery_criterion = rng.choice(self.taxonomy["mastery_criteria"])
+
+        return {
+            "skill_target": skill_target,
+            "domain_id": domain["id"],
+            "domain_name": domain["name"],
+            "level_id": level_id,
+            "learner_profile": profile,
+            "mastery_state": mastery_state,
+            "prompt_hierarchy": prompt_hierarchy,
+            "reinforcement_schedule": reinforcement_schedule,
+            "error_correction": error_correction,
+            "mastery_criterion": mastery_criterion,
+        }
+
+    # slot computation
+
+    def compute_slots(self, combo: dict, rng: random.Random) -> dict:
+        array_size_info = self.compat["array_size_by_level"][combo["level_id"]]
+        array_size_n = array_size_info["n"]
+        array_size_text = array_size_info["text"]
+
+        sd = generate_sd(combo["skill_target"], combo["domain_id"], rng)
+        stim = sample_stimuli(combo["skill_target"], array_size_n, rng)
+
+        if stim["distractors"]:
+            distractor_block = f"Distractor stimuli: {', '.join(stim['distractors'])}"
+        else:
+            distractor_block = "Distractor stimuli: N/A (no-array SD format)"
+
+        mastery_state = combo["mastery_state"]
+
+        return {
+            "skill_target": combo["skill_target"],
+            "curriculum_ref": f"{combo['domain_name']} {combo['level_id']}",
+            "learner_profile_name": combo["learner_profile"]["name"],
+            "learner_profile_article": article(combo["learner_profile"]["name"]),
+            "mastery_state_name": mastery_state["name"],
+            "mastery_state_short": mastery_state.get("short", mastery_state["name"].lower()),
+            "primary_sd": sd["primary_sd"],
+            "sd_variations": sd["sd_variations"],
+            "sd_presentation": sd["sd_presentation"],
+            "prompt_hierarchy_name": combo["prompt_hierarchy"]["name"],
+            "prompt_sequence": render_prompt_sequence(
+                combo["prompt_hierarchy"]["sequence"], self.prompt_types
+            ),
+            "current_prompt_guidance": current_prompt_guidance(mastery_state["id"]),
+            "array_size": array_size_text,
+            "target_stimuli": ", ".join(stim["targets"]),
+            "distractor_block": distractor_block,
+            "error_correction_steps": combo["error_correction"]["steps"].strip(),
+            "reinforcement_schedule_name": combo["reinforcement_schedule"]["name"],
+            "reinforcement_description": strip_trailing_period(combo["reinforcement_schedule"]["description"]),
+            "mastery_criterion_text": combo["mastery_criterion"]["text"],
+            "ioa_frequency": rng.choice([3, 4, 5]),
+            "n_generalization_therapists": rng.choice([2, 3]),
+            "n_generalization_settings": rng.choice([2, 3]),
+        }
+
+    # rendering
+
+    def render_example(self, rng: random.Random) -> dict:
+        combo = self.sample_combination(rng)
+        slots = self.compute_slots(combo, rng)
+
+        user_variant = rng.choice(self.template["user_variants"])
+        user_content = user_variant.format(**slots)
+        assistant_content = self.template["assistant_template"].format(**slots)
+
+        gold_labels = {
+            "method": AREA,
+            "domain": f"VB-MAPP.{combo['domain_id']}",
+            "level": combo["level_id"],
+            "learner_profile": combo["learner_profile"]["id"],
+            "mastery_state": combo["mastery_state"]["id"],
+        }
+        provenance = {
+            "layer": 1,
+            "area": AREA,
+            "template_id": self.template["template_id"],
+            "taxonomy_cells": {
+                "skill_target": combo["skill_target"],
+                "prompt_hierarchy": combo["prompt_hierarchy"]["id"],
+                "reinforcement_schedule": combo["reinforcement_schedule"]["id"],
+                "error_correction": combo["error_correction"]["id"],
+                "mastery_criterion": combo["mastery_criterion"]["id"],
+            },
+            "teacher_model": None,
+            "seed_tag": str(rng.getstate()[1][0] % 100000),
+        }
+
+        return make_example_envelope(
+            system_content=self.template["system_prompt"],
+            user_content=user_content,
+            assistant_content=assistant_content,
+            task_type=TASK_TYPE,
+            gold_labels=gold_labels,
+            provenance=provenance,
+        )

src/generators/aba_net.py

@@ -0,0 +1,216 @@
+"""NET area generator.
+
+Loads configs/net/ + configs/shared/ and produces naturalistic teaching
+program examples. Mand / Social / Spontaneous Vocal / some Intraverbal skills.
+"""
+
+import random
+from pathlib import Path
+
+from .base import (
+    load_area,
+    load_shared,
+    make_example_envelope,
+)
+
+AREA = "net"
+TASK_TYPE = "teaching_program"
+
+
+def pick_mo_category(skill_target: str, domain_id: str, compat: dict) -> str:
+    """Match skill text against domain + keyword rules to pick an MO category.
+
+    Domain is checked first to avoid false matches from shared keywords
+    (e.g., 'preferred' in both mand skills and spontaneous-vocal skills).
+    """
+    s = skill_target.lower()
+
+    if domain_id == "mand":
+        if "bathroom" in s or "potty" in s or "toilet" in s or "restroom" in s:
+            return "mand_bathroom"
+        if "break" in s:
+            return "mand_break"
+        if "all done" in s or "completion" in s or "finished" in s:
+            return "mand_completion"
+        if "missing" in s:
+            return "mand_missing"
+        if "help" in s:
+            return "mand_help"
+        if '"what"' in s or "what" in s.split():
+            return "mand_info_what"
+        if '"where"' in s or "where" in s.split():
+            return "mand_info_where"
+        if "attention" in s or "peers" in s:
+            return "mand_attention"
+        if "action" in s:
+            return "mand_action"
+        return "mand_item"
+
+    if domain_id == "social":
+        if "initiate" in s or "initiates" in s:
+            return "social_initiation"
+        if "turn" in s:
+            return "social_turn_taking"
+        if "reciprocal" in s or "conversation" in s:
+            return "intraverbal_multi_turn"
+        return "social_initiation"
+
+    if domain_id == "spontaneous_vocal":
+        if "greet" in s:
+            return "spontaneous_greeting"
+        return "spontaneous_comment"
+
+    if domain_id == "intraverbal":
+        if "multi-turn" in s or "conversation" in s:
+            return "intraverbal_multi_turn"
+        if "routine" in s:
+            return "intraverbal_routine"
+        return "intraverbal_multi_turn"
+
+    return compat["default_mo_category"]
+
+
+def pick_mo_arrangement(mo_category: str, mo_arrangements: list, rng: random.Random) -> dict:
+    """Find an MO arrangement matching the category, falling back to random."""
+    matches = [m for m in mo_arrangements if mo_category in m["applies_to"]]
+    if matches:
+        return rng.choice(matches)
+    return rng.choice(mo_arrangements)
+
+
+def current_prompt_guidance(mastery_state_id: str) -> str:
+    """Guidance for NET prompt level based on mastery state."""
+    if mastery_state_id in {"emerging", "developing"}:
+        return "begin with a model prompt delivered during the motivated moment; fade to expectant look across sessions."
+    if mastery_state_id == "approaching":
+        return "use time delay (0 s -> 2 s -> 4 s) before delivering any model prompt; reinforce independent responses differentially."
+    if mastery_state_id in {"near", "mastered", "generalization"}:
+        return "use expectant look only; avoid direct prompts. The MO itself should be sufficient to occasion the response."
+    return "prompt level calibrated to current performance."
+
+
+class NETGenerator:
+    def __init__(self, config_dir: Path):
+        self.config_dir = Path(config_dir)
+        self.shared = load_shared(self.config_dir)
+        self.area = load_area(self.config_dir, AREA)
+        self.template = self.area["template"]
+        self.taxonomy = self.area["taxonomy"]
+        self.compat = self.area["compatibility"]
+
+    def sample_combination(self, rng: random.Random) -> dict:
+        # Level with weights
+        level_weights = self.compat["level_sampling_weights"]
+        levels = list(level_weights.keys())
+        weights = [level_weights[k] for k in levels]
+        level_id = rng.choices(levels, weights=weights)[0]
+
+        # Sample domain with a level match
+        all_domains = self.taxonomy["skill_domains"]["vbmapp"]["domains"]
+        domains_with_level = [d for d in all_domains if level_id in d]
+        if not domains_with_level:
+            domain = rng.choice(all_domains)
+            available_levels = [lv for lv in levels if lv in domain]
+            level_id = rng.choice(available_levels)
+        else:
+            domain = rng.choice(domains_with_level)
+        skill_target = rng.choice(domain[level_id])
+
+        # Learner profile
+        profiles = self.shared["learner_profiles"]["profiles"]
+        allowed = set(self.compat["level_to_learner_profiles"][level_id])
+        profile = rng.choice([p for p in profiles if p["id"] in allowed])
+
+        mastery_state = rng.choice(self.shared["mastery_states"]["states"])
+
+        mo_category = pick_mo_category(skill_target, domain["id"], self.compat)
+        mo_arrangement = pick_mo_arrangement(mo_category, self.taxonomy["mo_arrangements"], rng)
+        natural_context = rng.choice(
+            mo_arrangement.get("context_examples") or self.taxonomy["natural_contexts"]
+        )
+        prompt_strategy = rng.choice(self.taxonomy["prompt_strategies"])
+        mastery_criterion = rng.choice(self.taxonomy["mastery_criteria"])
+
+        return {
+            "skill_target": skill_target,
+            "domain_id": domain["id"],
+            "domain_name": domain["name"],
+            "level_id": level_id,
+            "learner_profile": profile,
+            "mastery_state": mastery_state,
+            "mo_category": mo_category,
+            "mo_arrangement": mo_arrangement,
+            "natural_context": natural_context,
+            "prompt_strategy": prompt_strategy,
+            "mastery_criterion": mastery_criterion,
+        }
+
+    def compute_slots(self, combo: dict, rng: random.Random) -> dict:
+        mastery_state = combo["mastery_state"]
+        reinforcer_map = self.taxonomy["natural_reinforcer_examples"]
+        natural_reinforcer = reinforcer_map.get(combo["mo_category"], reinforcer_map["default"])
+
+        # Build a natural-opportunity description from the MO arrangement + natural context
+        opportunity_text = (
+            f"Embed the teaching opportunity within the learner's {combo['natural_context']} routine. "
+            f"Deliver the opportunity when the MO is evident (learner oriented to the relevant stimulus, approaching the materials, or demonstrating interest)."
+        )
+
+        return {
+            "skill_target": combo["skill_target"],
+            "curriculum_ref": f"{combo['domain_name']} {combo['level_id']}",
+            "learner_profile_name": combo["learner_profile"]["name"],
+            "mastery_state_name": mastery_state["name"],
+            "mastery_state_short": mastery_state.get("short", mastery_state["name"].lower()),
+            "mo_arrangement_text": combo["mo_arrangement"]["text"],
+            "primary_natural_context": combo["natural_context"],
+            "natural_opportunity_text": opportunity_text,
+            "prompt_strategy_name": combo["prompt_strategy"]["name"],
+            "prompt_strategy_description": combo["prompt_strategy"]["description"],
+            "current_prompt_guidance": current_prompt_guidance(mastery_state["id"]),
+            "natural_reinforcer_text": f"Natural reinforcer: {natural_reinforcer}",
+            "n_exemplars": rng.choice([3, 4, 5]),
+            "n_settings": rng.choice([2, 3]),
+            "n_therapists": rng.choice([2, 3]),
+            "mastery_criterion_text": combo["mastery_criterion"]["text"],
+            "ioa_frequency": rng.choice([3, 4, 5]),
+        }
+
+    def render_example(self, rng: random.Random) -> dict:
+        combo = self.sample_combination(rng)
+        slots = self.compute_slots(combo, rng)
+
+        user_variant = rng.choice(self.template["user_variants"])
+        user_content = user_variant.format(**slots)
+        assistant_content = self.template["assistant_template"].format(**slots)
+
+        gold_labels = {
+            "method": AREA,
+            "domain": f"VB-MAPP.{combo['domain_id']}",
+            "level": combo["level_id"],
+            "learner_profile": combo["learner_profile"]["id"],
+            "mastery_state": combo["mastery_state"]["id"],
+        }
+        provenance = {
+            "layer": 1,
+            "area": AREA,
+            "template_id": self.template["template_id"],
+            "taxonomy_cells": {
+                "skill_target": combo["skill_target"],
+                "mo_category": combo["mo_category"],
+                "mo_arrangement": combo["mo_arrangement"]["id"],
+                "prompt_strategy": combo["prompt_strategy"]["id"],
+                "mastery_criterion": combo["mastery_criterion"]["id"],
+            },
+            "teacher_model": None,
+            "seed_tag": str(rng.getstate()[1][0] % 100000),
+        }
+
+        return make_example_envelope(
+            system_content=self.template["system_prompt"],
+            user_content=user_content,
+            assistant_content=assistant_content,
+            task_type=TASK_TYPE,
+            gold_labels=gold_labels,
+            provenance=provenance,
+        )

src/generators/aba_session_interp.py

@@ -0,0 +1,931 @@
+"""Session Interpretation generator (Task 2).
+
+Generates multi-session behavioral logs and matching structured interpretations.
+The log is produced deterministically from a sampled hidden pattern so the
+interpretation's gold labels are known by construction.
+"""
+
+import random
+from datetime import date, timedelta
+from pathlib import Path
+
+from .base import (
+    load_area,
+    load_shared,
+    load_yaml,
+    strip_trailing_period,
+    make_example_envelope,
+)
+
+AREA = "session_interpretation"
+TASK_TYPE = "session_interpretation"
+
+
+# Trajectory math — generate per-session accuracy values following a pattern rule
+
+
+def _clip(x: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    return max(lo, min(hi, x))
+
+
+def generate_accuracy_trajectory(pattern_id: str, rule: dict, n_sessions: int, rng: random.Random) -> list:
+    """Return a list of accuracy values for n_sessions based on pattern rule."""
+    acc = rule["accuracy"]
+
+    if pattern_id == "generalization_failure":
+        alt = acc["alternating"]
+        tr_lo, tr_hi = alt["training_range"]
+        nov_lo, nov_hi = alt["novel_range"]
+        noise = alt["noise"]
+        vals = []
+        training = rng.uniform(tr_lo, tr_hi)
+        novel = rng.uniform(nov_lo, nov_hi)
+        for i in range(n_sessions):
+            base = training if i % 2 == 0 else novel
+            vals.append(_clip(base + rng.uniform(-noise, noise)))
+        return vals
+
+    if pattern_id == "skill_loss_after_break":
+        base = rng.uniform(*acc["base_range"])
+        drop = rng.uniform(*acc["initial_drop"])
+        rec = rng.uniform(*acc["recovery_per_session_range"])
+        noise = acc["noise"]
+        vals = [_clip(base - drop + rng.uniform(-noise, noise))]
+        for _ in range(1, n_sessions):
+            vals.append(_clip(vals[-1] + rec + rng.uniform(-noise, noise), 0.1, base))
+        return vals
+
+    if pattern_id == "motivating_operation_shift":
+        base = rng.uniform(*acc["base_range"])
+        dip_len = rng.randint(*acc["mo_dip_sessions"])
+        dip_mag = rng.uniform(*acc["mo_dip_magnitude"])
+        rec = rng.uniform(*acc["recovery_per_session_range"])
+        noise = acc["noise"]
+        dip_start = max(2, n_sessions // 3)
+        vals = []
+        for i in range(n_sessions):
+            in_dip = dip_start <= i < dip_start + dip_len
+            if in_dip:
+                v = base - dip_mag + rng.uniform(-noise, noise)
+            elif i >= dip_start + dip_len:
+                prev = vals[-1]
+                v = min(base, prev + rec + rng.uniform(-noise, noise))
+            else:
+                v = base + rng.uniform(-noise, noise)
+            vals.append(_clip(v, 0.1, 0.98))
+        return vals
+
+    if pattern_id == "setting_event_trigger":
+        base = rng.uniform(*acc["base_range"])
+        se_idx = max(1, int(acc["setting_event_session_fraction"] * n_sessions))
+        mag = rng.uniform(*acc["setting_event_magnitude"])
+        rec = rng.uniform(*acc["recovery_per_session_range"])
+        noise = acc["noise"]
+        vals = []
+        for i in range(n_sessions):
+            if i < se_idx:
+                v = base + rng.uniform(-noise, noise)
+            elif i == se_idx:
+                v = base - mag + rng.uniform(-noise, noise)
+            else:
+                prev = vals[-1]
+                v = min(base, prev + rec + rng.uniform(-noise, noise))
+            vals.append(_clip(v, 0.1, 0.98))
+        return vals
+
+    if pattern_id == "extinction_burst":
+        base = rng.uniform(*acc["base_range"])
+        delta = rng.uniform(*acc["delta_per_session_range"])
+        noise = acc["noise"]
+        vals = [_clip(base + i * delta + rng.uniform(-noise, noise)) for i in range(n_sessions)]
+        return vals
+
+    # Default: linear delta from base
+    base = rng.uniform(*acc["base_range"])
+    delta = rng.uniform(*acc["delta_per_session_range"])
+    noise = acc["noise"]
+    cap = acc.get("cap", 0.98)
+    floor_v = acc.get("floor", 0.05)
+    return [_clip(base + i * delta + rng.uniform(-noise, noise), floor_v, cap) for i in range(n_sessions)]
+
+
+def generate_behavior_frequencies(
+    traj_name: str, library: dict, n_sessions: int, rule: dict, rng: random.Random
+) -> list:
+    """Return a list of integer behavior frequencies per session."""
+    cfg = library[traj_name]
+    if traj_name == "temporary_spike":
+        base_lo, base_hi = cfg["base_freq_range"]
+        mult_range = cfg["spike_multiplier_range"]
+        noise = cfg["noise"]
+        burst_start = max(2, int(rule.get("burst_start_fraction", 0.33) * n_sessions))
+        burst_len = rule.get("burst_duration_sessions", 2)
+        base = rng.uniform(base_lo, base_hi)
+        mult = rng.uniform(*mult_range)
+        vals = []
+        for i in range(n_sessions):
+            if burst_start <= i < burst_start + burst_len:
+                v = base * mult + rng.uniform(-noise, noise)
+            else:
+                v = base + rng.uniform(-noise, noise)
+            vals.append(max(0, round(v)))
+        return vals
+    if traj_name == "coincident_spike":
+        # Spike coincides with setting event index
+        base_lo, base_hi = cfg["base_freq_range"]
+        mult_range = cfg["spike_multiplier_range"]
+        noise = cfg["noise"]
+        se_idx = max(1, int(rule["accuracy"]["setting_event_session_fraction"] * n_sessions))
+        base = rng.uniform(base_lo, base_hi)
+        mult = rng.uniform(*mult_range)
+        vals = []
+        for i in range(n_sessions):
+            if i in {se_idx, se_idx + 1}:
+                v = base * mult + rng.uniform(-noise, noise)
+            else:
+                v = base + rng.uniform(-noise, noise)
+            vals.append(max(0, round(v)))
+        return vals
+    # default: base_freq_range + cumulative delta + noise
+    base_lo, base_hi = cfg["base_freq_range"]
+    delta = cfg.get("delta_per_session", 0.0)
+    noise = cfg.get("noise", 1.0)
+    base = rng.uniform(base_lo, base_hi)
+    return [max(0, round(base + i * delta + rng.uniform(-noise, noise))) for i in range(n_sessions)]
+
+
+# Stimulus / profile sampling helpers
+
+
+SKILL_POOL_BY_CATEGORY = {
+    "early_language": [
+        ("Mand", "single-word mands for preferred items (e.g., \"cookie\", \"iPad\")", "NET"),
+        ("Mand", "mands for missing items needed to complete an activity", "NET"),
+        ("Mand", "2-word mand phrases (e.g., \"more cracker\", \"open please\")", "NET"),
+        ("Mand", "requesting a break ('break please' or AAC 'I need a break')", "NET"),
+        ("Mand", "indicating completion ('all done', 'finished')", "NET"),
+        ("Tact", "tacts common objects", "DTT"),
+        ("Tact", "tacts colors of objects", "DTT"),
+        ("Listener Responding", "follows 1-step motor instructions", "DTT"),
+        ("Listener Responding", "selects items by feature", "DTT"),
+        ("Echoic", "echoes 2-word phrases", "DTT variant"),
+        ("Motor Imitation", "imitates 3-step motor sequences", "DTT variant"),
+        ("Intraverbal", "answers WH-questions about familiar topics", "NET"),
+        ("Tolerating Denied Access", "wait calmly when access to preferred item is denied", "FCT"),
+    ],
+    "school_age": [
+        ("Reading", "reads 10–20 sight words", "DTT"),
+        ("Reading", "sounds out CVC words", "DTT"),
+        ("Writing", "copies simple words from model", "DTT"),
+        ("Math", "identifies numerals 1–20", "DTT"),
+        ("Math", "counts objects 1–20", "DTT"),
+        ("Mand", "requesting preferred items using AAC device (e.g., \"I want cookie please\")", "NET"),
+        ("Mand", "single-word requests for preferred items", "NET"),
+        ("Mand", "requesting preferred items using a full sentence", "NET"),
+        ("Mand", "requesting a break during non-preferred tasks", "NET"),
+        ("Mand", "indicating 'all done' when an activity is complete", "NET"),
+        ("Tolerating Denied Access", "wait calmly when access to preferred item is denied", "FCT"),
+        ("Social Behavior", "takes turns during structured activities", "PRT"),
+    ],
+    "adolescent": [
+        ("Self-Care", "washing hands independently", "Task Analysis"),
+        ("Self-Care", "dressing (pants, shirt)", "Task Analysis"),
+        ("Self-Care", "brushing teeth independently", "Task Analysis"),
+        ("Self-Care", "tolerating tooth brushing by caregiver", "Task Analysis"),
+        ("Self-Care", "tolerating haircut", "Task Analysis"),
+        ("Home Skills", "making the bed", "Task Analysis"),
+        ("Home Skills", "meal cleanup after eating", "Task Analysis"),
+        ("Community", "identifying community safety signs", "DTT"),
+        ("Community", "ordering in a restaurant", "Task Analysis"),
+        ("Mand", "requesting preferred items using AAC device", "NET"),
+        ("Mand", "requesting help when a task is difficult", "NET"),
+        ("Mand", "requesting a break during non-preferred activities", "NET"),
+        ("Mand", "indicating 'all done' with a step or activity", "NET"),
+        ("Tolerating Denied Access", "wait calmly when access to preferred item is denied", "FCT"),
+    ],
+    "adult": [
+        ("Independent Living", "scheduling medical appointments", "Task Analysis"),
+        ("Independent Living", "managing a budget", "Task Analysis"),
+        ("Independent Living", "self-advocacy statements", "BST"),
+        ("Vocational", "clocking in at start of shift", "Task Analysis"),
+        ("Vocational", "completing assigned tasks in order", "Task Analysis"),
+        ("Home Skills", "doing laundry", "Task Analysis"),
+        ("Home Skills", "simple meal preparation", "Task Analysis"),
+        ("Community", "using public transportation", "Task Analysis"),
+        ("Mand", "requesting assistance using AAC device", "NET"),
+        ("Mand", "requesting a break during extended tasks", "NET"),
+        ("Mand", "indicating 'all done' at task completion", "NET"),
+        ("Tolerating Denied Access", "wait calmly when a preferred activity is denied", "FCT"),
+    ],
+}
+
+
+def sample_programs(learner_profile_id: str, n: int, rng: random.Random) -> list:
+    """Sample a realistic set of n acceleration programs for the learner profile."""
+    category_map = {
+        "early": "early_language",
+        "school_age": "school_age",
+        "adolescent": "adolescent",
+        "adult": "adult",
+    }
+    primary = category_map.get(learner_profile_id, "school_age")
+    pool = list(SKILL_POOL_BY_CATEGORY[primary])
+    # Mix in one program from an adjacent category for realism
+    adjacent = {"early": "school_age", "school_age": "early_language", "adolescent": "school_age", "adult": "adolescent"}
+    pool += SKILL_POOL_BY_CATEGORY[adjacent.get(learner_profile_id, "school_age")][:3]
+    rng.shuffle(pool)
+    return pool[:n]
+
+
+# Session log rendering
+
+
+def _render_measurements_for_program(
+    skill_domain: str, accuracy: float, rng: random.Random
+) -> str:
+    """Return a one-line measurement string for one program in one session."""
+    trials = rng.randint(8, 15)
+    correct = round(accuracy * trials)
+    fp = rng.randint(0, max(0, trials // 3))
+    pp = rng.randint(0, max(0, trials // 3))
+    g = rng.randint(0, max(0, trials // 3))
+    indep = max(0, trials - fp - pp - g)
+    prompts = f"FP×{fp}, PP×{pp}, G×{g}, I×{indep}"
+    latency = 1.5 + (1.0 - accuracy) * 4.5 + rng.uniform(-0.3, 0.3)
+    return f"{correct}/{trials} correct ({round(accuracy*100)}%); latency {latency:.1f}s; prompts {prompts}"
+
+
+def _render_behavior_measurement(behavior_id: str, freq: int, rng: random.Random) -> str:
+    """Return a measurement string for one target behavior in one session."""
+    if behavior_id in {"tantrum"}:
+        if freq == 0:
+            return f"freq 0"
+        duration_total = freq * rng.randint(2, 5)
+        return f"freq {freq}, duration {duration_total}m total"
+    if behavior_id in {"motor_stereotypy", "vocal_stereotypy", "mouthing"}:
+        pir_pct = min(60, freq * rng.randint(3, 5) + rng.randint(0, 10))
+        return f"freq {freq}; PIR {pir_pct}%"
+    if behavior_id == "pica":
+        # Pica is measured as attempts (total) and successful ingestions (subset).
+        # Most pica events are caught by staff before ingestion — successful ≤ attempts.
+        if freq == 0:
+            return "attempts 0"
+        attempts = freq
+        # Successful ingestion is stochastic but bounded; most are intercepted.
+        successful = 0
+        for _ in range(attempts):
+            if rng.random() < 0.25:
+                successful += 1
+        unsuccessful = attempts - successful
+        return (
+            f"attempts {attempts} ({unsuccessful} unsuccessful — staff retrieved item before ingestion; "
+            f"{successful} successful — item ingested)"
+        )
+    if behavior_id == "fecal_smearing":
+        # Scatolia is measured as attempts (reaching for feces) and completed smearing (subset).
+        # Staff often intercept before smearing completes — completed ≤ attempts.
+        if freq == 0:
+            return "attempts 0"
+        attempts = freq
+        completed = 0
+        for _ in range(attempts):
+            if rng.random() < 0.35:
+                completed += 1
+        intercepted = attempts - completed
+        return (
+            f"attempts {attempts} ({intercepted} intercepted — staff redirected before smearing; "
+            f"{completed} completed — feces transferred to skin, clothing, or surface)"
+        )
+    if behavior_id == "toileting_accident":
+        # Toileting data tracks both successful voids (in toilet) and accidents.
+        # BM accidents scale with overall accident load but stay physiologically
+        # bounded — typical session window is 0–1 BMs; some learners with GI
+        # clustering (IBS, diet, medication-related) can reach 2.
+        if freq == 0:
+            bm_accidents = 0
+        elif freq == 1:
+            bm_accidents = 1 if rng.random() < 0.25 else 0
+        elif freq <= 4:
+            bm_accidents = rng.choices([0, 1], weights=[0.65, 0.35])[0]
+        else:
+            bm_accidents = rng.choices([0, 1, 2], weights=[0.50, 0.35, 0.15])[0]
+        urine_accidents = max(0, freq - bm_accidents)
+
+        # Successful voids scale inversely with accident load — a session full
+        # of accidents represents missed toileting opportunities.
+        if freq == 0:
+            urine_success = rng.randint(3, 6)
+        elif freq <= 2:
+            urine_success = rng.randint(2, 5)
+        elif freq <= 4:
+            urine_success = rng.randint(1, 3)
+        else:
+            urine_success = rng.randint(0, 2)
+
+        # BM successes: typically 0 per session window, sometimes 1. Learners
+        # with BM accidents can still have an earlier successful BM in the toilet
+        # (e.g., scheduled morning sit worked, later opportunities missed).
+        if bm_accidents > 0:
+            bm_success = 1 if rng.random() < 0.15 else 0
+        else:
+            bm_success = rng.choices([0, 1], weights=[0.75, 0.25])[0]
+
+        return (
+            f"urine: {urine_success} in-toilet / {urine_accidents} accidents; "
+            f"BM: {bm_success} in-toilet / {bm_accidents} accidents"
+        )
+    if behavior_id in {"elopement"}:
+        return f"freq {freq}"
+    return f"freq {freq}"
+
+
+ABC_TEMPLATES = {
+    "escape": [
+        ("worksheet task presented", "refused + pushed materials away", "task removed for 2 min"),
+        ("demand to complete math problem", "threw materials and vocalized 'no'", "staff removed demand, redirected"),
+        ("transition to non-preferred activity", "dropped to floor, cried", "transition delayed, preferred item offered"),
+        ("asked to finish dressing task", "kicked at materials", "task paused for 3 min"),
+    ],
+    "attention": [
+        ("adult attention diverted to another learner", "vocalized loudly + approached staff", "staff turned to address behavior"),
+        ("staff engaged in paperwork nearby", "yelled name + tapped staff", "staff attended and redirected"),
+    ],
+    "tangible": [
+        ("preferred iPad removed at end of break", "screamed + reached for device", "staff redirected to alternative"),
+        ("peer took preferred toy", "grabbed toy back + cried", "staff mediated and returned item"),
+    ],
+    "automatic": [
+        ("quiet unstructured moment between trials", "engaged in hand-flapping", "no social consequence; self-terminated after 30s"),
+        ("waiting in line transition", "mouthed own hand", "staff redirected to task materials"),
+    ],
+}
+
+
+# Behavior-specific ABC overrides — used in preference to the function-keyed
+# templates above when the behavior has distinctive antecedents / topography.
+BEHAVIOR_ABC_TEMPLATES = {
+    "fecal_smearing": [
+        ("quiet moment in bathroom after bowel movement", "reached into diaper, retrieved feces", "staff redirected hands and initiated clean-up"),
+        ("unstructured downtime, staff out of direct line of sight", "reached behind waistband of pants", "staff intercepted and guided to bathroom"),
+        ("post-toileting, before hygiene steps completed", "transferred feces to arm and wall surface", "staff blocked further smearing, cleaned skin and surface"),
+        ("lying down for rest period", "reached into pull-up, brought hand to face", "staff intercepted before oral contact; hygiene routine initiated"),
+    ],
+    "toileting_accident": [
+        ("during demand sequence at the work table", "voided (urine) without signaling need", "staff paused programming, changed clothing, resumed after 10 min"),
+        ("transition from preferred activity to non-preferred task", "voided (urine) en route to the work area", "staff redirected to bathroom, changed clothing"),
+        ("end of 90-minute block without scheduled toileting", "soiled (bowel) at the work table", "staff initiated clean-up and hygiene routine; program paused"),
+        ("during group activity without requesting bathroom", "voided (urine) in seat", "staff removed learner from group, changed clothing, re-entered after clean-up"),
+    ],
+}
+
+
+def _render_abc_entry(behavior_id: str, behavior_name: str, function: str, rng: random.Random) -> str:
+    templates = BEHAVIOR_ABC_TEMPLATES.get(behavior_id) or ABC_TEMPLATES.get(function) or ABC_TEMPLATES["escape"]
+    a, b, c = rng.choice(templates)
+    return f"ABC ({behavior_name.lower()}): A = {a}; B = {b}; C = {c}"
+
+
+def render_session_log(
+    *,
+    synthetic_id: int,
+    learner_profile: dict,
+    curricula_line: str,
+    programs: list,
+    accuracies_per_program: list,
+    behaviors: list,
+    behavior_frequencies_per_behavior: list,
+    behavior_functions: list,
+    n_sessions: int,
+    start_date: date,
+    duration_per_session: int,
+    ioa_session_idx: int | None,
+    ioa_agreement: float | None,
+    include_abc: bool,
+    abc_sessions: list,
+    behavioral_indicators_cluster: list,
+    rng: random.Random,
+) -> str:
+    """Render the full multi-session log as text."""
+    lines = []
+    lines.append("LEARNER PROFILE")
+    lines.append(f"Synthetic ID: SYN-{synthetic_id}")
+    profile_text = f"{learner_profile['name']}"
+    if "chronological_age" in learner_profile:
+        profile_text += f" ({learner_profile['chronological_age']})"
+    elif "developmental_age" in learner_profile:
+        profile_text += f" (dev age {learner_profile['developmental_age']})"
+    lines.append(f"Profile: {profile_text}")
+    lines.append(f"Curricula: {curricula_line}")
+    end_date = start_date + timedelta(days=n_sessions * 2)
+    lines.append(f"Date range: Sessions 1–{n_sessions} across {(end_date - start_date).days} days ({start_date.isoformat()} to {end_date.isoformat()})")
+    lines.append("")
+
+    lines.append("ACCELERATION PROGRAMS")
+    for i, (domain, skill, method) in enumerate(programs, 1):
+        lines.append(f"{i}. {skill} ({domain})")
+        lines.append(f"   Method: {method}")
+    lines.append("")
+
+    if behaviors:
+        lines.append("DECELERATION TARGETS")
+        for i, (beh, fn) in enumerate(zip(behaviors, behavior_functions), 1):
+            lines.append(f"{i}. {beh['name']} — function hypothesized: {fn}")
+        lines.append("")
+
+    lines.append("SESSION DATA")
+    for s_idx in range(n_sessions):
+        session_num = s_idx + 1
+        d = (start_date + timedelta(days=s_idx * 2)).isoformat()
+        if ioa_session_idx == s_idx:
+            lines.append(f"")
+            lines.append(f"Session {session_num} — {d} — IOA SESSION — 2 observers")
+            for i, (domain, skill, method) in enumerate(programs):
+                acc = accuracies_per_program[i][s_idx]
+                lines.append(f"  {skill}: {round(acc*100)}% (primary); IOA {round(ioa_agreement*100)}% agreement")
+            for i, beh in enumerate(behaviors):
+                freq = behavior_frequencies_per_behavior[i][s_idx]
+                ms = _render_behavior_measurement(beh["id"], freq, rng)
+                lines.append(f"  {beh['name']}: {ms}; IOA {round(ioa_agreement*100)}% agreement")
+        else:
+            lines.append(f"")
+            lines.append(f"Session {session_num} — {d} — {duration_per_session} min — 1 observer")
+            for i, (domain, skill, method) in enumerate(programs):
+                acc = accuracies_per_program[i][s_idx]
+                ms = _render_measurements_for_program(domain, acc, rng)
+                lines.append(f"  {skill}: {ms}")
+            for i, beh in enumerate(behaviors):
+                freq = behavior_frequencies_per_behavior[i][s_idx]
+                ms = _render_behavior_measurement(beh["id"], freq, rng)
+                lines.append(f"  {beh['name']}: {ms}")
+            # ABC entry for this session?
+            if include_abc and s_idx in abc_sessions and behaviors:
+                beh_idx = rng.randrange(len(behaviors))
+                fn = behavior_functions[beh_idx]
+                if behavior_frequencies_per_behavior[beh_idx][s_idx] > 0:
+                    beh = behaviors[beh_idx]
+                    lines.append(f"  {_render_abc_entry(beh['id'], beh['name'], fn, rng)}")
+
+    if behavioral_indicators_cluster:
+        lines.append("")
+        lines.append("BEHAVIORAL OBSERVATIONS (across sessions)")
+        for ind in behavioral_indicators_cluster:
+            lines.append(f"- {ind}")
+
+    return "\n".join(lines)
+
+
+# Interpretation section assembly
+
+
+def assemble_clinical_concerns(
+    pattern_id: str,
+    pattern: dict,
+    accuracies_first_last: tuple,
+    behaviors: list,
+    behavior_frequencies_per_behavior: list,
+    n_sessions: int,
+) -> str:
+    """Produce the clinical-concerns bullets."""
+    first, last = accuracies_first_last
+    bullets = []
+    if pattern_id == "mastery_progression":
+        bullets.append(f"- Steady improvement: accuracy rose from {round(first*100)}% to {round(last*100)}% across {n_sessions} sessions.")
+        bullets.append("- No clinical concerns at this time; mastery criteria should be reachable within a few additional sessions.")
+    elif pattern_id == "regression":
+        bullets.append(f"- **Regression identified**: accuracy has declined from {round(first*100)}% to {round(last*100)}% across {n_sessions} sessions.")
+        if behaviors:
+            bullets.append("- Accompanying behavior data suggests the decline may be function-related.")
+    elif pattern_id == "plateau":
+        bullets.append(f"- **Plateau**: accuracy has remained near {round(((first+last)/2)*100)}% for {n_sessions} sessions without meaningful improvement.")
+        bullets.append("- Performance is below mastery criteria; current teaching procedure may not be effective for this learner.")
+    elif pattern_id == "frustration_pattern":
+        bullets.append(f"- **Frustration pattern**: declining accuracy ({round(first*100)}% -> {round(last*100)}%) with escape-indicator behaviors.")
+        bullets.append("- Risk of learned helplessness and escape-maintained behavior if not addressed.")
+    elif pattern_id == "variable_performance":
+        avg = (first + last) / 2
+        bullets.append(f"- **Variable performance**: accuracy fluctuating around {round(avg*100)}% with no clear trend.")
+        bullets.append("- Inconsistency may indicate stimulus-control issues or motivational variability across sessions.")
+    elif pattern_id == "prompt_dependency":
+        bullets.append(f"- **Prompt dependency**: high accuracy maintained ({round(first*100)}%–{round(last*100)}%) but primarily at prompted levels.")
+        bullets.append("- Independent responding remains low despite extended training.")
+    elif pattern_id == "rapid_acquisition":
+        bullets.append(f"- **Rapid acquisition**: accelerated mastery from {round(first*100)}% to {round(last*100)}% across {n_sessions} sessions.")
+        bullets.append("- Acquisition has exceeded expected timeline.")
+    elif pattern_id == "generalization_failure":
+        bullets.append("- **Generalization failure**: strong performance in training context but failure to generalize to novel conditions.")
+        bullets.append("- Skill may be under restricted stimulus control.")
+    elif pattern_id == "extinction_burst":
+        bullets.append("- **Extinction burst** observed: temporary increase in problem behavior consistent with an extinction procedure.")
+        bullets.append("- This is an expected phase of behavior change and typically indicates the intervention is working.")
+    elif pattern_id == "skill_loss_after_break":
+        bullets.append(f"- **Skill loss following break**: performance dropped to {round(first*100)}% at return, recovering to {round(last*100)}%.")
+        bullets.append("- Maintenance schedule should be reviewed and strengthened.")
+    elif pattern_id == "motivating_operation_shift":
+        bullets.append("- **Motivating-operation shift**: mid-log dip in responding followed by recovery suggests reinforcer-value change.")
+        bullets.append("- Possible satiation with current reinforcer; preference reassessment indicated.")
+    elif pattern_id == "setting_event_trigger":
+        bullets.append("- **Setting event pattern**: observable change in performance correlated with an external event (illness, sleep, schedule).")
+        bullets.append("- Correlation between setting event and performance should be tracked explicitly.")
+    return "\n".join(bullets)
+
+
+def assemble_function_hypothesis_section(
+    behaviors: list, behavior_functions: list, abc_events_summary: str
+) -> str:
+    """Produce the function hypothesis section, or empty string if no behaviors."""
+    if not behaviors:
+        return ""
+    lines = ["", "## Behavior Function Hypothesis"]
+    for beh, fn in zip(behaviors, behavior_functions):
+        lines.append(f"{beh['name']}: {fn}")
+        if fn != "unknown":
+            ev_bits = []
+            if abc_events_summary:
+                ev_bits.append(f"ABC events in the log support the {fn} function")
+            # Function-specific evidence without showing the operational definition
+            func_evidence = {
+                "escape": "behavior occurs in the context of demand presentation and terminates contingent on task removal",
+                "attention": "behavior occurs during low-attention periods and results in social attention contingently",
+                "tangible": "behavior occurs when preferred items are restricted and is followed by access to the item",
+                "automatic": "behavior persists across contexts without clear social mediation",
+            }
+            if fn in func_evidence:
+                ev_bits.append(func_evidence[fn])
+            lines.append(f"  Evidence: " + "; ".join(ev_bits) + ".")
+        else:
+            lines.append("  Evidence: insufficient data to disambiguate functions; recommend FBA / preference assessment before programming changes.")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def assemble_replacement_section(behaviors: list, behavior_functions: list, recs_pool: list) -> str:
+    """Produce the replacement behavior (FCT) section — only if behaviors present."""
+    if not behaviors or not recs_pool:
+        return ""
+    lines = ["", "### Replacement behavior (FCT)"]
+    for r in recs_pool[:3]:
+        lines.append(f"- {r}")
+    return "\n".join(lines) + "\n"
+
+
+def assemble_crisis_section(recs_pool: list, escalation_level: int) -> str:
+    """Produce the crisis plan section — only if escalation >= 3 and pool has items."""
+    if escalation_level < 3 or not recs_pool:
+        return ""
+    lines = ["", "### Crisis plan"]
+    for r in recs_pool[:3]:
+        lines.append(f"- {r}")
+    return "\n".join(lines) + "\n"
+
+
+def assemble_rationale(
+    accuracies_first_last: tuple,
+    mean_accuracy: float,
+    n_sessions: int,
+    behaviors: list,
+    behavior_frequencies_per_behavior: list,
+    ioa_present: bool,
+    ioa_agreement: float | None,
+) -> str:
+    """Produce the data-supported rationale bullets."""
+    first, last = accuracies_first_last
+    bullets = []
+    bullets.append(f"- Mean accuracy across {n_sessions} sessions: {round(mean_accuracy*100, 1)}%.")
+    direction = "upward" if last > first else "downward" if last < first else "flat"
+    bullets.append(f"- Trend direction: {direction} (first session: {round(first*100)}%, last session: {round(last*100)}%).")
+    if behaviors:
+        for beh, freqs in zip(behaviors, behavior_frequencies_per_behavior):
+            mean_f = sum(freqs) / len(freqs)
+            first_third = sum(freqs[:max(1, len(freqs)//3)]) / max(1, len(freqs)//3)
+            last_third = sum(freqs[-max(1, len(freqs)//3):]) / max(1, len(freqs)//3)
+            bullets.append(f"- {beh['name']}: mean {mean_f:.1f}/session (early-window mean {first_third:.1f} -> late-window mean {last_third:.1f}).")
+    if ioa_present and ioa_agreement is not None:
+        bullets.append(f"- IOA data: {round(ioa_agreement*100)}% agreement on IOA session — {'adequate' if ioa_agreement >= 0.80 else 'below threshold'}.")
+    else:
+        bullets.append("- No IOA session in this log; reliability of measurements cannot be independently verified.")
+    return "\n".join(bullets)
+
+
+# Escalation + confidence inference
+
+
+def infer_escalation(
+    pattern: dict,
+    behaviors: list,
+    behavior_frequencies_per_behavior: list,
+    rules: dict,
+) -> int:
+    """Compute escalation level from pattern + behavior severity."""
+    level = int(pattern["default_escalation"])
+    severe_ids = set(rules.get("severe_behavior_ids", []))
+    if any(b["id"] in severe_ids for b in behaviors):
+        level = min(4, level + rules.get("severe_behavior_escalation_bump", 1))
+    # Safety-immediate threshold
+    safety_threshold_ids = set(rules.get("safety_immediate_threshold_behaviors", []))
+    threshold_rate = rules.get("safety_immediate_sib_rate_per_session", 8)
+    for beh, freqs in zip(behaviors, behavior_frequencies_per_behavior):
+        if beh["id"] in safety_threshold_ids:
+            if len(freqs) >= 2 and all(f >= threshold_rate for f in freqs[-2:]):
+                level = 4
+    return level
+
+
+def infer_confidence(
+    n_sessions: int,
+    ioa_present: bool,
+    accuracies: list,
+    rules: dict,
+) -> str:
+    """Compute confidence level from data-quality features.
+
+    Rules:
+      - low: very short log, OR short log with no IOA and non-trivial variance
+      - moderate: default when criteria for high are not met
+      - high: long log with IOA evidence and low variance
+    """
+    mean = sum(accuracies) / len(accuracies)
+    sd = (sum((a - mean) ** 2 for a in accuracies) / len(accuracies)) ** 0.5
+
+    # Explicit low triggers
+    if n_sessions < rules["min_sessions_for_moderate"]:
+        return "low"
+    if n_sessions < 7 and not ioa_present and sd > 0.15:
+        return "low"
+    if sd > 0.35:
+        return "low"
+
+    # High requires long log + IOA + modest variance
+    if (
+        n_sessions >= rules["min_sessions_for_high"]
+        and (not rules["ioa_required_for_high"] or ioa_present)
+        and sd <= rules["variance_threshold_low"]
+    ):
+        return "high"
+
+    return "moderate"
+
+
+# Main generator class
+
+
+class SessionInterpretationGenerator:
+    def __init__(self, config_dir: Path):
+        self.config_dir = Path(config_dir)
+        self.shared = load_shared(self.config_dir)
+        self.area = load_area(self.config_dir, AREA)
+        self.template = self.area["template"]
+        self.taxonomy = self.area["taxonomy"]
+        self.compat = self.area["compatibility"]
+        self.trajectory_rules = load_yaml(self.config_dir / AREA / "trajectory_rules.yaml")
+        self.recommendations = load_yaml(self.config_dir / AREA / "recommendations.yaml")
+
+    def _pattern_by_id(self, pid: str) -> dict:
+        return next(p for p in self.taxonomy["patterns"] if p["id"] == pid)
+
+    def _behavior_by_id(self, bid: str) -> dict:
+        return next(b for b in self.taxonomy["target_behaviors"] if b["id"] == bid)
+
+    def _escalation_label(self, level: int) -> str:
+        return next(e["label"] for e in self.taxonomy["escalation_levels"] if e["id"] == level)
+
+    def render_example(self, rng: random.Random) -> dict:
+        # Sample hidden pattern
+        pattern = rng.choice(self.taxonomy["patterns"])
+        pattern_id = pattern["id"]
+
+        # Log length
+        lo, hi = self.compat["log_length_by_pattern"][pattern_id]
+        n_sessions = rng.randint(lo, hi)
+
+        # Learner profile (any — patterns are profile-agnostic)
+        profile = rng.choice(self.shared["learner_profiles"]["profiles"])
+
+        # Acceleration programs
+        n_programs = rng.randint(*self.compat["programs_per_log_range"])
+        programs = sample_programs(profile["id"], n_programs, rng)
+        curricula_names = sorted(set(p[0] for p in programs))
+        curricula_line = " + ".join(curricula_names)
+
+        # Trajectory per program (all programs follow the pattern's trajectory loosely)
+        rule = self.trajectory_rules["rules"][pattern_id]
+        accuracies_per_program = [
+            generate_accuracy_trajectory(pattern_id, rule, n_sessions, rng)
+            for _ in programs
+        ]
+
+        # Target behaviors (if any)
+        n_beh_lo, n_beh_hi = self.compat["pattern_behavior_count_ranges"][pattern_id]
+        n_behaviors = rng.randint(n_beh_lo, n_beh_hi)
+        behaviors = []
+        behavior_functions = []
+        if n_behaviors > 0:
+            function_bias = self.compat["pattern_function_bias"].get(pattern_id, [])
+            candidate_behs = [
+                b for b in self.taxonomy["target_behaviors"]
+                if any(f in b["plausible_functions"] for f in function_bias) or not function_bias
+            ]
+            behaviors = rng.sample(candidate_behs, min(n_behaviors, len(candidate_behs)))
+            for beh in behaviors:
+                if function_bias:
+                    valid = [f for f in function_bias if f in beh["plausible_functions"]]
+                    behavior_functions.append(rng.choice(valid) if valid else rng.choice(beh["plausible_functions"]))
+                else:
+                    behavior_functions.append(rng.choice(beh["plausible_functions"]))
+
+        # Behavior frequencies per session
+        behavior_freqs = []
+        if behaviors:
+            traj_name = self.trajectory_rules["rules"][pattern_id]["behavior_trajectory"]
+            for _ in behaviors:
+                freqs = generate_behavior_frequencies(
+                    traj_name, self.trajectory_rules["behavior_trajectory_library"],
+                    n_sessions, rule, rng,
+                )
+                behavior_freqs.append(freqs)
+
+        # IOA decision
+        include_ioa = rng.random() < self.compat["ioa_inclusion_probability"]
+        ioa_session_idx = None
+        ioa_agreement = None
+        if include_ioa and n_sessions >= 4:
+            ioa_session_idx = rng.randint(n_sessions // 3, 2 * n_sessions // 3)
+            if rng.random() < self.compat["ioa_low_probability"]:
+                ioa_agreement = rng.uniform(*self.compat["ioa_low_range"])
+            else:
+                ioa_agreement = rng.uniform(*self.compat["ioa_agreement_range"])
+
+        # ABC decision
+        include_abc = bool(behaviors) and rng.random() < self.compat["abc_inclusion_probability"]
+        abc_sessions = []
+        if include_abc:
+            candidate_sessions = [i for i in range(n_sessions) if any(bf[i] > 0 for bf in behavior_freqs)]
+            n_abc = min(rng.randint(1, 3), len(candidate_sessions))
+            abc_sessions = rng.sample(candidate_sessions, n_abc) if candidate_sessions else []
+
+        # Behavioral indicators
+        cluster = self.compat["pattern_behavioral_indicator_cluster"].get(pattern_id)
+        indicators = []
+        if cluster:
+            pool = self.taxonomy["behavioral_indicators"][cluster]
+            indicators = rng.sample(pool, min(rng.randint(2, 4), len(pool)))
+
+        # Log dates
+        start_date = date(2026, rng.randint(1, 10), rng.randint(1, 28))
+        duration_per_session = rng.randint(*self.compat["session_duration_minutes_range"])
+
+        # Synthetic ID
+        synthetic_id = rng.randint(1000, 9999)
+
+        # Render the user's session log
+        session_log = render_session_log(
+            synthetic_id=synthetic_id,
+            learner_profile=profile,
+            curricula_line=curricula_line,
+            programs=programs,
+            accuracies_per_program=accuracies_per_program,
+            behaviors=behaviors,
+            behavior_frequencies_per_behavior=behavior_freqs,
+            behavior_functions=behavior_functions,
+            n_sessions=n_sessions,
+            start_date=start_date,
+            duration_per_session=duration_per_session,
+            ioa_session_idx=ioa_session_idx,
+            ioa_agreement=ioa_agreement,
+            include_abc=include_abc,
+            abc_sessions=abc_sessions,
+            behavioral_indicators_cluster=indicators,
+            rng=rng,
+        )
+
+        # Compute gold labels
+        escalation_level = infer_escalation(
+            pattern, behaviors, behavior_freqs, self.compat["escalation_rules"]
+        )
+        # Flatten accuracies across all programs for variance check
+        flat_accs = [v for traj in accuracies_per_program for v in traj]
+        confidence_level = infer_confidence(
+            n_sessions, ioa_session_idx is not None, flat_accs, self.compat["confidence_rules"]
+        )
+
+        # Primary-program accuracies for concerns/rationale (take first program)
+        primary_accs = accuracies_per_program[0]
+        mean_primary = sum(primary_accs) / len(primary_accs)
+
+        # Assemble the assistant message sections
+        clinical_concerns_bullets = assemble_clinical_concerns(
+            pattern_id, pattern, (primary_accs[0], primary_accs[-1]),
+            behaviors, behavior_freqs, n_sessions,
+        )
+
+        pattern_explanations = {
+            "mastery_progression": "Accuracy is ascending cleanly across sessions with no interfering behaviors, consistent with a mastery-progression trajectory.",
+            "regression": "Previously-established responding has declined across recent sessions, warranting review of environmental and reinforcement variables.",
+            "plateau": "Responding has stabilized below mastery criterion without meaningful movement, indicating the current procedure is limiting further acquisition.",
+            "frustration_pattern": "Declining accuracy co-occurs with escape-indicator behaviors, consistent with frustration and escape-maintained responding to demand.",
+            "variable_performance": "High session-to-session variability with no clear trend suggests environmental or motivational inconsistency rather than a single programmatic issue.",
+            "prompt_dependency": "Accuracy stays high only at prompted levels; independent responding remains low despite extended training.",
+            "rapid_acquisition": "Accuracy ascended steeply beyond expected timeline for this learner's profile.",
+            "generalization_failure": "Alternation between strong training performance and poor novel-condition performance indicates restricted stimulus control.",
+            "extinction_burst": "Mid-log spike in problem-behavior frequency followed by recovery is consistent with a planned extinction procedure.",
+            "skill_loss_after_break": "Sharp drop at the start of the log followed by gradual recovery indicates skill loss following an absence.",
+            "motivating_operation_shift": "A mid-log dip followed by recovery maps onto a motivating-operation change rather than a skill issue.",
+            "setting_event_trigger": "A discontinuous performance change at a specific session correlates with an external setting event.",
+        }
+
+        function_section = assemble_function_hypothesis_section(
+            behaviors, behavior_functions,
+            "ABC events present" if include_abc and abc_sessions else ""
+        )
+
+        pattern_recs = self.recommendations["patterns"][pattern_id]
+        antecedent_pool = pattern_recs["antecedent"] or ["Continue monitoring; reassess in 2 weeks."]
+        consequence_pool = pattern_recs["consequence"] or ["Maintain current consequences."]
+        ant_bullets = "\n".join(f"- {r}" for r in antecedent_pool[:4])
+        con_bullets = "\n".join(f"- {r}" for r in consequence_pool[:3])
+
+        rep_section = assemble_replacement_section(
+            behaviors, behavior_functions, pattern_recs.get("replacement", [])
+        )
+        crisis_section = assemble_crisis_section(
+            pattern_recs.get("crisis", []), escalation_level
+        )
+
+        escalation_justifications = {
+            1: "Current programming is effective; no change needed.",
+            2: "Programming adjustments indicated at next session; no immediate safety concern.",
+            3: "Combination of performance decline and/or behavior data warrants supervising BCBA review within 24–48 hours.",
+            4: "Safety-critical signals require immediate cessation of current program and direct BCBA contact; consider crisis-plan activation.",
+        }
+
+        confidence_justifications = {
+            "high": f"Pattern is well-supported: {n_sessions} sessions of data, low variance, and IOA evidence confirm reliability.",
+            "moderate": f"Pattern is supported but alternatives cannot be fully excluded: {n_sessions} sessions of data" + (" with IOA evidence." if ioa_session_idx is not None else "; no IOA session included."),
+            "low": f"Insufficient data: only {n_sessions} sessions, high variance, and/or no IOA evidence. Recommend additional data collection before programming changes.",
+        }
+
+        rationale_bullets = assemble_rationale(
+            (primary_accs[0], primary_accs[-1]),
+            mean_primary,
+            n_sessions,
+            behaviors,
+            behavior_freqs,
+            ioa_session_idx is not None,
+            ioa_agreement,
+        )
+
+        # Fill template
+        user_variant = rng.choice(self.template["user_variants"])
+        user_content = user_variant.format(session_log=session_log)
+
+        assistant_content = self.template["assistant_template"].format(
+            clinical_concerns_bullets=clinical_concerns_bullets,
+            pattern_class=pattern_id,
+            pattern_explanation=pattern_explanations[pattern_id],
+            function_hypothesis_section=function_section,
+            antecedent_bullets=ant_bullets,
+            replacement_section=rep_section,
+            consequence_bullets=con_bullets,
+            crisis_section=crisis_section,
+            escalation_level=escalation_level,
+            escalation_label=self._escalation_label(escalation_level),
+            escalation_justification=escalation_justifications[escalation_level],
+            confidence_level=confidence_level,
+            confidence_justification=confidence_justifications[confidence_level],
+            rationale_bullets=rationale_bullets,
+        )
+
+        # Metadata
+        gold_labels = {
+            "pattern_class": pattern_id,
+            "behavior_functions": {b["name"]: f for b, f in zip(behaviors, behavior_functions)},
+            "escalation_level": escalation_level,
+            "confidence": confidence_level,
+            "crisis_plan_required": escalation_level >= 3,
+        }
+        provenance = {
+            "layer": 1,
+            "area": AREA,
+            "template_id": self.template["template_id"],
+            "taxonomy_cells": {
+                "hidden_pattern_id": pattern_id,
+                "learner_profile": profile["id"],
+                "n_sessions": n_sessions,
+                "n_programs": len(programs),
+                "n_behaviors": len(behaviors),
+                "behavior_ids": [b["id"] for b in behaviors],
+                "behavior_functions": list(behavior_functions),
+                "has_abc_data": include_abc and bool(abc_sessions),
+                "has_ioa_session": ioa_session_idx is not None,
+            },
+            "teacher_model": None,
+            "seed_tag": str(rng.getstate()[1][0] % 100000),
+        }
+
+        return make_example_envelope(
+            system_content=self.template["system_prompt"],
+            user_content=user_content,
+            assistant_content=assistant_content,
+            task_type=TASK_TYPE,
+            gold_labels=gold_labels,
+            provenance=provenance,
+        )

src/generators/aba_task_analysis.py

@@ -0,0 +1,277 @@
+"""Task Analysis / Chaining area generator.
+
+Loads configs/task_analysis/ + configs/shared/ and produces chaining
+teaching program examples for AFLS modules (Basic Living, Home, Community,
+Vocational, Independent Living).
+"""
+
+import random
+from pathlib import Path
+
+from .base import (
+    load_area,
+    load_shared,
+    load_yaml,
+    make_example_envelope,
+)
+
+AREA = "task_analysis"
+TASK_TYPE = "teaching_program"
+
+
+# Mastery state -> which shaping step the learner is currently at (as index range
+# within the shaping_steps list). 0-indexed, end-exclusive.
+TOLERATION_MASTERY_STEP_RANGES = {
+    "emerging": (0, 2),
+    "developing": (1, 3),
+    "approaching": (2, 4),
+    "near": (3, 5),
+    "mastered": (4, 6),
+    "generalization": (5, 7),
+}
+
+
+def current_shaping_step_guidance(mastery_state_id: str, shaping_steps: list) -> str:
+    """Describe where the learner is currently sitting in the shaping progression."""
+    n = len(shaping_steps)
+    lo, hi = TOLERATION_MASTERY_STEP_RANGES.get(mastery_state_id, (0, 2))
+    lo = max(0, min(lo, n - 1))
+    hi = max(lo + 1, min(hi, n))
+    idx = min(lo, n - 1)
+    return (
+        f"begin at shaping step {idx + 1} (\"{shaping_steps[idx]}\") and advance through "
+        f"step {hi} across sessions as tolerance stabilizes."
+    )
+
+
+def render_shaping_steps(shaping_steps: list) -> str:
+    """Render numbered shaping progression."""
+    return "\n".join(f"{i}. {step}" for i, step in enumerate(shaping_steps, 1))
+
+
+def current_prompt_guidance(mastery_state_id: str, prompt_strategy_id: str) -> str:
+    """Guidance for chaining prompt level at the current mastery state."""
+    if mastery_state_id in {"emerging", "developing"}:
+        if prompt_strategy_id == "graduated_guidance":
+            return "provide hand-over-hand guidance at each step; reduce physical pressure across sessions."
+        return "use full-physical or partial-physical prompts at each step; fade systematically."
+    if mastery_state_id == "approaching":
+        return "use partial-physical or gestural prompts only at steps where errors occur; allow independence elsewhere."
+    if mastery_state_id in {"near", "mastered", "generalization"}:
+        return "deliver the least intrusive prompt that prevents an error; expect independence on previously-mastered steps."
+    return "prompt level calibrated to current performance."
+
+
+def render_steps(step_list: list, chain_type_id: str) -> str:
+    """Render numbered step list, with callout of the learner-taught step for backward chaining."""
+    lines = []
+    for i, step in enumerate(step_list, 1):
+        if chain_type_id == "backward" and i == len(step_list):
+            lines.append(f"{i}. {step}  <- Learner-taught step (backward chaining starts here)")
+        elif chain_type_id == "forward" and i == 1:
+            lines.append(f"{i}. {step}  <- Learner-taught step (forward chaining starts here)")
+        else:
+            lines.append(f"{i}. {step}")
+    return "\n".join(lines)
+
+
+def render_criterion_text(criterion: dict, rng: random.Random) -> str:
+    """Fill any slots in the mastery-criterion text (e.g., fluency seconds)."""
+    text = criterion["text"]
+    if "{fluency_seconds}" in text:
+        text = text.replace("{fluency_seconds}", str(rng.choice([60, 90, 120, 180])))
+    return text
+
+
+class TaskAnalysisGenerator:
+    def __init__(self, config_dir: Path):
+        self.config_dir = Path(config_dir)
+        self.shared = load_shared(self.config_dir)
+        self.area = load_area(self.config_dir, AREA)
+        self.template = self.area["template"]                        # chain-based (independence)
+        self.template_toleration = load_yaml(
+            self.config_dir / AREA / "template_toleration.yaml"
+        )
+        self.taxonomy = self.area["taxonomy"]
+        self.compat = self.area["compatibility"]
+
+    def sample_combination(self, rng: random.Random) -> dict:
+        # Weighted module selection
+        module_weights = self.compat["module_sampling_weights"]
+        modules = self.taxonomy["afls"]["modules"]
+        module_ids = [m["id"] for m in modules]
+        weights = [module_weights[mid] for mid in module_ids]
+        module = rng.choices(modules, weights=weights)[0]
+
+        # Sample a skill from the module
+        skill_entry = rng.choice(module["skills"])
+        skill_target = skill_entry["name"]
+        is_toleration = skill_entry.get("program_type") == "toleration"
+
+        # Learner profile — intersect module's allowed with the (shared) learner list
+        profiles = self.shared["learner_profiles"]["profiles"]
+        module_allowed = set(module["learner_profiles"])
+        profile = rng.choice([p for p in profiles if p["id"] in module_allowed])
+
+        mastery_state = rng.choice(self.shared["mastery_states"]["states"])
+
+        # Filter mastery criteria by program type (independence vs toleration)
+        program_type = "toleration" if is_toleration else "independence"
+        eligible_criteria = [
+            c for c in self.taxonomy["mastery_criteria"]
+            if c.get("applies_to", "independence") == program_type
+        ]
+        if not eligible_criteria:
+            eligible_criteria = self.taxonomy["mastery_criteria"]
+        mastery_criterion = rng.choice(eligible_criteria)
+
+        if is_toleration:
+            # Toleration programs: duration-based shaping, no chain / prompt / EC fields needed.
+            return {
+                "skill_target": skill_target,
+                "program_type": "toleration",
+                "shaping_steps": skill_entry["shaping_steps"],
+                "target_activity": skill_entry["target_activity"],
+                "end_goal_description": skill_entry["end_goal_description"],
+                "module_id": module["id"],
+                "module_name": module["name"],
+                "learner_profile": profile,
+                "mastery_state": mastery_state,
+                "mastery_criterion": mastery_criterion,
+            }
+
+        # Independence (chain-based) program — existing path
+        steps = skill_entry["steps"]
+        preferred_chain = skill_entry.get("chain_type_preferred", "total_task")
+
+        if rng.random() < self.compat["use_preferred_chain_type_probability"]:
+            chain_type = next(c for c in self.taxonomy["chain_types"] if c["id"] == preferred_chain)
+        else:
+            chain_type = rng.choice(self.taxonomy["chain_types"])
+
+        allowed_strategy_ids = set(self.compat["mastery_to_prompt_strategies"][mastery_state["id"]])
+        valid_strategies = [s for s in self.taxonomy["prompt_hierarchies"] if s["id"] in allowed_strategy_ids]
+        if not valid_strategies:
+            valid_strategies = self.taxonomy["prompt_hierarchies"]
+        prompt_strategy = rng.choice(valid_strategies)
+
+        allowed_schedule_ids = set(self.compat["mastery_to_reinforcement"][mastery_state["id"]])
+        valid_schedules = [s for s in self.taxonomy["reinforcement_schedules"] if s["id"] in allowed_schedule_ids]
+        if not valid_schedules:
+            valid_schedules = [s for s in self.taxonomy["reinforcement_schedules"] if s["id"] == "crf_per_step"]
+        reinforcement_schedule = rng.choice(valid_schedules)
+
+        error_correction = rng.choice(self.taxonomy["error_corrections"])
+
+        return {
+            "skill_target": skill_target,
+            "program_type": "independence",
+            "steps": steps,
+            "module_id": module["id"],
+            "module_name": module["name"],
+            "chain_type": chain_type,
+            "learner_profile": profile,
+            "mastery_state": mastery_state,
+            "prompt_strategy": prompt_strategy,
+            "reinforcement_schedule": reinforcement_schedule,
+            "error_correction": error_correction,
+            "mastery_criterion": mastery_criterion,
+        }
+
+    def compute_slots(self, combo: dict, rng: random.Random) -> dict:
+        mastery_state = combo["mastery_state"]
+        common = {
+            "skill_target": combo["skill_target"],
+            "curriculum_ref": f"AFLS {combo['module_name']}",
+            "learner_profile_name": combo["learner_profile"]["name"],
+            "mastery_state_name": mastery_state["name"],
+            "mastery_state_short": mastery_state.get("short", mastery_state["name"].lower()),
+            "mastery_criterion_text": render_criterion_text(combo["mastery_criterion"], rng),
+            "ioa_frequency": rng.choice([3, 4, 5]),
+            "n_generalization_settings": rng.choice([2, 3]),
+            "n_generalization_therapists": rng.choice([2, 3]),
+        }
+
+        if combo["program_type"] == "toleration":
+            return {
+                **common,
+                "target_activity": combo["target_activity"],
+                "end_goal_description": combo["end_goal_description"],
+                "shaping_step_list": render_shaping_steps(combo["shaping_steps"]),
+                "current_step_guidance": current_shaping_step_guidance(
+                    mastery_state["id"], combo["shaping_steps"]
+                ),
+            }
+
+        # Independence (chain-based)
+        ec_steps_clean = combo["error_correction"]["steps"].strip()
+        return {
+            **common,
+            "chain_type_name": combo["chain_type"]["name"],
+            "chain_type_description": combo["chain_type"]["description"],
+            "step_list": render_steps(combo["steps"], combo["chain_type"]["id"]),
+            "prompt_strategy_name": combo["prompt_strategy"]["name"],
+            "prompt_strategy_description": combo["prompt_strategy"]["description"],
+            "current_prompt_guidance": current_prompt_guidance(mastery_state["id"], combo["prompt_strategy"]["id"]),
+            "error_correction_name": combo["error_correction"]["name"],
+            "error_correction_steps": ec_steps_clean.rstrip("."),
+            "reinforcement_schedule_name": combo["reinforcement_schedule"]["name"],
+            "reinforcement_description": combo["reinforcement_schedule"]["description"].rstrip("."),
+        }
+
+    def render_example(self, rng: random.Random) -> dict:
+        combo = self.sample_combination(rng)
+        slots = self.compute_slots(combo, rng)
+
+        template = (
+            self.template_toleration
+            if combo["program_type"] == "toleration"
+            else self.template
+        )
+        user_variant = rng.choice(template["user_variants"])
+        user_content = user_variant.format(**slots)
+        assistant_content = template["assistant_template"].format(**slots)
+
+        gold_labels = {
+            "method": AREA,
+            "domain": f"AFLS.{combo['module_id']}",
+            "skill": combo["skill_target"],
+            "program_type": combo["program_type"],
+            "learner_profile": combo["learner_profile"]["id"],
+            "mastery_state": combo["mastery_state"]["id"],
+        }
+        if combo["program_type"] == "independence":
+            gold_labels["chain_type"] = combo["chain_type"]["id"]
+
+        taxonomy_cells = {
+            "skill_target": combo["skill_target"],
+            "module": combo["module_id"],
+            "mastery_criterion": combo["mastery_criterion"]["id"],
+        }
+        if combo["program_type"] == "independence":
+            taxonomy_cells.update({
+                "chain_type": combo["chain_type"]["id"],
+                "prompt_strategy": combo["prompt_strategy"]["id"],
+                "reinforcement_schedule": combo["reinforcement_schedule"]["id"],
+                "error_correction": combo["error_correction"]["id"],
+            })
+        else:
+            taxonomy_cells["shaping_n_steps"] = len(combo["shaping_steps"])
+
+        provenance = {
+            "layer": 1,
+            "area": AREA,
+            "template_id": template["template_id"],
+            "taxonomy_cells": taxonomy_cells,
+            "teacher_model": None,
+            "seed_tag": str(rng.getstate()[1][0] % 100000),
+        }
+
+        return make_example_envelope(
+            system_content=template["system_prompt"],
+            user_content=user_content,
+            assistant_content=assistant_content,
+            task_type=TASK_TYPE,
+            gold_labels=gold_labels,
+            provenance=provenance,
+        )

src/generators/base.py

@@ -0,0 +1,214 @@
+"""Shared base utilities for per-area generators.
+
+This module is domain-agnostic. Area-specific logic lives in
+`aba_<area>.py` modules.
+"""
+
+import random
+import re
+from pathlib import Path
+
+import yaml
+
+# ============================================================
+# YAML loading
+# ============================================================
+
+
+def load_yaml(path: Path) -> dict:
+    """Load a single YAML file."""
+    with open(path) as f:
+        return yaml.safe_load(f)
+
+
+def load_shared(config_dir: Path) -> dict:
+    """Load the shared primitives used across all areas.
+
+    Returns a dict keyed by primitive name:
+        learner_profiles, mastery_states, prompt_types
+    """
+    shared_dir = Path(config_dir) / "shared"
+    return {
+        "learner_profiles": load_yaml(shared_dir / "learner_profiles.yaml"),
+        "mastery_states": load_yaml(shared_dir / "mastery_states.yaml"),
+        "prompt_types": load_yaml(shared_dir / "prompt_types.yaml"),
+    }
+
+
+def load_area(config_dir: Path, area: str) -> dict:
+    """Load an area's self-contained config: taxonomy + template + compatibility."""
+    area_dir = Path(config_dir) / area
+    if not area_dir.is_dir():
+        raise FileNotFoundError(f"Area config directory not found: {area_dir}")
+    return {
+        "taxonomy": load_yaml(area_dir / "taxonomy.yaml"),
+        "template": load_yaml(area_dir / "template.yaml"),
+        "compatibility": load_yaml(area_dir / "compatibility.yaml"),
+    }
+
+
+# ============================================================
+# Text / rendering utilities
+# ============================================================
+
+
+def article(word: str) -> str:
+    """Return 'a' or 'an' appropriate for the following word."""
+    if not word:
+        return "a"
+    return "an" if word[0].lower() in "aeiou" else "a"
+
+
+def strip_trailing_period(text: str) -> str:
+    """Remove a single trailing period — for safe mid-sentence embedding."""
+    return text.rstrip().rstrip(".")
+
+
+def render_prompt_sequence(hierarchy_sequence: list, prompt_types: list) -> str:
+    """Render a prompt-hierarchy sequence as a human-readable arrow chain.
+
+    Looks up each item in the canonical prompt_types list; falls back to
+    underscore-to-space conversion for composite IDs like '0s_delay'.
+    """
+    id_to_name = {pt["id"]: pt["name"] for pt in prompt_types}
+    rendered = []
+    for seq_id in hierarchy_sequence:
+        if seq_id in id_to_name:
+            rendered.append(id_to_name[seq_id].lower())
+        else:
+            rendered.append(seq_id.replace("_", " "))
+    return " -> ".join(rendered)
+
+
+def parse_skill_numeric_range(skill_text: str):
+    """Extract (min, max) numeric range from skill text.
+
+    Handles patterns like '1-5', '1–5' (en-dash), 'to 10', '1-20'.
+    Returns None if no range is present.
+    """
+    s = skill_text.lower()
+    m = re.search(r"(\d+)\s*[-–]\s*(\d+)", s)
+    if m:
+        lo, hi = int(m.group(1)), int(m.group(2))
+        return (min(lo, hi), max(lo, hi))
+    m = re.search(r"to\s+(\d+)", s)
+    if m:
+        return (1, int(m.group(1)))
+    return None
+
+
+# ============================================================
+# Shared stimulus pools (used by DTT-like array-based generators)
+# ============================================================
+
+STIMULUS_POOLS = {
+    "objects": [
+        "ball", "cup", "shoe", "spoon", "book", "car", "block", "brush", "key",
+        "phone", "hat", "sock", "apple", "crayon", "scissors", "glue", "pencil",
+        "napkin", "plate", "towel", "jacket", "backpack", "bottle", "blanket",
+        "toothbrush",
+    ],
+    "colors": ["red", "blue", "green", "yellow", "orange", "purple", "pink", "brown", "black", "white"],
+    "shapes": ["circle", "square", "triangle", "rectangle", "star", "diamond", "oval", "heart"],
+    "animals": [
+        "dog", "cat", "bird", "fish", "horse", "cow", "pig", "sheep", "rabbit",
+        "frog", "bear", "lion", "elephant", "monkey", "duck", "chicken",
+    ],
+    "actions": [
+        "running", "jumping", "eating", "sleeping", "reading", "writing",
+        "drawing", "singing", "clapping", "washing", "brushing", "pouring",
+    ],
+    "letters": list("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
+    "numbers": [str(n) for n in range(1, 21)],
+}
+
+SKILL_TO_POOL = [
+    ("color", "colors"),
+    ("shape", "shapes"),
+    ("animal", "animals"),
+    ("letter", "letters"),
+    ("number", "numbers"),
+    ("numeral", "numbers"),
+    ("count", "numbers"),
+    ("action", "actions"),
+]
+
+
+def choose_stimulus_pool(skill_target: str) -> str:
+    """Pick the stimulus pool whose keyword appears in the skill name; default 'objects'."""
+    s = skill_target.lower()
+    for keyword, pool in SKILL_TO_POOL:
+        if keyword in s:
+            return pool
+    return "objects"
+
+
+def sample_stimuli(
+    skill_target: str, array_size_n: int, rng: random.Random
+) -> dict:
+    """Pick target + distractor stimuli, respecting any numeric range in the skill text."""
+    pool_name = choose_stimulus_pool(skill_target)
+    pool = list(STIMULUS_POOLS[pool_name])
+
+    rng_tuple = parse_skill_numeric_range(skill_target)
+    if rng_tuple is not None:
+        lo, hi = rng_tuple
+        if pool_name == "numbers":
+            pool = [str(n) for n in range(lo, hi + 1)]
+        elif pool_name == "letters":
+            pool = pool[: max(hi, 3)]
+
+    n_targets = min(3, len(pool))
+    targets = rng.sample(pool, n_targets)
+    remaining = [x for x in pool if x not in targets]
+    n_distractors = min(max(array_size_n - 1, 0), len(remaining))
+    distractors = rng.sample(remaining, n_distractors) if n_distractors > 0 else []
+    return {"targets": targets, "distractors": distractors}
+
+
+# ============================================================
+# Example envelope helpers
+# ============================================================
+
+
+import hashlib
+
+
+def make_example_envelope(
+    *,
+    system_content: str,
+    user_content: str,
+    assistant_content: str,
+    task_type: str,
+    gold_labels: dict,
+    provenance: dict,
+) -> dict:
+    """Assemble the final JSONL example dict with id + meta envelope.
+
+    Envelope is a deterministic function of its inputs: identical inputs produce
+    an identical envelope, including the example_id. The example_id is
+    ``sha256(user_content + assistant_content)[:16]`` computed on the *published*
+    (stripped) message content, so any consumer can verify it directly from the
+    JSONL row. Per-run wall-clock timestamps are deliberately NOT included so
+    that running the generator twice with the same seed produces byte-identical
+    output.
+    """
+    system_content = system_content.strip()
+    user_content = user_content.strip()
+    assistant_content = assistant_content.strip()
+    example_hash = hashlib.sha256(
+        (user_content + assistant_content).encode()
+    ).hexdigest()[:16]
+    return {
+        "messages": [
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": user_content},
+            {"role": "assistant", "content": assistant_content},
+        ],
+        "meta": {
+            "task_type": task_type,
+            "example_id": example_hash,
+            "gold_labels": gold_labels,
+            "provenance": provenance,
+        },
+    }

src/prepare_curation.py

@@ -0,0 +1,151 @@
+"""Render curation_pool.jsonl as a readable review document.
+
+This used to drive a hand-curation workflow with decisions.csv; we now
+use the whole curation pool as our test set (see compile_curation.py).
+review.md is still produced as a human-readable browse of the test
+corpus so clinical issues can be flagged ad hoc and fixed in the
+generator configs.
+
+Usage:
+    uv run python src/prepare_curation.py
+"""
+
+import json
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+POOL_PATH = REPO_ROOT / "data" / "splits" / "curation_pool.jsonl"
+REVIEW_MD = REPO_ROOT / "docs" / "curation" / "review.md"
+
+
+def category_of(example: dict) -> str:
+    """Short category label for a candidate."""
+    gl = example["meta"]["gold_labels"]
+    if example["meta"]["task_type"] == "teaching_program":
+        return gl.get("method", "?")
+    return gl.get("pattern_class", "?")
+
+
+def gold_labels_markdown(example: dict) -> str:
+    """Render gold labels inline for the review markdown."""
+    gl = example["meta"]["gold_labels"]
+    bits = []
+    for k, v in gl.items():
+        if isinstance(v, dict):
+            inner = ", ".join(f"{ik}->{iv}" for ik, iv in v.items())
+            bits.append(f"**{k}:** {{{inner}}}")
+        elif isinstance(v, bool):
+            bits.append(f"**{k}:** {str(v).lower()}")
+        else:
+            bits.append(f"**{k}:** `{v}`")
+    return " · ".join(bits)
+
+
+def provenance_markdown(example: dict) -> str:
+    """Render a short provenance line."""
+    prov = example["meta"].get("provenance", {})
+    bits = []
+    if "n_sessions" in prov:
+        bits.append(f"{prov['n_sessions']} sessions")
+    if "n_behaviors" in prov:
+        bits.append(f"{prov['n_behaviors']} behaviors")
+    if "has_ioa_session" in prov:
+        bits.append("IOA ✓" if prov["has_ioa_session"] else "no IOA")
+    if "has_abc_data" in prov:
+        bits.append("ABC ✓" if prov["has_abc_data"] else "no ABC")
+    return " · ".join(bits) if bits else ""
+
+
+def render_candidate(idx: int, example: dict) -> str:
+    """Render one candidate as a markdown block."""
+    task = example["meta"]["task_type"]
+    cat = category_of(example)
+    example_id = example["meta"]["example_id"]
+    user_content = example["messages"][1]["content"]
+    assistant_content = example["messages"][2]["content"]
+    prov_str = provenance_markdown(example)
+    prov_line = f"\n*{prov_str}*\n" if prov_str else "\n"
+
+    return f"""
+---
+
+### Candidate {idx:03d} | `{task}` | `{cat}` | id `{example_id}`
+
+**Gold labels:** {gold_labels_markdown(example)}
+{prov_line}
+<details>
+<summary><strong>User message (click to expand)</strong></summary>
+
+```
+{user_content}
+```
+
+</details>
+
+<details>
+<summary><strong>Assistant response (click to expand)</strong></summary>
+
+```
+{assistant_content}
+```
+
+</details>
+"""
+
+
+def main() -> int:
+    if not POOL_PATH.exists():
+        print(f"Curation pool not found: {POOL_PATH}", file=sys.stderr)
+        print("Run `uv run python src/split_data.py` first.", file=sys.stderr)
+        return 1
+
+    candidates: list[dict] = []
+    with open(POOL_PATH) as f:
+        for line in f:
+            candidates.append(json.loads(line))
+
+    # Group by category for diversity visibility.
+    grouped_raw: dict[str, list[dict]] = {}
+    for ex in candidates:
+        key = f"{ex['meta']['task_type']} / {category_of(ex)}"
+        grouped_raw.setdefault(key, []).append(ex)
+
+    ordered: list[tuple[int, dict, str]] = []
+    idx = 0
+    for key in sorted(grouped_raw.keys()):
+        for ex in grouped_raw[key]:
+            idx += 1
+            ordered.append((idx, ex, key))
+
+    REVIEW_MD.parent.mkdir(parents=True, exist_ok=True)
+    with open(REVIEW_MD, "w") as f:
+        f.write("# Corpus Review — TRACE test corpus\n\n")
+        f.write(f"**{len(candidates)} examples** held out as the evaluation corpus.\n\n")
+        f.write("## How to use this file\n")
+        f.write("- Browse candidates below to spot clinical-accuracy issues "
+                "(wrong topography, unrealistic scenario, inconsistent data, etc.).\n")
+        f.write("- When you find one, note the candidate id (shown next to the candidate title). "
+                "Fixes are applied by editing the generator configs in `configs/` and regenerating.\n")
+        f.write("- The test + sanity splits are compiled from this pool by "
+                "`uv run python src/compile_curation.py` (no per-example decisions required).\n\n")
+        f.write("## Distribution\n\n")
+        f.write("| Category | Count |\n|---|---|\n")
+        for key in sorted(grouped_raw.keys()):
+            f.write(f"| {key} | {len(grouped_raw[key])} |\n")
+        f.write("\n---\n\n")
+        f.write("## Candidates\n")
+        current_group = None
+        for idx, ex, key in ordered:
+            if key != current_group:
+                f.write(f"\n### Group: {key}\n")
+                current_group = key
+            f.write(render_candidate(idx, ex))
+
+    print(f"Wrote: {REVIEW_MD}  ({len(candidates)} candidates)")
+    print("Next: run `uv run python src/compile_curation.py` to produce test.jsonl + sanity.jsonl.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())