Add benchmark filesystem 1.3.0 with validated definitions and diagrams

Add immutable item-bank, protocol, model-panel, calibration and release artifacts; strict measurements, script-aware comparisons, response-matrix export, coverage auditing and complete artifact transfer. Include before/after diagrams, candidate foundation source pins, schemas and a separate synthetic end-to-end example. All 190 automated tests and extracted-package workflow checks pass. Real experiment collection and IRT fitting remain external; no real benchmark results are claimed.

ARTIFACTS.md

@@ -0,0 +1,270 @@
+# Benchmark artifact storage contract
+
+The archive now stores five kinds of benchmark artifacts alongside evaluation
+runs. This is a storage and validation contract. It does not download or audit
+the complete foundation automatically, run models, fit IRT models, verify a
+third-party fitting algorithm, or establish that a benchmark is scientifically
+valid.
+
+```text
+babel-data/
+  store.json
+  item-banks/<version-id>/
+    artifact.json
+    manifest.json
+  protocols/<version-id>/
+    artifact.json
+    manifest.json
+  model-panels/<version-id>/
+    artifact.json
+    manifest.json
+  runs/<run-id>/
+    manifest.json
+    raw/
+    records/
+    attachments/
+  calibrations/<version-id>/
+    artifact.json
+    manifest.json
+  releases/<version-id>/
+    artifact.json
+    manifest.json
+  derived/
+  .locks/
+  .staging/
+```
+
+Registry directories are optional in existing archives. Registering an artifact
+creates its directory. An artifact folder contains exactly `artifact.json` and
+`manifest.json`; extra files and symbolic links are rejected. Keep supporting
+files as registered run attachments or describe their separately managed
+provenance explicitly in the artifact.
+
+## Identity and immutability
+
+Every input artifact is one UTF-8 JSON object with:
+
+```json
+{"schema_version": 1, "kind": "item-bank", "id": "foundation-v1"}
+```
+
+The five permitted `kind` values are `item-bank`, `protocol`, `model-panel`,
+`calibration`, and `release`. IDs must be safe portable directory names. The
+fields below are additional required fields for each kind. Unknown JSON fields
+are preserved for task-specific metadata; they do not acquire validation rules
+merely by being present. Non-finite numbers and duplicate object keys are
+rejected throughout the document.
+
+Registration validates the artifact and dependencies, writes canonical JSON,
+and computes a SHA-256 checksum. The reference returned by registration is:
+
+```json
+{"kind": "item-bank", "id": "foundation-v1", "sha256": "64 lowercase hexadecimal characters"}
+```
+
+This example is schematic; real references contain an actual 64-character
+checksum. References require exactly these three fields. Loading verifies both
+the declared checksum and the schema. A registered ID cannot be overwritten;
+changes require a new version ID and a new checksum. Writes use the same archive
+lock as evaluation runs and publish an entire staged folder atomically.
+
+Checksums detect changes relative to a saved reference. They are not digital
+signatures or an operating-system prohibition against editing files. Keep the
+Hugging Face commit ID when sharing an archive snapshot.
+
+## Item bank
+
+Required top-level fields: `sources` and `items`, both nonempty arrays.
+
+Each source has:
+
+| Field | Meaning |
+| --- | --- |
+| `id` | Unique source identifier within the bank |
+| `repo_id` | Upstream repository identifier |
+| `revision` | Exact intended source version; floating `main`, `master`, `HEAD`, and `latest` are rejected |
+| `split` | Upstream split used, such as `test` |
+
+Use upstream immutable commit SHAs for `revision`. The filesystem records the
+identifier and rejects common floating aliases, but cannot establish that an
+arbitrary supplied version string actually identifies immutable upstream data.
+
+Each item represents **one question in one language and script**:
+
+| Field | Meaning |
+| --- | --- |
+| `item_id` | Unique identifier for this translated item |
+| `global_item_id` | Shared question identity across its translations, scoped by `task` |
+| `task` | Task identifier, such as `belebele` |
+| `language` | Explicit language identifier used by this bank |
+| `script` | Four-letter ISO 15924 form, such as `Latn`; syntax is checked |
+| `source_id` | An entry in `sources` |
+| `source_item_id` | Question identifier in the source |
+| `source_revision` | Must equal the referenced source's revision |
+| `passage_id` | Shared passage/group identifier, or explicit `null` |
+| `overlap_group_ids` | Array of known shared-material group IDs, possibly empty |
+| `choices` | At least two nonempty answer strings, in scoring order |
+| `answer_index` | Zero-based index of the correct choice |
+| `excluded` | Boolean exclusion decision |
+| `exclusion_reason` | Nonempty reason when excluded; otherwise `null` |
+| `input` | Question/passage/task fields as a JSON object |
+
+Duplicate `item_id` values and duplicate `(task, global_item_id, language,
+script)` identities are rejected. Translations may have different wording and
+answer order, with their own answer keys. Reusing a global ID across tasks does
+not make those questions equivalent.
+
+An optional `audit` object can retain audit findings and decisions. This system
+does not infer translation equivalence, detect FLORES overlap, populate passage
+groups, audit language intersections, or guarantee source counts. The researcher
+must supply those findings. An empty overlap list means no group was recorded;
+it is not evidence that overlap was investigated or ruled out.
+
+## Evaluation protocol
+
+Required fields:
+
+```json
+{
+  "task": "globalpiqa",
+  "scoring": {
+    "candidate_mode": "answer_text",
+    "normalization": "byte",
+    "tie_break": "first",
+    "candidate_prefix": " ",
+    "candidate_suffix": ""
+  },
+  "prompt_template": "{question}",
+  "demonstrations": [],
+  "harness": {"version": "PIN_THE_VERSION_USED", "task_config": {}},
+  "frozen": true
+}
+```
+
+`candidate_mode` is `answer_text` or `answer_label`. Answer-label scoring requires
+`scoring.candidate_labels`, an ordered list of unique nonempty labels. Labels
+are forbidden in answer-text mode. Optional prefix/suffix strings default to
+empty and represent the exact scored continuation text, including spaces.
+`normalization` is `none`, `byte`, or `token`; the supported deterministic tie
+rule selects the first maximum. Exact UTF-8 byte lengths include the prefix and
+suffix.
+
+Development protocols may use `frozen: false`. Strict benchmark runs,
+calibrations, and releases require frozen protocols. A calibration or release
+contains exactly one frozen protocol for every included bank task. Label counts
+must match each included question for their task.
+
+The artifact stores the prompt template, demonstrations, and harness settings.
+It does not execute an lm-eval task or prove that an upstream logger used those
+settings. Strict records must separately retain exact prompts, candidate text,
+likelihoods, and lengths.
+
+## Model panel
+
+`checkpoints` is a nonempty array. Each entry contains `id`, `model`, `revision`,
+`family`, `split`, and `is_base: true`. `split` is `calibration`, `development`,
+or `validation`. Checkpoint IDs and `(model, revision)` pairs must be unique.
+Every checkpoint in the same declared family must use the same split.
+
+This detects inconsistent declared splits. The archive does not independently
+classify model families or establish whether a checkpoint is a base model; those
+are explicit research metadata.
+
+## Calibration result
+
+A calibration stores externally produced fit results. Required fields:
+
+- `item_bank`: exact item-bank reference.
+- `protocols`: exact frozen protocol references, one per included task.
+- `model_panel`: exact panel reference.
+- `method`: `hierarchical-1pl` or `regularized-2pl`.
+- `synthetic`: explicit boolean.
+- `reference_scale`: nonempty object describing the scale definition and its
+  anchoring/identification choices.
+- `item_parameters`: one entry per included translated item, with `item_id` and
+  finite `difficulty`. A 2PL result also requires positive `discrimination`.
+  A supplied 1PL discrimination must equal 1. Shared/global effects and other
+  fitter output may be retained as additional fields.
+- `abilities`: entries with `checkpoint_id`, `task`, `language`, `script`, and
+  finite `ability`; identities must be known and unique.
+- `diagnostics` and `validation`: nonempty objects containing the externally
+  produced findings and their interpretation.
+- `run_refs`: exact evaluation evidence references described below.
+
+Parameters and abilities may include nonnegative `standard_error`, ordered
+`interval: [lower, upper]`, and `interval_level` strictly between 0 and 1 when an
+interval is supplied. These values are checked for type and range, not statistical
+coverage. Store fitter settings, regularization, posterior samples or covariance,
+linking checks, and family-level validation metrics explicitly when available.
+
+Each `run_refs` entry is:
+
+```json
+{
+  "run_id": "checkpoint-a-pilot",
+  "sha256": "SHA-256 of the exact sealed run manifest bytes",
+  "role": "calibration"
+}
+```
+
+`role` is `calibration`, `development`, or `validation` and must equal the
+checkpoint's family split in the panel. References must identify nonempty,
+sealed, checksum-valid strict runs using the same bank, panel, and compatible
+protocols. At least one calibration-role run is required. Only calibration-role
+runs are declared fitting data; other roles preserve development and validation
+evidence separately. `validation.run_ids`, when present, may name only referenced
+validation-role runs. Unpinned top-level `run_ids` are rejected.
+
+This validates the recorded data split and provenance. It cannot inspect a
+separate statistical program to prove which responses that program actually
+used to fit parameters or tune choices.
+
+If any referenced bank, protocol, panel, or run is explicitly synthetic, the
+calibration must be `synthetic: true`. A schema-valid artifact does not constitute
+an endorsement of a fit or its reported diagnostics.
+
+## Frozen benchmark release
+
+Required fields are `item_bank`, `protocols`, `model_panel`, `calibration`,
+`frozen: true`, an explicit `synthetic` boolean matching the calibration,
+`limitations` (a nonempty string array), and `aggregation`.
+
+Release bank, protocol, and panel references must exactly match the calibration.
+The calibration must name held-out evaluation evidence in
+`validation.run_ids`. This is an evidence requirement, not a statistical
+acceptance threshold or an automatic claim of good generalization.
+
+The default aggregation policy is:
+
+```json
+{"primary": "task-language", "overall": null}
+```
+
+To declare an overall score, set `overall` to an object with `task_weights` and
+`language_weights`. Each is a mapping from every included task or language to a
+nonnegative numeric weight, and each mapping must sum to one. This prevents an
+undeclared question-count-weighted overall policy in the release definition.
+The registry records the policy; it does not calculate calibrated scores,
+uncertainty, passage-aware resampling, or shortened-test comparisons.
+
+## Python API
+
+```python
+from babel_fs.artifacts import (
+    register_artifact, artifact_ref, load_artifact, list_artifacts,
+    validate_artifacts, archive_paths,
+)
+
+reference = register_artifact(root, "bank-v1.json")
+reference = artifact_ref(root, "item-bank", "foundation-v1")
+payload = load_artifact(root, reference)
+references = list_artifacts(root)
+report = validate_artifacts(root)
+paths = archive_paths(root)
+```
+
+`load_artifact` returns the original payload, without inserting inferred findings.
+`validate_artifacts` returns `ok`, `errors`, and the number of discovered
+`artifacts`. `archive_paths` returns only validated artifact and manifest files
+for the Hub transfer allowlist. A failed dependency blocks the artifact and
+release rather than silently substituting another version.

BENCHMARK_RUN_TEMPLATE.json

@@ -0,0 +1,26 @@
+{
+  "model": "REPLACE_WITH_MODEL_ID",
+  "model_revision": "REPLACE_WITH_EXACT_CHECKPOINT_REVISION",
+  "synthetic": false,
+  "description": "Template for a real strict benchmark run. Replace every placeholder with registered definitions and actual evaluation settings.",
+  "benchmark_contract": {
+    "item_bank": {
+      "kind": "item-bank",
+      "id": "REPLACE_WITH_BANK_ID",
+      "sha256": "REPLACE_WITH_REGISTERED_SHA256"
+    },
+    "protocols": [
+      {
+        "kind": "protocol",
+        "id": "REPLACE_WITH_TASK_PROTOCOL_ID",
+        "sha256": "REPLACE_WITH_REGISTERED_SHA256"
+      }
+    ],
+    "model_panel": {
+      "kind": "model-panel",
+      "id": "REPLACE_WITH_PANEL_ID",
+      "sha256": "REPLACE_WITH_REGISTERED_SHA256"
+    },
+    "checkpoint_id": "REPLACE_WITH_CHECKPOINT_ID_FROM_PANEL"
+  }
+}

BENCHMARK_WORKFLOW.md

@@ -0,0 +1,202 @@
+# Using the calibrated-benchmark archive
+
+Version 1.3.0 provides the storage and validation layer for the proposed benchmark.
+It does not execute language models, fit IRT models, or certify a benchmark's
+measurement quality. The real archive has no collected responses, assembled
+foundation bank, or estimated parameters yet.
+
+## Try the complete storage workflow
+
+From the extracted toolkit:
+
+```sh
+./babel --root my-synthetic-example benchmark-demo
+./babel --root my-synthetic-example artifacts
+./babel --root my-synthetic-example bank-audit demo-bank-v1
+./babel --root my-synthetic-example validate
+./babel --root my-synthetic-example compare demo-calibration \
+  --other-run demo-validation --baseline foundation --variant foundation \
+  --items my-synthetic-comparison.html
+./babel --root my-synthetic-example hub-plan
+```
+
+The example contains two handwritten question identities in English and French,
+three fictional base checkpoints from different fictional families, twelve
+handwritten responses, and illustrative calibration/release artifacts. No model
+was evaluated. No IRT fit or scientific validation was performed. Do not upload
+this example as real project results. The bundled `benchmark-demo-store/` is an
+already-built version of the same demonstration.
+
+## 1. Register the questions, protocols and model panel
+
+Prepare JSON definitions following [ARTIFACTS.md](ARTIFACTS.md). Register each:
+
+```sh
+./babel register /path/to/item-bank-v1.json
+./babel register /path/to/belebele-protocol-v1.json
+./babel register /path/to/globalpiqa-protocol-v1.json
+./babel register /path/to/sib200-protocol-v1.json
+./babel register /path/to/pilot-panel-v1.json
+./babel artifacts
+```
+
+Registration returns a reference containing `kind`, `id`, and `sha256`. Preserve
+that complete reference in dependent definitions and run settings. Reusing an ID
+with different content is rejected. Use a new ID for a changed version.
+
+An item is one particular language/script version of a question. `item_id` names
+that version; `global_item_id` links corresponding questions across translations,
+within a task. `language` and `script` are separate fields. Each item has choices,
+a zero-based answer index, source revision, passage/overlap groups, and explicit
+inclusion/exclusion status. Excluded rows remain available for audit.
+
+`bank-audit BANK-ID` reports counts by task/language/script, exclusions, missing
+translations relative to each task's observed item union, exact-content duplicate
+groups, and declared passage/overlap groups. It does not decide whether a
+translation is correct or discover every semantic overlap. FLORES relationships
+must be established from source provenance and entered explicitly. Expected
+counts in `examples/foundation-sources.json` are planning figures from the
+proposal, not the result of a completed coverage audit.
+
+Each task protocol declares answer-text or answer-label candidates, score
+normalization (`none`, `byte`, or `token`), a first-maximum tie rule, prompt
+template, demonstrations, and harness version/configuration. Strict runs require
+a frozen protocol, with one protocol per task. Development alternatives get
+separate IDs and runs. Freezing records the selected configuration; choosing
+which protocol is scientifically preferable still requires development analysis.
+
+Each model-panel entry names an exact checkpoint revision, its family, whether
+it is a base model, and its split: `calibration`, `development`, or `validation`.
+All entries in a family must use the same split. This checks declared family
+membership; the program cannot independently determine a model's ancestry.
+
+## 2. Collect evaluation output and create a strict run
+
+lm-evaluation-harness is the program that sends task prompts and candidate
+continuations to a language model and computes their likelihoods. This archive
+is the program that preserves and checks those measurements. Hugging Face hosts
+versioned copies of the archive and the toolkit.
+
+The ordinary harness sample importer remains supported. For the strict new
+benchmark contract, the evaluation producer must also supply the stable item
+mapping, exact candidate continuations, exact prompt, per-candidate scores, and
+byte/token lengths. Generic harness logs do not always include all of these.
+Use a task-specific logger or a verified conversion step to make canonical
+JSONL; the archive does not guess missing candidate order, lengths or prompts.
+Attach the original harness sample file/configuration alongside the canonical
+file so the conversion remains auditable.
+
+A strict run's metadata contains:
+
+```json
+{
+  "model": "organization/checkpoint-name",
+  "model_revision": "EXACT-CHECKPOINT-REVISION",
+  "benchmark_contract": {
+    "item_bank": {"kind": "item-bank", "id": "bank-v1", "sha256": "REGISTERED-HASH"},
+    "protocols": [{"kind": "protocol", "id": "protocol-v1", "sha256": "REGISTERED-HASH"}],
+    "model_panel": {"kind": "model-panel", "id": "pilot-v1", "sha256": "REGISTERED-HASH"},
+    "checkpoint_id": "CHECKPOINT-ID-FROM-PANEL"
+  }
+}
+```
+
+Replace the placeholders with references returned by registration. The bundled
+`benchmark-demo-store/runs/demo-calibration/manifest.json` contains a complete
+working synthetic example. A measurement row additionally supplies:
+
+- `item_id`, `global_item_id`, `question_id` equal to `global_item_id`, `benchmark`
+  equal to the item's task, `language`, `script`, `variant_id` (normally `foundation`),
+  and `protocol_id`.
+- `exact_prompt`, the ordered `candidates`, and `scores.logprobs`,
+  `scores.byte_lengths`, and `scores.token_lengths` with one value per candidate.
+- `target` as the bank's zero-based answer index, integer `prediction`, and
+  boolean `correct`.
+
+`scores.logprobs` must contain finite, nonpositive numbers. Both length arrays
+are required even when their corresponding normalization is not selected, and
+every length must be a positive integer. Optional `scores.normalized_scores`
+values are checked against the declared normalization.
+
+Candidate strings must match the item choices or the protocol's ordered labels,
+including declared candidate prefix/suffix text. Byte lengths are checked against
+the exact UTF-8 continuations. Token lengths must be measured with the model's
+actual tokenizer; the archive checks their shape and positivity, not tokenization.
+It recomputes the winning option under the declared length normalization and
+checks correctness against the bank's key. It preserves the submitted prompt but
+does not prove that an external model actually received it or that a likelihood
+was computed correctly.
+
+```sh
+./babel new-run --run-id checkpoint-a-pilot \
+  --model organization/checkpoint-name --metadata /path/to/run-settings.json
+./babel import checkpoint-a-pilot /path/to/canonical-responses.jsonl --format canonical
+./babel attach checkpoint-a-pilot /path/to/original-harness-samples.jsonl \
+  /path/to/task-config.yaml /path/to/results.json
+./babel validate --run checkpoint-a-pilot
+./babel seal checkpoint-a-pilot
+```
+
+Old runs without `benchmark_contract` retain their general-purpose validation.
+They do not become calibrated-benchmark measurements merely because they are
+sealed. A missing response is absent from the matrix, not automatically wrong.
+
+## 3. Export observations for statistical fitting
+
+```sh
+./babel response-matrix responses.jsonl \
+  --run checkpoint-a-pilot --run checkpoint-b-pilot
+```
+
+This produces one row per observed checkpoint/item/protocol/filter/repeat, with
+shared question IDs, language/script, family and split, correctness, passage and
+overlap groups, and exact artifact/run references. Runs must be sealed and use
+the same bank/panel, with a compatible protocol per task. Repeated observations
+with the same identity are rejected. It is a long-format table, not an already
+estimated ability/difficulty matrix.
+
+An external fitting program reads those rows, selects calibration families for
+fitting, uses development families for model choices, and evaluates final
+validation families separately. That program must implement the proposed
+hierarchical 1PL/2PL models, reference-scale identification, linking checks,
+parameter recovery, predictive validation and passage-aware uncertainty. These
+analyses are not supplied by the filesystem.
+
+## 4. Register fitting outputs and a release
+
+After running those analyses, register a calibration artifact containing the
+actual parameters, scale, diagnostics, validation evidence, and hashes of sealed
+input run manifests. Every input run declares its role; it must agree with its
+model-panel split. A release pins a compatible bank, complete task protocols,
+panel and calibration, plus limitations and aggregation settings.
+
+```sh
+./babel register /path/to/calibration-v1.json
+./babel register /path/to/release-v1.json
+./babel validate
+./babel hub-plan
+./babel hub-push
+```
+
+Task/language results are primary. Set `aggregation.overall` to `null` unless an
+overall score is intended; otherwise declare task and language weights. These
+weights are stored and validated, not applied by a calibrated scoring engine.
+Likewise, parameter uncertainty and diagnostics are recorded, not independently
+recalculated. Structural acceptance of a release is not scientific endorsement.
+
+`hub-plan` includes registered artifact dependencies and the sealed runs needed
+by calibration artifacts. Derived reports are not uploaded automatically. Upload
+refuses to overwrite a different existing artifact or sealed run. A pinned
+`hub-pull` restores all registered definitions and responses and validates them
+before exposing the new local archive.
+
+Artifact JSON files, including an entire registered item bank, are loaded into
+memory for validation; response rows are streamed. Plan memory for the full bank
+and disk space for preserved raw files, normalized records, temporary indexes
+and transfer snapshots.
+
+The release folders support future evaluation tooling, but that tooling still
+needs to estimate new models' abilities and uncertainty on the frozen scale.
+The filesystem alone does not deliver calibrated scoring or a validated short
+form. It also does not establish that the provisional 20/100-checkpoint budgets
+or any language count provide sufficient calibration data.

FILESYSTEM_DIAGRAMS.md

@@ -0,0 +1,99 @@
+# Babel Tower filesystem: before and after
+
+The filesystem is the project’s archive format: named folders, JSON definitions,
+original evaluation files, normalized item responses, and checks that keep these
+files consistent. Hugging Face hosts a copy of the archive and the downloadable
+toolkit. It does not run model evaluations or fit calibration models merely
+because these files are uploaded.
+
+The diagrams show the **supported folder layout**, including the contents of a
+future run or registered artifact. The production archive currently contains no
+real model results or fitted calibration. Synthetic examples are separate from
+production data.
+
+## Before: v1.2, organized around experiment runs
+
+![Original run-based folder structure](filesystem-before.svg)
+
+This version preserved raw evaluation output, normalized individual responses,
+and compared corresponding items. Experiment descriptions lived in each run’s
+metadata or attachments. There were no dedicated, validated collections defining
+the common question bank, scoring protocols, model-family splits, calibrated
+parameters, or released benchmark.
+
+```mermaid
+flowchart TD
+    A["babel-data/"] --> S["store.json<br/>Archive identity and HF destination"]
+    A --> R["runs/&lt;run-id&gt;/<br/>One evaluated model per run"]
+    R --> M["manifest.json<br/>Metadata, hashes, status"]
+    R --> W["raw/<br/>Original evaluation files"]
+    R --> N["records/<br/>Normalized item responses"]
+    R --> T["attachments/<br/>Explicitly attached files"]
+    A --> D["derived/<br/>Local summaries, exports and comparisons"]
+```
+
+## After: definitions, measurements, calibration and release
+
+![Revised benchmark folder structure](filesystem-after.svg)
+
+The five added collections make the benchmark’s definitions and outputs
+addressable parts of the archive. Each registered version has its own `<id>`
+folder, a `manifest.json` describing its identity and integrity, and an
+`artifact.json` containing its data. A new version gets a new identity; later
+experiments can still refer to an earlier version.
+
+```mermaid
+flowchart TD
+    A["babel-data/"] --> S["store.json<br/>Archive identity and HF destination"]
+    A --> B["item-banks/&lt;id&gt;/<br/>Question identities, translations, scripts,<br/>keys, sources, groups and exclusions"]
+    B --> BF["manifest.json + artifact.json"]
+    A --> P["protocols/&lt;id&gt;/<br/>Task prompts, demonstrations<br/>and candidate-scoring rules"]
+    P --> PF["manifest.json + artifact.json"]
+    A --> F["model-panels/&lt;id&gt;/<br/>Checkpoint revisions, families<br/>and family-level split assignments"]
+    F --> FF["manifest.json + artifact.json"]
+    A --> R["runs/&lt;run-id&gt;/<br/>Strict runs link to bank, protocol and panel"]
+    R --> RM["manifest.json<br/>Context, references, hashes and status"]
+    R --> RW["raw/<br/>Original evaluation output"]
+    R --> RN["records/<br/>Exact prompts, option measurements,<br/>predictions and correctness"]
+    R --> RT["attachments/<br/>Supporting files"]
+    A --> C["calibrations/&lt;id&gt;/<br/>Imported fitted parameters, scale,<br/>diagnostics and input-run references"]
+    C --> CF["manifest.json + artifact.json"]
+    A --> L["releases/&lt;id&gt;/<br/>Fixed bank, protocols and calibration,<br/>weighting and documented limits"]
+    L --> LF["manifest.json + artifact.json"]
+    A --> D["derived/<br/>Local reports and response-matrix exports"]
+    classDef added fill:#edf6f2,stroke:#719b8a,color:#183c30;
+    class B,P,F,C,L added;
+```
+
+The lines in both diagrams mean “contains.” References between definitions are
+stored inside their JSON files; they are not duplicated folders. For example, a
+strict run refers to a particular bank and protocol, a calibration refers to its input
+runs, and a release identifies the definitions and fitted calibration that make
+up that benchmark version.
+
+## What the new folders mean for this project
+
+| Folder | What belongs here |
+|---|---|
+| `item-banks/` | The selected Belebele, GlobalPIQA Parallel and SIB-200 questions and translated versions, stable identities, language/script identifiers, answer keys, pinned source versions, passage/overlap group information and documented exclusions. This is where the actual coverage audit is represented; “100+ languages” is not assumed merely from folder names. |
+| `protocols/` | The task’s declared prompt, demonstration settings, candidate text or label scoring, and normalization rules. Development definitions may be unfrozen; strict runs require a frozen version. |
+| `model-panels/` | Evaluated checkpoints and their exact revisions, model-family identities and calibration/development/final-validation assignments. Assigning the whole family to one group prevents putting different checkpoints of that family on both sides of a holdout. |
+| `runs/` | Actual model measurements: which item was evaluated, which settings and model were used, the exact recorded prompt, each option’s scores and lengths, the selected answer and correctness. Original output remains in `raw/`. |
+| `calibrations/` | Results produced by an external fitting program: item parameters, the chosen reference scale, diagnostics, validation evidence, and the archived responses used. Recording an IRT model name does not perform that fit. |
+| `releases/` | A fixed combination of bank, protocols and calibration, together with declared weighting and measurement limits. Task-specific results remain identifiable; any overall weighting must be declared. |
+| `derived/` | Reproducible local analysis products such as comparison reports and response matrices. These are outputs, rather than the authoritative original evaluation data. |
+
+An exact prompt can only be preserved if the evaluation producer supplies it.
+The archive does not reconstruct prompts, token/byte lengths, or scores that
+were never recorded. Likewise, storing passage groups enables later analyses to
+account for shared passages; it does not itself calculate clustered uncertainty.
+
+Validation checks data structure, supported relationships and file integrity.
+It cannot establish that a translation is correct, a likelihood was computed
+properly, an IRT assumption holds, or a benchmark measures every aspect of
+language capability. Those remain empirical evaluation and statistical tasks.
+
+The hidden `.locks/` and `.staging/` folders support safe writes and are omitted
+from the diagrams. The Python toolkit, documentation, example definitions and
+synthetic demonstration stores sit outside `babel-data/`. Local derived reports
+are not automatically part of a Hugging Face archive upload.

FORMAT.md

@@ -1,4 +1,10 @@
-# Data contract, version 1
+# Data contract, archive schema version 1
+
+Toolkit 1.3.0 retains the legacy archive/record version for compatibility and adds
+version-1 registered benchmark artifacts. See [ARTIFACTS.md](ARTIFACTS.md) and
+[BENCHMARK_WORKFLOW.md](BENCHMARK_WORKFLOW.md) for the strict benchmark contract.
+Runs without `benchmark_contract` remain legacy/general-purpose runs.
+
 
 Raw files are immutable through the application and authoritative. The normalized
 records are an analysis representation. They do not replace the source data or
@@ -16,6 +22,7 @@ within a run. A paired input line produces two records.
 | `question_id` | Persistent identity of the underlying question; shared by its variants. |
 | `variant_id` | E.g. `original`, `rephrased`, or a distinct rephrasing identifier. |
 | `benchmark` | Benchmark/task name, supplied by the record or run metadata. |
+| `script` (optional in legacy records) | Script identifier; separate scripts never share an item identity. Required for strict benchmark records. |
 | `language` | Language identifier or null. No language is guessed from a path. |
 | `model` | Evaluated model; must match run metadata. |
 | `rephrasing_model` | Model that generated the variant, when known. |
@@ -124,7 +131,7 @@ comparison summary. `.html`, `.csv`, and `.jsonl` select the format; an explicit
 Known conflicting dataset revisions in a cross-run comparison are rejected.
 
 One report item represents the union of stable identities on the two selected
-sides. Its identity is `(benchmark, language, question_id, filter, repeat_id)`.
+sides. Its identity is `(benchmark, language, script, question_id, filter, repeat_id)`.
 Matched items contain both records; unmatched items retain the available side.
 Run-local identities are excluded, with counts for each side in the summary.
 Duplicate stable identities are an error, not an arbitrary choice of one record.
@@ -165,3 +172,19 @@ After downloading a Hub repository, run `python3 -m babel_fs --root DOWNLOADED_F
 init` to recreate empty local operational directories that remote repositories
 cannot preserve. Then run `validate`. Missing registered data remains an error;
 initialization does not fabricate or recover lost results.
+
+## Registered benchmark extensions
+
+The five artifact registries are `item-banks/`, `protocols/`, `model-panels/`,
+`calibrations/`, and `releases/`. Each immutable ID stores `manifest.json` and
+`artifact.json`; references pin the payload SHA-256. `validate` checks all
+registered artifacts and their dependencies as well as runs. `hub-plan` includes
+all registered artifacts and adds calibration input runs even when a narrower
+run selection was requested. `hub-pull` restores and validates that dependency
+set from one pinned commit.
+
+For strict runs, identity also includes the explicit script; comparisons require
+the same bank and protocol references. Different checkpoints are intentionally
+comparable. A response matrix preserves shared global IDs across languages while
+keeping their separate observations and all family/split/grouping identifiers.
+It does not pool correctness across languages or estimate any IRT parameters.

LEGACY_REPHRASING_SOURCES.json

@@ -0,0 +1,79 @@
+{
+  "schema_version": 1,
+  "purpose": "Pinned benchmark inputs; these files are not model evaluation results.",
+  "results_repository": "base-model-evals/off-the-shelf-model-evals",
+  "verified_at": "2026-09-21",
+  "datasets": [
+    {
+      "repo_id": "base-model-evals/global-mmlu-rephrased",
+      "revision": "cd6952c6df3e52034886603e36c5ce4796f0777f",
+      "benchmark": "global-mmlu",
+      "row_counts": {
+        "all": 156,
+        "high_quality": 138,
+        "low_quality": 18
+      },
+      "license_from_dataset_card": "cc-by-nc-4.0",
+      "configs": [
+        "all",
+        "high_quality",
+        "low_quality"
+      ],
+      "split": "train",
+      "files": [
+        "high_quality/train-00000-of-00001.parquet",
+        "low_quality/train-00000-of-00001.parquet"
+      ],
+      "url": "https://huggingface.co/datasets/base-model-evals/global-mmlu-rephrased",
+      "card_url": "https://huggingface.co/datasets/base-model-evals/global-mmlu-rephrased/blob/cd6952c6df3e52034886603e36c5ce4796f0777f/README.md"
+    },
+    {
+      "repo_id": "base-model-evals/belebele-rephrased",
+      "revision": "e926d6cc0c50196e0d8bb0d018d9fbf1283dd2e8",
+      "benchmark": "belebele",
+      "row_counts": {
+        "all": 157,
+        "high_quality": 125,
+        "low_quality": 32
+      },
+      "license_from_dataset_card": "cc-by-nc-sa-4.0",
+      "configs": [
+        "all",
+        "high_quality",
+        "low_quality"
+      ],
+      "split": "train",
+      "files": [
+        "high_quality/train-00000-of-00001.parquet",
+        "low_quality/train-00000-of-00001.parquet"
+      ],
+      "url": "https://huggingface.co/datasets/base-model-evals/belebele-rephrased",
+      "card_url": "https://huggingface.co/datasets/base-model-evals/belebele-rephrased/blob/e926d6cc0c50196e0d8bb0d018d9fbf1283dd2e8/README.md"
+    }
+  ],
+  "input_fields": [
+    "id",
+    "language",
+    "original_question",
+    "original_choices",
+    "correct_index",
+    "context",
+    "rephrased_prefix",
+    "rephrased_choices",
+    "rephrasing_model",
+    "judge_overall_score"
+  ],
+  "interpretation": {
+    "stable_question_id": "id",
+    "correct_index": "Zero-based position in rephrased_choices, as documented in the source cards. Validate original-choice answer keys separately.",
+    "judge_overall_score": "Rewrite quality, not evaluated-model accuracy.",
+    "all_configuration": "Combines high_quality and low_quality; do not double-count them.",
+    "rephrasing_model": "CohereForAI/aya-expanse-8b",
+    "languages": [
+      "en",
+      "fr",
+      "ko",
+      "tr"
+    ]
+  }
+}

README.md

@@ -1,171 +1,146 @@
 ---
-pretty_name: Babel Tower — Base Model Evaluation Archive
-viewer: false
+pretty_name: Babel Tower benchmark archive
 tags:
 - evaluation
 - multilingual
 - babel-tower
-language:
-- en
-- fr
-- ko
-- tr
+- item-response-theory
+viewer: false
 ---
+# Babel Tower benchmark archive
 
-# Babel Tower evaluation archive
-
-Shared filesystem for the **base-model-evals** project. This repository stores
-the full result for each evaluated question: model responses, available scores,
-original/rephrased variants, and the settings needed to interpret each run.
-
-The archive is initialized and ready for runs. **No measured model results have
-been added yet.** The downloadable toolkit includes a separately labeled synthetic
-demo; those demonstration records are not published as evaluation runs here.
-
-**See an item-level comparison:** [Download the interactive demo report](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/item-comparison-demo.html?download=true)
-and open it in your browser. It shows original and rephrased questions, model
-answers, correctness, and available scores side by side, with search and filters.
-The demo uses synthetic results and works offline after downloading.
-
-## Start here
-
-1. [Download the filesystem toolkit](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/babel-tower-filesystem.zip?download=true) and extract it.
-2. Open `START_HERE.md`, or run `./babel` from the extracted folder to check local setup.
-3. Follow the workflow below to import real JSONL outputs, verify them, and add a sealed run.
-
-The toolkit requires Python 3.10+ on macOS/Linux. Local import, validation,
-comparison, and CSV/JSONL export work without additional Python packages.
-Hugging Face transfer support is an optional dependency.
-
-## What lives here
+**Filesystem toolkit 1.3.0** provides versioned storage and validation for the
+proposed multilingual difficulty-calibrated benchmark. It connects a question
+bank, evaluation protocols, model-family panels, item-level responses, external
+calibration results, and frozen benchmark releases.
 
-| File or location | Purpose |
-|---|---|
-| `store.json` | Archive identity, format version, and destination binding. |
-| [SOURCES.json](SOURCES.json) | Pinned input datasets, revisions, identities, and interpretation notes. |
-| [FORMAT.md](FORMAT.md) | Normalized record schema, provenance, validation, and recovery rules. |
-| [RUN_TEMPLATE.json](RUN_TEMPLATE.json) | Example run metadata; replace placeholders with actual evaluation settings. |
-| `babel-tower-filesystem.zip` | Runnable tools, tests, documentation, and a separate synthetic example. |
-| `item-comparison-demo.html` | Downloadable, self-contained item comparison using synthetic results. |
-| `runs/<run-id>/manifest.json` | Created for each real run: settings, file hashes, counts, and status. |
-| `runs/<run-id>/raw/` | Original JSONL outputs, preserved byte for byte. |
-| `runs/<run-id>/records/` | Normalized records for comparisons and summaries. |
-| `runs/<run-id>/attachments/` | Original configs, aggregate harness output, and input snapshots. |
+**Current data status:** no real evaluation runs, complete foundation item bank,
+or fitted calibration parameters have been published here. The toolkit includes
+separate synthetic examples. Uploading the filesystem does not run experiments,
+fit IRT models, or establish that the proposed benchmark works.
 
-Run folders appear when the first run is uploaded. Empty local working folders
-are recreated by the toolkit on initialization or download.
+[Download the updated toolkit](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/babel-tower-filesystem.zip?download=true)
+and extract it. Open `START_HERE.md`, then follow
+[the benchmark workflow](BENCHMARK_WORKFLOW.md).
+Python 3.10+ on macOS/Linux supports local operations without extra packages.
+Hugging Face transfer and Parquet export are optional dependencies.
 
-## Project inputs
+## Before: results organized by experiment run
 
-The existing inputs are versioned separately:
+![Previous filesystem](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/filesystem-before.png)
 
-| Benchmark input | Pinned revision | Configuration |
-|---|---|---|
-| [Global MMLU rephrased](https://huggingface.co/datasets/base-model-evals/global-mmlu-rephrased) | `cd6952c6df3e52034886603e36c5ce4796f0777f` | `all`, `high_quality`, or `low_quality`; split `train` |
-| [Belebele rephrased](https://huggingface.co/datasets/base-model-evals/belebele-rephrased) | `e926d6cc0c50196e0d8bb0d018d9fbf1283dd2e8` | `all`, `high_quality`, or `low_quality`; split `train` |
+The earlier structure preserved raw results and normalized item responses. Bank,
+protocol, model-panel and calibration definitions had no first-class validation.
 
-Use each input's `id` as the persistent question identity and retain `language`.
-The `all` configuration already combines high- and low-quality rows. In these
-source cards, `correct_index` refers to the **rephrased choices**: check the original
-answer key before comparing correctness. `judge_overall_score` measures rewrite
-quality and must not be treated as an evaluated model's accuracy.
+## After: a versioned benchmark archive
 
-Source license declarations are recorded per dataset in `SOURCES.json`. This
-archive does not replace the sources' licenses or assign one blanket license to
-future model outputs.
+![Updated filesystem](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/filesystem-after.png)
 
-## Add an evaluation run
+The diagram shows the supported layout. Empty folders are created locally by
+`init`; actual artifact and run directories appear on the Hub when registered
+content is uploaded. See [the full diagram explanation](FILESYSTEM_DIAGRAMS.md).
 
-Enable `--log_samples` and `--output_path` when using lm-evaluation-harness. Keep
-the input's persistent `id`/`question_id` in the task document. For example, from
-the extracted toolkit:
+| Collection | Purpose |
+|---|---|
+| `item-banks/<id>/` | Shared question identities, translated items, language/script, choices and keys, source revisions, passages/overlap groups and exclusions. |
+| `protocols/<id>/` | Task prompts, demonstrations, candidate text/label scoring, normalization and harness configuration. |
+| `model-panels/<id>/` | Checkpoint revisions, base-model declarations, family identities and calibration/development/validation splits. |
+| `runs/<id>/` | Original evaluation files and checked item responses tied to exact bank, protocol and checkpoint references. |
+| `calibrations/<id>/` | Imported IRT parameters, scale, uncertainty fields, diagnostics, validation evidence and hash-pinned input runs. |
+| `releases/<id>/` | A frozen compatible bank/protocol/calibration combination with declared weights and limitations. |
+
+Every new registered artifact contains an `artifact.json` payload and
+`manifest.json` integrity record. Existing IDs cannot be overwritten through the
+toolkit. New versions use new IDs. Existing legacy runs remain supported.
+
+## What changed
+
+- Strict benchmark runs validate question/script identity, answer keys, exact
+  checkpoint revisions and frozen per-task protocol references.
+- Candidate scores and lengths must align. UTF-8 byte lengths are checked, and
+  declared normalization determines the prediction and correctness checks.
+- Entire declared model families stay in one split. Calibration input roles must
+  match those assignments, and releases reference held-out validation runs.
+- A bank audit reports counts, exclusions, missing translation rows, exact-content
+  duplicates and declared grouping. It does not judge translation quality.
+- Response-matrix export retains global IDs, languages/scripts, family splits,
+  passage/overlap groups and exact provenance for an external statistical program.
+- Hugging Face transfer includes the new definitions and their dependencies,
+  verifies integrity, and refuses conflicting existing artifacts or sealed runs.
+
+These checks establish file/schema consistency, not scientific validity.
+Exact prompts are preserved when supplied; token counts and model execution
+cannot be independently verified without the actual evaluation environment.
+
+## Foundation sources
+
+The proposed first version uses
+[Belebele](https://huggingface.co/datasets/facebook/belebele),
+[GlobalPIQA Parallel](https://huggingface.co/datasets/mrlbenchmarks/global-piqa-parallel),
+and the [SIB-200 test set](https://huggingface.co/datasets/Davlan/sib200).
+[SOURCES.json](SOURCES.json) records candidate upstream commit pins. The actual
+language/script intersection, counts, exclusions and FLORES overlap still need
+an audit. No new translation or non-parallel component is included in this plan.
+
+The earlier Belebele/Global MMLU rephrasing sources remain recorded in
+[LEGACY_REPHRASING_SOURCES.json](LEGACY_REPHRASING_SOURCES.json) for earlier work.
+Source datasets retain their own licenses and usage terms; this archive does not
+assign a blanket license to future model outputs.
+
+## Try the complete synthetic storage example
+
+From the extracted toolkit:
 
 ```sh
-./babel new-run --run-id experiment-001 \
-  --model YOUR-MODEL-ID --benchmark belebele \
-  --metadata /path/to/completed-run-settings.json
-
-./babel import experiment-001 /path/to/original-samples.jsonl \
-  --format harness --variant original
-./babel import experiment-001 /path/to/rephrased-samples.jsonl \
-  --format harness --variant rephrased
-
-./babel attach experiment-001 /path/to/evaluation-config.yaml /path/to/results.json
-./babel validate --run experiment-001
-./babel compare experiment-001 --items comparison.html
-./babel seal experiment-001
-./babel hub-plan --run experiment-001
+./babel --root new-example benchmark-demo
+./babel --root new-example validate
+./babel --root new-example bank-audit demo-bank-v1
+./babel --root new-example artifacts
 ```
 
-The paired `original`/`rephrased` JSONL format is also supported with
-`--format paired`. A canonical format is available for custom producers.
-Record actual model/dataset revisions, prompts, seeds, harness version, and metric
-definitions. Missing data remains missing; logging cannot invent scores that the
-evaluation did not calculate.
+This creates two handwritten question identities in two languages, three
+fictional checkpoints, twelve handwritten responses, and illustrative
+calibration/release artifacts. **No model or IRT fitting program is run.**
+The ZIP also contains an already-built `benchmark-demo-store/`.
 
-Install transfer support and authenticate the command-line client when using it:
+The previous [item comparison demonstration](https://huggingface.co/datasets/base-model-evals/off-the-shelf-model-evals/resolve/main/item-comparison-demo.html?download=true)
+remains available for download. It uses synthetic original/rephrased responses.
+Real strict runs can also be compared item by item under compatible definitions.
 
-```sh
-python3 -m pip install '.[hub]'
-hf auth login
-./babel hub-push --run experiment-001
-```
+## Real workflow
 
-The bundled real archive is bound to this existing public dataset. The upload
-command sends only registered files for selected sealed runs. The preview lists
-exact paths and hashes. Browser sign-in and command-line sign-in are separate;
-the Hugging Face website's file uploader also works with an existing browser session.
+1. Assemble and audit the bank; register its definition, task protocols and model panel.
+2. Run evaluations using lm-evaluation-harness or another producer, recording the
+   exact prompts, candidates, likelihoods and lengths required by the contract.
+3. Import canonical responses, attach original logs/configurations, validate and seal.
+4. Export a response matrix. Use a separate program for hierarchical Rasch/2PL
+   fitting, uncertainty, linking checks and held-out-family validation.
+5. Register the actual fitting outputs and release definitions, then upload them.
 
-## Download and verify
+Read [BENCHMARK_WORKFLOW.md](BENCHMARK_WORKFLOW.md), [ARTIFACTS.md](ARTIFACTS.md),
+and [FORMAT.md](FORMAT.md) for commands, schemas and limits.
+[VERIFICATION.md](VERIFICATION.md) records software validation.
 
-```sh
-python3 -m babel_fs hub-pull \
-  --repo base-model-evals/off-the-shelf-model-evals \
-  --destination /path/to/new-local-archive
-```
+The toolkit does not yet run IRT fitting, score future models on a calibrated
+scale, compute clustered confidence intervals, apply overall release weights,
+or select/validate short forms. Ordinary accuracy summaries remain ordinary
+accuracy. The filesystem now preserves the data these analyses need.
 
-The download pins a commit, verifies registered files, restores local working
-folders, and refuses to overwrite an existing destination. Add `--revision` to
-select a specific commit or tag. Documentation and the toolkit remain available
-from this repository's Files tab.
+## Transfer and restore
 
-## Compare individual responses
-
-After importing original and rephrased outputs, generate a report from the
-extracted toolkit:
+`hub-plan` previews registered artifacts, selected sealed runs and calibration
+run dependencies. `hub-push` uses the configured public project repository.
+Command-line uploads use the Hugging Face client's authentication; browser sign-in
+is separate. Reports in `derived/` are not uploaded automatically.
 
 ```sh
-./babel compare experiment-001 --items comparison.html
-./babel compare experiment-001 --items comparison.csv
-./babel compare experiment-001 --items comparison.jsonl
+./babel hub-plan
+./babel hub-push
+./babel hub-pull --repo base-model-evals/off-the-shelf-model-evals \
+  --destination /path/to/new-local-archive
 ```
 
-The HTML report opens in a browser and works offline. Search or filter by outcome
-and language to inspect each question's inputs, answers, correctness, scores, and
-source file/line side by side. CSV provides one row per paired or unmatched stable
-item; JSONL retains both full normalized records. File extensions select the
-format, or supply `--format html`, `--format csv`, or `--format jsonl` with
-`--items`. Existing report files are never overwritten.
-
-The command still prints the summary and report metadata. Use `--baseline` and
-`--variant` to select other variants, or add `--other-run RUN-ID` to compare runs.
-Reports are local derived files and are not automatically sent by `hub-push`.
-
-## Analysis and integrity
-
-Summaries report total and scored counts separately. Comparisons join stable
-question identities, language, benchmark, filter, and repeat identifier. They
-report improvements, regressions, unscored pairs, and missing matches. Item-level
-reports include unmatched stable items; run-local identities are excluded and
-counted because their pairing cannot be established reliably. Known conflicting
-dataset revisions are rejected for cross-run comparisons.
-
-Correctness uses each version's own answer key. Missing correctness stays
-unscored. The reports display recorded log probabilities without inventing score
-differences; choice indices alone are not treated as semantic answer agreement.
-
-Raw files are retained alongside normalized files. SHA-256 hashes, duplicate
-checks, transactional imports, sealed runs, and explicit version metadata protect
-the archive from accidental corruption. CSV and optional Parquet are derived
-analysis exports. The automatic Dataset Viewer is disabled because this repository
-is a heterogeneous experiment archive; metadata files are not benchmark rows.
+A pull resolves one commit, validates the registered files and references, and
+refuses to overwrite an existing local destination. The Dataset Viewer is disabled
+because this repository contains heterogeneous archive files rather than one
+uniform data table.

SOURCES.json

@@ -1,79 +1,48 @@
 {
   "schema_version": 1,
-  "purpose": "Pinned benchmark inputs; these files are not model evaluation results.",
-  "results_repository": "base-model-evals/off-the-shelf-model-evals",
-  "verified_at": "2026-09-21",
+  "purpose": "Candidate upstream pins for the proposed existing-parallel-resource foundation; not an assembled item bank or completed audit.",
+  "observed_at": "2026-09-24",
+  "status": "coverage-and-overlap-audit-pending",
+  "new_machine_translation": false,
+  "nonparallel_component": false,
   "datasets": [
     {
-      "repo_id": "base-model-evals/global-mmlu-rephrased",
-      "revision": "cd6952c6df3e52034886603e36c5ce4796f0777f",
-      "benchmark": "global-mmlu",
-      "row_counts": {
-        "all": 156,
-        "high_quality": 138,
-        "low_quality": 18
-      },
-      "license_from_dataset_card": "cc-by-nc-4.0",
-      "configs": [
-        "all",
-        "high_quality",
-        "low_quality"
-      ],
-      "split": "train",
-      "files": [
-        "high_quality/train-00000-of-00001.parquet",
-        "low_quality/train-00000-of-00001.parquet"
-      ],
-      "url": "https://huggingface.co/datasets/base-model-evals/global-mmlu-rephrased",
-      "card_url": "https://huggingface.co/datasets/base-model-evals/global-mmlu-rephrased/blob/cd6952c6df3e52034886603e36c5ce4796f0777f/README.md"
+      "task": "belebele",
+      "repo_id": "facebook/belebele",
+      "revision": "7899cdfa4e1e0d733fd77c848e2c273cb1d32be2",
+      "split": "test",
+      "url": "https://huggingface.co/datasets/facebook/belebele",
+      "expected_items_per_language_from_proposal": 900,
+      "audit_complete": false
     },
     {
-      "repo_id": "base-model-evals/belebele-rephrased",
-      "revision": "e926d6cc0c50196e0d8bb0d018d9fbf1283dd2e8",
-      "benchmark": "belebele",
-      "row_counts": {
-        "all": 157,
-        "high_quality": 125,
-        "low_quality": 32
-      },
-      "license_from_dataset_card": "cc-by-nc-sa-4.0",
-      "configs": [
-        "all",
-        "high_quality",
-        "low_quality"
-      ],
-      "split": "train",
-      "files": [
-        "high_quality/train-00000-of-00001.parquet",
-        "low_quality/train-00000-of-00001.parquet"
-      ],
-      "url": "https://huggingface.co/datasets/base-model-evals/belebele-rephrased",
-      "card_url": "https://huggingface.co/datasets/base-model-evals/belebele-rephrased/blob/e926d6cc0c50196e0d8bb0d018d9fbf1283dd2e8/README.md"
+      "task": "globalpiqa-parallel",
+      "repo_id": "mrlbenchmarks/global-piqa-parallel",
+      "revision": "b0b18516a8bc2cb1106bce3dd4db32848ca715ea",
+      "split": "test",
+      "url": "https://huggingface.co/datasets/mrlbenchmarks/global-piqa-parallel",
+      "expected_items_per_language_from_proposal": 103,
+      "audit_complete": false,
+      "proposal_exception": {
+        "language": "Ekpeye",
+        "expected_items": 101
+      }
+    },
+    {
+      "task": "sib200",
+      "repo_id": "Davlan/sib200",
+      "revision": "38977a667f6fc264d5c26ec57a01e16db040b358",
+      "split": "test",
+      "url": "https://huggingface.co/datasets/Davlan/sib200",
+      "expected_items_per_language_from_proposal": 204,
+      "audit_complete": false
     }
   ],
-  "input_fields": [
-    "id",
-    "language",
-    "original_question",
-    "original_choices",
-    "correct_index",
-    "context",
-    "rephrased_prefix",
-    "rephrased_choices",
-    "rephrasing_model",
-    "judge_overall_score"
-  ],
-  "interpretation": {
-    "stable_question_id": "id",
-    "correct_index": "Zero-based position in rephrased_choices, as documented in the source cards. Validate original-choice answer keys separately.",
-    "judge_overall_score": "Rewrite quality, not evaluated-model accuracy.",
-    "all_configuration": "Combines high_quality and low_quality; do not double-count them.",
-    "rephrasing_model": "CohereForAI/aya-expanse-8b",
-    "languages": [
-      "en",
-      "fr",
-      "ko",
-      "tr"
-    ]
-  }
+  "audit_requirements": [
+    "Audit exact language/script/item intersection before claiming 100+ language coverage.",
+    "Preserve source IDs and shared question IDs; do not infer equivalence from row order alone.",
+    "Map shared passages and FLORES source overlap, especially Belebele versus SIB-200.",
+    "Record exclusions and license/provenance requirements when assembling the bank.",
+    "Upstream commit pins do not freeze a protocol or supply calibrated parameters."
+  ]
 }

VERIFICATION.md

@@ -0,0 +1,93 @@
+# Verification record
+
+## Toolkit 1.3.0 — 2026-09-24
+
+- **190 automated tests passed** on macOS with Python 3.13, including all earlier
+  archive/adapter/report tests and the new benchmark registry/measurement tests.
+- Immutable artifact registration rejects damaged hashes, invalid dependencies,
+  duplicate identities, split-family leakage, inconsistent keys, non-finite
+  parameters, invalid weighting, and synthetic evidence labeled as real.
+- Strict response validation checks bank/protocol/checkpoint links, script identity,
+  candidate order, score/length alignment, exact UTF-8 byte counts, normalization,
+  prediction and correctness. Optional prefixes/suffixes are included exactly.
+- Matrix export shares parsed bank definitions across checkpoints and streams
+  observations. It checks input integrity, missing/duplicate observations,
+  compatibility, provenance and safe output publication.
+- Fake-provider Hub tests exercise artifact-only transfer, mixed strict archives,
+  pinned restores, calibration-run dependency closure, conflicting remote bytes,
+  missing dependencies and changed-byte upload planning.
+- Independent review added regressions for artifact-read and run-manifest races,
+  synthetic-label propagation and shared definition caching.
+- The delivered benchmark demonstration validates with **5 registered artifacts,
+  3 sealed runs and 12 synthetic records**. Its matrix contains 12 observations;
+  comparing two checkpoints pairs the expected 4 translated items.
+- Both filesystem diagrams were rendered and visually inspected.
+
+The real `babel-data/` archive has **0 runs and 0 registered benchmark artifacts**.
+The new folders are an implemented storage contract, not a claim that the
+foundation was assembled or calibrated. No real model execution, IRT estimation,
+parameter-recovery study, held-out generalization analysis, clustered uncertainty,
+calibrated future-model scoring or short-form validation was performed.
+
+The software's tests establish implementation behavior on the cases tested; they
+do not establish the scientific validity of a future registered benchmark.
+
+## Earlier version 1.1.0
+
+Version 1.1.0 verified locally on macOS on 2026-09-21.
+
+- **116 automated tests passed** across adapters, storage, analytics, readiness, and the CLI/Hub integration.
+- A generated input of **10,000 synthetic questions / 20,000 normalized results**
+  imported, sealed, validated, and compared successfully using streaming reads
+  and temporary disk indexes.
+- A built Python wheel installed in a fresh virtual environment without runtime
+  dependencies. Its installed command successfully created a demo, validated it,
+  compared variants, generated an offline upload plan, and exported CSV from
+  outside the source directory.
+- The delivered example archive validates with **8 records**. Its four question
+  pairs produce the expected one regression and two improvements.
+- Tests exercise raw-byte preservation, malformed-input rollback, duplicate IDs
+  and duplicate raw content, checksum damage, invalid paths, concurrent writer
+  rejection, crash recovery, sealing, score/ID semantics, missing observations,
+  export overwrite protection, and optional Parquet roundtrips.
+- Hugging Face behavior was verified with a simulated provider: private/public
+  selection, exact upload allowlists, immutable verified snapshots, conflicting
+  remote files, repeated uploads, concurrent source edits, and download/restore.
+- The ready-to-run launcher was exercised from another working directory using
+  relative archive and input paths, including a conflicting local module name.
+- Download-and-restore tests verify pinned revisions, checksum failures, missing
+  registered files, unsafe paths/symlinks, network interruption cleanup, and
+  preservation of existing or concurrently created destination folders.
+- Canonical input validation now rejects mismatched choice/score counts and
+  out-of-range answer indexes, while preserving request-order likelihoods that
+  legitimately include extra scoring requests.
+- The local readiness check reports that the real archive is valid and empty;
+  Hugging Face support is installed in the current source-run environment, but
+  no local Hugging Face credential was detected. The check never returns tokens
+  or claims that a detected credential has been verified online.
+
+## Project connection
+
+The user's signed-in browser identifies the organization as `base-model-evals`.
+The existing public `off-the-shelf-model-evals` repository initially contained only
+`.gitattributes`; the two rephrasing repositories contain input questions and
+rewrites, with no evaluated-model predictions or log-probability results.
+Their pinned revisions and interpretation notes are recorded in
+`examples/project-sources.json`. The local real archive is bound to the existing
+results repository. Browser authentication and command-line SDK authentication
+are separate.
+
+## Not exercised
+
+The command-line authenticated upload path has been tested with a simulated
+provider, rather than a persistent API token. The browser session is used for
+the project bootstrap. Large-file uploads and provider storage quotas have not
+been load-tested. Remote integration unit tests use a simulated provider and real
+local filesystem operations.
+
+Babel Tower's real evaluation scripts and output JSONL files are not present in
+the project repositories inspected. The
+adapters were tested against synthetic examples of the noted paired format and
+the documented harness sample structure. Metric definitions and question identity
+semantics must be confirmed against the actual producer before using results in
+research. All included demo results are explicitly synthetic.

babel-tower-filesystem.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fa56588b62df0e10581a21e61d6a2b18ae92957e3271c02c076579629e4e1107
-size 97308
+oid sha256:327a5cacc9b5bfff92cd5d8ece14c7bcd51642f111bcbd606c2ee02f8b5ff495
+size 496976