Synthetic Data Factory (Thalamic / Spikenaut / Agoge): unencumbered generation

Registry, schemas, pipelines, and tests for synthetic data generated without a frontier model producing it: registry-registered procedural generators with fresh human-authored or permissively sourced catalogs, deterministic in-repo simulators admitted as authoritative oracles, and, only after their terms snapshots are pinned, DeepSeek / Nemotron lanes. Frontier hosted-model outputs (Claude Fable 5, GPT-5.6-Sol, Grok 4.6, Muse Spark) are research-only under the project rights policy (#161); the public Fable 5 and Grok 4.6 datasets stay published as research artifacts.

Notebook: synthetic-factory on Notion. Repo is source of truth. Raw JSONL is append-only.

Generation attribution (historical)

The legacy research corpora — the five public Fable 5 datasets below and the 44-dataset Grok 4.6 family — were generated by Claude Fable 5 (Ultracode) and Grok 4.6 respectively, operating through the prompt-driven factory prompts and agent roles. That attribution is historical: neither model is the project's generator, and their outputs are research-only (intended_use: research_only, project_training_policy: blocked). Subsequent curation, validation, filtering, schema normalization, and release engineering may include work by Codex, Grok, other AI systems, and human reviewers.

Generator lanes and rights

Every factory is one reviewed row in config/FACTORY-REGISTRY.json (factory-registry-v0.4), keyed by exact path_id and payload_factory, that names its generator and, where the row has them, its provider/channel assignment and rights profile (the Fable 5 generator appears on five rows, Grok 4.6 on 44). Four rows have no provider/channel: the two procedural rows (python-function-repair-factory, oracle-grounded) also have no rights profile and rest on their sealed source policy instead, and the two native-parity rows (hardware-parity-spike-trajectories, nir-cross-runtime-equivalence) carry the native-parity-research-only-v1 rights profile. The fail-closed rights policy from PR #168 (pipelines/rights_*.py, schemas/rights-policy-v1.mapping.json) resolves that row to intended_use and project_training_policy; unknown provenance resolves to blocked. There are two lanes:

• Research-only (research_only / blocked): frontier hosted-model outputs — Claude Fable 5, GPT-5.6-Sol, Grok 4.6, Muse Spark — and the mill-generated records whose catalogs were authored in Grok sessions (#173). They can be measured, compared, and, where redistribution is cleared, published; they never enter SFT, DPO, RL, distillation, or any other weight update.
• Training-candidate (training_candidate / allowed once the row's evidence is in place): registry-registered procedural generators with fresh human-authored or permissively sourced catalogs (#175, epic #169); deterministic in-repo simulators admitted as authoritative oracles (#171, epic #76); pinned local open-weight generators on local_vllm (Nemotron 3 Nano 4B first, then Lightning / Muse Glimmer / Granite specialists) and OpenRouter models only when generation-time distillable=true catalog membership plus underlying terms snapshots are pinned (#186, #170, #163). A rights decision for one channel never unblocks another: local vLLM ≠ local Ollama ≠ OpenRouter ≠ NIM/watsonx/hosted API.

Today identity attaches a bound rights envelope to every retained mapping. Compose, the training audit, the curation gate, and Hugging Face export enforce that envelope. Research-only records stay available for measurement and, where redistribution is cleared, publication; they cannot become training_ready or enter a training export. training_ready for identity-cleaned or composed records, in COMPOSE.json, or in export provenance.json includes both structural and rights checks. Raw-run audits remain structural diagnostics and do not grant export authority. Hosted frontier rows stay research_only / blocked. The procedural python-function-repair-factory and oracle-grounded rows are training-candidate paths (training_candidate / allowed) after sealed source admission, fresh replay, and completed-round gates; the reviewed model-channel rows carry allowed as channel eligibility, not a publish or training-ready claim. Project policy and provider training status are independent: both must be allowed, with reviewed evidence and an exact source-byte binding, before a record can enter a training-ready export. Retained rights are replayed from the reviewed registry and exact source bytes; a declared allowed value is insufficient. Existing curated artifacts without complete bound rights evidence must be regenerated through identity and compose before training export. Procedural curation preserves the original record bytes and verifies completion against the original published source tree, which must remain available for audit and promotion. The contract every new generator must meet is the "Generator rule" (formerly AGENTS.md, retired in #184; preserved at the tag).

A public dataset can ship a machine-readable rights.json sidecar, validated by pipelines/rights_document.py (strict JSON, exact field set, closed vocabularies; anything else raises at load). Schema 0.1.0 is the hosted-frontier route: provider, channel, model, terms evidence, and a decision that must equal the sealed hosted authorization. Schema 0.2.0 adds the procedural route (source_type: procedural, pipelines/rights_document_procedural.py) for a dataset produced by a procedural registry row (python-function-repair-factory, oracle-grounded): the document names the row (path_id, payload_factory, generator, generator_version), repeats its intended_use, project_training_policy, source_license_evidence, catalog pins (catalog_id, catalog_sha256, programs_sha256) and procedural_policy_sha256 exactly as the loaded registry states them, and declares release_license: apache-2.0 and training_ready: false. Hosted documents stay at 0.1.0, and a 0.2.0 document that is not procedural is refused. When release-status.json declares rights_record: "rights.json", pipelines/verify_hf_release.py fetches the sidecar and requires it to validate, name the repository, and agree with the intended_use / project_training_policy that release-status.json restates; a procedural sidecar must also match the card's license, the LICENSE text, and release-status.json on the release license and training_ready. A release whose rights_record is null keeps the earlier contract. The sidecar grants nothing: training eligibility remains the registry row plus the fresh replay and completed-round gates, and publication authority is separate.

Public dataset family

Dataset payloads are published separately on Hugging Face. This code repository does not carry full raw, cleaned, candidate, or curated corpora.

Dataset	Purpose	Spikenaut target
Thalamic Relay Trajectories	Relay-gated state, proposal, decision, reward, and update trajectories	Yes
Neuromorphic Event-Language Bridge	Event-stream and language-view pairs for neuromorphic grounding	Yes
Multi-Agent Ouroboros Swarm	Multi-agent coordination, critique, and densification	No
Failure-as-Fuel Preference Cascade	Same-context preference data for recovery and alignment	No
Agentic Coding Trajectories	Observable coding-agent planning and tool use	No

All five repositories are organized in the public Claude Fable 5 (Ultracode) collection.

Raw is public; curated is still empty. All five repositories publish their raw, uncurated JSONL payload under data/raw/ plus a lossless Parquet viewer projection. Their cards and LICENSE files declare Apache-2.0; the still-pending release-status.json alignment is documented below. They are no longer metadata-only shells. Visibility is not a claim of training readiness, and publication is not training eligibility: every one of these corpora is research-only under the policy above. outputs/curated/ is empty here and no curated corpus is published, because that still depends on deterministic curation, strict audit, and sampled review.

The 44-dataset Grok 4.6 family in the Synthetic Data Factory (Grok 4.6) collection is published by scripts/publish_grok46_hub.py under the same research-only status. Nothing historical is deleted or rewritten: the Fable and Grok cards are re-published once, after #165 makes publication and release verification rights-aware. Card viewer schemas are declared by hand for 35 of the 44 datasets (python3 scripts/publish_grok46_hub.py schemas lists the gaps).

# Read-only: the viewer-schema audit (reads no root) and local mirror/source counts
python3 scripts/publish_grok46_hub.py schemas --strict
python3 scripts/publish_grok46_hub.py status --hf-root ~/hf --factory-root outputs/raw/2026-08-19-agentic
# Writes the local Hub mirror under <hf-root>/grok-4.6/
python3 scripts/publish_grok46_hub.py snapshot --only long-horizon-coding-trajectories --hf-root ~/hf
# Hub writes (network): create, upload, collect, or all four in order
python3 scripts/publish_grok46_hub.py create --hf-root ~/hf
python3 scripts/publish_grok46_hub.py upload --only long-horizon-coding-trajectories --hf-root ~/hf
python3 scripts/publish_grok46_hub.py collect --hf-root ~/hf
python3 scripts/publish_grok46_hub.py all --hf-root ~/hf

The publisher reads published rounds from a factory source root and mirrors them under <hf-root>/grok-4.6/<dataset>/. Each root resolves once per run: the --hf-root / --factory-root flag, then SYNTHETIC_FACTORY_HF_ROOT / SYNTHETIC_FACTORY_SOURCE_ROOT, then the owner's defaults (/home/raulmc/rmems/hf, and the first existing outputs/raw/2026-08-19-agentic under this checkout, ~/synthetic-factory, or ~/synthetic-data). A configured root is refused unless it already exists as a real, non-symlinked directory; the publisher does not create it. The Hub root is refused when it names or aliases outputs/raw/ or overlaps the factory source root, so a Hub working tree cannot mutate raw bytes. A refusal exits 2 and names the flag or variable, not its value. schemas reads neither root and refuses the root flags, even with an empty value.

License

This repository is licensed under the Apache License 2.0 — see NOTICE for attribution. This covers the repository's contents: generator registry, schemas, pipelines, skills, tests, and documentation.

Apache-2.0 is the authorized payload license. Each Hugging Face dataset repository ships the identical Apache-2.0 LICENSE file and declares license: apache-2.0 in its card front matter, Hub tag, and release-status.json. python3 pipelines/verify_hf_release.py fails closed when those three declarations disagree.

Development environment

Pipelines are stdlib Python 3.14+. There is no network service to boot.

python3 -m unittest discover -s tests -p 'test_*.py' -q
python3 .claude/skills/run-synthetic-factory/driver.py smoke
python3 pipelines/census.py tests/fixtures/mini-run

GitHub Actions runs those checks on pull requests and main (.github/workflows/python.yml and .github/workflows/python-smoke.yml).

Cursor Cloud Agents build from .cursor/Dockerfile via .cursor/environment.json. The install script is idempotent; it compiles the tree and prefetches and builds the Rust sf-oracle, while the unit tests and operator smoke check run in GitHub Actions.

Structure

• schemas/ — Thalamic schema, the two parity-family schemas, + provenance.md; oracle-grounded-v1.schema.json and oracle-grounded/ for the oracle-grounded families, plus actor-provenance-v1, vset-record-v1, and vset-release-manifest-v1
• prompts/ — retired in #184; the factory prompts are preserved at tag legacy-prompt-factory-v0.2 (see below)
• outputs/raw/ — dated dumps. 2026-08-17/ is the live run; 2026-08-17-prehalt/ is the pre-resume copy. NEXT_ROUND.json is a generated index, not a record
• outputs/cleaned/ — remapped copies (sim_or_real never real)
• outputs/curated/ — gitignored compose destinations (records/, manifest/, COMPOSE.json) built by pipelines/compose_curated.py, exports written by pipelines/export_hf.py, plus reviewed promotion snapshots written by pipelines/curate_gate.py promote
• config/ — reviewed factory registry (FACTORY-REGISTRY.json) and mill-script inventory (MILL-SCRIPT-INVENTORY.json). Identity authority is the registry (exact path_id + payload_factory), not a slug allowlist. Onboard a generator by adding a registry row and its exact (generator, generator_version) provider/channel assignment to _REVIEWED_GENERATOR_RIGHTS in pipelines/curate_identity.py (defined in pipelines/curate_identity_registry_rows.py); both reviews are required. Model-channel rows must also match schemas/model-channel-source-policy-v1.json exactly. Classify leftover mill scripts in the mill-script inventory (docs/mill-script-inventory.md).
• pipelines/ — census, identity, next-round allocator, shape validator, deep checker, curation integration/promotion, compose, and export; oracle_grounded/ holds the oracle-grounded generators, oracle adapters, and reference simulators; model_channel/ holds the local and OpenRouter generator clients; tool_world/ holds the deterministic tool-use environment, its four surfaces, scripted solvers, and replay oracle

Historical prompt lane

The prompt-driven lane (prompts/01–13 plus the factory contracts) produced the historical corpora and was retired in #184. The full lane is preserved at tag legacy-prompt-factory-v0.2:

git fetch --tags
git show legacy-prompt-factory-v0.2:prompts/01-thalamic-trajectory-factory.md

Historical Fable/Grok provenance remains reproducible from Git history and the published Hugging Face artifacts above. Do not reintroduce hosted-model prompt generation on main: new records come from registry-registered generators (see Generator lanes and rights and the retired "Generator rule", preserved at the tag).

Historical mill generators

Leftover-round mill scripts (*_mill.py under experiments/ on origin/legacy-mill-lane) produced mill-mix records in the 2026-08-19 agentic run. They are retained historical generators, not production CLIs. Main keeps the mill detectors (pipelines/leftover_mill.py, pipelines/mill_family.py, pipelines/compose_mill.py) and cleaned mill-family packages that AST-extract catalogs without vendoring those scripts. Classification, the unclassified-file guard, and quality-scope globs live in config/MILL-SCRIPT-INVENTORY.json (docs/mill-script-inventory.md).

git fetch origin legacy-mill-lane:refs/remotes/origin/legacy-mill-lane
git show origin/legacy-mill-lane:experiments/srl_r6110_leftover3_mill.py | head
python3 pipelines/mill_script_inventory.py --check

Pipelines

python3 pipelines/census.py outputs/raw/2026-08-17          # JSON counts + mill_mix; no writes
python3 pipelines/curate_identity.py outputs/raw/2026-08-17 --out outputs/cleaned/<new-label>
python3 pipelines/validate_run.py outputs/raw/2026-08-17    # shape gate; no manifest unless --write
python3 pipelines/validate_vset.py tests/fixtures/vset/records/accept
python3 pipelines/validate_vset.py --oracle --pack tests/fixtures/vset/repo-pack-counter \
  tests/fixtures/vset/records/accept/issue-patch-validated.json
python3 pipelines/validate_vset.py --manifest tests/fixtures/vset/manifests/pilot-v1.json
python3 pipelines/check_records.py outputs/raw/2026-08-17   # reward / spike order / ids
python3 pipelines/promote.py outputs/raw/2026-08-17 outputs/cleaned/2026-08-17

--pack is only meaningful with --oracle; passing it alone is rejected rather than silently ignored, so a pack never looks like it participated in a run that never executed one.

Some VSET fixture fields are hashes of live repository bytes — the repo-pack snapshot, the reviewed config/FACTORY-REGISTRY.json pin, and the manifest counts and hash. Editing the registry or the counter pack invalidates them and the VSET tests fail. Restate them from the same functions the validator uses:

python3 scripts/refresh_vset_fixture_pins.py --check   # report drift only
python3 scripts/refresh_vset_fixture_pins.py           # rewrite the pins

The census mill_mix section reports records whose mill signals — declared payload factory, mill id prefix, goal family (pipelines/mill_family.py) — belong to a different factory than the directory they were published under. curate_agentic.py quarantines the same records instead of composing them into a cleaned tree. Neither keys on leftover appearing in a record id, nor on a destination-specific field being absent: published mixes defeat both. Because prefix and goal ownership are cross-factory properties, a single file or one-factory source remains dry-run only; cleaned output fails closed until the source provides multi-factory ownership context.

Oracle-grounded parity families

Two verification-oriented families ask whether a neuromorphic computation survives deployment or interchange, rather than treating a successful export as proof that it did.

python3 pipelines/neuro_oracle.py                           # which oracles can run here
python3 pipelines/hardware_parity.py availability
python3 pipelines/hardware_parity.py generate outputs/staging/<date> --round 1
python3 pipelines/nir_equivalence.py availability
python3 pipelines/nir_equivalence.py generate outputs/staging/<date> --round 1
# `generate` writes outputs/staging/<date>/<family-slug>/batch-rNN.jsonl. To
# promote a round into outputs/raw/, run the round transaction against the
# raw factory directory and move the generated batch into the private stage
# the reservation returns (publish expects batch-rNN.jsonl, plus a
# NOTES-rNN.md carrying a "Novel coverage: <N>%" line, directly there):
#   python3 pipelines/round_txn.py reserve outputs/raw/<date>/<family-slug> \
#       --round N --expected <records>          # prints staging_dir + token
#   mv outputs/staging/<date>/<family-slug>/batch-rNN.jsonl <staging_dir>/
#   $EDITOR <staging_dir>/NOTES-rNN.md
#   python3 pipelines/round_txn.py publish outputs/raw/<date>/<family-slug> \
#       --round N --token <token> --allow-inconclusive "<reason>"
# The publish gate's execution-evidence verifier does not yet model the two
# parity shapes, so it reports them inconclusive and fails closed; the
# families' own validators re-derive every recorded number, and the explicit
# --allow-inconclusive waiver (recorded in the completion marker) is how an
# operator acknowledges that split today.
# (outputs/raw/ itself is immutable committed evidence — never a generate target)

Both route through census.py, validate_run.py, and check_records.py like any other family, and both re-derive every recorded number during validation. No FPGA and no upstream NIR runtime executes in this repository's environment. What each oracle did and did not do, and what that leaves unverified, is spelled out in docs/parity-oracles.md. A committed fixture round lives in tests/fixtures/parity-run/.

The factory supports agentic and coding datasets for LLMs and neuromorphic datasets for SNNs. An explicit Rust backend uses axon-encoder 0.4.0 and neuromod 0.6.0 for crate-native encoder and neuron episodes, with fresh execution replay during assembly and local export.

Oracle-grounded families (generator proposes, oracle measures — see docs/oracle-grounded-datasets.md):

python3 pipelines/oracle_generate.py --count 8 outputs/oracle-grounded/2026-09-01
python3 pipelines/oracle_validate.py --reproduce outputs/oracle-grounded/2026-09-01

Those default runs use deterministic in-repo reference simulators and are stamped implementation: "reference". Selecting --backend rust runs the two crate-native profiles through a prebuilt executable; the remaining three families continue to use their reference implementations. Under #171 an accepted reference record whose oracle.module_digest matches the current sources is publishable as a reproducible simulator measurement; it is never publishable as a measurement of the named runtimes, and a digest the current sources cannot reproduce keeps publishable: false.

Tool-world families (tool calling, MCP, browser, delegation)

A deterministic, stdlib-only environment executes every tool call a solver proposes, so an observation is measured rather than authored, success is a predicate over environment state, and every record replays from (pack, seed, actions). The design and its admission milestones are in docs/tool-world-families-design.md (#422); the first slice is generator side only and writes candidate runs outside outputs/raw/.

python3 pipelines/tool_world_cli.py catalog-check --json
python3 pipelines/tool_world_cli.py generate --seed 1 --count 3 --out outputs/tool-world/<label> --json
python3 pipelines/tool_world_cli.py replay outputs/tool-world/<label> --json   # exit 1 on any disagreement
python3 pipelines/tool_world_cli.py catalog-check --write-pins --json          # re-pin after a reviewed pack edit

Honest-stop episodes

Infrastructure for agent-honest-stop-episode records (dataset rmems/agent-honest-stop-episodes). A local tool world executes each scenario, and the acceptance gate re-executes the trajectory in a subprocess. generate --dry-run plans an OpenRouter writer call (deepseek/deepseek-v4.1-flash, reasoning effort high, or a dated snapshot such as deepseek/deepseek-v4.1-flash-1017) and qwen3-embedding:8b dedup. Ollama gemma4:12b is included only with --secondary-writer. Dry-run makes no network calls. A live send reads OPENROUTER_API_KEY from the environment and is not invoked by this CLI. This slice writes no dataset records and does not publish to the Hugging Face Hub.

python3 pipelines/honest_stop_cli.py generate --dry-run --seed 1 --count 4
python3 pipelines/honest_stop_cli.py export --dry-run

Curation integration and promotion gate

pipelines/curate_gate.py is the final step of the curation pass. It composes the six lane outputs into one brand-new cleaned destination, runs the structural validator, the strict deep checker, and the strict training audit, records a stratified human-review sample, and promotes to a brand-new curated path only when training_ready is true and every sampled record has a verdict. Both subcommands refuse a destination that already exists. training_ready there is the audit verdict, not training eligibility (see Generator lanes and rights).

The composition order is data, not code: it lives in an integration plan (curation-integration-plan/v1) so a reviewer can read the exact chain that produced a corpus. Lane outputs are overlaid in plan order — bridge timing, identity/provenance, preference purity, reward ontology, coding observability, tag taxonomy — and every supersession is recorded in the manifest. In a production plan, source_run: outputs/raw/<run> resolves from the repository root even when the plan itself lives under outputs/curation/; lane output, manifest, and artifact paths remain relative to the plan.

python3 pipelines/curate_gate.py integrate \
  --plan outputs/curation/plan.json \
  --cleaned-out outputs/cleaned/2026-08-17-curated-v1
# writes curation-manifest.json, review-sample.json, review-verdicts.json

# a human records a verdict for every sampled record, then:
python3 pipelines/curate_gate.py promote \
  --cleaned outputs/cleaned/2026-08-17-curated-v1 \
  --review outputs/cleaned/2026-08-17-curated-v1/review-verdicts.json \
  --curated-out outputs/curated/2026-08-17-v1

The final curation-manifest.json carries source and output hashes, the transform name and version of every lane, exclusions and quarantines with reason codes, per-kind and per-factory counts, gate results, and the recorded review. See the module docstring for the plan schema.

Tests: python3 -m unittest discover -s tests -p 'test_*.py' -q

Compose and export (curated → train/eval split)

The five ordered curation lanes are identity, bridge, preferences, coding, and rewards. Six record-level transform modules implement those five positions: the coding position dispatches ordinary episodes to curate_coding and registered multi-agent or safety-case records to curate_agentic; it does not run both transforms or add a sixth pass. compose_curated.py applies the lanes in one documented order and export_hf.py turns the result into a lossless export plus a tiny split. Preference sides are classified explicitly: same-state Thalamic pairs use the same-context gate, homogeneous episode pairs use the reviewed trajectory gate (or its fail-closed compatible core until that sibling module is stacked), and mixed side families are excluded with an explicit reason code.

# 1. Compose: identity -> bridge -> preferences -> coding -> rewards
#    (tag normalization is not composed yet). Never overwrites a destination.
python3 pipelines/compose_curated.py outputs/raw/2026-08-17 outputs/curated/2026-08-23
python3 pipelines/compose_curated.py --strict outputs/raw/2026-08-17 outputs/curated/2026-08-23-strict   # exit 1 unless training_ready

# 2. Export: refuses unless training_audit reports training_ready: true
python3 pipelines/export_hf.py outputs/curated/2026-08-23 outputs/curated/2026-08-23-export

Compose writes a brand-new destination:

Path	Contents
records/<factory>/<file>.jsonl	curated payload — the only subtree the audit reads
manifest/compose-manifest.jsonl	one entry per source record: source hashes, per-lane transform name/version, action, reason codes, output hash
manifest/reward-sidecars.jsonl	reversible copies of every source reward
COMPOSE.json	counts, exclusions by reason code, output digests, audit result, and the eval_exclusion block (sha256 of both exclusion lists and of the alias cache)

Eval denylist / do-not-train gate (#494). After the lanes decide a line, compose runs pipelines/compose_eval_gate.py over it, and export replays the same gate. A retained record that names a public source repository (code_repair upstream at scenario.source.upstream.repository, or a real_public_engineering record's environment.source_repo) is canonicalized offline: lowercased, then resolved through the committed, timestamped alias cache config/eval-exclusion/repo-aliases.json (renames and transfers; compose never calls GitHub). The canonical owner/name, program_id, and task_id are then matched as whole values against config/eval-exclusion/eval-denylist.json and config/eval-exclusion/do-not-train.json. A match is excluded with compose.eval_denylisted or compose.do_not_train_listed; a repository that is missing, malformed, or absent from the cache is excluded with compose.source_repo_unresolved or compose.source_repo_invalid. An invalid list or cache raises at import. COMPOSE.json and export provenance.json record all three file digests, and export refuses a compose made under different lists. scripts/refresh_repo_aliases.py is the operator step that resolves names through gh api repos/<owner>/<name> into a new cache file for review. The committed lists are reviewed: the eval denylist names 23 canonical repositories and the do-not-train list names 19. repo-aliases.json is a 381-entry cache resolved through the GitHub API on 2026-10-19T01:28:28Z.

Export writes data/curated/… (byte-identical payload), data/viewer/records.parquet ({source_file, source_line, record_json}, uncompressed PLAIN, written and read back with the standard library), data/splits/train.jsonl, data/splits/eval.jsonl, provenance.json carrying training_ready from the audit, and a one-page EVAL_PROTOCOL.md. Before export, every COMPOSE.json output, manifest, and reward-sidecar path, digest, count, coordinate, and annotation link is checked against the emitted bytes. The exporter also replays the deterministic compose contract from every current source line and requires exact agreement with stages, exclusions, source/output mappings, and sidecars. This authenticates the source snapshot available at export time; it does not claim that a mutable source directory remained unchanged between the original compose and that replay. Symlink and hard-link aliases are refused, and the strict audit consumes the same in-memory bytes the export writes rather than reopening mutable paths. The split is deterministic for one immutable post-curation snapshot. A global hash-order fallback keeps both sides nonempty for any corpus with at least two records, so changing the snapshot can change the fallback-selected row. The eval side is held out from a future trainer; it is not tuning-independent evidence for the curation rules that produced the snapshot.

No trainer. Neither command launches local or cloud training, and neither creates or uploads a Hugging Face repository. They produce split files and an evaluation protocol on disk; running a trainer is a separate, explicitly approved decision, and only training-candidate rows (project_training_policy: allowed) may ever reach one.