Update README

README.md

@@ -1,3 +1,598 @@
----
-license: mit
----
+---
+license: mit
+task_categories:
+- question-answering
+- text-generation
+language:
+- en
+tags:
+- forecasting
+- benchmark
+- llm-evaluation
+- reasoning
+- temporal-reasoning
+- contamination-control
+- leakage-control
+- prediction
+- agent
+size_categories:
+- n<1K
+pretty_name: OracleProto Forecasting Eval Set (Example, v1.0)
+---
+
+# OracleProto — Forecasting Evaluation Set (Example, v1.0)
+
+**Dataset:** [`MaYiding/OracleProto`](https://huggingface.co/datasets/MaYiding/OracleProto) ·
+**Framework:** [`MaYiding/OracleProto`](https://github.com/MaYiding/OracleProto) ·
+**License:** MIT
+
+A small, hand-curated benchmark of **80 real-world forecasting questions** whose ground truths
+resolve between **2026-03-12 and 2026-04-14**. The set is the public example release shipped
+with the [OracleProto framework](https://github.com/MaYiding/OracleProto) — a reproducible
+harness for benchmarking LLM-native forecasting via knowledge-cutoff and temporal-masking
+discipline.
+
+The dataset is shipped as **a single SQLite database file** named
+`forecast_eval_set_example.db`, which contains **two tables**:
+
+* `forecast_eval_set_example` — the 80 forecasting rows (one row per question).
+* `dataset_metadata` — a one-row table holding the canonical prompt-reconstruction recipe
+  (prompt template, output formats, agent role, answer-encoding rules, provenance).
+
+The dataset is designed to be the **dataset $`\mathcal{D}`$** in the OracleProto run unit
+$`\mathcal{R} = (\mathcal{D}, M, \kappa_M, \delta, T, C, R, \Psi, \phi, \Gamma)`$: every column,
+prompt template, and answer-encoding rule below is byte-stable and round-trip parsed by the
+reference parser, so a forecasting run on this set is auditable, replayable, and comparable
+across models and across calendar years.
+
+> **TL;DR.** 80 yes/no, two-named-entity, and multiple-choice (single-answer / multi-select)
+> questions on real-world events. All ground truths are verified end-to-end via parser
+> round-trip; 0 critical / 0 high / 0 medium ambiguity issues remain. Distributed as a single
+> SQLite database file `forecast_eval_set_example.db` containing tables
+> `forecast_eval_set_example` (rows) and `dataset_metadata` (recipe), so the
+> prompt-reconstruction recipe and per-question metadata stay co-located with the rows.
+
+---
+
+## 1. Dataset at a glance
+
+| Field                  | Value                                                                  |
+| ---------------------- | ---------------------------------------------------------------------- |
+| Schema version         | `v1.0`                                                                 |
+| Release date           | `2026-04-29`                                                           |
+| Rows                   | 80                                                                     |
+| Splits                 | `train` (80) — single split, intended as a held-out evaluation set     |
+| Resolution-date range  | `2026-03-12` → `2026-04-14`                                            |
+| Question types         | `yes_no`, `binary_named`, `multiple_choice`                            |
+| Choice types           | `single` (one correct letter), `multi` (one-or-more correct letters)   |
+| Database file          | `forecast_eval_set_example.db` (SQLite 3, ~52 KB)                      |
+| Tables in the file     | `forecast_eval_set_example` (80 rows), `dataset_metadata` (1 row)      |
+| License                | MIT                                                                    |
+| Source upstream        | HuggingFace forecasting questions (levels 1+2 only), heavily curated   |
+
+### Type distribution
+
+| `question_type`     | `choice_type` | Rows |
+| ------------------- | ------------- | ---- |
+| `yes_no`            | `single`      | 37   |
+| `binary_named`      | `single`      | 3    |
+| `multiple_choice`   | `single`      | 32   |
+| `multiple_choice`   | `multi`       | 8    |
+| **Total**           |               | **80** |
+
+`yes_no` is binary Yes/No, `binary_named` is binary between two named entities (e.g. sports
+teams, fighters, sides), and `multiple_choice` carries ≥3 labelled options where multiple
+correct answers are allowed; *"None of the above"* is a valid answer. Every question lists the
+exact option labels, so labels are the source of truth — letter labels (`A`, `B`, …) are
+implied by index.
+
+---
+
+## 2. Files
+
+```text
+OracleProto/
+├── forecast_eval_set_example.db   # SQLite database file (the dataset; ~52 KB)
+├── README.md                      # this file
+├── LICENSE                        # MIT
+└── .gitattributes                 # standard HF binary attributes
+```
+
+The dataset ships as **one SQLite database file** rather than as Parquet/JSONL, because the
+prompt-reconstruction recipe, the column-level schema, and per-row provenance live in the
+same file (in the `dataset_metadata` table). This keeps the canonical source of truth —
+including the byte-stable `prompt_template` used by the evaluator — co-located with the
+rows. The file `forecast_eval_set_example.db` contains exactly two tables:
+
+* **`forecast_eval_set_example`** — the 80 forecasting rows. Schema and column semantics in §3.1 / §3.3.
+* **`dataset_metadata`** — a single-row table whose `features_json` blob holds the prompt
+  template, the four output formats, the outcomes-block rule, the agent-role string, and
+  the curation provenance. Schema in §3.2; full recipe rendered in §5.
+
+A loader example for converting to `datasets.Dataset` / Parquet is provided in §6.
+
+---
+
+## 3. Database schema
+
+The database **file** is `forecast_eval_set_example.db`. It contains exactly **two tables**:
+`forecast_eval_set_example` (80 forecasting rows) and `dataset_metadata` (1 metadata row).
+Note that the database file and the rows table happen to share the same name — the file is
+named after its primary table.
+
+### 3.1 Table `forecast_eval_set_example` (the rows)
+
+```sql
+CREATE TABLE forecast_eval_set_example (
+    id            TEXT PRIMARY KEY,
+    choice_type   TEXT NOT NULL CHECK (choice_type IN ('single','multi')),
+    question_type TEXT NOT NULL,    -- yes_no | binary_named | multiple_choice
+    event         TEXT NOT NULL,    -- the event being predicted
+    options       TEXT NOT NULL,    -- JSON array of option labels
+    answer        TEXT NOT NULL,    -- canonical correct answer as letter(s)
+    end_time      TEXT NOT NULL     -- 'YYYY-MM-DD'
+);
+
+CREATE INDEX idx_forecast_eval_set_example_choice_type   ON forecast_eval_set_example(choice_type);
+CREATE INDEX idx_forecast_eval_set_example_question_type ON forecast_eval_set_example(question_type);
+CREATE INDEX idx_forecast_eval_set_example_end_time      ON forecast_eval_set_example(end_time);
+```
+
+### 3.2 Table `dataset_metadata` (the recipe)
+
+A single row recording the dataset name, split, row count, import timestamp, and a JSON
+`features_json` blob with the **full prompt-reconstruction recipe** used by the OracleProto
+evaluator. This is what makes the run reproducible — the prompt template, the four output
+formats, the outcomes-block rule, and the agent role are all here in canonical form.
+
+```sql
+CREATE TABLE dataset_metadata (
+    dataset_name      TEXT NOT NULL,
+    split_name        TEXT NOT NULL,
+    table_name        TEXT NOT NULL,
+    row_count         INTEGER NOT NULL,
+    imported_at_utc   TEXT NOT NULL,
+    features_json     TEXT NOT NULL   -- see §5
+);
+```
+
+### 3.3 Column semantics
+
+| Column          | Type    | Description                                                                                                                                                                                                                                       |
+| --------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `id`            | TEXT    | Stable source-side question ID inherited from the upstream HuggingFace forecasting set. Use this as the primary join key.                                                                                                                          |
+| `choice_type`   | TEXT    | `'single'` if exactly one letter is correct, `'multi'` if one-or-more letters can be correct. Derived from the number of letters in `answer`. Drives output-format selection (single-answer vs multi-select instructions).                          |
+| `question_type` | TEXT    | One of `yes_no`, `binary_named`, `multiple_choice`. Selects which prompt template is rendered (see §5).                                                                                                                                            |
+| `event`         | TEXT    | Natural-language description of the event being predicted. Author-edited for explicit time anchoring, unit explicitness, and unambiguous binary framing.                                                                                          |
+| `options`       | TEXT    | JSON array of option **labels**. For `yes_no` it is fixed to `["Yes","No"]`. For `binary_named` it is two named entities. For `multiple_choice` it is a list of choice labels; the letter is implied by index (A=options[0], B=options[1], …).      |
+| `answer`        | TEXT    | Canonical correct answer encoded as **letters**. For `yes_no` and `binary_named` it is a single letter `'A'` or `'B'`. For `multiple_choice` it is a comma-separated letter list in option order, e.g. `'A'` (single) or `'A, B'` (multi).          |
+| `end_time`      | TEXT    | Resolution date in `YYYY-MM-DD` format. The dataset stores a date only (no timestamp and no timezone field) — treat resolutions as "occurred during that day" at the granularity of one calendar day. Use this as the source of truth for the question's resolution day. |
+
+### 3.4 Letter-to-index encoding
+
+Letters `A`, `B`, … map to option indices `0`, `1`, … using the rule
+`index = ord(letter) - ord('A')`. Beyond the 26-letter alphabet (≥27 options) the labels
+land on `[`, `\`, `]`, `^`, `_`, `` ` ``, `a`, `b`, …, i.e. the contiguous ASCII range
+starting at `A`. The reference renderer wraps any non-`A`–`Z` label in backticks so the
+label survives Markdown rendering. None of the 80 example questions exceed 26 options, but
+the encoding scheme is documented for completeness because the evaluator and parser support
+it.
+
+---
+
+## 4. Sample rows
+
+A few representative rows (truncated for readability):
+
+```json
+{
+  "id": "699d9ffc098cca008728b6f0",
+  "choice_type": "single",
+  "question_type": "yes_no",
+  "event": "Will the US PCE annual inflation be greater than 2.9% in January 2026?",
+  "options": ["Yes", "No"],
+  "answer": "B",
+  "end_time": "2026-03-13"
+}
+```
+
+```json
+{
+  "id": "69a2e39e5692ef005cdbf2d3",
+  "choice_type": "single",
+  "question_type": "binary_named",
+  "event": "Will US or Israel strike Iran first?",
+  "options": ["US", "Israel"],
+  "answer": "B",
+  "end_time": "2026-03-31"
+}
+```
+
+```json
+{
+  "id": "6995b1073ea64b005b11f285",
+  "choice_type": "single",
+  "question_type": "multiple_choice",
+  "event": "Which men's basketball team will win the Big 12 Conference Championship tournament in the 2025-26 season?",
+  "options": ["Arizona", "Baylor", "Brigham Young University (BYU)",
+              "Houston", "Iowa State", "Kansas", "Kansas State"],
+  "answer": "A",
+  "end_time": "2026-03-14"
+}
+```
+
+```json
+{
+  "id": "698f198bda7a8b006575444c",
+  "choice_type": "multi",
+  "question_type": "multiple_choice",
+  "event": "Which movies will win multiple Oscars? (2026)",
+  "options": ["One Battle After Another", "Sinners", "Frankenstein",
+              "KPop Demon Hunters", "F1", "Sentimental Value", "Hamnet",
+              "Marty Supreme", "The Secret Agent", "Avatar: Fire and Ash",
+              "Train Dreams", "Bugonia", "Blue Moon", "It Was Just An Accident"],
+  "answer": "A, B, C, D",
+  "end_time": "2026-03-15"
+}
+```
+
+---
+
+## 5. Prompt reconstruction (canonical recipe)
+
+Every row is rendered into a single user message using the recipe stored in
+`dataset_metadata.features_json.prompt_reconstruction`. The recipe is byte-stable and is the
+source of truth for the OracleProto evaluator; downstream users who reconstruct prompts
+themselves should follow it exactly so results stay comparable.
+
+### 5.1 Static fragments
+
+```text
+agent_role: "You are an agent that can predict future events."
+
+guidance: "Do not use any other format. Do not refuse to make a prediction.
+           Do not say \"I cannot predict the future.\" You must make a clear
+           prediction based on the best data currently available, using the
+           box format specified above."
+```
+
+### 5.2 Master template
+
+The block below is reproduced **verbatim** from the value stored in
+`dataset_metadata.features_json.prompt_reconstruction.prompt_template`. It is a literal
+string baked into the recipe; the dataset itself does not otherwise carry a timezone field
+on `end_time` (see §3.3).
+
+```text
+{agent_role} The event to be predicted: "{event} (resolved around {end_time} (GMT+8)).{outcomes_block}"
+
+IMPORTANT: Your final answer MUST end with this exact format:
+{output_format}
+{guidance}
+```
+
+### 5.3 `outcomes_block`
+
+* For `yes_no` and `binary_named`: empty string (the option labels are baked into
+  `output_format` instead).
+* For `multiple_choice`: a leading newline followed by one line per option in `A. <label>`
+  form, e.g. `\nA. Arizona\nB. Baylor\nC. Brigham Young University (BYU)\n…`. Labels whose
+  derived letter falls outside `A`–`Z` are wrapped in backticks.
+
+### 5.4 `output_format` (one of four, chosen by `question_type` × `choice_type`)
+
+**`yes_no`:**
+```text
+Your task is to predict whether the event will occur based on your analysis.
+Your prediction will be scored based on its accuracy. You will only receive points if your answer is correct.
+Your final answer MUST end with this exact format:
+\boxed{Yes} or \boxed{No}
+```
+
+**`binary_named`** (the literals `<options[0]>` and `<options[1]>` are replaced by the two
+named entities from `options`):
+```text
+Your task is to predict which of the two outcomes will occur based on your analysis.
+Your prediction will be scored based on its accuracy. You will only receive points if your answer is correct.
+Your final answer MUST end with this exact format:
+\boxed{<options[0]>} or \boxed{<options[1]>}
+```
+
+**`multiple_choice` with `choice_type='single'`:**
+```text
+This is a SINGLE-ANSWER question: exactly ONE of the listed options is correct.
+Your prediction will be scored on strict equality with the unique correct letter; choosing the wrong letter, or selecting more than one letter, scores zero.
+Your final answer MUST end with this exact format:
+the single correct letter inside the box, e.g. \boxed{A}.
+Do NOT list more than one letter, even if you believe two outcomes are tied — pick the one you find most likely.
+```
+
+**`multiple_choice` with `choice_type='multi'`:**
+```text
+This is a MULTI-SELECT question: ONE OR MORE of the listed options can be correct.
+Your prediction will be scored on strict equality with the FULL set of correct letters: any extra letter, any missing letter, or any wrong letter scores zero. You must include ALL correct options and NO incorrect options.
+Your final answer MUST end with this exact format:
+listing all correct option(s) you have identified, separated by commas, within the box.
+For example: \boxed{A} for a single correct option, or \boxed{B, C} for multiple correct options.
+```
+
+### 5.5 Answer parsing
+
+A reference parser is shipped with the OracleProto framework
+([`forecast_eval/parser.py::parse_answer`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/parser.py)).
+The rules are:
+
+1. Take the **last** `\boxed{...}` substring in the model's reply (everything else is
+   reasoning / scratchpad and is ignored).
+2. For `yes_no`: `Yes` (case-insensitive) → `A`, `No` → `B`. Anything else → unparsed.
+3. For `binary_named`: case-insensitive match of the boxed payload against `options[0]` or
+   `options[1]`. Anything else → unparsed.
+4. For `multiple_choice`: split the boxed payload on commas/whitespace, validate that each
+   token is exactly one letter, and check that each letter resolves to a valid option index.
+   Out-of-range letters or multi-character tokens → unparsed.
+5. Predictions are scored by **strict set equality** against the canonical letter set
+   parsed from `answer`. A missing or unparsed boxed answer is recorded as `parse_ok = 0`
+   and is **not** an error of the parser — the run records it and moves on.
+
+> The parser is the formal answer-validator $`\Psi`$ in the OracleProto run unit. Re-using
+> it (rather than rolling your own regex) is the easiest way to get bit-identical scores
+> across implementations.
+
+---
+
+## 6. Loading the dataset
+
+### 6.1 With raw `sqlite3` (no extra deps)
+
+```python
+import sqlite3
+import json
+
+conn = sqlite3.connect("forecast_eval_set_example.db")
+conn.row_factory = sqlite3.Row
+
+# Read the rows.
+rows = conn.execute("SELECT * FROM forecast_eval_set_example").fetchall()
+print(f"loaded {len(rows)} rows")
+sample = dict(rows[0])
+sample["options"] = json.loads(sample["options"])  # JSON-decode option list
+print(sample)
+
+# Read the canonical prompt-reconstruction recipe.
+meta_row = conn.execute("SELECT features_json FROM dataset_metadata").fetchone()
+meta = json.loads(meta_row["features_json"])
+prompt_template = meta["prompt_reconstruction"]["prompt_template"]
+print(prompt_template)
+```
+
+### 6.2 With `huggingface_hub`
+
+```python
+from huggingface_hub import hf_hub_download
+import sqlite3, json
+
+db_path = hf_hub_download(
+    repo_id="MaYiding/OracleProto",
+    filename="forecast_eval_set_example.db",
+    repo_type="dataset",
+)
+conn = sqlite3.connect(db_path)
+rows = conn.execute("SELECT * FROM forecast_eval_set_example").fetchall()
+```
+
+### 6.3 Convert to a `datasets.Dataset`
+
+```python
+import sqlite3, json
+from datasets import Dataset
+
+conn = sqlite3.connect("forecast_eval_set_example.db")
+cur = conn.execute("SELECT * FROM forecast_eval_set_example")
+cols = [c[0] for c in cur.description]
+
+def _row(r):
+    d = dict(zip(cols, r))
+    d["options"] = json.loads(d["options"])         # list[str]
+    d["answer_letters"] = [
+        s.strip() for s in d["answer"].split(",") if s.strip()
+    ]                                               # list[str]
+    return d
+
+ds = Dataset.from_list([_row(r) for r in cur.fetchall()])
+print(ds)
+print(ds[0])
+```
+
+### 6.4 Render a prompt (minimal, faithful to the canonical recipe)
+
+```python
+def render_prompt(row, meta):
+    rcp = meta["prompt_reconstruction"]
+    options = row["options"]
+    qt, ct = row["question_type"], row["choice_type"]
+
+    if qt == "yes_no":
+        outcomes_block = ""
+        out_fmt = rcp["yes_no_output_format"]
+    elif qt == "binary_named":
+        outcomes_block = ""
+        out_fmt = (
+            rcp["binary_named_output_format"]
+            .replace("<options[0]>", options[0])
+            .replace("<options[1]>", options[1])
+        )
+    elif qt == "multiple_choice":
+        outcomes_block = "\n" + "\n".join(
+            f"{chr(ord('A') + i)}. {label}" for i, label in enumerate(options)
+        )
+        key = (
+            "multiple_choice_single_output_format" if ct == "single"
+            else "multiple_choice_multi_output_format"
+        )
+        out_fmt = rcp[key]
+    else:
+        raise ValueError(qt)
+
+    return rcp["prompt_template"].format(
+        agent_role=rcp["agent_role"],
+        event=row["event"],
+        end_time=row["end_time"],
+        outcomes_block=outcomes_block,
+        output_format=out_fmt,
+        guidance=rcp["guidance"],
+    )
+```
+
+> The full reference renderer (with the > 26-option backtick rule and an optional reflection
+> / belief-elicitation tail) lives at
+> [`forecast_eval/prompts.py`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/prompts.py)
+> in the OracleProto framework. Re-using it gives byte-identical prompts.
+
+---
+
+## 7. Recommended evaluation protocol
+
+This dataset is meant to be paired with the **OracleProto** evaluation harness, which adds
+information-boundary discipline on top of the bare prompt-and-score loop. The headline
+recommendations are:
+
+1. **Declare a knowledge cutoff $`\kappa_M`$ for every model.** OracleProto admits a question
+   for model $`M`$ only when its prediction cutoff $`\chi_i`$ satisfies
+   $`\kappa_M \le \chi_i < \tau_i`$, where $`\tau_i`$ is the resolution time. Inadmissible
+   questions are filtered upstream (not counted as model errors). This separates *"the model
+   failed to forecast"* from *"the model already knew the answer"*. Models with no declared
+   cutoff cannot be fairly compared to those with one.
+
+2. **Time-mask any retrieval / browsing tool.** If your harness lets the model issue web
+   searches (e.g. via Tavily), pin the search-side `end_date` to $`\chi_i + \delta`$ with a
+   conservative offset (OracleProto defaults to $`\delta = -1`$ day). This is the L2
+   "tool-mediated" leakage barrier.
+
+3. **Run an independent retrieval-content auditor.** Each retrieved snippet is passed to a
+   separate LLM auditor that decides whether the snippet leaks the resolution. This is the
+   L3 "retrieval-content" barrier in the OracleProto threat model.
+
+4. **Forbid provider-native browsing.** OracleProto refuses model slugs ending in `:online`
+   and similar hosted-browsing variants on three layers (config validation, on-the-wire
+   client, and detector client) — the L4 residual that *must* pass before any billable LLM
+   call leaves the process.
+
+5. **Score with strict set equality on letter sets** (the parser semantics in §5.5). Optional
+   probability-calibration metrics (Brier / NLL / ECE / Murphy decomposition) are supported
+   when the model emits an additional `<belief>{ ... }</belief>` JSON block per the v4
+   belief protocol; the schema is documented in
+   [`forecast_eval/prompts.py::BELIEF_PROTOCOL`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/prompts.py).
+
+If you run *without* OracleProto, treat the numbers as **upper bounds on forecasting
+ability**: any model that can browse the open web or that was trained past a question's
+`end_time` may have memorised the answer. The dataset is designed to make this honesty audit
+*possible*; it does not enforce it on its own.
+
+---
+
+## 8. Provenance and curation
+
+* **Source.** Upstream HuggingFace forecasting questions, restricted to *levels 1+2* only
+  (the easier two of the upstream difficulty bands). The raw set was harvested as 322
+  candidate questions.
+* **Curation pipeline (5 passes).**
+  1. Source-side broken-row removal and column flattening.
+  2. `end_time` / answer-encoding / option-label normalization (`end_time` reduced to a
+     `YYYY-MM-DD` calendar date; `Yes/No` mapped to `A/B`; option labels stripped of stray
+     markdown).
+  3. Down-sampling 322 → 200 → 100 → 80 with placeholder/noise removal, deduplication, and
+     ambiguity audit.
+  4. Final HIGH+MEDIUM ambiguity remediation: 4 rows reworded for explicit time anchoring,
+     unit explicitness, and unambiguous binary framing.
+  5. CRITICAL fix on one S&P 500 multi-select truth set so it satisfies the
+     monotonic-threshold logic implied by the option ladder.
+* **Verification.** All 80 ground-truths verified end-to-end by parser round-trip (the
+  rendered prompt is parsed and re-encoded back to the canonical letter set). Final tally:
+  **0 critical / 0 high / 0 medium ambiguity issues remaining**.
+
+---
+
+## 9. Intended uses and limitations
+
+### 9.1 Intended uses
+
+* **Forecasting benchmark for LLMs and LLM agents** — particularly tool-using agents that
+  combine parametric knowledge with time-masked web retrieval.
+* **Reproducibility testbed for forecasting harnesses** — the `dataset_metadata` table makes
+  every prompt byte-stable; pair it with the OracleProto framework to get a run unit that
+  yields bit-identical scoring artefacts when the configuration matches.
+* **Calibration / proper-scoring research** — the 80-row size is deliberately small so
+  per-question analysis (belief evolution, source attribution, calibration plots) is
+  tractable.
+
+### 9.2 Out-of-scope uses
+
+* **Training data.** Do not include the rows in any training, fine-tuning, or RLHF corpus;
+  doing so contaminates downstream forecasting evaluations of the trained model. The dataset
+  is an **evaluation-only** artefact.
+* **Long-horizon forecasting.** All resolutions land in a one-month window
+  (2026-03-12 → 2026-04-14). The set is *not* representative of multi-quarter or
+  multi-year forecasting tasks.
+* **Open-ended generation.** Every question has a closed answer set; this is not a
+  generation benchmark.
+
+### 9.3 Known limitations and biases
+
+* **Sample size.** 80 rows is small. Confidence intervals on accuracy / Brier are wide; we
+  recommend reporting them alongside point estimates and using paired tests when comparing
+  models on the same set.
+* **Topical skew.** The questions are concentrated in finance / macro indicators, sports
+  events, awards (Oscars, NBA, UEFA, etc.), and US-centric political and geopolitical
+  events — reflecting the upstream HuggingFace forecasting market mix. They are **not** a
+  globally representative sample of forecastable events.
+* **English-only.** All `event` and `options` strings are English.
+* **Date-only resolution.** `end_time` is a *date*, not a timestamp, and the dataset does
+  not carry a timezone field. If you need finer-grained admissibility, treat resolutions
+  conservatively as "occurred any time during that calendar day".
+* **Provider-side residual leakage (L4 channel).** Any LLM that has ingested the upstream
+  HuggingFace dataset, or that was trained past the resolution window, can recover ground
+  truths from parametric memory. The dataset cannot patch this on its own — it relies on the
+  harness to enforce admissibility ($`\kappa_M`$).
+* **Snapshot of a moving label space.** A few questions ("none of the above", "all of the
+  above") interact non-trivially with multi-select scoring; the curation pass fixed the one
+  S&P 500 case but the convention for similar questions in future revisions may shift. Pin
+  to the schema-version field if you need byte-stable behaviour across releases.
+
+---
+
+## 10. Versioning
+
+* **`v1.0` (2026-04-29)** — initial public example release. 80 rows; resolution dates
+  2026-03-12 → 2026-04-14; pipeline passes 1–5 above; 0 critical / 0 high / 0 medium
+  ambiguity issues remaining.
+
+The schema version is recorded inside the database
+(`dataset_metadata.features_json.schema_version`), so consumers can pin against it without
+re-deriving from the file's hash.
+
+---
+
+## 11. License
+
+The dataset is released under the **MIT License** (see `LICENSE`). You are free to use,
+copy, modify, and redistribute it, including for commercial purposes, provided the copyright
+notice and license text are preserved.
+
+The upstream questions originate from a public HuggingFace forecasting set; the curation
+work, the schema, the prompt-reconstruction recipe, and the answer encodings in this release
+are the contribution of this project.
+
+---
+
+## 12. Contact and contributions
+
+Issues, schema feedback, and ambiguity reports are welcome. If you find a row whose ground
+truth has changed, or whose framing is ambiguous under the §5.5 parser, please open an issue
+in either of the project repositories:
+
+* Dataset (this repo): [`MaYiding/OracleProto` on Hugging Face](https://huggingface.co/datasets/MaYiding/OracleProto/discussions) — for row-level questions, ambiguity reports, and label disputes.
+* Framework code: [`MaYiding/OracleProto` on GitHub](https://github.com/MaYiding/OracleProto/issues) — for evaluator, parser, or harness behaviour.
+
+When reporting a row-level issue, please include the `id`, the disputed framing, and (if
+available) a primary source — those are the two inputs the curation pipeline needs to update
+the row for the next release.