From fcec7714ade455bf9caa7eeced45a439cc7721e5 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:00:56 -0400
Subject: [PATCH 01/13] PRD-002: a rederivation eval, and its plan

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 docs/prds/PRD-002-rederivation-eval.md        | 183 ++++++++
 .../plans/2026-10-20-rederivation-eval.md     | 440 ++++++++++++++++++
 2 files changed, 623 insertions(+)
 create mode 100644 docs/prds/PRD-002-rederivation-eval.md
 create mode 100644 docs/superpowers/plans/2026-10-20-rederivation-eval.md

diff --git a/docs/prds/PRD-002-rederivation-eval.md b/docs/prds/PRD-002-rederivation-eval.md
new file mode 100644
index 0000000..f55894b
--- /dev/null
+++ b/docs/prds/PRD-002-rederivation-eval.md
@@ -0,0 +1,183 @@
+# PRD-002: A rederivation eval
+
+Status: approved, 2026-10-20 · Part 2 of 3 (PRD-001: ship v0.8; PRD-003: Olah-compass principles)
+
+## Why
+
+The v0.8 quiz is at its ceiling. Every condition scores 94–100%, because a model reader answers from any competent explanation (`docs/evals.md`). So the quiz cannot tell PRD-003 whether a change to the principles helps.
+
+An explanation here aims for the reader to grok the subject: once they hold its building blocks, they can work out results nobody told them. Rederivation tests exactly that.
+
+An example from outside the 30 subjects: an explanation of entropy as "the average length of the best code for a source" never mentions KL divergence, but a reader who holds that idea can derive it.
+
+- Messages from p sent with a code built for q cost −log q each instead of −log p.
+- So the average extra cost is Σ p log(p/q).
+- Its properties follow without being taught:
+  - it is never negative, because no code beats the one built for the real source;
+  - it is zero only when p = q;
+  - it is not symmetric;
+  - it is infinite when q gives zero probability to something p produces.
+
+Each quiz already ends with a one-step "predict" item. This PRD adds the several-step version and grades the chain of reasoning, not only the answer.
+
+The reader is a model that already knows most results, so a right answer alone proves nothing. The fix: every step must rest on a part of the explanation that the reader names, and the grader checks that the part carries the idea.
+
+## Goals
+
+### 1. A rederivation target for every subject, frozen before any run
+
+Each of the 30 subjects in `evals/artifact/questions.yaml` gets a target with three parts:
+
+- **the question** the reader works out;
+- **the expected steps:** 3–6 of them, one sentence each. Each step is an idea that any valid derivation needs, not the bookkeeping of one route. Each is marked as one of:
+  - a **building block**, which a good explanation gives;
+  - a **derived step**, which the reader works out from earlier steps.
+- **the result:** the expected conclusion, specific enough to be right or wrong.
+
+Each target passes three tests:
+
+1. **Allowed building blocks only.** Every step uses one of:
+   - an idea from the subject's question;
+   - an idea from the quiz's expected answers;
+   - background at the reader's level. That level is set by the `reader` line in `questions.yaml`: school mathematics and science, and basic programming.
+
+   A target that needs an idea a focused explanation can leave out rewards length, not understanding. The conditions average from 606 to 1,689 words, so that bias would be large. PRD-003 would then tune the principles toward length, the opposite of their aim.
+2. **Several steps:** at least three.
+3. **Not stated:** a good answer to the subject's question would not state the result.
+
+Claude drafts the targets. A fresh `claude -p` checker sees the subject's question, its quiz with the expected answers, and the target, then applies the three tests and returns pass or fail with a reason.
+
+- A failed target is rewritten and checked again, at most twice.
+- A subject whose target still fails gets no target, and the report lists it.
+- The checker's verdicts are saved with the targets.
+
+All 30 targets, test subjects included, are committed in one commit before the first rederivation run. Writing them now means the PRD-003 changes cannot shape them. The owner may skim them; nothing waits on that.
+
+### 2. A rederive stage in the artifact eval
+
+**Reader.** The reader gets the renderings only, as today, and the target's question. It does not see the expected steps or the result. It works the question out step by step. For each step it gives:
+
+- the idea the step uses;
+- the part of the explanation that idea comes from: a heading, a paragraph, a figure or diagram, or a control on a page;
+- that idea in its own words.
+
+If the explanation lacks an idea the reader needs, it says so and stops there. A gap is evidence.
+
+**Outside-knowledge rule.** The same text goes in the reader prompt and the grader prompt:
+
+- background at the reader's level may be used without citing anything;
+- any fact about the subject must come from a part of the explanation that the reader names.
+
+**Grader.** The grader works blind, under shuffled labels, as today. For each explanation it sees the text, the reader's chain, and the target's expected steps and result. The expected steps are a checklist of ideas, not a script. A step counts when the reader's chain establishes the same idea in any order, whether merged with another step, split in two, or reached by an equivalent route. The grader marks each expected step as one of:
+
+- **supported:** the reader made the step, and either the cited parts carry the ideas it rests on, or it uses only reader-level background on top of earlier steps;
+- **unsupported:** the reader made the step from its own knowledge, or from a part that does not carry the idea;
+- **missing;**
+- **stated:** a derived step that the explanation states outright, so the reader looked it up instead of working it out.
+
+The grader also marks whether the result is right, and whether the explanation states the result outright.
+
+**Scores.** Each condition gets three scores:
+
+- **supported:** the share of expected steps that are supported;
+- **raw:** the share made at all;
+- **result right.**
+
+These mirror the quiz's grounded and raw scores.
+
+A stated derived step, or a stated result, is left out of that explanation's score: out of both the count and the total. The report counts these per condition. That way a long explanation is neither rewarded nor penalized for spelling out what the reader was meant to derive.
+
+**Passes.** Every run of the stage makes three passes. In each pass, a fresh reader works through every build, and the grader grades it once under its own label shuffle. The spread across passes then covers both the reader's variation and the grader's.
+
+The stage runs in every `eval artifact` run from now on, because PRD-003 needs it on new builds. It can also run alone on the saved builds of an earlier run.
+
+### 3. A dev baseline on the saved v0.8 builds
+
+- **No new builds.** The results go in a new folder that reuses the 40 builds saved in `evals/artifact/results/2026-10-04-dev/` (10 subjects × 4 conditions).
+- **Models.** The reader and the grader use the `claude` CLI's default model, as the v0.8 baseline did.
+- **Three passes,** as defined in Goal 2, each reported. The v0.8 ranges came from three different gradings, one of them the faulty first run, so they are no model to copy.
+- **The report** gives, per condition, the three scores (with their range across passes), next to words and the v0.8 quiz score, plus a table per subject.
+
+### 4. The result is written up, whatever it is
+
+`docs/evals.md` gets a "Rederivation" section. It says what the eval measures and gives the three target tests. Then it reports what the dev baseline found, judged by the rule below.
+
+**The separation rule, fixed before the first run.** Condition A beats condition B when A's supported score is higher than B's in all three passes.
+
+The section says:
+
+- which pairs of conditions separate;
+- whether the order follows word count, which would mean the score measures length;
+- if no pair separates, that the eval does not yet rank the conditions, and that PRD-003 should not adopt it as its measure without changes.
+
+The "Next" list in ROADMAP §15 and the "Unreleased" section of `CHANGELOG.md` record the stage and its result.
+
+### 5. A human check that does not block
+
+`evals/artifact/human-check.md` is a one-page brief for a person who reads one explanation and works out its target on paper, before seeing the expected steps. Their chain is graded with the same rubric. `docs/evals.md` then records whether the person's score and the model reader's score on that explanation agree.
+
+PRD-002 is done without any human results; they are added when they come in.
+
+## Non-goals
+
+- **No change to the principles, the skills, or other measured text.** That is PRD-003.
+- **No new builds and no run on the test split.** A test run needs new builds for all 20 test subjects. It runs when PRD-003 confirms a change.
+- **No changed-world variants and no reader run without an explanation.** They were cut to keep this simple.
+- **No change to the quiz, its scoring, or the v0.8 reports.**
+
+## Anti-goals
+
+- Changing a target, its steps, or the separation rule after seeing any rederivation score.
+- A target that rewards length because it needs an idea outside the allowed building blocks.
+- Claiming a separation the rule does not support, or presenting a 10-subject dev run as more than that.
+
+## Constraints
+
+- **The repo is public (MIT).** Targets and docs contain no personal or private-project context.
+- **The shipped v0.8 record stays as it is.** `evals/artifact/results/2026-10-04-dev/` and `2026-10-04-dev-haiku-reader/` stay byte-identical: `git diff --exit-code` on them is clean.
+- **The builder never sees a target.** Build prompts are unchanged.
+- **The reader never sees** the expected steps or the result.
+- **Grading stays blind** under shuffled labels.
+- **Every stage saves its output,** and a rerun skips what exists, as today.
+- **Tests run offline,** without the `claude` CLI, like the existing artifact eval tests.
+
+## Decided
+
+All decided by the owner on 2026-10-19.
+
+- **Rederivation is the test of grokking.** Once the reader has the building blocks, they can rederive the results and the rest of the theory from first principles.
+- **A citation names a part of the explanation and restates its idea.** Word-for-word quotes are too strict, and an idea carried by a figure cannot be quoted.
+- **The owner's time is not required.** Claude drafts the targets, a model checks them, and the owner may skim.
+- **Simpler beats complete.** No changed-world variants and no control run without an explanation.
+- **Human calibration happens when a tester is free.** It blocks nothing.
+- **Targets are frozen before the first run.**
+
+## Calls made by Claude (check these)
+
+Approving this PRD approves these calls. Nothing else waits on the owner.
+
+- **The allowed-building-blocks test:** the question, the quiz's expected answers, and reader-level background. This keeps the score from rewarding length.
+- **Targets for all 30 subjects now;** only dev runs in this PRD.
+- **The separation rule:** higher in all three passes.
+- **A pass is a fresh reader run, graded once under its own shuffle.** This triples the reader calls in every run. Reads are cheap next to builds, and only this design tests whether a difference survives the reader's own variation.
+- **Credit for other routes.** Expected steps are a checklist of ideas, credited in any order or form. Each step must be one that any valid derivation needs.
+- **Stated derived steps and stated results are left out of the score and counted.** They are neither rewarded nor penalized.
+- **Scores:** supported, raw and result-right, mirroring the quiz.
+- **The rederive stage joins every artifact eval run** from now on.
+- **No release is decided here.** The owner decides at the end whether PRD-002 ships as v0.9.0 or waits for PRD-003.
+
+## Left to the builder
+
+- Field names in `questions.yaml`, and the prompt wording beyond the outside-knowledge rule.
+- The CLI form for running the stage on an earlier run's builds.
+- How the new folder reuses the builds, by copy or by reference, provided the v0.8 folders stay unchanged.
+- Whether the grader sees a subject's four explanations in one call, as today, or one at a time, provided the labels stay shuffled.
+
+## Done when
+
+- Each of the 30 subjects has a target whose checker verdict is pass, or is listed as having none. The targets were committed before any rederivation result.
+- The dev baseline is in a new results folder with three passes. Its report shows the scores next to word count and the quiz.
+- `docs/evals.md` states the result under the separation rule, including "no separation" if that is the outcome.
+- The v0.8 results folders are unchanged.
+- `evals/artifact/human-check.md` exists.
+- Tests pass offline, `explainer check` passes, and CI is green.
diff --git a/docs/superpowers/plans/2026-10-20-rederivation-eval.md b/docs/superpowers/plans/2026-10-20-rederivation-eval.md
new file mode 100644
index 0000000..8b983b2
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-20-rederivation-eval.md
@@ -0,0 +1,440 @@
+# Rederivation Eval Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a rederivation stage to the artifact eval, give all 30 subjects a frozen, model-checked target, and report a three-pass dev baseline on the saved v0.8 builds, whatever it shows.
+
+**Architecture:**
+- One new module, `explainer_kit/rederive.py`, holds the targets (validation, hashing, checker), the reader, the grader, scoring, the run, the report, and the grading of a human chain.
+- `artifact_eval.py` changes only where the reader's file copies are made: that code is extracted into `copy_for_reader` so both stages share it.
+- The CLI gains three `eval` suites (`targets`, `rederive`, `human`), and `eval artifact` runs the rederive stage after it grades.
+- The stage reads builds from a `--builds` folder and writes only to `--out`. That is how the baseline reuses the v0.8 builds without touching them.
+- Work happens on branch `prd-002-rederivation` from `main`.
+
+**Tech Stack:** Python 3 / uv, pytest, PyYAML, the `claude` CLI through `explainer_kit.agent.ask`.
+
+**Spec:** `docs/prds/PRD-002-rederivation-eval.md`
+
+## Global Constraints
+
+- **Measured text does not change:** `git diff --stat main -- plugin/skills explainers` is empty at every commit.
+- **The builder never sees a target.** In `artifact_eval.py`, `TASK`, `SKILL_TIER` and `build()` are unchanged: `git diff main -- explainer_kit/artifact_eval.py` touches only `read()` and the new `copy_for_reader`.
+- **The v0.8 record stays byte-identical:** `git status --porcelain -- evals/artifact/results/2026-10-04-dev evals/artifact/results/2026-10-04-dev-haiku-reader` is empty at every commit.
+- **Targets are frozen at the Task 2 commit.** Afterwards, `rederive` blocks in `evals/artifact/questions.yaml` never change. A test (Task 5) fails if a results folder's snapshot differs from the file.
+- **The repo is public.** No committed file holds an absolute path, a username, an email address, a key, or private-project context.
+- **The reader prompt and the grader prompt contain the same constant, `OUTSIDE_RULE`:**
+  > Background that this reader already has (see the reader above) may be used without a citation. Every fact about the subject must come from a part of the explanation that the reader names.
+- **The separation rule, verbatim:** "Condition A beats condition B when A's supported score is higher than B's in all three passes."
+- **A pass** is a fresh reader run over every build, then one grading per subject under its own label shuffle (`random.Random(k)` for pass `k`).
+- **Tests run offline.** They stub `agent.ask` and `agent.subprocess.run` and never call the `claude` CLI.
+- **The baseline uses the `claude` CLI's default model,** so no `--model` and no `--reader-model`.
+
+## Review Focus
+
+1. **A build with no renderings** (a failed build). Expect the reader to be skipped and every step marked missing. The run must not crash, and the report shows it. The test is in Task 3, `test_read_chain_skips_a_build_with_no_renderings`.
+2. **A rerun after the targets changed.** Expect the run to refuse, naming the changed subjects, so no folder mixes two target versions. The test is in Task 5, `test_rerun_refuses_changed_targets`.
+3. **Absolute paths leaking into saved output** (public repo). Expect the source folder saved relative to `--out`, and no prompt or temp path saved. The test is in Task 5, `test_outputs_hold_no_absolute_paths`.
+4. **Grader replies that don't fit:** too few or too many marks, an unknown word, "stated" on a building block, or a missing label. Expect normalisation, not a crash or a skewed score. The test is in Task 4, `test_marks_are_normalised`.
+5. **A page whose idea lives in a control.** Expect the grader to see the page's script as well as its visible text, so a reader citing a slider can be checked. The test is in Task 4, `test_grader_text_includes_page_scripts`.
+
+---
+
+### Task 0: Branch
+
+- [ ] **Step 1:** Create the branch. In the PRD, change `Status: draft, 2026-10-19` to `Status: approved, 2026-10-20`; committing it before any run is what pre-registers the separation rule. Commit the spec and the plan.
+
+```bash
+git switch -c prd-002-rederivation
+git add docs/prds/PRD-002-rederivation-eval.md docs/superpowers/plans/2026-10-20-rederivation-eval.md
+git commit -m "PRD-002: a rederivation eval, and its plan"
+```
+
+### Task 1: Targets — format, validation, and the checker
+
+**Files:**
+- Create: `explainer_kit/rederive.py`
+- Modify: `explainer_kit/cli.py`. Add `targets` to the `eval` suite choices; `cmd_eval` dispatches it.
+- Create: `tests/test_rederive.py`
+
+**Interfaces:**
+- Produces:
+  - `checks_file() -> Path`, which returns `project_root()/"evals"/"artifact"/"rederive-checks.json"`.
+  - `target_problems(t: dict) -> list[str]`.
+  - `target_hash(t: dict) -> str`: the first 12 hex digits of the sha256 of `json.dumps(t, sort_keys=True, ensure_ascii=False)`.
+  - `check_prompt(subject: dict, reader: str) -> str`.
+  - `check_targets(only: list[str] | None = None, model: str | None = None) -> Path`.
+- The target format in `questions.yaml`, under each subject:
+
+  ```yaml
+  rederive:
+    q: "…"
+    steps:
+      - {kind: block, text: "…"}
+      - {kind: derived, text: "…"}
+    result: "…"
+  ```
+
+- The checks file maps `{subject_id: {"verdict": "pass"|"fail", "tests": {...}, "reason": str, "hash": str, "attempt": int}}`.
+
+- [ ] **Step 1: Write the failing tests** in `tests/test_rederive.py`.
+  - `test_target_problems`:
+    - a valid target (3 steps, at least one `derived`, non-empty `q` and `result`) gives `[]`;
+    - each of these gives a non-empty list: 2 steps; 7 steps; no `derived` step; kind `"lemma"`; empty `result`; missing `q`.
+  - `test_target_hash_is_stable_and_sensitive`: the same dict in a different key order hashes the same, and changing one step's text changes the hash.
+  - `test_check_prompt_shows_the_building_blocks`. For the first dev subject, given a target, the prompt contains:
+    - every quiz `expect`, the reader line, every step text with its kind, and the result;
+    - the phrases `"any valid derivation needs"`, `"would not state"`, and `"no new fact about the subject"`.
+  - `test_check_targets_records_and_resumes`. Monkeypatch `rederive.checks_file` to a tmp file and `ae.questions_file` to a tmp YAML with two subjects that have targets, and a stub `agent.ask` that returns:
+
+    ```json
+    {"tests": {"correct": true, "blocks": true, "derived_follow": true, "steps": true, "not_stated": true}, "reason": "ok"}
+    ```
+
+    for one subject, and `"derived_follow": false` for the other. Assert:
+    - verdicts `pass` and `fail` (the verdict is computed in code as all five tests true, never read from the reply);
+    - each `hash` equals `target_hash`, and `attempt == 1`;
+    - a second call makes **no** `agent.ask` call;
+    - after editing the failing target and calling again, that subject has `attempt == 2` and only it was asked.
+- [ ] **Step 2: Run them to verify they fail.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: FAIL. The module is not found.
+- [ ] **Step 3: Implement the four functions in `explainer_kit/rederive.py`.**
+  - Module docstring style matches `artifact_eval.py`.
+  - `CHECKER_SYSTEM = "You are a careful scientist and teacher. You check test questions. Reply with JSON only."`
+  - The checker prompt asks for five booleans:
+    - `correct`: the steps and the result are true;
+    - `blocks`: every `block` step is an idea from the subject's question, from the quiz's expected answers, or background this reader already has;
+    - `derived_follow`: every `derived` step follows from the steps before it plus background this reader already has, and introduces no new fact about the subject (otherwise only explanations that happen to contain that fact could support it, and length wins);
+    - `steps`: there are at least three steps, and each is an idea any valid derivation needs, not one route's bookkeeping;
+    - `not_stated`: a good answer to the subject's question would not state the result.
+
+    It also asks for a one-sentence `reason` that names any failing step.
+  - `check_targets` walks `ae.load("all", only)[1]`. It skips subjects without `rederive` and subjects whose saved hash matches. It sets `attempt` to the saved attempt plus 1 when the hash changed. It writes the file sorted by id, with a trailing newline.
+  - `cmd_eval` with `suite == "targets"` calls `check_targets(args.only, args.model)` and prints a count of pass and fail.
+- [ ] **Step 4: Run the tests to verify they pass.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: 4 passed.
+- [ ] **Step 5: Commit.**
+  `git add explainer_kit/rederive.py explainer_kit/cli.py tests/test_rederive.py && git commit -m "rederive: target format, validation, and the checker"`
+
+### Task 2: Draft, check and freeze all 30 targets
+
+This task is content work plus live checker calls (`claude -p`), about 30–60 calls. Nothing from Tasks 3–5 may exist in the working tree yet. The targets are written before the reader or grader prompts exist, and stay unchanged afterwards.
+
+**Files:**
+- Modify: `evals/artifact/questions.yaml`. Add a `rederive` block to every subject, and add a header paragraph explaining the block and that the builder and reader never see the steps or the result.
+- Create: `evals/artifact/rederive-checks.json` (generated).
+- Modify: `tests/test_rederive.py` (one test).
+
+**How to draft a target.** The worked example below is from outside the 30 subjects and is not added to the file:
+
+```yaml
+rederive:
+  q: "A code was built for the letter frequencies q of one language and is used for text from another, with frequencies p. How many extra bits per letter does it cost on average, and can that cost ever be negative?"
+  steps:
+    - {kind: block, text: "In the best code, a symbol of probability p gets a codeword of about -log2 p bits."}
+    - {kind: block, text: "Entropy is the average codeword length of the best code: the sum of -p log2 p."}
+    - {kind: derived, text: "With q's code, each letter costs -log2 q instead of -log2 p, so the average extra cost is the sum of p log2(p/q)."}
+    - {kind: derived, text: "No code beats the one built for the true source, so the extra cost is never negative, and it is zero only when p = q."}
+  result: "The sum of p log2(p/q) bits per letter (the KL divergence); never negative, zero only when p = q."
+```
+
+- A `block` step restates an idea from the subject's `q`, from a quiz `expect`, or from background at the reader's level. If you cannot point to one, the step is not a block, and the target likely rewards length: redraft it.
+- Derived steps follow from the steps before them plus reader-level background, and bring in no new fact about the subject. The result follows from those steps.
+- The question names a concrete case, quantity, sign, or limit that is not one of the quiz questions.
+
+- [ ] **Step 1: Write the failing test** `test_every_subject_has_a_checked_target`. For each subject in `ae.load("all")`, with `checks = json.loads(rederive.checks_file().read_text())`:
+  - if the subject has a `rederive` block: `target_problems(...) == []`, `checks[id]["verdict"] == "pass"`, and `checks[id]["hash"] == target_hash(...)`;
+  - otherwise: `checks[id]["verdict"] == "fail"` and `checks[id]["attempt"] == 3`. This is the "listed as having none" case.
+- [ ] **Step 2: Run it to verify it fails.**
+  Run: `uv run pytest tests/test_rederive.py::test_every_subject_has_a_checked_target -q`
+  Expected: FAIL, because the checks file is missing.
+- [ ] **Step 3: Draft the 30 `rederive` blocks** in `questions.yaml`, using the guidance above, and run the checker.
+  Run: `uv run explainer eval targets`
+  Expected: one verdict per subject in `evals/artifact/rederive-checks.json`.
+- [ ] **Step 4: Rewrite failures, at most twice.**
+  - For each `fail`, rewrite the target using the checker's `reason`, then rerun the checker. The attempt count reaches 2, then 3.
+  - If a subject still fails at attempt 3, delete its `rederive` block and keep its `fail` entry.
+  - Ledger each deletion as a ruling.
+- [ ] **Step 5: Run the test to verify it passes.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: all pass.
+- [ ] **Step 6: Commit. This is the freeze commit.**
+  - `git add evals/artifact/questions.yaml evals/artifact/rederive-checks.json tests/test_rederive.py && git commit -m "Freeze the rederivation targets: 30 subjects, model-checked"`
+  - Ledger the commit hash as `FREEZE`.
+
+### Task 3: The reader
+
+**Files:**
+- Modify: `explainer_kit/artifact_eval.py`. Extract `copy_for_reader(files: list[Path], shown: Path) -> list[Path]` from `read()`. It empties `shown`, then copies each file into it and returns the copies. `read()` calls it, and its behaviour is unchanged.
+- Modify: `explainer_kit/rederive.py`
+- Modify: `tests/test_rederive.py`
+
+**Interfaces:**
+- Consumes: `ae.renderings(ws, sid)` and `ae.copy_for_reader`.
+- Produces:
+  - `OUTSIDE_RULE: str`, the exact text in Global Constraints;
+  - `reader_prompt(files: list[Path], reader: str, question: str) -> str`;
+  - `chain_reply(text: str) -> dict`, which returns `{"steps": [{"step": str, "part": str, "idea": str}], "result": str, "gap": str}`;
+  - `chain_text(chain: dict) -> str`;
+  - `read_chain(subject: dict, cond: str, reader: str, builds: Path, out: Path, k: int, model: str | None) -> dict`, which saves to `out/"rederive"/f"pass-{k}"/"read"/<id>/f"{cond}.json"`.
+
+- [ ] **Step 1: Write the failing tests.**
+  - `test_reader_prompt_is_blind_to_steps_and_result`:
+    - it contains the target `q`, `OUTSIDE_RULE`, every file path, `"gap"` and `"part"`;
+    - it contains no step text and no result text from a real dev target.
+  - `test_chain_reply_tolerates_shapes`:
+    - valid JSON round-trips;
+    - `{"steps": "x"}` gives `steps == []`;
+    - `"no json"` gives `{"steps": [], "result": "", "gap": ""}`;
+    - step items that are not dicts are dropped.
+  - `test_chain_text_numbers_steps`: two steps give lines starting `1.` and `2.`, each with its part and idea, then a `Result:` line.
+  - `test_read_chain_uses_copies_and_leaves_builds_untouched`. Use a tmp builds folder with `work/<id>/a/explanation.md` and a stub `agent.ask` that captures `read=` and returns a chain. Assert:
+    - every `read` folder lies outside `builds`;
+    - the saved file exists at the path above;
+    - a second call makes no `agent.ask` call;
+    - the sha256 of every file under `builds` is unchanged.
+  - `test_read_chain_skips_a_build_with_no_renderings`: there is no `agent.ask` call, and the result has `"missing": True` and `steps == []`.
+  - The existing `tests/test_artifact_eval.py` must still pass.
+- [ ] **Step 2: Run them to verify they fail.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: the new tests FAIL with `AttributeError`.
+- [ ] **Step 3: Implement.**
+  - The reader prompt states, in order:
+    - the reader line;
+    - "Read ONLY these files" and the file list;
+    - the `.html` rule from `ae.reader_prompt`;
+    - the question;
+    - "work it out step by step from the explanation";
+    - per step: what it establishes (`step`), the part it rests on (`part`: a heading, paragraph, figure or diagram, a page control, an earlier step number, or `background`), and that part's idea in its own words (`idea`);
+    - `OUTSIDE_RULE`;
+    - "if the explanation lacks an idea you need, say which in `gap` and stop there";
+    - the JSON shape.
+  - Reuse `ae.READER_SYSTEM`.
+  - Make copies in `tempfile.mkdtemp()` and remove them afterwards.
+  - Retry the call once if `steps` comes back empty and `gap` is empty, as `ae.read` does.
+- [ ] **Step 4: Run the tests to verify they pass.**
+  Run: `uv run pytest tests/test_rederive.py tests/test_artifact_eval.py -q`
+  Expected: all pass.
+- [ ] **Step 5: Commit.**
+  `git add -u && git commit -m "rederive: the reader works the target out and cites the parts it rests on"`
+
+### Task 4: The grader and the scores
+
+**Files:** modify `explainer_kit/rederive.py` and `tests/test_rederive.py`.
+
+**Interfaces:**
+- Consumes: `chain_text`, `OUTSIDE_RULE`, `ae.shown_text`, `ae.renderings`, and `ae.GRADER_SYSTEM`.
+- Produces:
+  - `MARKS = ("supported", "unsupported", "missing", "stated")`;
+  - `grader_text(path: Path) -> str`;
+  - `grade_prompt(subject: dict, reader: str, entries: dict[str, dict]) -> str`, where `entries` maps a label to `{"text": str, "chain": str}`;
+  - `marks(raw: object, kinds: list[str]) -> list[str]`;
+  - `tally(marks: list[str], kinds: list[str], right: bool, stated: bool) -> dict[str, int]`, with keys `supported, made, counted, stated, right, results, results_stated`;
+  - `pass_scores(tallies: dict[str, list[dict]]) -> dict[str, dict]`. It maps a condition to `{"supported": float, "raw": float, "result": float | None}`, pooled over subjects;
+  - `separations(passes: list[dict[str, dict]]) -> list[tuple[str, str]]`;
+  - `grade_subject(subject: dict, key: dict[str, str], reader: str, builds: Path, out: Path, k: int, model: str | None) -> dict`. It saves `out/"rederive"/f"pass-{k}"/"grades"/f"{id}.json"` as `{"key": key, "grades": {cond: {"marks": [...], "result_right": bool, "result_stated": bool}}}`.
+
+- [ ] **Step 1: Write the failing tests.**
+  - `test_grader_text_includes_page_scripts`. `<p>Drag the slider</p><script>const loss = x => x * x</script>` gives text containing both `"Drag the slider"` and `"const loss"`. A `.md` file gives the same as `ae.shown_text`.
+  - `test_grade_prompt_is_blind_and_carries_the_rule`. The prompt contains:
+    - `OUTSIDE_RULE`;
+    - each expected step with its kind;
+    - the result;
+    - `"=== Explanation A ==="` and the chain text;
+    - the words `"any order"` and `"stated"`.
+
+    It does not contain `"principles"` or `"skill"`, in any case.
+  - `test_marks_are_normalised`:
+    - `marks(["supported", "stated", "bogus"], ["block", "block", "derived", "derived"]) == ["supported", "supported", "missing", "missing"]`;
+    - `marks("x", ["block"]) == ["missing"]`;
+    - extra marks are dropped.
+  - `test_tally`:
+    - `tally(["supported", "unsupported", "stated", "missing"], ["block", "derived", "derived", "derived"], True, False)` gives `{"supported": 1, "made": 2, "counted": 3, "stated": 1, "right": 1, "results": 1, "results_stated": 0}`;
+    - with `stated=True`, it gives `right == 0`, `results == 0` and `results_stated == 1`.
+  - `test_pass_scores_pool_subjects`. For condition `a`, tallies `{"supported": 1, "made": 2, "counted": 2, …, "right": 1, "results": 1}` and `{"supported": 2, "made": 2, "counted": 3, …, "right": 0, "results": 1}` give supported `0.6`, raw `0.8` and result `0.5`. A condition with `results == 0` everywhere gives `result is None`.
+  - `test_separations_need_every_pass`.
+
+    ```python
+    separations([
+        {"a": {"supported": .7}, "b": {"supported": .5}, "c": {"supported": .6}},
+        {"a": {"supported": .7}, "b": {"supported": .5}, "c": {"supported": .4}},
+        {"a": {"supported": .6}, "b": {"supported": .6}, "c": {"supported": .3}},
+    ]) == [("a", "c")]
+    ```
+  - `test_grade_subject_maps_labels_back_and_fills_missing`. Use a stub grader reply that grades label `A` only:
+    - the saved grades are keyed by condition;
+    - the condition whose label is missing gets all `missing` marks and `result_right: False`;
+    - a rerun makes no call.
+- [ ] **Step 2: Run them to verify they fail.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: the new tests FAIL.
+- [ ] **Step 3: Implement.**
+  - `grader_text`: for `.html`, `ae.shown_text(path)` plus the text of each `<script>…</script>` under a `--- page script ---` line; otherwise `ae.shown_text(path)`. Each explanation is truncated at `ae.TEXT_LIMIT`.
+  - The grader prompt states:
+    - the subject `q`, the reader, and the target `q`;
+    - the expected steps, numbered, with kind, and the expected result;
+    - `OUTSIDE_RULE`;
+    - "the expected steps are a checklist of ideas: credit a step when the chain establishes the same idea in any order, merged, split, or by an equivalent route";
+    - the four marks as the PRD defines them, adding that `stated` applies to derived steps only and that building blocks are meant to be in the explanation;
+    - `result_right`, and `result_stated` (the explanation states the result outright);
+    - the reply shape `{"grades": {"<label>": {"marks": [...], "result_right": bool, "result_stated": bool}}}`.
+  - A missing build's entry text is `"(no explanation)"`, and its chain is `"(no chain)"`.
+- [ ] **Step 4: Run the tests to verify they pass.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: all pass.
+- [ ] **Step 5: Commit.**
+  `git add -u && git commit -m "rederive: blind grading of each chain, scores, and the separation rule"`
+
+### Task 5: The run, the report, and the CLI
+
+**Files:** modify `explainer_kit/rederive.py`, `explainer_kit/cli.py` and `tests/test_rederive.py`.
+
+**Interfaces:**
+- Consumes: everything above, plus `ae.load`, `ae.visible`, `evals.words`, and `ae.RENDERINGS`.
+- Produces: `run(out: Path, builds: Path, split: str = "dev", only: list[str] | None = None, model: str | None = None, reader_model: str | None = None, workers: int = 4, passes: int = 3) -> Path`. It returns `out/"rederive.md"` and also writes the following.
+  - `out/"rederive-scores.json"`:
+    - `{"passes": [pass_scores…], "tallies": {...}, "separations": [[a, b], …]}`.
+  - `out/"rederive"/"targets.json"`:
+    - `{id: target}` for the subjects run;
+    - if it already exists and differs from the current targets, `SystemExit("targets changed since this run: <ids>")`.
+  - `out/"rederive"/"source.json"`:
+    - `{"builds": os.path.relpath(builds, out)}`.
+  - The conditions are the keys of `builds/"conditions.json"`, in file order.
+  - Only subjects with a `rederive` block run.
+
+- [ ] **Step 1: Write the failing tests.** They use one fixture: a tmp `questions.yaml` with one subject and target, monkeypatched in through `ae.questions_file`. The builds folder holds `conditions.json` `{"a": "none", "b": "quick"}`, explanations containing `ALPHA` and `BETA`, and a `scores.json` like `fake_run_folder`'s. The stub `agent.ask` returns a chain for reader calls. For grader calls, it finds which label's block contains `ALPHA`, marks every step `supported` for it and `missing` for the other, and counts its calls.
+  - `test_run_end_to_end`. There are 3 × 2 reader calls plus 3 grader calls. The report contains:
+    - the table header `| condition | supported | raw | result right | stated steps | stated results | words | quiz (grounded) |`;
+    - a row starting `| a | 100%, 100%, 100% | 100%, 100%, 100% |`;
+    - the line `Separation (higher supported score in all three passes): a > b.`
+  - `test_rerun_makes_no_calls`: a second `run` makes zero calls and gives an identical report.
+  - `test_rerun_refuses_changed_targets`: edit the target's result, then `pytest.raises(SystemExit, match="targets changed")`.
+  - `test_outputs_hold_no_absolute_paths`: no file under `out` contains `str(tmp_path)`, and `source.json` gives a relative path.
+  - `test_builds_folder_is_untouched`: the sha256 of every file under `builds` is the same before and after `run`.
+  - `test_frozen_targets_match_every_results_folder`. For every `evals/artifact/results/*/rederive/targets.json` in the repo, each entry equals the current target in `questions.yaml`. This passes vacuously until Task 6.
+  - `test_cli_rederive_and_artifact_call_the_stage`. Monkeypatch `sys.argv` and the stage functions:
+    - `explainer eval rederive --builds B --out O` calls `rederive.run(O, B, …)`;
+    - `explainer eval artifact --out O` calls `artifact_eval.run`, then `rederive.run(O, O, …)`.
+- [ ] **Step 2: Run them to verify they fail.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: the new tests FAIL.
+- [ ] **Step 3: Implement `run` and its report.**
+  - Read all passes in parallel (`ThreadPoolExecutor(workers)`), then grade.
+  - Pass `k`'s label key per subject is built like `ae.run`'s, with `random.Random(k)`.
+  - The report:
+    - title `# Rederivation, <date> (<split>, <n> subjects)`;
+    - one line on the builds folder (as saved in `source.json`) and the models;
+    - the condition table, where every score cell lists the passes as `x%, y%, z%`. Words are the mean visible words per explanation. The quiz cell is that condition's grounded share from `builds/"scores.json"`, or `–` if the file is missing;
+    - the separation line, or `Separation (…): none.`;
+    - a table per subject whose cells are `supported/counted` per pass;
+    - a short key explaining each column, in `ae.summary`'s style.
+- [ ] **Step 4: Wire the CLI.**
+  - Add `--builds` to the `eval` parser.
+  - The `rederive` suite's default `--out` is `evals/artifact/results/<date>-<split>-rederive`.
+  - `artifact` calls `rederive.run(out, out, …)` after `artifact_eval.run`.
+- [ ] **Step 5: Run the tests to verify they pass.**
+  Run: `uv run pytest -q`
+  Expected: all pass, about 255 tests.
+- [ ] **Step 6: Commit.**
+  `git add -u && git commit -m "rederive: three-pass run, report, and the eval rederive command; eval artifact runs it"`
+
+### Task 6: The dev baseline (live)
+
+This step makes about 120 reader calls and 30 grader calls through the `claude` CLI, with no builds.
+
+**Files:** create `evals/artifact/results/<YYYY-MM-DD>-dev-rederive/`, which is generated.
+
+- [ ] **Step 0: Run a smoke test first.** Saved outputs are never redone, so a malformed reply saved in the real folder would stay there.
+  Run: `uv run explainer eval rederive --builds evals/artifact/results/2026-10-04-dev --only bloom-filter --out <scratchpad>/smoke`
+  Expected:
+  - one `read/*.json` with a non-empty `steps` list of `{step, part, idea}`;
+  - one `grades/*.json` with 4 conditions, each with one mark per expected step;
+  - a report with 4 rows.
+
+  Fix only mechanics (parsing, paths), never scoring or targets, and ledger any fix as a ruling. Delete the scratch folder.
+- [ ] **Step 1: Run the baseline.**
+  Run: `uv run explainer eval rederive --builds evals/artifact/results/2026-10-04-dev --out evals/artifact/results/$(date +%F)-dev-rederive`
+  Expected:
+  - `rederive.md` and `rederive-scores.json` exist;
+  - three `pass-*` folders, each holding 40 reads and 10 grades;
+  - the report table has 4 rows.
+- [ ] **Step 2: Verify that the record and the targets are intact, and that the output is clean.**
+  - `git status --porcelain -- evals/artifact/results/2026-10-04-dev evals/artifact/results/2026-10-04-dev-haiku-reader` prints nothing.
+  - `git diff FREEZE -- evals/artifact/questions.yaml` prints nothing.
+  - `grep -rlE '/Users/|/home/|@[a-z0-9-]+\.[a-z]|sk-[A-Za-z0-9]' evals/artifact/results/*-dev-rederive` prints nothing.
+  - `uv run pytest -q` passes, including `test_frozen_targets_match_every_results_folder`, which is now non-vacuous.
+- [ ] **Step 3: Commit.**
+  `git add evals/artifact/results && git commit -m "Rederivation dev baseline on the v0.8 builds: three passes"`
+
+### Task 7: The human check
+
+**Files:**
+- Create: `evals/artifact/human-check.md`
+- Modify: `explainer_kit/rederive.py` and `explainer_kit/cli.py`. Add the `human` suite and `--chain`.
+- Modify: `tests/test_rederive.py`
+
+**Interfaces:**
+- Consumes: `grade_prompt`, `grader_text`, `marks`, and `tally`.
+- Produces: `grade_human(chain_file: Path, builds: Path, model: str | None = None) -> dict`.
+  - The chain file is Markdown with front matter `subject: <id>` and `condition: <name>`. Its body is the person's working.
+  - The function grades the body as the chain under the single label `A`.
+  - It saves `{"subject", "condition", "marks", "result_right", "result_stated", "tally"}` to `chain_file.with_suffix(".grade.json")` and returns it.
+
+- [ ] **Step 1: Write the failing tests.**
+  - `test_grade_human_uses_the_same_rubric`. With a stub `agent.ask`:
+    - the prompt it receives contains `OUTSIDE_RULE` and the person's body text;
+    - the saved JSON has a tally computed by `tally`.
+  - `test_human_check_lists_only_questions`. For every dev subject that has a target, `human-check.md` contains its `q`, and none of its step texts or its result.
+- [ ] **Step 2: Run them to verify they fail.**
+  Run: `uv run pytest tests/test_rederive.py -q`
+  Expected: FAIL.
+- [ ] **Step 3: Implement `grade_human`, wire `explainer eval human --builds B --chain F`, and write `human-check.md`.** The brief is one page:
+  - **Who:** a technical reader who is new to the subject.
+  - **What to do:**
+    1. Pick a dev subject.
+    2. Read the explanation the owner sends (one condition's `explanation.md` or page from the baseline builds) once.
+    3. Without looking anything up, work out that subject's question, listed below, on paper. Note which part of the explanation each step rests on.
+  - **How to send it back:** as `evals/artifact/human/<id>-<condition>.md` with the front matter above, with no name or personal details.
+  - **How it's graded:** `uv run explainer eval human --builds evals/artifact/results/2026-10-04-dev --chain <file>`. `docs/evals.md` records whether the person's marks agree with the model reader's on the same explanation.
+  - **The 10 dev questions,** questions only.
+- [ ] **Step 4: Run the tests to verify they pass.**
+  Run: `uv run pytest -q`
+  Expected: all pass.
+- [ ] **Step 5: Commit.**
+  `git add -A evals/artifact/human-check.md && git add -u && git commit -m "rederive: a human check graded with the same rubric"`
+
+### Task 8: Write it up
+
+**Files:**
+- Modify: `docs/evals.md`, `docs/cli.md`, `ROADMAP.md` (§15), `CHANGELOG.md`, `CLAUDE.md` and `AGENTS.md` (command lists).
+
+- [ ] **Step 1: Add a "Rederivation" section to `docs/evals.md`,** after "What the artifact eval found". It covers:
+  - **What it measures and why the quiz couldn't.** Give the entropy → KL example in two sentences.
+  - **The target format and the three tests,** plus the checker. Give the counts that passed and the subjects with no target.
+  - **Reader, grader, `OUTSIDE_RULE`, the four marks, the "stated" exclusion, and a pass.**
+  - **What the dev baseline found.**
+    - Show the condition table from `rederive.md`, with a link to the report.
+    - State the separation rule verbatim, then say which pairs separate.
+    - Say whether the supported order follows the word counts (none 1,689; principles 1,006; published 1,016; quick 606).
+    - If no pair separates, say that the eval does not yet rank the conditions, and that PRD-003 should not adopt it as its measure without changes.
+    - Use plain statements and no softening, in the style of the v0.8 section.
+  - **Human check:** pending, with a link to `evals/artifact/human-check.md`.
+- [ ] **Step 2: Update the other docs.**
+  - **`docs/cli.md`:** add rows for `eval targets`, `eval rederive --builds`, and `eval human --builds --chain`, and note that `eval artifact` now runs the stage.
+  - **ROADMAP §15:**
+    - add a **Built** bullet for the stage;
+    - add an **Evidence** bullet giving the baseline result in one sentence;
+    - under **Next**, record whether PRD-003 adopts it.
+  - **`CHANGELOG.md`:** add a `## Unreleased` section above 0.8.0, with bullets in the 0.8.0 style.
+  - **`CLAUDE.md` and `AGENTS.md`:** add one line, `uv run explainer eval rederive --builds <run>`.
+- [ ] **Step 3: Verify.**
+  - `uv run pytest -q` passes. This includes the link and AGENTS tests.
+  - `uv run explainer check` passes.
+  - `git diff --stat main -- plugin/skills explainers` is empty.
+- [ ] **Step 4: Commit.**
+  `git add -u && git commit -m "Docs: the rederivation eval and what its dev baseline found"`
+
+### After the last task
+
+Run the final whole-branch review per the execution skill, then stop. Pushing, merging, and whether this ships as v0.9.0 or waits for PRD-003 are the owner's calls.

From 1244915889d580fc6f353bd9d5e97526d7861535 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:02:33 -0400
Subject: [PATCH 02/13] rederive: target format, validation, and the checker

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/cli.py      |  13 ++++-
 explainer_kit/rederive.py | 114 ++++++++++++++++++++++++++++++++++++++
 tests/test_rederive.py    |  85 ++++++++++++++++++++++++++++
 3 files changed, 210 insertions(+), 2 deletions(-)
 create mode 100644 explainer_kit/rederive.py
 create mode 100644 tests/test_rederive.py

diff --git a/explainer_kit/cli.py b/explainer_kit/cli.py
index 1a10a24..e1e3ad3 100644
--- a/explainer_kit/cli.py
+++ b/explainer_kit/cli.py
@@ -22,6 +22,7 @@
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import re
 import shutil
@@ -216,6 +217,13 @@ def cmd_decide(args) -> None:
 
 
 def cmd_eval(args) -> None:
+    if args.suite == "targets":
+        from explainer_kit.rederive import check_targets
+
+        path = check_targets(args.only, args.model)
+        verdicts = [c["verdict"] for c in json.loads(path.read_text()).values()] if path.exists() else []
+        print(f"targets   {verdicts.count('pass')} pass, {verdicts.count('fail')} fail   {display(path)}")
+        return
     default = {"chat": ["none", "v0.5=git:v0.5.0", "v0.6=principles"],
                "artifact": ["none", "principles", "quick", "published"]}[args.suite]
     conditions = dict(c.split("=", 1) if "=" in c else (c, c) for c in (args.conditions or default))
@@ -339,8 +347,9 @@ def main() -> None:
     p.set_defaults(fn=cmd_decide)
 
     p = sub.add_parser("eval", help="chat: answers under several system prompts; artifact: explainers built under "
-                                     "several conditions, read and graded blind")
-    p.add_argument("suite", choices=["chat", "artifact"])
+                                     "several conditions, read and graded blind; targets: check the rederivation "
+                                     "targets")
+    p.add_argument("suite", choices=["chat", "artifact", "targets"])
     p.add_argument("--conditions", nargs="+",
                    help="name=source; source is none, principles, git:<rev>, or a file; for artifact also quick or "
                         "published (the explain skill at that tier). Default: chat none v0.5 v0.6; artifact none "
diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
new file mode 100644
index 0000000..4078045
--- /dev/null
+++ b/explainer_kit/rederive.py
@@ -0,0 +1,114 @@
+"""Rederivation: can a reader of an explainer work out a result it never states?
+
+Each subject in evals/artifact/questions.yaml has a target: a question, the steps a derivation needs (building
+blocks a good explanation gives, and derived steps the reader works out), and the result. The quiz checks what an
+explanation says; a target checks whether its building blocks let the reader go further. A model reader already
+knows most results, so a right answer proves little: every step must rest on a part of the explanation the reader
+names, and the grader checks that the part carries the idea.
+
+1. Targets are drafted by hand and checked by a fresh `claude -p` agent (`explainer eval targets`), then frozen.
+2. The reader sees only the renderings and the target's question, and works it out step by step.
+3. The grader sees each subject's explanations and chains under shuffled labels, and marks each expected step.
+
+A pass is a fresh reader run over every build, graded once under its own shuffle; a run makes three.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+from explainer_kit import agent
+from explainer_kit import artifact_eval as ae
+from explainer_kit.paths import project_root
+
+KINDS = ("block", "derived")
+CHECKER_SYSTEM = "You are a careful scientist and teacher. You check test questions. Reply with JSON only."
+CHECKS = ("correct", "blocks", "derived_follow", "steps", "not_stated")
+
+
+def checks_file() -> Path:
+    return project_root() / "evals" / "artifact" / "rederive-checks.json"
+
+
+# ---------------------------------------------------------------- 1. targets
+
+def target_problems(t: dict) -> list[str]:
+    """What makes a target malformed: 3–6 steps, each a block or derived, at least one derived, a question and a
+    result."""
+    problems = []
+    if not str(t.get("q") or "").strip():
+        problems.append("no question")
+    if not str(t.get("result") or "").strip():
+        problems.append("no result")
+    steps = t.get("steps")
+    if not isinstance(steps, list) or not 3 <= len(steps) <= 6:
+        return problems + ["needs 3–6 steps"]
+    for i, s in enumerate(steps, 1):
+        if not isinstance(s, dict) or s.get("kind") not in KINDS or not str(s.get("text") or "").strip():
+            problems.append(f"step {i}: needs a kind ({' or '.join(KINDS)}) and a text")
+    if not any(isinstance(s, dict) and s.get("kind") == "derived" for s in steps):
+        problems.append("no derived step")
+    return problems
+
+
+def target_hash(t: dict) -> str:
+    return hashlib.sha256(json.dumps(t, sort_keys=True, ensure_ascii=False).encode()).hexdigest()[:12]
+
+
+def check_prompt(subject: dict, reader: str) -> str:
+    t = subject["rederive"]
+    quiz = "\n".join(f"  - {item['q']}\n    Expected: {item['expect']}" for item in subject["quiz"])
+    steps = "\n".join(f"  {i}. ({s['kind']}) {s['text']}" for i, s in enumerate(t["steps"], 1))
+    return "\n".join([
+        f"Subject: {subject['q']}",
+        f"The reader: {reader}",
+        "",
+        "An explanation of this subject will be written for this reader. A good one gives the ideas in the quiz's "
+        "expected answers:",
+        quiz,
+        "",
+        "After reading it, the reader is asked to work out a result the explanation was never asked to state:",
+        f"Question: {t['q']}",
+        "Expected steps (block: an idea a good explanation gives; derived: worked out from the steps before it):",
+        steps,
+        f"Expected result: {t['result']}",
+        "",
+        "Check this target. Answer each with true or false:",
+        "- correct: every step and the result are true.",
+        "- blocks: every block step is an idea from the subject's question, from the quiz's expected answers, or "
+        "background this reader already has. A block that needs any other idea makes the target reward long "
+        "explanations instead of understanding.",
+        "- derived_follow: every derived step follows from the steps before it plus background this reader "
+        "already has, and brings in no new fact about the subject.",
+        "- steps: there are at least three steps, and each is an idea any valid derivation needs, not the "
+        "bookkeeping of one route.",
+        "- not_stated: a good answer to the subject's question would not state the result.",
+        "",
+        "Then give one sentence of reason that names any step that fails.",
+        "",
+        'Reply with JSON only: {"tests": {"correct": true, "blocks": true, "derived_follow": true, "steps": true, '
+        '"not_stated": true}, "reason": "..."}',
+    ])
+
+
+def check_targets(only: list[str] | None = None, model: str | None = None) -> Path:
+    """Checks every target whose text changed since its last check; a verdict passes only when all five tests do.
+    A subject without a target keeps its last entry, so a target dropped after failing stays listed."""
+    path = checks_file()
+    saved = json.loads(path.read_text()) if path.exists() else {}
+    reader, subjects = ae.load("all", only)
+    for s in subjects:
+        t = s.get("rederive")
+        if not t:
+            continue
+        h, before = target_hash(t), saved.get(s["id"], {})
+        if before.get("hash") == h:
+            continue
+        reply = agent.parse_json(agent.ask(CHECKER_SYSTEM, check_prompt(s, reader), model=model))
+        tests = {k: reply.get("tests", {}).get(k) is True for k in CHECKS}
+        saved[s["id"]] = {"verdict": "pass" if all(tests.values()) else "fail", "tests": tests,
+                          "reason": reply.get("reason", ""), "hash": h, "attempt": before.get("attempt", 0) + 1}
+        path.write_text(json.dumps(dict(sorted(saved.items())), indent=2, ensure_ascii=False) + "\n")
+    return path
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
new file mode 100644
index 0000000..ee1a9a3
--- /dev/null
+++ b/tests/test_rederive.py
@@ -0,0 +1,85 @@
+"""The rederivation stage, without calling the claude CLI."""
+
+import json
+
+import yaml
+
+from explainer_kit import agent, artifact_eval as ae, rederive
+
+TARGET = {"q": "What follows?",
+          "steps": [{"kind": "block", "text": "Idea one."}, {"kind": "block", "text": "Idea two."},
+                    {"kind": "derived", "text": "So three."}],
+          "result": "Three."}
+
+
+def target(**change):
+    return {**json.loads(json.dumps(TARGET)), **change}
+
+
+def test_target_problems():
+    assert rederive.target_problems(target()) == []
+    steps = TARGET["steps"]
+    assert rederive.target_problems(target(steps=steps[:2]))
+    assert rederive.target_problems(target(steps=steps + steps + steps[:1]))                  # 7 steps
+    assert rederive.target_problems(target(steps=[{**s, "kind": "block"} for s in steps]))     # nothing derived
+    assert rederive.target_problems(target(steps=[{"kind": "lemma", "text": "x"}, *steps[1:]]))
+    assert rederive.target_problems(target(result=""))
+    assert rederive.target_problems({k: v for k, v in TARGET.items() if k != "q"})
+
+
+def test_target_hash_is_stable_and_sensitive():
+    reordered = {"result": TARGET["result"], "steps": TARGET["steps"], "q": TARGET["q"]}
+    assert rederive.target_hash(reordered) == rederive.target_hash(TARGET)
+    assert len(rederive.target_hash(TARGET)) == 12
+    changed = target(steps=[{"kind": "block", "text": "Idea one!"}, *TARGET["steps"][1:]])
+    assert rederive.target_hash(changed) != rederive.target_hash(TARGET)
+
+
+def test_check_prompt_shows_the_building_blocks():
+    reader, subjects = ae.load("dev")
+    s = {**subjects[0], "rederive": TARGET}
+    p = rederive.check_prompt(s, reader)
+    assert reader in p and s["q"] in p and TARGET["q"] in p and TARGET["result"] in p
+    assert all(item["expect"] in p for item in s["quiz"])
+    assert all(f"({step['kind']}) {step['text']}" in p for step in TARGET["steps"])
+    assert "any valid derivation needs" in p and "would not state" in p and "no new fact about the subject" in p
+
+
+def subjects_file(tmp_path, targets):
+    spec = {"reader": "A reader.", "subjects": [
+        {"id": sid, "split": "dev", "q": f"Question {sid}?", "misconception": "m",
+         "quiz": [{"q": "a?", "expect": "b"}], "rederive": t} for sid, t in targets.items()]}
+    path = tmp_path / "questions.yaml"
+    path.write_text(yaml.safe_dump(spec, sort_keys=False))
+    return path
+
+
+def test_check_targets_records_and_resumes(monkeypatch, tmp_path):
+    checks = tmp_path / "checks.json"
+    monkeypatch.setattr(rederive, "checks_file", lambda: checks)
+    monkeypatch.setattr(ae, "questions_file", lambda: subjects_file(tmp_path, {"s1": target(), "s2": target(q="Why?")}))
+    asked = []
+
+    def ask(system, prompt, model=None, **kw):
+        sid = "s2" if "Question s2?" in prompt else "s1"
+        asked.append(sid)
+        tests = {"correct": True, "blocks": True, "derived_follow": sid == "s1", "steps": True, "not_stated": True}
+        return json.dumps({"verdict": "pass", "tests": tests, "reason": "ok"})   # the verdict is computed, not read
+
+    monkeypatch.setattr(agent, "ask", ask)
+    rederive.check_targets()
+    saved = json.loads(checks.read_text())
+    assert saved["s1"]["verdict"] == "pass" and saved["s2"]["verdict"] == "fail"
+    assert saved["s1"]["hash"] == rederive.target_hash(target())
+    assert saved["s2"]["hash"] == rederive.target_hash(target(q="Why?"))
+    assert saved["s1"]["attempt"] == saved["s2"]["attempt"] == 1
+    assert checks.read_text().endswith("\n") and list(saved) == ["s1", "s2"]
+
+    asked.clear()
+    rederive.check_targets()
+    assert asked == []                                           # unchanged targets are not checked again
+
+    monkeypatch.setattr(ae, "questions_file", lambda: subjects_file(tmp_path, {"s1": target(), "s2": target(q="How?")}))
+    rederive.check_targets()
+    saved = json.loads(checks.read_text())
+    assert asked == ["s2"] and saved["s2"]["attempt"] == 2 and saved["s1"]["attempt"] == 1

From 6b61cdff312a4ef6d9383df8f0c72cc9c7184085 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:12:29 -0400
Subject: [PATCH 03/13] Freeze the rederivation targets: 30 subjects,
 model-checked

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 evals/artifact/questions.yaml       | 250 ++++++++++++++++++
 evals/artifact/rederive-checks.json | 392 ++++++++++++++++++++++++++++
 tests/test_rederive.py              |  13 +
 3 files changed, 655 insertions(+)
 create mode 100644 evals/artifact/rederive-checks.json

diff --git a/evals/artifact/questions.yaml b/evals/artifact/questions.yaml
index 460b1b2..8382288 100644
--- a/evals/artifact/questions.yaml
+++ b/evals/artifact/questions.yaml
@@ -4,6 +4,12 @@
 # it does not depend on what the builder chose to cover. The last item of each quiz is a prediction
 # (kind: predict): a case the explanation need not mention, answered from the mechanism it gives.
 #
+# Each subject also has a rederivation target (rederive): a question about a result the explanation was never asked
+# to state, the steps a derivation needs (block: an idea a good explanation gives; derived: worked out from the
+# steps before it), and the result. Neither the builder nor the reader sees the steps or the result; the reader gets
+# only the question (docs/evals.md#rederivation). A fresh agent checked each target (rederive-checks.json), and the
+# targets were frozen before the first rederivation run: do not edit them.
+#
 # Split: tune against `dev` only. Run `test` to confirm a change before a release, and do not change the
 # principles or skills in response to a single test subject (docs/evals.md).
 #
@@ -27,6 +33,14 @@ subjects:
       - q: "A receiver's clock is 1 µs fast, and it uses three satellites as if its clock were right. About how large is the error in the distances it computes?"
         expect: "About 300 m per satellite: the speed of light × 1 µs; a fourth satellite would let it solve for the clock error."
         kind: predict
+    rederive:
+      q: "A receiver's own clock is right, but one of the four satellites it uses has a clock 10 nanoseconds fast that nothing corrects. Roughly how wrong is the distance to that satellite, and why can the receiver's fourth unknown not absorb this error the way it absorbs its own clock error?"
+      steps:
+        - {kind: block, text: "The receiver turns each signal's travel time into a distance: distance = speed of light × travel time, where the travel time is the arrival time minus the send time stamped in the signal."}
+        - {kind: block, text: "The receiver's own clock error is a fourth unknown, solved for together with the three coordinates from four distances."}
+        - {kind: derived, text: "A satellite clock 10 ns fast stamps its signal 10 ns too late, so that travel time comes out 10 ns short and that one distance about 3 m short (3×10^8 m/s × 10^-8 s)."}
+        - {kind: derived, text: "An error in the receiver's clock shifts every distance by the same amount; an error in one satellite's distance alone does not have that form, so solving for the clock error cannot remove it, and it moves the computed position."}
+      result: "About 3 m, in that one distance only; the clock unknown can absorb only an error shared by all the distances, so this one shifts the position fix."
 
   - id: vaccine-memory
     split: dev
@@ -42,6 +56,14 @@ subjects:
       - q: "A virus changes the shape of the part that antibodies recognize. What happens to the protection from an old vaccine, and why?"
         expect: "It weakens: the memory cells and antibodies match the old shape and bind the new one poorly; a vaccine with the new antigen restores it."
         kind: predict
+    rederive:
+      q: "In a simple model, the immune cells that match an antigen double every 12 hours until there are enough to clear the infection. Vaccination leaves 1,000 times more matching cells than a first infection starts with. About how much sooner does the response reach full strength, and why does the answer not depend on how many cells count as 'enough'?"
+      steps:
+        - {kind: block, text: "A first response starts from few matching cells and must select and multiply them, which takes one to two weeks."}
+        - {kind: block, text: "After vaccination, memory cells specific to that antigen remain, so the response starts from many more matching cells."}
+        - {kind: derived, text: "Starting with 1,000 times more cells saves the doublings needed to grow 1,000-fold: about 10 doublings, since 2^10 ≈ 1,000."}
+        - {kind: derived, text: "Ten doublings at 12 hours each is about 5 days; each start needs log2(enough ÷ start) doublings, so the difference between the two starts is log2(1,000) whatever 'enough' is."}
+      result: "About 5 days sooner (about 10 doublings saved); the saving is the same whatever number of cells counts as enough."
 
   - id: key-exchange
     split: dev
@@ -57,6 +79,15 @@ subjects:
       - q: "With p = 23 and g = 5, Alice's secret is 6 and Bob's is 15. What do they send, and what key do they share?"
         expect: "Alice sends 5^6 mod 23 = 8, Bob sends 5^15 mod 23 = 19; the key is 19^6 mod 23 = 8^15 mod 23 = 2."
         kind: predict
+    rederive:
+      q: "Three people, Alice, Bob, and Carol, want one shared secret key, using the same public p and g and sending only messages anyone can read. How can they do it, and why does an eavesdropper still not get the key?"
+      steps:
+        - {kind: block, text: "Each person keeps a secret exponent and can raise any number they receive to it, mod p."}
+        - {kind: block, text: "Exponents multiply and their order does not matter: (g^a)^b = (g^b)^a = g^(ab) mod p."}
+        - {kind: block, text: "Recovering an exponent from g^x mod p (the discrete logarithm) is infeasible for large p."}
+        - {kind: derived, text: "So the key can be g^(abc): each person needs g raised to the product of the other two secrets, which can be built by passing values around (Alice sends g^a to Bob, who sends g^(ab) to Carol, and likewise from each starting person), and then raises it to their own secret."}
+        - {kind: derived, text: "The eavesdropper sees only values like g^a and g^(ab); getting g^(abc) needs one of the secret exponents, which means solving a discrete logarithm."}
+      result: "Each computes g^(abc) mod p by raising a public value g^(product of the other two secrets), built by passing values around, to their own secret; the eavesdropper sees only values like g^a and g^(ab), and undoing them needs a discrete logarithm."
 
   - id: two-tides
     split: dev
@@ -72,6 +103,14 @@ subjects:
       - q: "If the Moon stayed fixed in the sky instead of moving along its orbit, how often would high tides come?"
         expect: "Every 12 hours exactly: Earth turns once in 24 hours under two fixed bulges."
         kind: predict
+    rederive:
+      q: "At first and third quarter Moon, the Sun and Moon are at right angles as seen from Earth. How large are the tides then, compared with spring tides?"
+      steps:
+        - {kind: block, text: "Each body stretches the oceans along the line toward it, raising water at both ends of that line and lowering it in between."}
+        - {kind: block, text: "The Sun's tidal effect is about half the Moon's; at new and full Moon the two lie in line and their effects add."}
+        - {kind: derived, text: "At right angles, the Sun's stretch raises water where the Moon's lowers it, so the two effects work against each other."}
+        - {kind: derived, text: "The range is then about 1 − ½ of the Moon's alone, against 1 + ½ at spring tide: about a third of a spring tide's range."}
+      result: "Smallest (neap) tides, with a range of about (1 − ½) ÷ (1 + ½) ≈ one third of a spring tide's, because the Sun's stretch works against the Moon's."
 
   - id: bloom-filter
     split: dev
@@ -87,6 +126,14 @@ subjects:
       - q: "Every bit in a filter is 1. What does it answer for an item that was never added?"
         expect: "'Probably seen': every lookup finds all its bits set, so every answer is a false positive."
         kind: predict
+    rederive:
+      q: "Two Bloom filters have the same size and the same hash functions; one was built from a set A and the other from a set B. How can you get a filter for A ∪ B without the items, and is it exact? What does a bitwise AND of the two give?"
+      steps:
+        - {kind: block, text: "Adding an item sets the k bits its hash functions choose to 1, and bits are never cleared."}
+        - {kind: derived, text: "So a bit in a filter is 1 exactly when at least one added item chose it."}
+        - {kind: derived, text: "The items of A ∪ B choose exactly the bits chosen by A's items or by B's items, so OR-ing the two arrays gives the same bits as building the filter from A ∪ B: exact."}
+        - {kind: derived, text: "AND keeps a bit that one item of A and a different item of B both chose, even when no item in both sets chose it; every item in both sets still has all its bits set, so AND gives a filter for A ∩ B with no false negatives but possibly extra 1s."}
+      result: "OR the bit arrays: the result is exactly the filter built from A ∪ B. AND gives a filter for A ∩ B that never misses a common item but can have extra 1s, so more false positives than one built from A ∩ B."
 
   - id: heat-pump
     split: dev
@@ -102,6 +149,14 @@ subjects:
       - q: "By the ideal limit, how does a heat pump that heats a house to 35 °C compare between a 5 °C day and a −15 °C day?"
         expect: "COP limit 308/30 ≈ 10 at 5 °C and 308/50 ≈ 6 at −15 °C: the colder day gives less heat per unit of electricity."
         kind: predict
+    rederive:
+      q: "The same machine run in reverse is an air conditioner: it takes heat from the cold inside and gives it to the warm outside. What is its ideal limit on heat removed per unit of electricity, and why is it exactly one less than the heating limit for the same two temperatures?"
+      steps:
+        - {kind: block, text: "Energy is conserved: the heat given off on the warm side = the heat taken from the cold side + the electrical work."}
+        - {kind: block, text: "The ideal heating limit is COP = T_hot ÷ (T_hot − T_cold), in kelvin."}
+        - {kind: derived, text: "The heat taken from the cold side is the heat given off minus the work, so the heat removed per unit of work is the heating COP minus 1."}
+        - {kind: derived, text: "T_hot ÷ (T_hot − T_cold) − 1 = T_cold ÷ (T_hot − T_cold)."}
+      result: "COP_cooling = T_cold ÷ (T_hot − T_cold), exactly one less than the heating limit, because the work ends up in the heat given off but not in the heat removed."
 
   - id: quorum
     split: dev
@@ -117,6 +172,14 @@ subjects:
       - q: "A 5-server cluster splits into a group of 3 and a group of 2. Which group can still commit writes, and why?"
         expect: "Only the group of 3: it is a majority; the 2 cannot form one, so the two groups cannot commit conflicting writes."
         kind: predict
+    rederive:
+      q: "A five-server store uses a write group of W servers and a read group of R servers, not necessarily majorities. What must W and R satisfy for every read to see the latest committed write, and with W = 4 and R = 2, how many failures can writes and reads each survive?"
+      steps:
+        - {kind: block, text: "A write is committed when a group of servers acknowledges it."}
+        - {kind: block, text: "Majorities are used because any two majorities share at least one server, so the next group always sees every committed write."}
+        - {kind: derived, text: "What matters is the overlap: a read group of R and a write group of W among N servers must share a server whenever R + W > N."}
+        - {kind: derived, text: "With N = 5, W = 4, R = 2: 4 + 2 > 5, so every read sees the latest write; writes need 4 of 5 servers and survive 1 failure, reads need 2 and survive 3."}
+      result: "R + W > N (here R + W > 5); with W = 4 and R = 2, every read overlaps every write, writes survive 1 failure, and reads survive 3."
 
   - id: antibiotic-resistance
     split: dev
@@ -132,6 +195,14 @@ subjects:
       - q: "One bacterium in a billion in an infection is resistant. Why can a full course of antibiotics end with a resistant infection?"
         expect: "The drug kills the susceptible ones; the resistant one survives and, with its competitors gone, multiplies into a resistant population."
         kind: predict
+    rederive:
+      q: "In an infection of 10^10 bacteria, one in 10^8 resists drug A and one in 10^9 resists drug B, by unrelated mutations. Why is giving both drugs together much less likely to end with a resistant infection than giving either alone?"
+      steps:
+        - {kind: block, text: "Resistance comes from random mutations that already exist before the drug is used."}
+        - {kind: block, text: "A drug kills the susceptible bacteria, and the resistant ones survive and multiply (selection)."}
+        - {kind: derived, text: "With unrelated mutations, a bacterium resists both with probability about 10^-8 × 10^-9 = 10^-17."}
+        - {kind: derived, text: "The infection holds about 100 cells resistant to A and about 10 resistant to B, which either drug alone would select, but expects only 10^10 × 10^-17 = 10^-7 cells resistant to both, so with both drugs there is almost surely nothing to select."}
+      result: "About 100 A-resistant and 10 B-resistant cells are present, which either drug alone would select, but a double-resistant cell has a probability of about 10^-17 each, so the infection almost surely holds none and the combination leaves no survivors to multiply."
 
   - id: float-sum
     split: dev
@@ -147,6 +218,14 @@ subjects:
       - q: "Is 0.5 + 0.25 == 0.75 true in the same languages? Why?"
         expect: "True: 1/2, 1/4, and 3/4 have power-of-2 denominators, so all are stored exactly and no rounding error occurs."
         kind: predict
+    rederive:
+      q: "Which of these can a double store exactly: 0.375, 0.2, 0.0625, 0.3? And why does adding 0.125 eight times give exactly 1.0, while adding 0.1 ten times does not?"
+      steps:
+        - {kind: block, text: "Floating-point numbers are binary fractions: a value is stored exactly only if it is a fraction whose denominator is a power of 2 (within the available digits)."}
+        - {kind: block, text: "0.1 has no finite binary expansion, so it is stored as the nearest double, with a small error."}
+        - {kind: derived, text: "0.375 = 3/8 and 0.0625 = 1/16 have power-of-2 denominators and are exact; 0.2 = 1/5 and 0.3 = 3/10 have a factor of 5 in the denominator and are not."}
+        - {kind: derived, text: "0.125 = 1/8 and every sum of eighths up to 1 is exact, so eight additions give exactly 1.0; the stored 0.1 carries an error, and the additions round again, so ten of them do not land exactly on 1.0."}
+      result: "Exact: 0.375 and 0.0625; not exact: 0.2 and 0.3. Eighths add exactly to 1.0, but ten copies of the inexact 0.1 sum to a nearby double (0.9999999999999999), not 1.0."
 
   - id: greenhouse
     split: dev
@@ -162,6 +241,14 @@ subjects:
       - q: "On a planet with no greenhouse gases, where would its heat radiate to space from, and what follows for its surface temperature?"
         expect: "From the surface itself, so the surface settles at the temperature that balances sunlight (about 255 K for Earth, instead of the actual 288 K)."
         kind: predict
+    rederive:
+      q: "Suppose the atmosphere had the same temperature at every height. What would adding CO2 then do to the surface temperature, and why?"
+      steps:
+        - {kind: block, text: "The Earth radiates to space from the height at which infrared can escape, and adding CO2 raises that height."}
+        - {kind: block, text: "Higher air is normally colder and radiates less, so raising the emission height makes the Earth give off less than it takes in until the surface and lower air warm."}
+        - {kind: derived, text: "If temperature did not fall with height, the new emission height would be as warm as the old one, so the Earth would give off as much as before."}
+        - {kind: derived, text: "With no imbalance between what comes in and what goes out, nothing would have to warm: adding CO2 would not warm the surface."}
+      result: "Nothing: with no drop in temperature with height, raising the emission height does not reduce the outgoing radiation, so there is no imbalance and no warming."
 
   # ------------------------------------------------------------------ test
   - id: jpeg
@@ -178,6 +265,14 @@ subjects:
       - q: "At the same quality setting, which compresses better as JPEG: a photo of a clear sky or a scan of printed text? Why?"
         expect: "The sky: smooth areas are mostly low frequencies, which quantize to few nonzero values; text has sharp edges that need high frequencies (and shows artifacts)."
         kind: predict
+    rederive:
+      q: "You open a JPEG and save it again, unchanged, at the same quality setting. Why does this second save lose much less than the first one did?"
+      steps:
+        - {kind: block, text: "JPEG splits the image into 8×8 blocks and transforms each into frequency components."}
+        - {kind: block, text: "Quantization, the lossy step, rounds each component to a multiple of a step size, coarser for high frequencies."}
+        - {kind: derived, text: "After the first save, the decoded image's blocks transform back into components that already lie on, or very near, multiples of the same step sizes."}
+        - {kind: derived, text: "Rounding a value that is already on the grid changes little, so the second quantization loses little more (only small effects, such as rounding pixels to whole numbers, remain)."}
+      result: "Its frequency components are already at or near multiples of the same quantization steps, so rounding them again changes little; most of the loss happened in the first save."
 
   - id: transistor-switch
     split: test
@@ -193,6 +288,14 @@ subjects:
       - q: "What happens to a CMOS chip's power use when its clock frequency doubles, the voltage unchanged?"
         expect: "The switching power about doubles: the gates charge and discharge their capacitance twice as often."
         kind: predict
+    rederive:
+      q: "A chip's supply voltage is lowered from 1.0 V to 0.8 V, with the same clock frequency. By about how much does its switching power fall, and why?"
+      steps:
+        - {kind: block, text: "A CMOS chip spends power mainly on charging and discharging capacitance each time its gates switch."}
+        - {kind: block, text: "Switching power is proportional to how often the gates switch: twice the clock gives twice the power."}
+        - {kind: derived, text: "Charging a capacitance C to voltage V takes charge C × V from the supply at voltage V, so each charge-and-discharge costs energy C × V²."}
+        - {kind: derived, text: "Power ≈ switches per second × C × V², so at the same clock it scales with V²: 0.8² = 0.64, about 36% less."}
+      result: "About 36% less (to about 0.64 of before), because switching power scales with the square of the supply voltage."
 
   - id: kidney-filter
     split: test
@@ -208,6 +311,14 @@ subjects:
       - q: "A drug blocks the transporters that take glucose back in the tubules. What happens to the urine and to blood sugar?"
         expect: "Glucose stays in the urine, and blood sugar falls (this is how SGLT2-inhibitor drugs work)."
         kind: predict
+    rederive:
+      q: "If the tubules took back 98% of the filtered water instead of about 99%, about how much urine would a person make each day, and why does such a small change matter so much?"
+      steps:
+        - {kind: block, text: "The kidneys filter about 180 litres a day."}
+        - {kind: block, text: "The tubules take back about 99% of the filtered water, and about 1.5 litres a day leaves as urine."}
+        - {kind: derived, text: "At 98%, 2% of 180 litres leaves: about 3.6 litres a day, about double."}
+        - {kind: derived, text: "Urine is the small difference between two large flows, so a one-point change in the fraction taken back changes it by about 1.8 litres a day."}
+      result: "About 3.6 litres a day, about double, because urine is the small difference between the large filtered flow and the nearly equal amount taken back."
 
   - id: garbage-collection
     split: test
@@ -223,6 +334,15 @@ subjects:
       - q: "Two objects refer to each other, and nothing else refers to either. Does a tracing collector free them? Does pure reference counting?"
         expect: "Tracing: yes, they are unreachable from the roots. Reference counting: no, each keeps the other's count at 1."
         kind: predict
+    rederive:
+      q: "A program builds a doubly linked list of a million nodes (each node refers to the next and the previous one) and then sets its only variable pointing to the head to null. What does a tracing collector free, and what does pure reference counting free? What changes if a global cache still refers to the tail?"
+      steps:
+        - {kind: block, text: "A tracing collector keeps the objects reachable from the roots by following references and frees the rest."}
+        - {kind: block, text: "Reference counting frees an object when no reference to it remains; objects in a cycle keep each other's counts above zero."}
+        - {kind: derived, text: "After the head variable is cleared, no root reaches any node, so a tracing collector frees all million nodes."}
+        - {kind: derived, text: "Every node is still referred to by a neighbor (the head by the second node's back link), so no count reaches zero and pure reference counting frees none."}
+        - {kind: derived, text: "If the cache refers to the tail, every node is reachable from it through the back links, so the tracing collector frees nothing."}
+      result: "Tracing frees all million nodes; pure reference counting frees none, since neighbors keep each other's counts above zero. If the cache holds the tail, every node is reachable through the back links and nothing is freed."
 
   - id: liquid-core
     split: test
@@ -238,6 +358,14 @@ subjects:
       - q: "If the outer core were solid, what would change in the records of seismometers on the far side of the Earth?"
         expect: "Direct S waves would arrive there too: no S-wave shadow zone."
         kind: predict
+    rederive:
+      q: "If the Earth's liquid core were much larger, reaching most of the way to the surface, how would the zone where no direct S waves arrive change?"
+      steps:
+        - {kind: block, text: "S waves cannot travel through a liquid."}
+        - {kind: block, text: "Beyond about 104° from an earthquake no direct S waves arrive, because the liquid core lies in their way."}
+        - {kind: derived, text: "The shadow begins where a wave's path from the earthquake just grazes the core."}
+        - {kind: derived, text: "A larger core is grazed by paths to points closer to the earthquake, so the shadow would begin at a smaller angle than 104° and cover more of the Earth."}
+      result: "The S-wave shadow would start closer to the earthquake (at a smaller angle than 104°) and cover more of the Earth's surface."
 
   - id: backprop
     split: test
@@ -253,6 +381,14 @@ subjects:
       - q: "A weight's gradient is zero. What happens to it in one training step, and why?"
         expect: "It does not change: a small change to it does not change the loss (to first order), so the step is zero."
         kind: predict
+    rederive:
+      q: "A network's loss, as a function of one weight, is L = (w − 3)². Starting at w = 0 with a learning rate of 0.1, where is w after one step? Above what learning rate does w never settle at 3?"
+      steps:
+        - {kind: block, text: "Each training step moves a weight against the gradient of the loss: by the learning rate times the gradient."}
+        - {kind: block, text: "Too large a learning rate makes steps overshoot, so the loss jumps around or diverges."}
+        - {kind: derived, text: "The gradient is 2(w − 3) = −6 at w = 0, so the step is −0.1 × (−6) = +0.6: w = 0.6."}
+        - {kind: derived, text: "Each step multiplies the distance from 3 by (1 − 2 × learning rate), so the distance shrinks only if that factor is between −1 and 1: a learning rate of 1 or more never settles (1 bounces between 0 and 6; more diverges)."}
+      result: "w = 0.6 after one step; each step scales the distance from 3 by (1 − 2 × rate), so a rate of 1 or more never settles (1 oscillates between 0 and 6, larger rates diverge)."
 
   - id: mountain-boiling
     split: test
@@ -268,6 +404,15 @@ subjects:
       - q: "At the top of Everest the air pressure is about a third of sea level's. Will an egg in boiling water cook faster or slower than at sea level? Why?"
         expect: "Slower: water boils there at about 70 °C, so the egg sits in cooler water."
         kind: predict
+    rederive:
+      q: "A pressure cooker's valve holds the pressure inside 1 atmosphere above the air outside. At 3,000 m, does water in it boil hotter, colder, or the same as in the same cooker at sea level?"
+      steps:
+        - {kind: block, text: "Water boils when its vapor pressure equals the pressure above it, so a lower pressure means a lower boiling point."}
+        - {kind: block, text: "At 3,000 m the air pressure is about 70% of sea level's, so open water boils at about 90 °C."}
+        - {kind: block, text: "A pressure cooker adds about 1 atmosphere, so at sea level its water boils at about 120 °C."}
+        - {kind: derived, text: "The valve holds a fixed pressure above the outside air, so at 3,000 m the inside is about 1.7 atmospheres instead of 2."}
+        - {kind: derived, text: "A lower pressure gives a lower boiling point, so the water boils a few degrees below 120 °C, though still far above an open pot's 90 °C."}
+      result: "Colder: the inside reaches only about 1.7 atmospheres instead of 2, so the water boils a few degrees below 120 °C (still well above the open pot's 90 °C)."
 
   - id: ssd-wear
     split: test
@@ -283,6 +428,14 @@ subjects:
       - q: "An SSD holds photos that are written once and read every day for years. Will it wear out from this use? Why?"
         expect: "No: reading does not wear the cells; wear comes from program/erase cycles, and these photos use very few."
         kind: predict
+    rederive:
+      q: "A 1 TB SSD's cells each last about 1,000 program/erase cycles. If its writes are spread evenly over all cells, about how much data can be written over its life, and how many years would that last at 50 GB a day? (Ignore any extra writes the drive makes internally.)"
+      steps:
+        - {kind: block, text: "A cell lasts a limited number of program/erase cycles."}
+        - {kind: block, text: "Wear leveling spreads writes and erases across the whole drive, so no block wears out early."}
+        - {kind: derived, text: "With even spreading, writing the drive's full capacity once uses about one cycle of every cell, so the drive can take about 1,000 full writes: about 1,000 TB (1 PB)."}
+        - {kind: derived, text: "1,000,000 GB ÷ 50 GB a day = 20,000 days, about 55 years."}
+      result: "About 1,000 TB (1 PB) in total, which at 50 GB a day lasts about 20,000 days, roughly 55 years."
 
   - id: rent-cap
     split: test
@@ -298,6 +451,14 @@ subjects:
       - q: "A city caps rents in existing buildings but exempts new construction. Which part of the mechanism does that weaken, and which part remains?"
         expect: "It weakens the effect on new building (construction is not discouraged); the shortage in existing capped units, conversions, and lower mobility remain."
         kind: predict
+    rederive:
+      q: "A city sets its rent cap above the current market rent. What happens to the shortage now, and what happens if market rents later rise above the cap?"
+      steps:
+        - {kind: block, text: "A rent cap creates a shortage only when it holds the price below the market level: then more people want housing than is offered."}
+        - {kind: block, text: "The effect grows over time, as landlords convert, sell, or stop maintaining units and less is built."}
+        - {kind: derived, text: "A cap above the market rent holds no price down, so it causes no shortage now."}
+        - {kind: derived, text: "If demand pushes the market rent above the cap, the cap starts to hold the price down: a shortage opens and grows over the following years as supply responds."}
+      result: "No shortage while the cap is above the market rent; once market rents rise past it, the cap binds, a shortage opens, and it grows over time."
 
   - id: pagerank
     split: test
@@ -313,6 +474,14 @@ subjects:
       - q: "Page X gets one link from a page with 1,000 outgoing links; page Y gets one link from a page of equal rank with 2 outgoing links. Which gains more rank from its link?"
         expect: "Y: a page shares its rank among its outgoing links, so Y gets half of that page's share and X a thousandth."
         kind: predict
+    rederive:
+      q: "A small web has three pages: A links only to B, B links only to A, and C links only to A; no page links to C. With the usual random jump (probability 0.15, to any of the three pages), which page ranks highest and which lowest, and what is C's rank?"
+      steps:
+        - {kind: block, text: "Each page shares its rank equally among the pages it links to."}
+        - {kind: block, text: "With probability about 0.15 the random surfer jumps to a random page, so every page gets at least its share of the jumps."}
+        - {kind: derived, text: "No page links to C, so C gets only its share of the jumps: 0.15 ÷ 3 = 0.05."}
+        - {kind: derived, text: "A receives all of B's rank and all of C's, while B receives all of A's; A therefore gets more than B, and both far more than C (about 0.49 and 0.46)."}
+      result: "A ranks highest (about 0.49), then B (about 0.46); C is lowest, with only its share of the random jumps: 0.05."
 
   - id: muscle-contraction
     split: test
@@ -328,6 +497,14 @@ subjects:
       - q: "After death, cells stop making ATP. What happens to the muscles, and why?"
         expect: "They lock stiff (rigor mortis): without ATP the myosin heads cannot release from actin."
         kind: predict
+    rederive:
+      q: "A muscle fiber has plenty of ATP, but its calcium pumps stop working. What happens to the muscle, and how does this differ from rigor mortis?"
+      steps:
+        - {kind: block, text: "A nerve signal releases calcium inside the fiber, which uncovers actin's binding sites; when calcium is pumped away, the sites are covered again and the contraction stops."}
+        - {kind: block, text: "ATP releases the myosin head from actin, and splitting ATP re-cocks it for the next stroke; without ATP the heads stay bound (rigor)."}
+        - {kind: derived, text: "With the pumps stopped, calcium stays high and the binding sites stay uncovered, so the heads keep binding and pulling: the muscle stays contracted."}
+        - {kind: derived, text: "Unlike rigor, the heads keep cycling and using ATP; when the ATP runs out, they can no longer release, and the muscle locks in rigor."}
+      result: "It stays contracted, with the heads still cycling and using ATP, because the binding sites stay uncovered; in rigor mortis the heads are stuck because there is no ATP to release them. Once the ATP runs out, this muscle locks in rigor too."
 
   - id: noise-cancelling
     split: test
@@ -343,6 +520,14 @@ subjects:
       - q: "If the headphone played the microphone's sound without inverting it, what would the listener hear?"
         expect: "The noise louder, about twice the amplitude: the waves add in step instead of cancelling."
         kind: predict
+    rederive:
+      q: "Two speakers play the same steady 170 Hz hum, in step. You stand where one speaker is 1 m farther from you than the other. Is the hum louder or quieter there than near either speaker alone? (Sound travels at 340 m/s.)"
+      steps:
+        - {kind: block, text: "Two sound waves with opposite pressure at the same moment add to nearly zero (destructive interference); waves in step add to a louder sound."}
+        - {kind: block, text: "A delay shifts a wave by a fraction of its period; a shift of half a period turns a wave into its inverse."}
+        - {kind: derived, text: "The extra metre takes 1 ÷ 340 s ≈ 2.9 ms, and the 170 Hz hum has a period of 1 ÷ 170 s ≈ 5.9 ms, so the farther wave arrives half a period late."}
+        - {kind: derived, text: "Half a period late, the two waves arrive inverted relative to each other and cancel."}
+      result: "Quieter: the 1 m path difference is half the 2 m wavelength (half a period), so the two waves arrive inverted and largely cancel."
 
   - id: sort-bound
     split: test
@@ -358,6 +543,14 @@ subjects:
       - q: "What is the smallest number of comparisons that always suffices to sort 3 items, and why can 2 not be enough?"
         expect: "3: there are 3! = 6 orderings; 2 comparisons separate at most 4, and 3 separate up to 8."
         kind: predict
+    rederive:
+      q: "By the same counting argument, at least how many comparisons does any comparison-based algorithm need, in the worst case, to merge two sorted lists of 2 items each into one sorted list?"
+      steps:
+        - {kind: block, text: "An algorithm must tell apart every input that needs a different output."}
+        - {kind: block, text: "Each comparison has two outcomes, so k comparisons separate at most 2^k cases."}
+        - {kind: derived, text: "Two sorted lists of 2 can interleave in 4!/(2!·2!) = 6 ways, and each needs a different output."}
+        - {kind: derived, text: "2^2 = 4 < 6 ≤ 8 = 2^3, so at least 3 comparisons are needed."}
+      result: "At least 3: the 6 possible interleavings need 6 different outcomes, and 2 comparisons separate at most 4."
 
   - id: lightning
     split: test
@@ -373,6 +566,14 @@ subjects:
       - q: "You see a flash and hear its thunder 9 seconds later. About how far away was the stroke?"
         expect: "About 3 km (9 s ÷ 3 s per km)."
         kind: predict
+    rederive:
+      q: "Thunder from one stroke often rumbles for several seconds instead of arriving as one bang. Why? If the nearest point of a stroke's channel is 1 km away and its farthest point 4 km away, about when does the rumble start and how long does it last?"
+      steps:
+        - {kind: block, text: "The stroke heats the air along its whole channel in microseconds, and that expansion makes the sound."}
+        - {kind: block, text: "Sound travels about 340 m/s, about 3 s per kilometer, while the light arrives almost at once."}
+        - {kind: derived, text: "Sound from each part of the channel starts at almost the same moment but travels a different distance, so the nearest part is heard first and the farthest last."}
+        - {kind: derived, text: "1 km takes about 3 s and 4 km about 12 s, so the rumble starts about 3 s after the flash and lasts about 9 s."}
+      result: "It rumbles because each part of the channel is at a different distance; here it starts about 3 s after the flash and lasts about 9 s, until about 12 s."
 
   - id: double-spend
     split: test
@@ -388,6 +589,14 @@ subjects:
       - q: "An attacker controls 60% of the network's hashing power. Do six confirmations protect a merchant? Why?"
         expect: "No: with most of the hashing power the attacker's chain grows faster and eventually overtakes the honest one, however many blocks it starts behind."
         kind: predict
+    rederive:
+      q: "Suppose Bitcoin blocks did not contain the hash of the previous block, but each still needed the same proof of work. How could an attacker undo a payment that is six blocks deep, and what would waiting for confirmations then be worth?"
+      steps:
+        - {kind: block, text: "Each block holds the hash of the one before it."}
+        - {kind: block, text: "Each block needs a costly proof of work, and an attacker who changes a block must redo the work of that block and every later one."}
+        - {kind: derived, text: "Changing a block changes its hash; with the previous hash in each block, every later block's stored hash stops matching, which is why all later blocks must be redone."}
+        - {kind: derived, text: "Without that link, later blocks would not depend on the changed block, so the attacker could replace only the block with the payment, redoing one block's work: depth would give no protection, and confirmations would be worth almost nothing."}
+      result: "The attacker could redo just the one block holding the payment, since later blocks would not depend on it; waiting for more confirmations would then add almost no protection."
 
   - id: screen-yellow
     split: test
@@ -403,6 +612,14 @@ subjects:
       - q: "A spectrometer measures a screen showing yellow and a sodium lamp (light near 589 nm). Do the spectra match? Why do the two look alike?"
         expect: "No: the screen shows separate red and green peaks, the lamp one line near 589 nm; both give the cones about the same ratio of responses."
         kind: predict
+    rederive:
+      q: "Suppose an animal had four kinds of cone instead of three. Could a red-green-blue screen make red plus green light look the same to it as spectral yellow? Why or why not?"
+      steps:
+        - {kind: block, text: "The eye measures color as the responses of its kinds of cone, and the brain sees color from their ratio."}
+        - {kind: block, text: "Red plus green looks like spectral yellow to us because together they give our three kinds of cone about the same responses as yellow light does."}
+        - {kind: derived, text: "To look identical to the animal, two lights must give the same response in all four of its cone kinds."}
+        - {kind: derived, text: "A mix of three primaries has only three intensities to adjust, so it cannot in general match four separate responses: red plus green would usually look different from spectral yellow to the animal."}
+      result: "Generally no: a match must give the same response in all four cone kinds, and three primaries offer only three adjustable intensities, so red-plus-green 'yellow' would usually look different from spectral yellow."
 
   - id: https-identity
     split: test
@@ -418,6 +635,14 @@ subjects:
       - q: "A phishing site has a valid certificate and a padlock. How is that possible?"
         expect: "A certificate proves control of a domain name, not honesty; the attacker gets a certificate for their own look-alike domain."
         kind: predict
+    rederive:
+      q: "An attacker steals a website's private key, but not the certificate authority's. What can the attacker do, and why do they not need the certificate authority's key?"
+      steps:
+        - {kind: block, text: "A certificate binds a domain name to a public key, is signed by a certificate authority, and is public."}
+        - {kind: block, text: "During the handshake, the server proves it is the site by signing with the private key that matches the certificate's public key."}
+        - {kind: derived, text: "With the stolen private key, the attacker can present the site's own certificate and complete that proof, so to a browser whose traffic they can intercept, they are the site."}
+        - {kind: derived, text: "They need no new signature from the certificate authority: the existing, public certificate already binds the name to the stolen key."}
+      result: "They can impersonate the site to anyone whose traffic they can intercept, using its own public certificate; no new signature is needed, because the existing certificate already binds the domain to the stolen key."
 
   - id: skater-spin
     split: test
@@ -433,6 +658,15 @@ subjects:
       - q: "A skater spinning at 2 turns per second pulls in until the moment of inertia is a third of what it was. What is the new spin rate?"
         expect: "6 turns per second: L = Iω is constant, so ω triples."
         kind: predict
+    rederive:
+      q: "If a skater could move all the arm mass from 0.8 m to 0.4 m from the spin axis, and the arms were all that mattered, how much faster would the skater spin, and how would the kinetic energy change?"
+      steps:
+        - {kind: block, text: "Moment of inertia depends on mass × distance² from the axis."}
+        - {kind: block, text: "Angular momentum L = I × ω stays the same."}
+        - {kind: block, text: "Kinetic energy of spinning is ½ I ω²; the muscles supply the extra by pulling the arms in."}
+        - {kind: derived, text: "Halving the distance divides I by 4, so ω is multiplied by 4."}
+        - {kind: derived, text: "½ I ω² = ½ L ω with L fixed, so the kinetic energy is multiplied by 4 too."}
+      result: "Four times faster, with four times the kinetic energy, supplied by the muscles' work."
 
   - id: bond-prices
     split: test
@@ -448,6 +682,14 @@ subjects:
       - q: "Rates rise by 1 point. Which falls more in price: a 2-year bond or a 30-year bond? Why?"
         expect: "The 30-year bond: more of its payments are far in the future, where a higher discount rate shrinks them most."
         kind: predict
+    rederive:
+      q: "A bond pays a single $1,000 in 10 years and nothing before. What is it worth today if rates are 3%, and by about how much does its price fall if rates rise to 5%?"
+      steps:
+        - {kind: block, text: "A bond's price is its fixed future payments discounted at the current rate: what you would need to invest today, at that rate, to have those payments then."}
+        - {kind: block, text: "When rates rise, the payments are discounted more, so the price falls."}
+        - {kind: derived, text: "At 3%: 1,000 ÷ 1.03^10 ≈ $744."}
+        - {kind: derived, text: "At 5%: 1,000 ÷ 1.05^10 ≈ $614, a fall of about 17%."}
+      result: "About $744 at 3% and about $614 at 5%: a fall of about 17%."
 
   - id: cache-order
     split: test
@@ -463,3 +705,11 @@ subjects:
       - q: "The array is stored column-major instead (Fortran, or NumPy with order='F'). Which loop order is fast now? Why?"
         expect: "Column by column: now each column is contiguous, so that order uses every value in each cache line."
         kind: predict
+    rederive:
+      q: "A loop reads every element of a 1000 × 1000 array of doubles, stored row-major, column by column. If no cache line survives from one column to the next, about how many cache lines does it load, compared with reading row by row? How does that ratio change for an array of 1-byte chars?"
+      steps:
+        - {kind: block, text: "In row-major order each row is stored contiguously."}
+        - {kind: block, text: "Memory moves into the cache in lines of about 64 bytes; row order uses every value in a line, while column order uses one value per line loaded."}
+        - {kind: derived, text: "Row by row, the 8,000,000 bytes take 8,000,000 ÷ 64 = 125,000 lines; column by column, each of the 1,000,000 reads loads a new line: 8 times as many."}
+        - {kind: derived, text: "With 1-byte chars a line holds 64 values: row order loads 1,000,000 ÷ 64 ≈ 15,600 lines and column order still 1,000,000, about 64 times as many."}
+      result: "About 1,000,000 lines against 125,000 (8×) for doubles; for 1-byte chars, about 1,000,000 against 15,600 (64×): the smaller the elements, the larger the gap."
diff --git a/evals/artifact/rederive-checks.json b/evals/artifact/rederive-checks.json
new file mode 100644
index 0000000..a39318a
--- /dev/null
+++ b/evals/artifact/rederive-checks.json
@@ -0,0 +1,392 @@
+{
+  "antibiotic-resistance": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: blocks 1 and 2 come straight from the quiz's expected answers on pre-existing mutations and selection, step 3 multiplies independent probabilities (10^-8 × 10^-9 = 10^-17), and step 4 correctly counts 100 A-resistant, 10 B-resistant and 10^-7 expected double-resistant cells, a combination-therapy result a good answer to the subject question would not state.",
+    "hash": "20ab0c96ca5c",
+    "attempt": 1
+  },
+  "backprop": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: steps 1 and 2 come from the quiz answers. Step 3 (gradient −6, so w = 0.6) and step 4 (distance scales by 1 − 2η, so it settles only for 0 < η < 1, and η = 1 bounces between 0 and 6) use only school calculus and algebra. A general explanation would not state this specific result.",
+    "hash": "3bc7edde990c",
+    "attempt": 1
+  },
+  "bloom-filter": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: step 1 comes from the quiz's add/lookup and no-false-negatives answers, steps 2–4 follow by plain set reasoning (OR exactly reproduces the A ∪ B filter; AND covers every common item but may keep bits set by different items), and the subject's question does not ask about combining filters.",
+    "hash": "560ff6efa258",
+    "attempt": 1
+  },
+  "bond-prices": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: 1,000/1.03^10 ≈ $744 and 1,000/1.05^10 ≈ $614 give a fall of about 17.5%, which \"about 17%\" covers. The two block steps come from the quiz's discounting answers, the derived steps are plain arithmetic, and a good explanation would give the 9% coupon-bond example, not this zero-coupon result.",
+    "hash": "df104d611f07",
+    "attempt": 2
+  },
+  "cache-order": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: blocks 1 and 2 come straight from the expected answers. Step 3 is arithmetic (8,000,000/64 = 125,000 against 1,000,000), and step 4 applies the same reasoning to 64 one-byte values per line (about 15,600 against 1,000,000). A good explanation might imply the 8-doubles-per-line factor but would not give the line counts or the 64× result for chars.",
+    "hash": "ebcc3f60beb0",
+    "attempt": 1
+  },
+  "double-spend": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Steps 1 and 2 come straight from the quiz answers. Step 3 follows from the basic fact that changing data changes its hash. Step 4 follows from removing the link, giving a correct result that a standard explanation would not state; no step fails.",
+    "hash": "4dd74969073e",
+    "attempt": 1
+  },
+  "float-sum": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: steps 1 and 2 come from the quiz answers on binary fractions and power-of-2 denominators; steps 3 and 4 follow by factoring the denominators and reasoning about accumulated rounding; and the result (0.9999999999999999) is correct and not something a good explanation would have to state.",
+    "hash": "689ec94927ed",
+    "attempt": 1
+  },
+  "garbage-collection": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: steps 1 and 2 come straight from the quiz answers on reachability and cycles. Steps 3–5 apply them, since each adjacent pair of nodes forms a mutual-reference cycle and the back links make every node reachable from the tail. A good explanation covers a two-object cycle, not this list-plus-cache case.",
+    "hash": "6f783b2ee8c0",
+    "attempt": 1
+  },
+  "gps-relativity": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "No step fails: both block steps come from the quiz answers, step 3 (10 ns stamped late gives a distance about 3 m short) follows from distance = c × travel time, step 4 (a receiver clock error shifts every distance equally, so a single-satellite error cannot be absorbed and moves the fix) follows from the clock being a shared fourth unknown, and a good explanation would not state this result.",
+    "hash": "5923692adc45",
+    "attempt": 1
+  },
+  "greenhouse": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Steps 1 and 2 come straight from the quiz's expected answer on emission height and colder upper air. Steps 3 and 4 follow from those by setting the temperature drop with height to zero, which gives the standard result that an isothermal atmosphere produces no warming from extra CO2. A good explanation would rely on the drop in temperature with height but would not usually spell out the isothermal case, so no step fails.",
+    "hash": "226ec88cb282",
+    "attempt": 1
+  },
+  "heat-pump": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: steps 1 and 2 are blocks taken from the quiz answers, step 3 follows by subtracting the work from the heat given off, step 4 is algebra, and an explanation of heating would not state the cooling limit.",
+    "hash": "ce4d6e45f052",
+    "attempt": 1
+  },
+  "https-identity": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: blocks 1 and 2 come directly from the quiz's expected answers on certificates and the handshake proof. Steps 3 and 4 follow from them without new facts. A good explanation of how HTTPS proves identity would not have to spell out the consequence of a stolen site key.",
+    "hash": "031a92e3530a",
+    "attempt": 1
+  },
+  "jpeg": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: steps 1 and 2 restate the quiz's DCT and quantization ideas (a multiple of a step size is just what coarse rounding means); step 3 follows because decoding inverts the transform on the same block grid with the same step sizes, step 4 follows from rounding an on-grid value being nearly a no-op, and a good answer to the main question would not state this re-save result.",
+    "hash": "a3bad24d6a30",
+    "attempt": 1
+  },
+  "key-exchange": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All three blocks (secret exponents, exponents commuting, discrete-log hardness) come from the expected answers, steps 4 and 5 follow from them, and a two-party explanation would not state the three-party scheme; one caveat is that step 5's claim that getting g^(abc) needs a secret exponent is slightly strong, since security strictly rests on the computational Diffie-Hellman assumption, but the subject's own expected answer makes the same simplification.",
+    "hash": "b85695538fee",
+    "attempt": 1
+  },
+  "kidney-filter": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: steps 1 and 2 come from the quiz's expected answers, and steps 3 and 4 follow by simple arithmetic (2% of 180 L is 3.6 L, and 1% of 180 L is 1.8 L); the only quibble is that exactly 99% of 180 L gives 1.8 L rather than 1.5 L, so 'about double' is approximate, but this is within the stated 'about' figures.",
+    "hash": "6cb220af6b63",
+    "attempt": 1
+  },
+  "lightning": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: both blocks come from the quiz's expected answers (the channel is heated and expands, and sound takes about 3 s/km), step 3 follows from sound starting along the whole channel at different distances, and step 4 (1 km gives 3 s, 4 km gives 12 s, so a 9 s rumble) is simple arithmetic that a good answer would not state.",
+    "hash": "1b76a18bf3c2",
+    "attempt": 1
+  },
+  "liquid-core": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: steps 1 and 2 come from the quiz answers, step 3 follows by simple ray geometry, and step 4 follows because a larger core is grazed by rays reaching the surface at smaller angles, so the shadow starts before 104° and covers more of the surface, a result a good explanation would not state.",
+    "hash": "f4c8c1cfb18a",
+    "attempt": 1
+  },
+  "mountain-boiling": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: blocks 1–3 come straight from the quiz's expected answers, step 4 is simple addition (0.7 + 1 ≈ 1.7 atm), step 5 applies step 1 to give roughly 115 °C, which is a few degrees below 120 °C and well above 90 °C, and an explanation of why water boils lower on mountains would not state this combined result.",
+    "hash": "a9f022e889be",
+    "attempt": 1
+  },
+  "muscle-contraction": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Steps 1 and 2 come straight from the quiz's expected answers on calcium control and ATP. Step 3 follows because calcium that stays high keeps the sites uncovered. Step 4 follows from step 2, since cycling heads keep splitting ATP and lock once it is gone. The result needs this inference and is not something an explanation of contraction would state.",
+    "hash": "224f36e68f92",
+    "attempt": 1
+  },
+  "noise-cancelling": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: 1/340 s ≈ 2.9 ms is half of the 5.9 ms period of 170 Hz. Both blocks come from the quiz answers (inversion cancels and in-step adds; a half-cycle shift reverses the effect). The derived steps use only distance ÷ speed. A good answer about headphones would not state the two-speaker result.",
+    "hash": "8bd54e521de1",
+    "attempt": 1
+  },
+  "pagerank": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: C receives no links, so its rank is only its share of the jumps (0.15/3 = 0.05); solving A = 0.05 + 0.85(B + C) and B = 0.05 + 0.85A gives A ≈ 0.49 and B ≈ 0.46; both block steps come from the quiz's expected answers, and the derived steps use only that sharing and jump rule plus algebra.",
+    "hash": "502ad9c4b075",
+    "attempt": 1
+  },
+  "quorum": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: steps 1 and 2 come straight from the quiz answers, step 3 is a pigeonhole count (R + W > N forces overlap) that this reader can do, step 4 is arithmetic (writes need 4 of 5 and survive 1 failure, reads need 2 and survive 3), and a majority-quorum explanation would not state the general R + W > N rule or these numbers.",
+    "hash": "b214be60e719",
+    "attempt": 1
+  },
+  "rent-cap": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps pass: step 1's 'only when' is the plain contrapositive of the expected mechanism (a price held below the market level), step 2 restates the expected answer on time, steps 3 and 4 follow from them without new subject facts, and a good explanation would not normally discuss non-binding caps that later bind.",
+    "hash": "7f2c4e8c5d88",
+    "attempt": 1
+  },
+  "screen-yellow": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Both block steps come from the quiz's expected answers on cone ratios and metamers. Step 3 extends the cone-response idea to four cone kinds. Step 4 follows from counting: three or fewer adjustable intensities cannot generally match four responses. The four-cone result is not something a good explanation of the subject would state, so no step fails.",
+    "hash": "db2f9e6b3adb",
+    "attempt": 1
+  },
+  "skater-spin": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All three block steps come from the quiz's expected answers. Step 4 (half the distance makes I a quarter, so ω is four times) and step 5 (KE = ½Lω with L fixed, so KE is four times) follow by algebra alone. The good answer covers only halving I and doubling energy, so the factor-of-four result is not stated.",
+    "hash": "af0fba675bc5",
+    "attempt": 1
+  },
+  "sort-bound": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Every step holds: steps 1 and 2 come straight from the quiz's expected answers, step 3 counts the 4!/(2!·2!) = 6 interleavings with school combinatorics, step 4 compares 6 with 4 and 8 to give at least 3 (which a standard merge also achieves), and an explanation of the sorting lower bound would not mention merging.",
+    "hash": "6ebaa9162a54",
+    "attempt": 1
+  },
+  "ssd-wear": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "Both block steps (the limited program/erase cycles and wear leveling) come from the quiz's expected answers, and the two derived steps follow by plain arithmetic: 1 TB × 1,000 cycles = 1 PB, and 1,000,000 GB ÷ 50 GB/day = 20,000 days, about 55 years. Every step is needed, and a good explanation would not state this result.",
+    "hash": "76b77b030ab4",
+    "attempt": 2
+  },
+  "transistor-switch": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: blocks 1 and 2 come from the quiz answers. Step 3 follows from school physics: Q = CV, and energy drawn is QV, all of which ends up as heat over a charge-discharge cycle. Step 4 combines these to give the V² scaling (0.64, about 36% less), which a good explanation of transistor switching would not state outright.",
+    "hash": "54acd6f25a3a",
+    "attempt": 1
+  },
+  "two-tides": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: steps 1 and 2 come from the quiz's answers on the two bulges and on spring tides (the dip between bulges follows from the stretching picture), step 3 follows from the right-angle geometry, and step 4's (1 − ½)/(1 + ½) ≈ ⅓ matches the real ratio of about 0.37; though an explanation might name neap tides in passing, it would not work out the one-third figure.",
+    "hash": "fd810e590ec0",
+    "attempt": 1
+  },
+  "vaccine-memory": {
+    "verdict": "pass",
+    "tests": {
+      "correct": true,
+      "blocks": true,
+      "derived_follow": true,
+      "steps": true,
+      "not_stated": true
+    },
+    "reason": "All steps hold: 10 doublings at 12 hours each is 120 hours, about 5 days. Steps 1 and 2 come from the quiz's expected answers. Steps 3 and 4 need only logarithms, and the 'enough' term cancels in the difference. A good explanation would say 'within days' but not derive the 5-day saving.",
+    "hash": "549a8fdc9fc9",
+    "attempt": 1
+  }
+}
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index ee1a9a3..60153ec 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -83,3 +83,16 @@ def ask(system, prompt, model=None, **kw):
     rederive.check_targets()
     saved = json.loads(checks.read_text())
     assert asked == ["s2"] and saved["s2"]["attempt"] == 2 and saved["s1"]["attempt"] == 1
+
+
+def test_every_subject_has_a_checked_target():
+    # Targets are frozen once checked: a target that changed since its check, or a subject with neither a passing
+    # target nor a record of three failed attempts, fails here.
+    checks = json.loads(rederive.checks_file().read_text())
+    for s in ae.load("all")[1]:
+        c = checks.get(s["id"], {})
+        if "rederive" in s:
+            assert rederive.target_problems(s["rederive"]) == [], s["id"]
+            assert c.get("verdict") == "pass" and c.get("hash") == rederive.target_hash(s["rederive"]), s["id"]
+        else:
+            assert c.get("verdict") == "fail" and c.get("attempt") == 3, s["id"]

From 1bea9c6322e499dabc43b8865f43eb4e024d2d2f Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:13:47 -0400
Subject: [PATCH 04/13] rederive: the reader works the target out and cites the
 parts it rests on

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/artifact_eval.py | 19 +++++----
 explainer_kit/rederive.py      | 74 ++++++++++++++++++++++++++++++++++
 tests/test_rederive.py         | 72 +++++++++++++++++++++++++++++++++
 3 files changed, 157 insertions(+), 8 deletions(-)

diff --git a/explainer_kit/artifact_eval.py b/explainer_kit/artifact_eval.py
index 3c60f2f..c5f9a92 100644
--- a/explainer_kit/artifact_eval.py
+++ b/explainer_kit/artifact_eval.py
@@ -204,6 +204,16 @@ def reader_prompt(files: list[Path], reader: str, quiz: list[dict]) -> str:
     ])
 
 
+def copy_for_reader(files: list[Path], shown: Path) -> list[Path]:
+    """The reader gets copies of the renderings alone, so it cannot open model.md or the review runs."""
+    if shown.exists():
+        shutil.rmtree(shown)
+    shown.mkdir(parents=True)
+    for f in files:
+        shutil.copy(f, shown / f.name)
+    return [shown / f.name for f in files]
+
+
 def read(subject: dict, name: str, reader: str, out: Path, model: str | None) -> dict:
     ws = out / "work" / subject["id"] / name
     saved = ws / "read.json"
@@ -213,15 +223,8 @@ def read(subject: dict, name: str, reader: str, out: Path, model: str | None) ->
     if not files:
         result = {"answers": {}, "stops": [], "excess": [], "missing": True}
     else:
-        # The reader gets copies of the renderings alone, so it cannot open model.md or the review runs.
         shown = out / "shown" / subject["id"] / name
-        if shown.exists():
-            shutil.rmtree(shown)
-        shown.mkdir(parents=True)
-        copies = []
-        for f in files:
-            shutil.copy(f, shown / f.name)
-            copies.append(shown / f.name)
+        copies = copy_for_reader(files, shown)
         prompt = reader_prompt(copies, reader, subject["quiz"])
         for _ in range(2):  # a smaller reader model sometimes breaks the JSON shape; ask once more
             result = reader_reply(agent.ask(READER_SYSTEM, prompt, model=model, read=[shown]), len(subject["quiz"]))
diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 4078045..4889a29 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -17,6 +17,8 @@
 
 import hashlib
 import json
+import shutil
+import tempfile
 from pathlib import Path
 
 from explainer_kit import agent
@@ -26,6 +28,9 @@
 KINDS = ("block", "derived")
 CHECKER_SYSTEM = "You are a careful scientist and teacher. You check test questions. Reply with JSON only."
 CHECKS = ("correct", "blocks", "derived_follow", "steps", "not_stated")
+# The same words in the reader's prompt and the grader's: what the reader may bring, and what must come from the text.
+OUTSIDE_RULE = ("Background that this reader already has (see the reader above) may be used without a citation. Every "
+                "fact about the subject must come from a part of the explanation that the reader names.")
 
 
 def checks_file() -> Path:
@@ -112,3 +117,72 @@ def check_targets(only: list[str] | None = None, model: str | None = None) -> Pa
                           "reason": reply.get("reason", ""), "hash": h, "attempt": before.get("attempt", 0) + 1}
         path.write_text(json.dumps(dict(sorted(saved.items())), indent=2, ensure_ascii=False) + "\n")
     return path
+
+
+# ---------------------------------------------------------------- 2. read
+
+def reader_prompt(files: list[Path], reader: str, question: str) -> str:
+    return "\n".join([
+        "You are reading an explanation for the first time, as this reader: " + reader,
+        "",
+        "Read ONLY these files. Do not open any other file, and do not search the web:",
+        *[f"- {f}" for f in files],
+        "",
+        "An .html file is an interactive page: read its visible text, and its script to learn what the controls show.",
+        "",
+        "Then work out this question from what the explanation gives you. The explanation may not answer it directly:",
+        question,
+        "",
+        "Work it out step by step. For each step give: step (what it establishes); part (the part of the explanation "
+        "it rests on: a heading, a paragraph, a figure or diagram, or a control on a page; or the number of an "
+        "earlier step; or \"background\"); and idea (what that part gives you, in your own words).",
+        OUTSIDE_RULE,
+        "If the explanation lacks an idea you need, say which in gap and stop there: do not fill it from your own "
+        "knowledge. A gap is useful evidence. Otherwise end with your result.",
+        "",
+        'Reply with JSON only: {"steps": [{"step": "...", "part": "...", "idea": "..."}], "result": "...", '
+        '"gap": ""}',
+    ])
+
+
+def chain_reply(text: str) -> dict:
+    """The reader's chain in a fixed shape, whatever the reply looked like."""
+    try:
+        reply = agent.parse_json(text)
+    except ValueError:
+        reply = {}
+    reply = reply if isinstance(reply, dict) else {}
+    steps = reply.get("steps") if isinstance(reply.get("steps"), list) else []
+    return {"steps": [{k: str(s.get(k) or "") for k in ("step", "part", "idea")} for s in steps if isinstance(s, dict)],
+            "result": str(reply.get("result") or ""), "gap": str(reply.get("gap") or "")}
+
+
+def chain_text(chain: dict) -> str:
+    lines = [f"{i}. {s['step']} (rests on: {s['part']}; {s['idea']})" for i, s in enumerate(chain.get("steps", []), 1)]
+    if chain.get("gap"):
+        lines.append(f"Gap: {chain['gap']}")
+    return "\n".join([*lines, f"Result: {chain.get('result', '')}"])
+
+
+def read_chain(subject: dict, cond: str, reader: str, builds: Path, out: Path, k: int, model: str | None) -> dict:
+    """One reader's chain for one build in pass k. The builds folder is only read: copies go to a temp folder."""
+    saved = out / "rederive" / f"pass-{k}" / "read" / subject["id"] / f"{cond}.json"
+    if saved.exists():
+        return json.loads(saved.read_text())
+    files = ae.renderings(builds / "work" / subject["id"] / cond, subject["id"])
+    if not files:
+        result = {**chain_reply(""), "missing": True}
+    else:
+        tmp = Path(tempfile.mkdtemp(prefix="explainer-rederive-"))
+        try:
+            shown = tmp / "explanation"
+            prompt = reader_prompt(ae.copy_for_reader(files, shown), reader, subject["rederive"]["q"])
+            for _ in range(2):  # a broken JSON shape gets one more try
+                result = chain_reply(agent.ask(ae.READER_SYSTEM, prompt, model=model, read=[shown]))
+                if result["steps"] or result["gap"]:
+                    break
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+    saved.parent.mkdir(parents=True, exist_ok=True)
+    saved.write_text(json.dumps(result, indent=2, ensure_ascii=False))
+    return result
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 60153ec..2b4636b 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -1,7 +1,10 @@
 """The rederivation stage, without calling the claude CLI."""
 
+import hashlib
 import json
+from pathlib import Path
 
+import pytest
 import yaml
 
 from explainer_kit import agent, artifact_eval as ae, rederive
@@ -96,3 +99,72 @@ def test_every_subject_has_a_checked_target():
             assert c.get("verdict") == "pass" and c.get("hash") == rederive.target_hash(s["rederive"]), s["id"]
         else:
             assert c.get("verdict") == "fail" and c.get("attempt") == 3, s["id"]
+
+
+CHAIN = {"steps": [{"step": "One holds.", "part": "Section 'Adding'", "idea": "bits are set"},
+                   {"step": "So three.", "part": "step 1", "idea": "follows"}], "result": "Three.", "gap": ""}
+
+
+def tree(root):
+    return {str(p.relative_to(root)): hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob("*") if p.is_file()}
+
+
+def builds_folder(tmp_path, sid="s1", texts=None):
+    builds = tmp_path / "builds"
+    for cond, text in (texts or {"a": "ALPHA explains it.", "b": "BETA explains it."}).items():
+        folder = builds / "work" / sid / cond / "explainers" / sid
+        folder.mkdir(parents=True)
+        if text is not None:
+            (folder / "explanation.md").write_text(f"# Title\n\n{text}\n")
+        (builds / "work" / sid / cond / "run.json").write_text("{}")
+    return builds
+
+
+def test_reader_prompt_is_blind_to_steps_and_result(tmp_path):
+    reader, subjects = ae.load("dev")
+    t = subjects[0]["rederive"]
+    files = [tmp_path / "explanation.md", tmp_path / "index.html"]
+    p = rederive.reader_prompt(files, reader, t["q"])
+    assert t["q"] in p and rederive.OUTSIDE_RULE in p and all(str(f) in p for f in files)
+    assert '"gap"' in p and '"part"' in p
+    assert all(s["text"] not in p for s in t["steps"]) and t["result"] not in p
+
+
+def test_chain_reply_tolerates_shapes():
+    assert rederive.chain_reply(json.dumps(CHAIN)) == CHAIN
+    assert rederive.chain_reply(json.dumps({"steps": "x", "result": "r"}))["steps"] == []
+    assert rederive.chain_reply("no json") == {"steps": [], "result": "", "gap": ""}
+    mixed = {"steps": ["loose text", CHAIN["steps"][0]], "result": "r", "gap": ""}
+    assert rederive.chain_reply(json.dumps(mixed))["steps"] == [CHAIN["steps"][0]]
+
+
+def test_chain_text_numbers_steps():
+    lines = rederive.chain_text(CHAIN).splitlines()
+    assert lines[0].startswith("1. One holds.") and "Section 'Adding'" in lines[0] and "bits are set" in lines[0]
+    assert lines[1].startswith("2. So three.")
+    assert lines[-1] == "Result: Three."
+
+
+def test_read_chain_uses_copies_and_leaves_builds_untouched(monkeypatch, tmp_path):
+    builds, out = builds_folder(tmp_path), tmp_path / "out"
+    before, seen = tree(builds), []
+
+    def ask(system, prompt, model=None, read=None, **kw):
+        seen.append(read)
+        return json.dumps(CHAIN)
+
+    monkeypatch.setattr(agent, "ask", ask)
+    s = {"id": "s1", "rederive": TARGET}
+    assert rederive.read_chain(s, "a", "A reader.", builds, out, 1, None)["steps"] == CHAIN["steps"]
+    assert len(seen) == 1 and all(builds.resolve() not in Path(d).resolve().parents for d in seen[0])
+    assert (out / "rederive" / "pass-1" / "read" / "s1" / "a.json").exists()
+    rederive.read_chain(s, "a", "A reader.", builds, out, 1, None)
+    assert len(seen) == 1                                          # saved: not read again
+    assert tree(builds) == before
+
+
+def test_read_chain_skips_a_build_with_no_renderings(monkeypatch, tmp_path):
+    builds = builds_folder(tmp_path, texts={"a": None})
+    monkeypatch.setattr(agent, "ask", lambda *a, **k: pytest.fail("no explanation, so no reader"))
+    r = rederive.read_chain({"id": "s1", "rederive": TARGET}, "a", "A reader.", builds, tmp_path / "out", 1, None)
+    assert r["missing"] is True and r["steps"] == []

From b1b7ba60260507bcc0a5faa8584e49b04b3c3a83 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:15:24 -0400
Subject: [PATCH 05/13] rederive: blind grading of each chain, scores, and the
 separation rule

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/rederive.py | 120 ++++++++++++++++++++++++++++++++++++++
 tests/test_rederive.py    |  81 +++++++++++++++++++++++++
 2 files changed, 201 insertions(+)

diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 4889a29..4215bf5 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -17,6 +17,7 @@
 
 import hashlib
 import json
+import re
 import shutil
 import tempfile
 from pathlib import Path
@@ -26,6 +27,7 @@
 from explainer_kit.paths import project_root
 
 KINDS = ("block", "derived")
+MARKS = ("supported", "unsupported", "missing", "stated")
 CHECKER_SYSTEM = "You are a careful scientist and teacher. You check test questions. Reply with JSON only."
 CHECKS = ("correct", "blocks", "derived_follow", "steps", "not_stated")
 # The same words in the reader's prompt and the grader's: what the reader may bring, and what must come from the text.
@@ -186,3 +188,121 @@ def read_chain(subject: dict, cond: str, reader: str, builds: Path, out: Path, k
     saved.parent.mkdir(parents=True, exist_ok=True)
     saved.write_text(json.dumps(result, indent=2, ensure_ascii=False))
     return result
+
+
+# ---------------------------------------------------------------- 3. grade
+
+def grader_text(path: Path) -> str:
+    """What the grader reads: as for the quiz, plus a page's scripts, so a step that cites a control can be checked."""
+    text = ae.shown_text(path)
+    if path.suffix == ".html":
+        scripts = [s.strip() for s in re.findall(r"<script\b[^>]*>(.*?)</script>", path.read_text(), flags=re.S | re.I)]
+        if any(scripts):
+            text += "\n\n--- page script ---\n" + "\n\n".join(s for s in scripts if s)
+    return text
+
+
+def grade_prompt(subject: dict, reader: str, entries: dict[str, dict]) -> str:
+    t = subject["rederive"]
+    steps = "\n".join(f"  {i}. ({s['kind']}) {s['text']}" for i, s in enumerate(t["steps"], 1))
+    blocks = [f"=== Explanation {label} ===\n{e['text'][:ae.TEXT_LIMIT]}\n\n--- Reader's working from {label} ---\n"
+              f"{e['chain']}" for label, e in entries.items()]
+    return "\n".join([
+        f"Subject: {subject['q']}",
+        f"The reader: {reader}",
+        "",
+        "A reader read each explanation once, then worked out this question, which the explanation was not asked to "
+        "answer:",
+        f"Question: {t['q']}",
+        "Expected steps (block: an idea a good explanation gives; derived: worked out from the steps before it):",
+        steps,
+        f"Expected result: {t['result']}",
+        "",
+        "The reader was told: " + OUTSIDE_RULE,
+        "",
+        *blocks,
+        "",
+        "Grade each reader's working on its own, against its own explanation. The expected steps are a checklist of "
+        "ideas, not a script: credit a step when the working establishes the same idea, in any order, merged with "
+        "another step, split in two, or by an equivalent route. For each expected step, in order, give one mark:",
+        "- supported: the reader made the step, and either the parts of the explanation it names carry the ideas it "
+        "rests on, or it uses only background this reader already has on top of earlier steps;",
+        "- unsupported: the reader made the step, but from its own knowledge of the subject, or from a part of the "
+        "explanation that does not carry the idea;",
+        "- missing: the reader did not make the step;",
+        "- stated: a derived step that the explanation itself states outright, so the reader looked it up instead of "
+        "working it out. Use stated for derived steps only; building blocks are meant to be in the explanation.",
+        "Then give result_right (the reader's result matches the expected result) and result_stated (the explanation "
+        "itself states the expected result outright).",
+        "",
+        'Reply with JSON only: {"grades": {"<label>": {"marks": ["supported", ...], "result_right": true, '
+        '"result_stated": false}}}',
+    ])
+
+
+def marks(raw: object, kinds: list[str]) -> list[str]:
+    """One mark per expected step: unknown or absent marks are missing, and "stated" on a building block (which
+    is meant to be in the explanation) is supported."""
+    raw = raw if isinstance(raw, list) else []
+    out = []
+    for i, kind in enumerate(kinds):
+        m = str(raw[i]).strip().lower() if i < len(raw) else "missing"
+        m = m if m in MARKS else "missing"
+        out.append("supported" if m == "stated" and kind == "block" else m)
+    return out
+
+
+def tally(marks: list[str], kinds: list[str], right: bool, stated: bool) -> dict[str, int]:
+    """Counts for one chain. A stated derived step, or a stated result, is left out of the score: neither rewarded
+    nor penalized."""
+    n_stated = sum(m == "stated" for m in marks)
+    supported = sum(m == "supported" for m in marks)
+    return {"supported": supported, "made": supported + sum(m == "unsupported" for m in marks),
+            "counted": len(marks) - n_stated, "stated": n_stated, "right": int(right and not stated),
+            "results": int(not stated), "results_stated": int(stated)}
+
+
+def pass_scores(tallies: dict[str, list[dict]]) -> dict[str, dict]:
+    """Per condition, pooled over subjects: supported and raw shares of the counted steps, and the share of results
+    right (None when nothing was counted)."""
+    def share(key: str, of: str, ts: list[dict]) -> float | None:
+        total = sum(t[of] for t in ts)
+        return sum(t[key] for t in ts) / total if total else None
+    return {c: {"supported": share("supported", "counted", ts), "raw": share("made", "counted", ts),
+                "result": share("right", "results", ts)} for c, ts in tallies.items()}
+
+
+def separations(passes: list[dict[str, dict]]) -> list[tuple[str, str]]:
+    """Pairs (a, b) where a's supported score is higher than b's in every pass: the separation rule."""
+    if not passes:
+        return []
+    names = list(passes[0])
+    return [(a, b) for a in names for b in names if a != b and all(
+        p[a]["supported"] is not None and p[b]["supported"] is not None and p[a]["supported"] > p[b]["supported"]
+        for p in passes)]
+
+
+def grade_subject(subject: dict, key: dict[str, str], reader: str, builds: Path, out: Path, k: int,
+                  model: str | None) -> dict:
+    """One grading of a subject's chains in pass k, under the labels in `key` (label -> condition)."""
+    saved = out / "rederive" / f"pass-{k}" / "grades" / f"{subject['id']}.json"
+    if saved.exists():
+        return json.loads(saved.read_text())
+    entries = {}
+    for label, cond in key.items():
+        chain = json.loads((out / "rederive" / f"pass-{k}" / "read" / subject["id"] / f"{cond}.json").read_text())
+        files = ae.renderings(builds / "work" / subject["id"] / cond, subject["id"])
+        entries[label] = {"text": "\n\n".join(grader_text(f) for f in files) or "(no explanation)",
+                          "chain": "(no chain)" if chain.get("missing") else chain_text(chain)}
+    reply = agent.parse_json(agent.ask(ae.GRADER_SYSTEM, grade_prompt(subject, reader, entries), model=model))
+    kinds = [s["kind"] for s in subject["rederive"]["steps"]]
+    grades = {}
+    for label, cond in key.items():
+        g = (reply.get("grades") or {}).get(label)
+        g = g if isinstance(g, dict) else {}
+        grades[cond] = {"marks": marks(g.get("marks"), kinds), "result_right": g.get("result_right") is True,
+                        "result_stated": g.get("result_stated") is True}
+    result = {"key": key, "grades": grades}
+    saved.parent.mkdir(parents=True, exist_ok=True)
+    saved.write_text(json.dumps(result, indent=2, ensure_ascii=False))
+    return result
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 2b4636b..b9c2bdc 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -168,3 +168,84 @@ def test_read_chain_skips_a_build_with_no_renderings(monkeypatch, tmp_path):
     monkeypatch.setattr(agent, "ask", lambda *a, **k: pytest.fail("no explanation, so no reader"))
     r = rederive.read_chain({"id": "s1", "rederive": TARGET}, "a", "A reader.", builds, tmp_path / "out", 1, None)
     assert r["missing"] is True and r["steps"] == []
+
+
+def test_grader_text_includes_page_scripts(tmp_path):
+    html = tmp_path / "index.html"
+    html.write_text("<p>Drag the slider</p><script>const loss = x => x * x</script>")
+    assert "const loss" not in ae.shown_text(html)                 # the visible text alone misses what a control shows
+    text = rederive.grader_text(html)
+    assert "Drag the slider" in text and "const loss" in text
+    md = tmp_path / "explanation.md"
+    md.write_text("# T\n\nBody `x = 1`.\n<!-- note -->\n")
+    assert rederive.grader_text(md) == ae.shown_text(md)
+
+
+def test_grade_prompt_is_blind_and_carries_the_rule():
+    reader, subjects = ae.load("dev")
+    s = subjects[0]
+    p = rederive.grade_prompt(s, reader, {"A": {"text": "body", "chain": rederive.chain_text(CHAIN)},
+                                          "B": {"text": "other", "chain": "(no chain)"}})
+    assert rederive.OUTSIDE_RULE in p and s["rederive"]["result"] in p
+    assert all(f"({step['kind']}) {step['text']}" in p for step in s["rederive"]["steps"])
+    assert "=== Explanation A ===" in p and "=== Explanation B ===" in p and rederive.chain_text(CHAIN) in p
+    assert "any order" in p and "stated" in p
+    assert "principles" not in p.lower() and "skill" not in p.lower()   # the grader does not know the conditions
+
+
+def test_marks_are_normalised():
+    assert rederive.marks(["supported", "stated", "bogus"], ["block", "block", "derived", "derived"]) == \
+        ["supported", "supported", "missing", "missing"]                # "stated" on a building block is supported
+    assert rederive.marks("x", ["block"]) == ["missing"]
+    assert rederive.marks(["supported", "unsupported", "supported"], ["block", "derived"]) == ["supported", "unsupported"]
+
+
+def test_tally():
+    marks, kinds = ["supported", "unsupported", "stated", "missing"], ["block", "derived", "derived", "derived"]
+    assert rederive.tally(marks, kinds, True, False) == \
+        {"supported": 1, "made": 2, "counted": 3, "stated": 1, "right": 1, "results": 1, "results_stated": 0}
+    t = rederive.tally(marks, kinds, True, True)                     # a stated result is left out of the result score
+    assert t["right"] == 0 and t["results"] == 0 and t["results_stated"] == 1
+
+
+def test_pass_scores_pool_subjects():
+    base = {"stated": 0, "results_stated": 0}
+    scores = rederive.pass_scores({
+        "a": [{**base, "supported": 1, "made": 2, "counted": 2, "right": 1, "results": 1},
+              {**base, "supported": 2, "made": 2, "counted": 3, "right": 0, "results": 1}],
+        "b": [{**base, "supported": 0, "made": 0, "counted": 2, "right": 0, "results": 0, "results_stated": 1}],
+    })
+    assert scores["a"] == {"supported": 0.6, "raw": 0.8, "result": 0.5}
+    assert scores["b"]["result"] is None
+
+
+def test_separations_need_every_pass():
+    assert rederive.separations([
+        {"a": {"supported": .7}, "b": {"supported": .5}, "c": {"supported": .6}},
+        {"a": {"supported": .7}, "b": {"supported": .5}, "c": {"supported": .4}},
+        {"a": {"supported": .6}, "b": {"supported": .6}, "c": {"supported": .3}},
+    ]) == [("a", "c")]
+
+
+def test_grade_subject_maps_labels_back_and_fills_missing(monkeypatch, tmp_path):
+    builds, out = builds_folder(tmp_path), tmp_path / "out"
+    s = {"id": "s1", "q": "Question?", "rederive": TARGET}
+    for cond in ("a", "b"):
+        f = out / "rederive" / "pass-1" / "read" / "s1" / f"{cond}.json"
+        f.parent.mkdir(parents=True, exist_ok=True)
+        f.write_text(json.dumps(CHAIN))
+    calls = []
+
+    def ask(system, prompt, model=None, **kw):
+        calls.append(prompt)
+        return json.dumps({"grades": {"A": {"marks": ["supported", "supported", "stated"], "result_right": True,
+                                            "result_stated": False}}})
+
+    monkeypatch.setattr(agent, "ask", ask)
+    g = rederive.grade_subject(s, {"A": "b", "B": "a"}, "A reader.", builds, out, 1, None)
+    assert g["grades"]["b"] == {"marks": ["supported", "supported", "stated"], "result_right": True, "result_stated": False}
+    assert g["grades"]["a"] == {"marks": ["missing"] * 3, "result_right": False, "result_stated": False}
+    assert "BETA" in calls[0].split("=== Explanation A ===")[1].split("=== Explanation B ===")[0]
+    assert (out / "rederive" / "pass-1" / "grades" / "s1.json").exists()
+    rederive.grade_subject(s, {"A": "b", "B": "a"}, "A reader.", builds, out, 1, None)
+    assert len(calls) == 1

From 5258c2d88aa8e6fc9c85e1eff3b3dc63d7ec60d4 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:17:23 -0400
Subject: [PATCH 06/13] rederive: three-pass run, report, and the eval rederive
 command; eval artifact runs it

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/cli.py      |  30 ++++++----
 explainer_kit/rederive.py | 123 +++++++++++++++++++++++++++++++++++++-
 tests/test_rederive.py    |  97 ++++++++++++++++++++++++++++++
 3 files changed, 239 insertions(+), 11 deletions(-)

diff --git a/explainer_kit/cli.py b/explainer_kit/cli.py
index e1e3ad3..adc7b9f 100644
--- a/explainer_kit/cli.py
+++ b/explainer_kit/cli.py
@@ -225,7 +225,7 @@ def cmd_eval(args) -> None:
         print(f"targets   {verdicts.count('pass')} pass, {verdicts.count('fail')} fail   {display(path)}")
         return
     default = {"chat": ["none", "v0.5=git:v0.5.0", "v0.6=principles"],
-               "artifact": ["none", "principles", "quick", "published"]}[args.suite]
+               "artifact": ["none", "principles", "quick", "published"]}.get(args.suite, [])
     conditions = dict(c.split("=", 1) if "=" in c else (c, c) for c in (args.conditions or default))
     if args.suite == "chat":
         from explainer_kit.evals import run
@@ -233,12 +233,20 @@ def cmd_eval(args) -> None:
         out = Path(args.out) if args.out else project_root() / "evals" / "chat" / "results" / date.today().isoformat()
         run(conditions, out, model=args.model, workers=args.workers)
         return
-    from explainer_kit.artifact_eval import run
-
-    out = Path(args.out) if args.out else (project_root() / "evals" / "artifact" / "results"
-                                           / f"{date.today().isoformat()}-{args.split}")
-    run(conditions, out, split=args.split, only=args.only, model=args.model, workers=args.workers,
-        reader_model=args.reader_model)
+    from explainer_kit import artifact_eval, rederive
+
+    results = project_root() / "evals" / "artifact" / "results"
+    stage = dict(split=args.split, only=args.only, model=args.model, reader_model=args.reader_model,
+                 workers=args.workers)
+    if args.suite == "rederive":
+        if not args.builds:
+            raise SystemExit("eval rederive needs --builds <an artifact run folder>")
+        out = Path(args.out) if args.out else results / f"{date.today().isoformat()}-{args.split}-rederive"
+        rederive.run(out, Path(args.builds), **stage)
+        return
+    out = Path(args.out) if args.out else results / f"{date.today().isoformat()}-{args.split}"
+    artifact_eval.run(conditions, out, **stage)
+    rederive.run(out, out, **stage)
 
 
 def cmd_frames(args) -> None:
@@ -347,9 +355,11 @@ def main() -> None:
     p.set_defaults(fn=cmd_decide)
 
     p = sub.add_parser("eval", help="chat: answers under several system prompts; artifact: explainers built under "
-                                     "several conditions, read and graded blind; targets: check the rederivation "
-                                     "targets")
-    p.add_argument("suite", choices=["chat", "artifact", "targets"])
+                                     "several conditions, read and graded blind (then the rederivation stage); "
+                                     "targets: check the rederivation targets; rederive: the rederivation stage on "
+                                     "an earlier artifact run's builds")
+    p.add_argument("suite", choices=["chat", "artifact", "targets", "rederive"])
+    p.add_argument("--builds", help="rederive: the artifact run folder whose builds are read (it is not changed)")
     p.add_argument("--conditions", nargs="+",
                    help="name=source; source is none, principles, git:<rev>, or a file; for artifact also quick or "
                         "published (the explain skill at that tier). Default: chat none v0.5 v0.6; artifact none "
diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 4215bf5..12e457b 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -17,14 +17,19 @@
 
 import hashlib
 import json
+import os
+import random
 import re
 import shutil
 import tempfile
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date
 from pathlib import Path
 
 from explainer_kit import agent
 from explainer_kit import artifact_eval as ae
-from explainer_kit.paths import project_root
+from explainer_kit.evals import words
+from explainer_kit.paths import display, project_root
 
 KINDS = ("block", "derived")
 MARKS = ("supported", "unsupported", "missing", "stated")
@@ -306,3 +311,119 @@ def grade_subject(subject: dict, key: dict[str, str], reader: str, builds: Path,
     saved.parent.mkdir(parents=True, exist_ok=True)
     saved.write_text(json.dumps(result, indent=2, ensure_ascii=False))
     return result
+
+
+# ---------------------------------------------------------------- run and report
+
+def run(out: Path, builds: Path, split: str = "dev", only: list[str] | None = None, model: str | None = None,
+        reader_model: str | None = None, workers: int = 4, passes: int = 3) -> Path:
+    """Reads and grades the builds in `builds` (an artifact run folder, only read) into `out`."""
+    reader, subjects = ae.load(split, only)
+    subjects = [s for s in subjects if s.get("rederive")]
+    if not subjects:
+        raise SystemExit(f"no subjects with a rederivation target for split {split!r}" + (f" and ids {only}" if only else ""))
+    names = list(json.loads((builds / "conditions.json").read_text()))
+    stage = out / "rederive"
+    stage.mkdir(parents=True, exist_ok=True)
+    # The targets this folder ran, so a rerun after a target changed cannot mix two versions in one folder.
+    snapshot, targets = stage / "targets.json", {s["id"]: s["rederive"] for s in subjects}
+    if snapshot.exists():
+        before = json.loads(snapshot.read_text())
+        changed = sorted(i for i in targets if i in before and before[i] != targets[i])
+        if changed:
+            raise SystemExit(f"targets changed since this run: {', '.join(changed)}")
+        targets = {**before, **targets}
+    snapshot.write_text(json.dumps(dict(sorted(targets.items())), indent=2, ensure_ascii=False) + "\n")
+    source = os.path.relpath(builds.resolve(), out.resolve())
+    (stage / "source.json").write_text(json.dumps({"builds": source}) + "\n")
+
+    def read_job(job):
+        k, s, n = job
+        r = read_chain(s, n, reader, builds, out, k, reader_model or model)
+        print(f"read    pass {k}  {s['id']:22} {n:12} {len(r['steps'])} steps{'  gap' if r['gap'] else ''}"
+              f"{'  NO EXPLANATION' if r.get('missing') else ''}", flush=True)
+
+    ks = range(1, passes + 1)
+    with ThreadPoolExecutor(workers) as pool:
+        list(pool.map(read_job, [(k, s, n) for k in ks for s in subjects for n in names]))
+    keys = {}
+    for k in ks:
+        rng = random.Random(k)
+        for s in subjects:
+            labels = list(names)
+            rng.shuffle(labels)
+            keys[k, s["id"]] = {chr(ord("A") + i): n for i, n in enumerate(labels)}
+    with ThreadPoolExecutor(workers) as pool:
+        futures = {(k, s["id"]): pool.submit(grade_subject, s, keys[k, s["id"]], reader, builds, out, k, model)
+                   for k in ks for s in subjects}
+        grades = {key: f.result() for key, f in futures.items()}
+    report = out / "rederive.md"
+    report.write_text(summary(names, subjects, builds, out, grades, passes, split, source, model, reader_model))
+    print(f"\nreport  {display(report)}")
+    return report
+
+
+def summary(names: list[str], subjects: list[dict], builds: Path, out: Path, grades: dict, passes: int, split: str,
+            source: str, model: str | None, reader_model: str | None) -> str:
+    ks = range(1, passes + 1)
+    tallies = {k: {n: [] for n in names} for k in ks}
+    for k in ks:
+        for s in subjects:
+            kinds = [step["kind"] for step in s["rederive"]["steps"]]
+            for n in names:
+                g = grades[k, s["id"]]["grades"][n]
+                tallies[k][n].append(tally(g["marks"], kinds, g["result_right"], g["result_stated"]))
+    scores = [pass_scores(tallies[k]) for k in ks]
+    seps = separations(scores)
+    (out / "rederive-scores.json").write_text(json.dumps(
+        {"passes": scores, "tallies": {str(k): v for k, v in tallies.items()}, "separations": [list(p) for p in seps]},
+        indent=2, ensure_ascii=False) + "\n")
+    pct = lambda x: "–" if x is None else f"{x:.0%}"  # noqa: E731
+    ids = {s["id"] for s in subjects}
+    quiz_file = builds / "scores.json"
+    quiz = json.loads(quiz_file.read_text()) if quiz_file.exists() else {}
+
+    def quiz_share(n: str) -> str:
+        per = [p for p in quiz.get(n, {}).get("subjects", []) if p["id"] in ids]
+        full = sum(2 * len(p["raw"]) for p in per)
+        return f"{sum(sum(p['score']) for p in per) / full:.0%}" if full else "–"
+
+    def mean_words(n: str) -> str:
+        counts = [sum(words(ae.visible(f)) for f in ae.renderings(builds / "work" / s["id"] / n, s["id"])) for s in subjects]
+        return f"{sum(counts) / len(counts):.0f}"
+
+    head = ["condition", "supported", "raw", "result right", "stated steps", "stated results", "words", "quiz (grounded)"]
+    table = ["| " + " | ".join(head) + " |", "|" + "---|" * len(head)]
+    for n in names:
+        table.append("| " + " | ".join([
+            n,
+            ", ".join(pct(sc[n]["supported"]) for sc in scores),
+            ", ".join(pct(sc[n]["raw"]) for sc in scores),
+            ", ".join(pct(sc[n]["result"]) for sc in scores),
+            ", ".join(str(sum(t["stated"] for t in tallies[k][n])) for k in ks),
+            ", ".join(str(sum(t["results_stated"] for t in tallies[k][n])) for k in ks),
+            mean_words(n),
+            quiz_share(n),
+        ]) + " |")
+    rule = "in all three passes" if passes == 3 else f"in all {passes} passes"
+    sep = ", ".join(f"{a} > {b}" for a, b in seps) or "none"
+    lines = [
+        f"# Rederivation, {date.today().isoformat()} ({split}, {len(subjects)} subjects)", "",
+        f"Builds: `{source}`. Reader and grader: fresh `claude -p`{f' --model {model}' if model else ''} agents"
+        f"{f' (reader: --model {reader_model})' if reader_model else ''}. The reader saw only the renderings and the "
+        "target's question; the grader saw each subject's explanations and the readers' working under shuffled "
+        f"labels. {passes} passes: each a fresh reader run over every build, graded once under its own shuffle.", "",
+        *table, "",
+        f"Separation (higher supported score {rule}): {sep}.", "",
+        "Each cell lists the passes in order. Supported: the share of expected steps the reader made and grounded in a "
+        "part of the explanation it named (or in background this reader has); raw: the share made at all; result "
+        "right: the share of results that match. Stated steps and stated results: derived steps and results the "
+        "explanation states outright, left out of the shares above. Words: visible words per explanation. Quiz: the "
+        "grounded quiz score of the same builds.", "",
+        "## Per subject (supported/counted steps, per pass)", "",
+        "| subject | " + " | ".join(names) + " |", "|---|" + "---|" * len(names),
+    ]
+    for i, s in enumerate(subjects):
+        cells = [", ".join(f"{tallies[k][n][i]['supported']}/{tallies[k][n][i]['counted']}" for k in ks) for n in names]
+        lines.append(f"| {s['id']} | " + " | ".join(cells) + " |")
+    return "\n".join(lines) + "\n"
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index b9c2bdc..1355559 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -2,6 +2,8 @@
 
 import hashlib
 import json
+import re
+import sys
 from pathlib import Path
 
 import pytest
@@ -249,3 +251,98 @@ def ask(system, prompt, model=None, **kw):
     assert (out / "rederive" / "pass-1" / "grades" / "s1.json").exists()
     rederive.grade_subject(s, {"A": "b", "B": "a"}, "A reader.", builds, out, 1, None)
     assert len(calls) == 1
+
+
+ROOT = Path(__file__).resolve().parent.parent
+
+
+def run_fixture(monkeypatch, tmp_path):
+    """One subject, two conditions (a: ALPHA, b: BETA), a stub reader, and a grader that supports every step of the
+    ALPHA explanation and none of the other. Returns builds, out, and the list of calls."""
+    monkeypatch.setattr(ae, "questions_file", lambda: subjects_file(tmp_path, {"s1": target()}))
+    builds = builds_folder(tmp_path)
+    (builds / "conditions.json").write_text(json.dumps({"a": "none", "b": "quick"}))
+    (builds / "scores.json").write_text(json.dumps({
+        "a": {"subjects": [{"id": "s1", "score": [2, 2, 1, 2], "raw": [2, 2, 2, 2]}]},
+        "b": {"subjects": [{"id": "s1", "score": [1, 0, 0, 0], "raw": [1, 0, 2, 0]}]}}))
+    calls = []
+
+    def ask(system, prompt, model=None, **kw):
+        calls.append(system)
+        if system == ae.READER_SYSTEM:
+            return json.dumps(CHAIN)
+        blocks = dict(re.findall(r"=== Explanation (\w) ===\n(.*?)(?==== Explanation|\Z)", prompt, re.S))
+        return json.dumps({"grades": {lab: {"marks": ["supported" if "ALPHA" in b else "missing"] * 3,
+                                            "result_right": "ALPHA" in b, "result_stated": False}
+                                      for lab, b in blocks.items()}})
+
+    monkeypatch.setattr(agent, "ask", ask)
+    return builds, tmp_path / "out", calls
+
+
+def test_run_end_to_end(monkeypatch, tmp_path):
+    builds, out, calls = run_fixture(monkeypatch, tmp_path)
+    report = rederive.run(out, builds).read_text()
+    assert calls.count(ae.READER_SYSTEM) == 3 * 2 and calls.count(ae.GRADER_SYSTEM) == 3
+    assert ("| condition | supported | raw | result right | stated steps | stated results | words | quiz (grounded) |"
+            in report)
+    assert "| a | 100%, 100%, 100% | 100%, 100%, 100% |" in report
+    assert "| b | 0%, 0%, 0% | 0%, 0%, 0% |" in report
+    assert "Separation (higher supported score in all three passes): a > b." in report
+    assert "| s1 | 3/3, 3/3, 3/3 | 0/3, 0/3, 0/3 |" in report
+    scores = json.loads((out / "rederive-scores.json").read_text())
+    assert scores["separations"] == [["a", "b"]] and len(scores["passes"]) == 3
+
+
+def test_rerun_makes_no_calls(monkeypatch, tmp_path):
+    builds, out, calls = run_fixture(monkeypatch, tmp_path)
+    first = rederive.run(out, builds).read_text()
+    calls.clear()
+    assert rederive.run(out, builds).read_text() == first and calls == []
+
+
+def test_rerun_refuses_changed_targets(monkeypatch, tmp_path):
+    builds, out, _ = run_fixture(monkeypatch, tmp_path)
+    rederive.run(out, builds)
+    monkeypatch.setattr(ae, "questions_file", lambda: subjects_file(tmp_path, {"s1": target(result="Four.")}))
+    with pytest.raises(SystemExit, match="targets changed since this run: s1"):
+        rederive.run(out, builds)
+
+
+def test_outputs_hold_no_absolute_paths(monkeypatch, tmp_path):
+    builds, out, _ = run_fixture(monkeypatch, tmp_path)
+    rederive.run(out, builds)
+    leaks = [p for p in out.rglob("*") if p.is_file() and str(tmp_path) in p.read_text()]
+    assert not leaks, leaks
+    assert json.loads((out / "rederive" / "source.json").read_text()) == {"builds": "../builds"}
+
+
+def test_builds_folder_is_untouched(monkeypatch, tmp_path):
+    builds, out, _ = run_fixture(monkeypatch, tmp_path)
+    before = tree(builds)
+    rederive.run(out, builds)
+    assert tree(builds) == before
+
+
+def test_frozen_targets_match_every_results_folder():
+    # A results folder records the targets it ran; they must still be the targets in questions.yaml (the freeze).
+    current = {s["id"]: s.get("rederive") for s in ae.load("all")[1]}
+    for snap in (ROOT / "evals" / "artifact" / "results").glob("*/rederive/targets.json"):
+        for sid, t in json.loads(snap.read_text()).items():
+            assert current.get(sid) == t, f"{snap.parent.parent.name}: the target for {sid} changed after the run"
+
+
+def test_cli_rederive_and_artifact_call_the_stage(monkeypatch, tmp_path):
+    from explainer_kit import cli
+
+    seen = []
+    monkeypatch.setattr(rederive, "run", lambda out, builds, **kw: seen.append(("rederive", out, builds)))
+    monkeypatch.setattr(ae, "run", lambda conditions, out, **kw: seen.append(("artifact", out)))
+    b, o = tmp_path / "b", tmp_path / "o"
+    monkeypatch.setattr(sys, "argv", ["explainer", "eval", "rederive", "--builds", str(b), "--out", str(o)])
+    cli.main()
+    assert seen == [("rederive", o, b)]
+    seen.clear()
+    monkeypatch.setattr(sys, "argv", ["explainer", "eval", "artifact", "--out", str(o)])
+    cli.main()
+    assert seen == [("artifact", o), ("rederive", o, o)]

From 637af1d5eda0dca024ade9cfce06fcf70c00522e Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:20:07 -0400
Subject: [PATCH 07/13] rederive: name the builds folder relative to the
 project, never through the home folder

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/rederive.py |  7 +++++--
 tests/test_rederive.py    | 12 +++++++++++-
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 12e457b..3e68ff0 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -17,7 +17,6 @@
 
 import hashlib
 import json
-import os
 import random
 import re
 import shutil
@@ -334,7 +333,11 @@ def run(out: Path, builds: Path, split: str = "dev", only: list[str] | None = No
             raise SystemExit(f"targets changed since this run: {', '.join(changed)}")
         targets = {**before, **targets}
     snapshot.write_text(json.dumps(dict(sorted(targets.items())), indent=2, ensure_ascii=False) + "\n")
-    source = os.path.relpath(builds.resolve(), out.resolve())
+    # Named relative to the project, or by folder name: a path relative to --out can climb through the home folder.
+    try:
+        source = str(builds.resolve().relative_to(project_root().resolve()))
+    except ValueError:
+        source = builds.name
     (stage / "source.json").write_text(json.dumps({"builds": source}) + "\n")
 
     def read_job(job):
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 1355559..3700440 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -314,7 +314,17 @@ def test_outputs_hold_no_absolute_paths(monkeypatch, tmp_path):
     rederive.run(out, builds)
     leaks = [p for p in out.rglob("*") if p.is_file() and str(tmp_path) in p.read_text()]
     assert not leaks, leaks
-    assert json.loads((out / "rederive" / "source.json").read_text()) == {"builds": "../builds"}
+    assert json.loads((out / "rederive" / "source.json").read_text()) == {"builds": "builds"}   # outside the project: its name
+
+
+def test_source_names_builds_inside_the_project_relative_to_it(monkeypatch, tmp_path):
+    # A path relative to --out climbs through the home folder when --out is elsewhere (a scratch folder).
+    builds, _, _ = run_fixture(monkeypatch, tmp_path)
+    monkeypatch.setattr(rederive, "project_root", lambda: tmp_path)
+    out = tmp_path.parent / f"{tmp_path.name}-elsewhere" / "deep" / "out"
+    rederive.run(out, builds)
+    assert json.loads((out / "rederive" / "source.json").read_text()) == {"builds": "builds"}
+    assert "Builds: `builds`." in (out / "rederive.md").read_text()
 
 
 def test_builds_folder_is_untouched(monkeypatch, tmp_path):

From 7c29fe5e56e817c1cc4337974350ffcc99911bef Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:21:21 -0400
Subject: [PATCH 08/13] rederive: a human check graded with the same rubric

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 evals/artifact/human-check.md | 49 +++++++++++++++++++++++++++++++++++
 explainer_kit/cli.py          | 21 +++++++++++----
 explainer_kit/rederive.py     | 30 +++++++++++++++++++++
 tests/test_rederive.py        | 28 ++++++++++++++++++++
 4 files changed, 123 insertions(+), 5 deletions(-)
 create mode 100644 evals/artifact/human-check.md

diff --git a/evals/artifact/human-check.md b/evals/artifact/human-check.md
new file mode 100644
index 0000000..67abade
--- /dev/null
+++ b/evals/artifact/human-check.md
@@ -0,0 +1,49 @@
+# Human check for the rederivation eval
+
+The rederivation eval asks a model reader to work out a result that an explanation never states, and a model grader marks each step. This page is for a person who does the same thing, so we can see whether the grader's marks agree with a person's working.
+
+**Who.** A technical reader who is new to the subject: comfortable with school mathematics and science and with basic programming. Someone who already knows the subject well is not the right tester for it.
+
+**What to do.**
+
+1. Pick one subject below that you do not already know well.
+2. The owner sends you one explanation of it: one condition's `explanation.md` or page from the saved builds in `evals/artifact/results/2026-10-04-dev/work/<subject>/<condition>/`. Read it once.
+3. Without looking anything up, work out that subject's question below, on paper or in a text file. Write it as steps. For each step, note which part of the explanation it rests on (a heading, a paragraph, a figure, a control on the page), or "background" when it is something you already knew, such as arithmetic. If the explanation leaves out something you need, say what, and stop there: that gap is useful.
+4. Write down your result.
+
+Do not read `questions.yaml` before you finish: it holds the expected steps and result.
+
+**Send it back** as `evals/artifact/human/<subject>-<condition>.md`, with no name or personal details:
+
+```markdown
+---
+subject: bloom-filter
+condition: principles
+---
+
+1. ... (rests on: the section "Adding an item")
+2. ...
+
+Result: ...
+```
+
+**How it is graded.** With the same rubric and the same grader as the model readers:
+
+```bash
+uv run explainer eval human --builds evals/artifact/results/2026-10-04-dev --chain evals/artifact/human/<subject>-<condition>.md
+```
+
+The marks are saved next to the file. [docs/evals.md](../../docs/evals.md#rederivation) records whether the person's marks agree with the model readers' marks on the same explanation.
+
+## The questions (dev subjects)
+
+- **gps-relativity.** A receiver's own clock is right, but one of the four satellites it uses has a clock 10 nanoseconds fast that nothing corrects. Roughly how wrong is the distance to that satellite, and why can the receiver's fourth unknown not absorb this error the way it absorbs its own clock error?
+- **vaccine-memory.** In a simple model, the immune cells that match an antigen double every 12 hours until there are enough to clear the infection. Vaccination leaves 1,000 times more matching cells than a first infection starts with. About how much sooner does the response reach full strength, and why does the answer not depend on how many cells count as 'enough'?
+- **key-exchange.** Three people, Alice, Bob, and Carol, want one shared secret key, using the same public p and g and sending only messages anyone can read. How can they do it, and why does an eavesdropper still not get the key?
+- **two-tides.** At first and third quarter Moon, the Sun and Moon are at right angles as seen from Earth. How large are the tides then, compared with spring tides?
+- **bloom-filter.** Two Bloom filters have the same size and the same hash functions; one was built from a set A and the other from a set B. How can you get a filter for A ∪ B without the items, and is it exact? What does a bitwise AND of the two give?
+- **heat-pump.** The same machine run in reverse is an air conditioner: it takes heat from the cold inside and gives it to the warm outside. What is its ideal limit on heat removed per unit of electricity, and why is it exactly one less than the heating limit for the same two temperatures?
+- **quorum.** A five-server store uses a write group of W servers and a read group of R servers, not necessarily majorities. What must W and R satisfy for every read to see the latest committed write, and with W = 4 and R = 2, how many failures can writes and reads each survive?
+- **antibiotic-resistance.** In an infection of 10^10 bacteria, one in 10^8 resists drug A and one in 10^9 resists drug B, by unrelated mutations. Why is giving both drugs together much less likely to end with a resistant infection than giving either alone?
+- **float-sum.** Which of these can a double store exactly: 0.375, 0.2, 0.0625, 0.3? And why does adding 0.125 eight times give exactly 1.0, while adding 0.1 ten times does not?
+- **greenhouse.** Suppose the atmosphere had the same temperature at every height. What would adding CO2 then do to the surface temperature, and why?
diff --git a/explainer_kit/cli.py b/explainer_kit/cli.py
index adc7b9f..b97aa97 100644
--- a/explainer_kit/cli.py
+++ b/explainer_kit/cli.py
@@ -238,9 +238,18 @@ def cmd_eval(args) -> None:
     results = project_root() / "evals" / "artifact" / "results"
     stage = dict(split=args.split, only=args.only, model=args.model, reader_model=args.reader_model,
                  workers=args.workers)
+    if args.suite in ("rederive", "human") and not args.builds:
+        raise SystemExit(f"eval {args.suite} needs --builds <an artifact run folder>")
+    if args.suite == "human":
+        if not args.chain:
+            raise SystemExit("eval human needs --chain <a person's working, see evals/artifact/human-check.md>")
+        r = rederive.grade_human(Path(args.chain), Path(args.builds), args.model)
+        t = r["tally"]
+        print(f"human   {r['subject']} ({r['condition']}): {t['supported']}/{t['counted']} steps supported, "
+              f"result {'right' if r['result_right'] else 'stated' if r['result_stated'] else 'wrong'}   "
+              f"{', '.join(r['marks'])}")
+        return
     if args.suite == "rederive":
-        if not args.builds:
-            raise SystemExit("eval rederive needs --builds <an artifact run folder>")
         out = Path(args.out) if args.out else results / f"{date.today().isoformat()}-{args.split}-rederive"
         rederive.run(out, Path(args.builds), **stage)
         return
@@ -357,9 +366,11 @@ def main() -> None:
     p = sub.add_parser("eval", help="chat: answers under several system prompts; artifact: explainers built under "
                                      "several conditions, read and graded blind (then the rederivation stage); "
                                      "targets: check the rederivation targets; rederive: the rederivation stage on "
-                                     "an earlier artifact run's builds")
-    p.add_argument("suite", choices=["chat", "artifact", "targets", "rederive"])
-    p.add_argument("--builds", help="rederive: the artifact run folder whose builds are read (it is not changed)")
+                                     "an earlier artifact run's builds; human: grade a person's working")
+    p.add_argument("suite", choices=["chat", "artifact", "targets", "rederive", "human"])
+    p.add_argument("--builds", help="rederive, human: the artifact run folder whose builds are read (it is not "
+                                    "changed)")
+    p.add_argument("--chain", help="human: a person's working, as in evals/artifact/human-check.md")
     p.add_argument("--conditions", nargs="+",
                    help="name=source; source is none, principles, git:<rev>, or a file; for artifact also quick or "
                         "published (the explain skill at that tier). Default: chat none v0.5 v0.6; artifact none "
diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 3e68ff0..095089a 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -25,6 +25,8 @@
 from datetime import date
 from pathlib import Path
 
+import yaml
+
 from explainer_kit import agent
 from explainer_kit import artifact_eval as ae
 from explainer_kit.evals import words
@@ -430,3 +432,31 @@ def mean_words(n: str) -> str:
         cells = [", ".join(f"{tallies[k][n][i]['supported']}/{tallies[k][n][i]['counted']}" for k in ks) for n in names]
         lines.append(f"| {s['id']} | " + " | ".join(cells) + " |")
     return "\n".join(lines) + "\n"
+
+
+# ---------------------------------------------------------------- a person's working
+
+def grade_human(chain_file: Path, builds: Path, model: str | None = None) -> dict:
+    """Grades a person's working (evals/artifact/human-check.md) with the same rubric as a model reader's. The file
+    is Markdown with front matter naming the subject and the condition whose explanation the person read."""
+    m = re.match(r"---\n(.*?)\n---\n(.*)", chain_file.read_text(), re.S)
+    meta = (yaml.safe_load(m.group(1)) or {}) if m else {}
+    if not m or "subject" not in meta or "condition" not in meta:
+        raise SystemExit(f"{chain_file.name}: needs front matter with subject and condition")
+    reader, subjects = ae.load("all", [meta["subject"]])
+    if not subjects or not subjects[0].get("rederive"):
+        raise SystemExit(f"no subject {meta['subject']!r} with a rederivation target")
+    s, cond = subjects[0], meta["condition"]
+    files = ae.renderings(builds / "work" / s["id"] / cond, s["id"])
+    if not files:
+        raise SystemExit(f"no explanation for {s['id']} under {cond!r} in {builds.name}")
+    entries = {"A": {"text": "\n\n".join(grader_text(f) for f in files), "chain": m.group(2).strip()}}
+    reply = agent.parse_json(agent.ask(ae.GRADER_SYSTEM, grade_prompt(s, reader, entries), model=model))
+    g = (reply.get("grades") or {}).get("A")
+    g = g if isinstance(g, dict) else {}
+    kinds = [step["kind"] for step in s["rederive"]["steps"]]
+    mk, right, stated = marks(g.get("marks"), kinds), g.get("result_right") is True, g.get("result_stated") is True
+    result = {"subject": s["id"], "condition": cond, "marks": mk, "result_right": right, "result_stated": stated,
+              "tally": tally(mk, kinds, right, stated)}
+    chain_file.with_suffix(".grade.json").write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n")
+    return result
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 3700440..709e3b4 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -356,3 +356,31 @@ def test_cli_rederive_and_artifact_call_the_stage(monkeypatch, tmp_path):
     monkeypatch.setattr(sys, "argv", ["explainer", "eval", "artifact", "--out", str(o)])
     cli.main()
     assert seen == [("artifact", o), ("rederive", o, o)]
+
+
+def test_grade_human_uses_the_same_rubric(monkeypatch, tmp_path):
+    builds, _, _ = run_fixture(monkeypatch, tmp_path)
+    chain = tmp_path / "s1-a.md"
+    chain.write_text("---\nsubject: s1\ncondition: a\n---\n\nIdea one gives idea two, so three.\n")
+    seen = []
+
+    def ask(system, prompt, model=None, **kw):
+        seen.append(prompt)
+        return json.dumps({"grades": {"A": {"marks": ["supported", "unsupported", "missing"], "result_right": True,
+                                            "result_stated": False}}})
+
+    monkeypatch.setattr(agent, "ask", ask)
+    r = rederive.grade_human(chain, builds)
+    assert rederive.OUTSIDE_RULE in seen[0] and "Idea one gives idea two, so three." in seen[0] and "ALPHA" in seen[0]
+    kinds = [s["kind"] for s in TARGET["steps"]]
+    assert r["tally"] == rederive.tally(["supported", "unsupported", "missing"], kinds, True, False)
+    assert json.loads((tmp_path / "s1-a.grade.json").read_text()) == r
+    assert r["subject"] == "s1" and r["condition"] == "a"
+
+
+def test_human_check_lists_only_questions():
+    text = (ROOT / "evals" / "artifact" / "human-check.md").read_text()
+    for s in ae.load("dev")[1]:
+        if "rederive" in s:
+            assert s["rederive"]["q"] in text, s["id"]
+            assert all(step["text"] not in text for step in s["rederive"]["steps"]) and s["rederive"]["result"] not in text

From 67fe861e340a558243560426e7237bbd29084c17 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:32:49 -0400
Subject: [PATCH 09/13] Rederivation dev baseline on the v0.8 builds: three
 passes

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 .../rederive-scores.json                      | 1188 +++++++++++++++++
 .../2026-10-20-dev-rederive/rederive.md       |   29 +
 .../pass-1/grades/antibiotic-resistance.json  |   50 +
 .../rederive/pass-1/grades/bloom-filter.json  |   50 +
 .../rederive/pass-1/grades/float-sum.json     |   50 +
 .../pass-1/grades/gps-relativity.json         |   50 +
 .../rederive/pass-1/grades/greenhouse.json    |   50 +
 .../rederive/pass-1/grades/heat-pump.json     |   50 +
 .../rederive/pass-1/grades/key-exchange.json  |   54 +
 .../rederive/pass-1/grades/quorum.json        |   50 +
 .../rederive/pass-1/grades/two-tides.json     |   50 +
 .../pass-1/grades/vaccine-memory.json         |   50 +
 .../read/antibiotic-resistance/none.json      |   36 +
 .../antibiotic-resistance/principles.json     |   41 +
 .../read/antibiotic-resistance/published.json |   36 +
 .../read/antibiotic-resistance/quick.json     |   36 +
 .../pass-1/read/bloom-filter/none.json        |   46 +
 .../pass-1/read/bloom-filter/principles.json  |   41 +
 .../pass-1/read/bloom-filter/published.json   |   36 +
 .../pass-1/read/bloom-filter/quick.json       |   46 +
 .../rederive/pass-1/read/float-sum/none.json  |   41 +
 .../pass-1/read/float-sum/principles.json     |   36 +
 .../pass-1/read/float-sum/published.json      |   46 +
 .../rederive/pass-1/read/float-sum/quick.json |   41 +
 .../pass-1/read/gps-relativity/none.json      |   31 +
 .../read/gps-relativity/principles.json       |   31 +
 .../pass-1/read/gps-relativity/published.json |   36 +
 .../pass-1/read/gps-relativity/quick.json     |   36 +
 .../rederive/pass-1/read/greenhouse/none.json |   41 +
 .../pass-1/read/greenhouse/principles.json    |   31 +
 .../pass-1/read/greenhouse/published.json     |   41 +
 .../pass-1/read/greenhouse/quick.json         |   36 +
 .../rederive/pass-1/read/heat-pump/none.json  |   46 +
 .../pass-1/read/heat-pump/principles.json     |   41 +
 .../pass-1/read/heat-pump/published.json      |   36 +
 .../rederive/pass-1/read/heat-pump/quick.json |   36 +
 .../pass-1/read/key-exchange/none.json        |   51 +
 .../pass-1/read/key-exchange/principles.json  |   46 +
 .../pass-1/read/key-exchange/published.json   |   51 +
 .../pass-1/read/key-exchange/quick.json       |   56 +
 .../rederive/pass-1/read/quorum/none.json     |   36 +
 .../pass-1/read/quorum/principles.json        |   36 +
 .../pass-1/read/quorum/published.json         |   41 +
 .../rederive/pass-1/read/quorum/quick.json    |   31 +
 .../rederive/pass-1/read/two-tides/none.json  |   36 +
 .../pass-1/read/two-tides/principles.json     |   36 +
 .../pass-1/read/two-tides/published.json      |   36 +
 .../rederive/pass-1/read/two-tides/quick.json |   36 +
 .../pass-1/read/vaccine-memory/none.json      |   36 +
 .../read/vaccine-memory/principles.json       |   36 +
 .../pass-1/read/vaccine-memory/published.json |   36 +
 .../pass-1/read/vaccine-memory/quick.json     |   36 +
 .../pass-2/grades/antibiotic-resistance.json  |   50 +
 .../rederive/pass-2/grades/bloom-filter.json  |   50 +
 .../rederive/pass-2/grades/float-sum.json     |   50 +
 .../pass-2/grades/gps-relativity.json         |   50 +
 .../rederive/pass-2/grades/greenhouse.json    |   50 +
 .../rederive/pass-2/grades/heat-pump.json     |   50 +
 .../rederive/pass-2/grades/key-exchange.json  |   54 +
 .../rederive/pass-2/grades/quorum.json        |   50 +
 .../rederive/pass-2/grades/two-tides.json     |   50 +
 .../pass-2/grades/vaccine-memory.json         |   50 +
 .../read/antibiotic-resistance/none.json      |   41 +
 .../antibiotic-resistance/principles.json     |   26 +
 .../read/antibiotic-resistance/published.json |   36 +
 .../read/antibiotic-resistance/quick.json     |   31 +
 .../pass-2/read/bloom-filter/none.json        |   41 +
 .../pass-2/read/bloom-filter/principles.json  |   46 +
 .../pass-2/read/bloom-filter/published.json   |   41 +
 .../pass-2/read/bloom-filter/quick.json       |   36 +
 .../rederive/pass-2/read/float-sum/none.json  |   46 +
 .../pass-2/read/float-sum/principles.json     |   41 +
 .../pass-2/read/float-sum/published.json      |   41 +
 .../rederive/pass-2/read/float-sum/quick.json |   36 +
 .../pass-2/read/gps-relativity/none.json      |   36 +
 .../read/gps-relativity/principles.json       |   31 +
 .../pass-2/read/gps-relativity/published.json |   36 +
 .../pass-2/read/gps-relativity/quick.json     |   31 +
 .../rederive/pass-2/read/greenhouse/none.json |   36 +
 .../pass-2/read/greenhouse/principles.json    |   36 +
 .../pass-2/read/greenhouse/published.json     |   36 +
 .../pass-2/read/greenhouse/quick.json         |   36 +
 .../rederive/pass-2/read/heat-pump/none.json  |   36 +
 .../pass-2/read/heat-pump/principles.json     |   36 +
 .../pass-2/read/heat-pump/published.json      |   36 +
 .../rederive/pass-2/read/heat-pump/quick.json |   41 +
 .../pass-2/read/key-exchange/none.json        |   51 +
 .../pass-2/read/key-exchange/principles.json  |   41 +
 .../pass-2/read/key-exchange/published.json   |   41 +
 .../pass-2/read/key-exchange/quick.json       |   51 +
 .../rederive/pass-2/read/quorum/none.json     |   36 +
 .../pass-2/read/quorum/principles.json        |   36 +
 .../pass-2/read/quorum/published.json         |   21 +
 .../rederive/pass-2/read/quorum/quick.json    |   31 +
 .../rederive/pass-2/read/two-tides/none.json  |   36 +
 .../pass-2/read/two-tides/principles.json     |   36 +
 .../pass-2/read/two-tides/published.json      |   26 +
 .../rederive/pass-2/read/two-tides/quick.json |   36 +
 .../pass-2/read/vaccine-memory/none.json      |   41 +
 .../read/vaccine-memory/principles.json       |   26 +
 .../pass-2/read/vaccine-memory/published.json |   31 +
 .../pass-2/read/vaccine-memory/quick.json     |   31 +
 .../pass-3/grades/antibiotic-resistance.json  |   50 +
 .../rederive/pass-3/grades/bloom-filter.json  |   50 +
 .../rederive/pass-3/grades/float-sum.json     |   50 +
 .../pass-3/grades/gps-relativity.json         |   50 +
 .../rederive/pass-3/grades/greenhouse.json    |   50 +
 .../rederive/pass-3/grades/heat-pump.json     |   50 +
 .../rederive/pass-3/grades/key-exchange.json  |   54 +
 .../rederive/pass-3/grades/quorum.json        |   50 +
 .../rederive/pass-3/grades/two-tides.json     |   50 +
 .../pass-3/grades/vaccine-memory.json         |   50 +
 .../read/antibiotic-resistance/none.json      |   36 +
 .../antibiotic-resistance/principles.json     |   41 +
 .../read/antibiotic-resistance/published.json |   36 +
 .../read/antibiotic-resistance/quick.json     |   41 +
 .../pass-3/read/bloom-filter/none.json        |   41 +
 .../pass-3/read/bloom-filter/principles.json  |   36 +
 .../pass-3/read/bloom-filter/published.json   |   41 +
 .../pass-3/read/bloom-filter/quick.json       |   36 +
 .../rederive/pass-3/read/float-sum/none.json  |   46 +
 .../pass-3/read/float-sum/principles.json     |   46 +
 .../pass-3/read/float-sum/published.json      |   46 +
 .../rederive/pass-3/read/float-sum/quick.json |   36 +
 .../pass-3/read/gps-relativity/none.json      |   36 +
 .../read/gps-relativity/principles.json       |   36 +
 .../pass-3/read/gps-relativity/published.json |   36 +
 .../pass-3/read/gps-relativity/quick.json     |   31 +
 .../rederive/pass-3/read/greenhouse/none.json |   41 +
 .../pass-3/read/greenhouse/principles.json    |   31 +
 .../pass-3/read/greenhouse/published.json     |   41 +
 .../pass-3/read/greenhouse/quick.json         |   26 +
 .../rederive/pass-3/read/heat-pump/none.json  |   36 +
 .../pass-3/read/heat-pump/principles.json     |   36 +
 .../pass-3/read/heat-pump/published.json      |   36 +
 .../rederive/pass-3/read/heat-pump/quick.json |   36 +
 .../pass-3/read/key-exchange/none.json        |   51 +
 .../pass-3/read/key-exchange/principles.json  |   46 +
 .../pass-3/read/key-exchange/published.json   |   46 +
 .../pass-3/read/key-exchange/quick.json       |   46 +
 .../rederive/pass-3/read/quorum/none.json     |   36 +
 .../pass-3/read/quorum/principles.json        |   36 +
 .../pass-3/read/quorum/published.json         |   41 +
 .../rederive/pass-3/read/quorum/quick.json    |   36 +
 .../rederive/pass-3/read/two-tides/none.json  |   41 +
 .../pass-3/read/two-tides/principles.json     |   36 +
 .../pass-3/read/two-tides/published.json      |   26 +
 .../rederive/pass-3/read/two-tides/quick.json |   26 +
 .../pass-3/read/vaccine-memory/none.json      |   36 +
 .../read/vaccine-memory/principles.json       |   36 +
 .../pass-3/read/vaccine-memory/published.json |   31 +
 .../pass-3/read/vaccine-memory/quick.json     |   31 +
 .../rederive/source.json                      |    1 +
 .../rederive/targets.json                     |  226 ++++
 154 files changed, 7481 insertions(+)
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive-scores.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive.md
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/antibiotic-resistance.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/bloom-filter.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/float-sum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/gps-relativity.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/greenhouse.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/heat-pump.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/key-exchange.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/quorum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/two-tides.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/vaccine-memory.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/antibiotic-resistance.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/bloom-filter.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/float-sum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/gps-relativity.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/greenhouse.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/heat-pump.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/key-exchange.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/quorum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/two-tides.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/vaccine-memory.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/antibiotic-resistance.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/bloom-filter.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/float-sum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/gps-relativity.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/greenhouse.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/heat-pump.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/key-exchange.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/quorum.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/two-tides.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/vaccine-memory.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/none.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/principles.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/published.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/quick.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/source.json
 create mode 100644 evals/artifact/results/2026-10-20-dev-rederive/rederive/targets.json

diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive-scores.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive-scores.json
new file mode 100644
index 0000000..ab108d1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive-scores.json
@@ -0,0 +1,1188 @@
+{
+  "passes": [
+    {
+      "none": {
+        "supported": 1.0,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "principles": {
+        "supported": 0.9459459459459459,
+        "raw": 0.972972972972973,
+        "result": 0.8888888888888888
+      },
+      "quick": {
+        "supported": 0.9230769230769231,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "published": {
+        "supported": 0.9473684210526315,
+        "raw": 0.9736842105263158,
+        "result": 0.8888888888888888
+      }
+    },
+    {
+      "none": {
+        "supported": 1.0,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "principles": {
+        "supported": 1.0,
+        "raw": 1.0,
+        "result": 0.8888888888888888
+      },
+      "quick": {
+        "supported": 1.0,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "published": {
+        "supported": 0.9473684210526315,
+        "raw": 0.9736842105263158,
+        "result": 0.7777777777777778
+      }
+    },
+    {
+      "none": {
+        "supported": 1.0,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "principles": {
+        "supported": 0.9722222222222222,
+        "raw": 1.0,
+        "result": 1.0
+      },
+      "quick": {
+        "supported": 0.8974358974358975,
+        "raw": 0.9230769230769231,
+        "result": 0.8888888888888888
+      },
+      "published": {
+        "supported": 0.9473684210526315,
+        "raw": 1.0,
+        "result": 0.8888888888888888
+      }
+    }
+  ],
+  "tallies": {
+    "1": {
+      "none": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        }
+      ],
+      "principles": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "quick": [
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "published": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ]
+    },
+    "2": {
+      "none": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        }
+      ],
+      "principles": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "quick": [
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "published": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 3,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ]
+    },
+    "3": {
+      "none": [
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        }
+      ],
+      "principles": [
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "quick": [
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 1,
+          "made": 1,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 3,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ],
+      "published": [
+        {
+          "supported": 3,
+          "made": 3,
+          "counted": 3,
+          "stated": 1,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 5,
+          "made": 5,
+          "counted": 5,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 0,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 4,
+          "made": 4,
+          "counted": 4,
+          "stated": 0,
+          "right": 1,
+          "results": 1,
+          "results_stated": 0
+        },
+        {
+          "supported": 2,
+          "made": 2,
+          "counted": 2,
+          "stated": 2,
+          "right": 0,
+          "results": 0,
+          "results_stated": 1
+        }
+      ]
+    }
+  },
+  "separations": [
+    [
+      "none",
+      "published"
+    ]
+  ]
+}
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive.md b/evals/artifact/results/2026-10-20-dev-rederive/rederive.md
new file mode 100644
index 0000000..7bf5bb5
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive.md
@@ -0,0 +1,29 @@
+# Rederivation, 2026-10-20 (dev, 10 subjects)
+
+Builds: `evals/artifact/results/2026-10-04-dev`. Reader and grader: fresh `claude -p` agents. The reader saw only the renderings and the target's question; the grader saw each subject's explanations and the readers' working under shuffled labels. 3 passes: each a fresh reader run over every build, graded once under its own shuffle.
+
+| condition | supported | raw | result right | stated steps | stated results | words | quiz (grounded) |
+|---|---|---|---|---|---|---|---|
+| none | 100%, 100%, 100% | 100%, 100%, 100% | 100%, 100%, 100% | 2, 2, 3 | 0, 0, 1 | 1689 | 100% |
+| principles | 95%, 100%, 97% | 97%, 100%, 100% | 89%, 89%, 100% | 4, 4, 5 | 1, 1, 2 | 1006 | 99% |
+| quick | 92%, 100%, 90% | 100%, 100%, 92% | 100%, 100%, 89% | 2, 2, 2 | 1, 1, 1 | 606 | 95% |
+| published | 95%, 95%, 95% | 97%, 97%, 100% | 89%, 78%, 89% | 3, 3, 3 | 1, 1, 1 | 1016 | 95% |
+
+Separation (higher supported score in all three passes): none > published.
+
+Each cell lists the passes in order. Supported: the share of expected steps the reader made and grounded in a part of the explanation it named (or in background this reader has); raw: the share made at all; result right: the share of results that match. Stated steps and stated results: derived steps and results the explanation states outright, left out of the shares above. Words: visible words per explanation. Quiz: the grounded quiz score of the same builds.
+
+## Per subject (supported/counted steps, per pass)
+
+| subject | none | principles | quick | published |
+|---|---|---|---|---|
+| gps-relativity | 3/3, 3/3, 2/2 | 3/3, 3/3, 2/2 | 4/4, 4/4, 4/4 | 3/3, 3/3, 3/3 |
+| vaccine-memory | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 |
+| key-exchange | 5/5, 5/5, 5/5 | 5/5, 5/5, 5/5 | 5/5, 5/5, 5/5 | 5/5, 5/5, 5/5 |
+| two-tides | 3/3, 3/3, 3/3 | 3/3, 3/3, 3/3 | 3/4, 4/4, 1/4 | 3/4, 2/4, 2/4 |
+| bloom-filter | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 |
+| heat-pump | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 |
+| quorum | 4/4, 4/4, 4/4 | 3/4, 4/4, 3/4 | 3/4, 4/4, 3/4 | 4/4, 4/4, 4/4 |
+| antibiotic-resistance | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 | 4/4, 4/4, 4/4 |
+| float-sum | 4/4, 4/4, 4/4 | 3/4, 4/4, 4/4 | 3/4, 4/4, 4/4 | 3/4, 4/4, 4/4 |
+| greenhouse | 4/4, 4/4, 4/4 | 2/2, 2/2, 2/2 | 2/2, 2/2, 2/2 | 2/2, 2/2, 2/2 |
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/antibiotic-resistance.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/antibiotic-resistance.json
new file mode 100644
index 0000000..01355b3
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/antibiotic-resistance.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "quick",
+    "B": "published",
+    "C": "principles",
+    "D": "none"
+  },
+  "grades": {
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/bloom-filter.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/bloom-filter.json
new file mode 100644
index 0000000..38b001b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/bloom-filter.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "quick",
+    "C": "principles",
+    "D": "none"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/float-sum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/float-sum.json
new file mode 100644
index 0000000..fb0f186
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/float-sum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "quick",
+    "C": "published",
+    "D": "none"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "missing"
+      ],
+      "result_right": false,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "unsupported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "missing"
+      ],
+      "result_right": false,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/gps-relativity.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/gps-relativity.json
new file mode 100644
index 0000000..fe1eea1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/gps-relativity.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "none",
+    "C": "quick",
+    "D": "principles"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/greenhouse.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/greenhouse.json
new file mode 100644
index 0000000..81b5bb7
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/greenhouse.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "none",
+    "C": "quick",
+    "D": "published"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/heat-pump.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/heat-pump.json
new file mode 100644
index 0000000..bd84120
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/heat-pump.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "principles",
+    "C": "quick",
+    "D": "none"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/key-exchange.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/key-exchange.json
new file mode 100644
index 0000000..4639ece
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/key-exchange.json
@@ -0,0 +1,54 @@
+{
+  "key": {
+    "A": "none",
+    "B": "quick",
+    "C": "principles",
+    "D": "published"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/quorum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/quorum.json
new file mode 100644
index 0000000..310eb52
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/quorum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "none",
+    "C": "published",
+    "D": "quick"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/two-tides.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/two-tides.json
new file mode 100644
index 0000000..ba4f665
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/two-tides.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "quick",
+    "B": "published",
+    "C": "none",
+    "D": "principles"
+  },
+  "grades": {
+    "quick": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/vaccine-memory.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/vaccine-memory.json
new file mode 100644
index 0000000..9e4cb48
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/grades/vaccine-memory.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "principles",
+    "C": "none",
+    "D": "quick"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/none.json
new file mode 100644
index 0000000..40ebbb4
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Before any drug is given, the infection already contains about 10^10 / 10^8 = 100 cells resistant to A and about 10^10 / 10^9 = 10 cells resistant to B.",
+      "part": "Section 3a, 'Mutation', including the 'Quick estimate' box",
+      "idea": "Resistant mutants appear at random before the drug is given. To get the expected number, divide the population size by 1 over the mutation frequency (10^10 / 10^8 = 100). The page's last 'What to try' bullet says the same thing: resistance is a numbers game of population size × mutation rate."
+    },
+    {
+      "step": "Giving drug A alone kills the susceptible cells but spares the roughly 100 A-resistant cells. Those survivors multiply until they make up most of the infection. Drug B alone does the same thing with its roughly 10 B-resistant cells.",
+      "part": "Section 4, 'Selection', and the 'A toy calculation' paragraph; the short answer, points 2 and 3",
+      "idea": "The drug removes the competition. Exponential growth then turns a handful of survivors (100 × 2^20 ≈ 10^8 in 10 hours) into most of the population, so a starting count of even 10 or 100 cells is plenty."
+    },
+    {
+      "step": "When both drugs are given together, only a cell resistant to both drugs survives. A cell resistant to A alone is still killed by B, and a cell resistant to B alone is still killed by A.",
+      "part": "Section 8, 'Combine drugs, sometimes'",
+      "idea": "With a combination, the cell that matters is one that is resistant to both drugs."
+    },
+    {
+      "step": "The mutations are unrelated, so the chance that one cell carries both is the product of the two chances: 10^-8 × 10^-9 = 10^-17.",
+      "part": "Section 8, 'Combine drugs, sometimes', plus background (multiplying probabilities of independent events)",
+      "idea": "The section works the same example with two rates of 1 in 10^8: a cell resistant to both arises by chance only about 1 in 10^16 times."
+    },
+    {
+      "step": "The expected number of doubly resistant cells is 10^10 × 10^-17 = 10^-7. In practice that means almost certainly none, about a 1-in-10-million chance of even one.",
+      "part": "Steps 1 and 4; Section 8 ('more cells than are in the infection')",
+      "idea": "10^17 is far more than the 10^10 cells present, so there is almost certainly no doubly resistant cell for the drugs to select."
+    },
+    {
+      "step": "With no resistant cell present, the treatment wipes out the population.",
+      "part": "index.html, 'What to try' bullet 'Lower the mutation rate to 10⁻¹⁰' and the readout text for the case where every cell dies",
+      "idea": "If no resistant cell exists when the drug arrives, treatment succeeds. Selection only works when a resistant cell is already there for it to act on."
+    }
+  ],
+  "result": "Either drug alone faces cells that already resist it: about 100 resistant to A, or about 10 resistant to B. The drug kills everything else, and those few survivors multiply until they take over. With both drugs, a cell must resist both to survive. The mutations are unrelated, so that chance is 10^-8 × 10^-9 = 10^-17 per cell. In 10^10 cells that means about 10^-7 doubly resistant cells, almost certainly none. With no doubly resistant cell for the drugs to select, the combination clears the infection. That makes ending with a resistant infection about ten million times less likely than with either drug alone.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/principles.json
new file mode 100644
index 0000000..710fc80
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Growing an infection to 10^10 bacteria takes about 10^10 cell divisions, and each division is a chance for a copying error.",
+      "part": "Section 3, 'Mutation', worked example",
+      "idea": "Going from one cell to 10^10 cells takes about 10^10 divisions. Resistance mutations are rare errors made while the cell copies its DNA."
+    },
+    {
+      "step": "With drug A alone, about 10^10 × 1/10^8 = 100 cells already resist A before the first dose. With drug B alone, about 10^10 × 1/10^9 = 10 cells resist B.",
+      "part": "Section 3, 'Mutation', worked example; and step 1",
+      "idea": "Expected number of resistant cells = number of divisions × mutation rate. These cells exist before treatment starts; the drug does not create them."
+    },
+    {
+      "step": "With either drug alone, those few resistant cells survive and grow back into a resistant infection.",
+      "part": "Section 4, 'How the drug makes resistance common'",
+      "idea": "The drug kills the susceptible cells. The resistant cells are not affected and keep doubling (100 × 2^24 ≈ 1.7 × 10^9 in a day), so resistance takes over. Even 10 B-resistant cells are enough to start this."
+    },
+    {
+      "step": "When both drugs are given together, a cell survives only if it resists both, so it needs both unrelated mutations.",
+      "part": "Section 4, 'Dose controls which cells survive', last paragraph",
+      "idea": "Some treatments use two drugs at once because a cell would need two independent mutations to survive both."
+    },
+    {
+      "step": "Because the two mutations are independent, their rates multiply: 1/10^8 × 1/10^9 = 1 in 10^17 divisions.",
+      "part": "Section 4, 'Dose controls which cells survive', last paragraph (the 1 in 10^8 × 1 in 10^8 = 1 in 10^16 example)",
+      "idea": "The chance of a cell having two independent mutations is the product of the two rates. I used the question's rates in place of the explanation's example numbers."
+    },
+    {
+      "step": "The expected number of cells that resist both drugs is 10^10 × 10^-17 = 10^-7. In practice that is almost certainly zero.",
+      "part": "Steps 1 and 5; background (arithmetic)",
+      "idea": "10^17 divisions would be needed to expect one double mutant, which is far more than the 10^10 divisions in the whole infection."
+    },
+    {
+      "step": "With no cell that resists both drugs, the combination kills every cell, and nothing is left to be selected and grow back.",
+      "part": "Section 4 (selection only multiplies cells that already exist); step 6",
+      "idea": "Selection can only enrich cells that are already there. One drug faces about 100 or 10 survivors; two drugs face about one chance in 10 million that a single survivor exists."
+    }
+  ],
+  "result": "Given alone, drug A faces about 100 cells that already resist it (10^10 × 10^-8), and drug B faces about 10 (10^10 × 10^-9). The drug kills everything else, and those few cells multiply into a resistant infection. Given together, the drugs kill any cell that resists only one of them. A cell survives only if it carries both unrelated mutations, and because they are independent that happens about once in 10^8 × 10^9 = 10^17 divisions. An infection of 10^10 cells is expected to hold only about 10^-7 such cells, roughly a 1-in-10-million chance that even one exists. So the combination almost certainly leaves nothing to select. One caveat from the explanation: a single plasmid passed between bacteria can carry several resistance genes at once, so this argument holds only when the two resistances come from separate mutations, as the question states.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/published.json
new file mode 100644
index 0000000..78fbec3
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Before any drug, the 10^10-cell infection already holds about 10^10 × 10^-8 = 100 cells resistant to A, and about 10^10 × 10^-9 = 10 cells resistant to B.",
+      "part": "Resistant cells are there before the drug",
+      "idea": "Growing to 10^10 cells takes about 10^10 divisions. Expected number of resistant mutants = number of divisions × chance of the mutation per division, and they exist before treatment starts."
+    },
+    {
+      "step": "So giving A alone, or B alone, almost certainly leaves some resistant cells, and the drug selects them: they regrow into a resistant infection.",
+      "part": "The drug selects them",
+      "idea": "The drug removes the susceptible cells. The resistant cells keep dividing (100 cells need about 27 doublings to reach 10^10 again), and the infection comes back almost entirely resistant."
+    },
+    {
+      "step": "To survive both drugs together, one cell must carry both mutations. The mutations are unrelated, so their chances multiply: 10^-8 × 10^-9 = 10^-17 per cell.",
+      "part": "What this predicts (combination bullet)",
+      "idea": "Two drugs with independent targets need two independent mutations in the same cell, so the probabilities multiply. The explanation's example uses 10^-8 × 10^-8; I applied the same rule to 10^-9."
+    },
+    {
+      "step": "Expected number of cells resistant to both: 10^10 × 10^-17 = 10^-7, so about a one-in-ten-million chance that even one such cell exists.",
+      "part": "Step 3; background arithmetic",
+      "idea": "Multiply the population size by the per-cell chance, as the explanation does to get 10^-6 in its own example."
+    },
+    {
+      "step": "With almost certainly no cell resistant to both, the combination kills or stops every cell, including the single-drug mutants: cells resistant to A are still stopped by B, and the other way round. The treatment clears the infection.",
+      "part": "What this predicts (combination bullet); The drug selects them",
+      "idea": "Selection can only work on resistant cells that already exist. If no cell resists both drugs, nothing survives to regrow."
+    },
+    {
+      "step": "Caveat: this only holds if the two resistances really are separate events. If one plasmid carries both genes, or one pump exports both drugs, a single event gives resistance to both, and about as many cells survive as with one drug.",
+      "part": "What this predicts (combination bullet); Genes from other bacteria",
+      "idea": "A single event giving resistance to both drugs means the chances no longer multiply, and plasmids often carry several resistance genes."
+    }
+  ],
+  "result": "Used alone, either drug faces resistant cells that are already there: about 100 that resist A and about 10 that resist B in 10^10 cells. The drug clears the susceptible cells and those resistant cells regrow. Used together, a cell survives only if it carries both unrelated mutations. That chance is 10^-8 × 10^-9 = 10^-17 per cell, so only about 10^-7 such cells are expected in 10^10. Almost certainly no cell resists both, so the combination clears the infection. This only works as long as no single plasmid or pump gives resistance to both drugs.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/quick.json
new file mode 100644
index 0000000..ebee5cc
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/antibiotic-resistance/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A resistant cell must already exist before the drug is given; the drug only selects the cells that are already resistant, and they then regrow the infection.",
+      "part": "Step 2: the antibiotic selects the resistant cells; Why selection, and not adaptation",
+      "idea": "Survivors were resistant before they met the drug. When the drug kills the susceptible cells, about 10 resistant cells can rebuild 10^10 in about 30 doublings. So the outcome depends on whether any resistant cell is present at the start."
+    },
+    {
+      "step": "Drug A alone: the expected number of A-resistant cells is 10^10 × 10^-8 = 100, so the infection almost certainly comes back resistant.",
+      "part": "Step 2 worked numbers (multiply the population by the frequency)",
+      "idea": "Expected resistant cells = population × chance per cell. Here that is 100, far more than 1."
+    },
+    {
+      "step": "Drug B alone: 10^10 × 10^-9 = 10 expected resistant cells, which is again enough to regrow a resistant infection.",
+      "part": "Step 2 worked numbers",
+      "idea": "This is the same calculation as the explanation's own example, which gives 10 survivors."
+    },
+    {
+      "step": "Both drugs together: a cell survives only if it resists both, which needs two independent rare events, so the chances multiply: 10^-8 × 10^-9 = 10^-17 per cell.",
+      "part": "What follows from this: 'Two drugs at once help'",
+      "idea": "Two independent rare events are both needed, so their probabilities multiply (the explanation's example is 10^-9 × 10^-9)."
+    },
+    {
+      "step": "Expected doubly resistant cells = 10^10 × 10^-17 = 10^-7, which is effectively zero. No cell is there to be selected, so the drugs clear the infection.",
+      "part": "What follows from this (combination) together with the small-population prediction in Step 2",
+      "idea": "When the expected count is far below 1, usually no resistant cell exists, and the drug clears the infection."
+    },
+    {
+      "step": "Caveat: this holds only because the mutations are unrelated. One plasmid carrying both resistance genes would break the multiplication.",
+      "part": "What follows from this: 'This fails if one plasmid carries both resistance genes'; Step 1 gene transfer",
+      "idea": "A single transfer can give resistance to several drugs at once, so the two events would no longer be independent."
+    }
+  ],
+  "result": "With one drug, about 100 cells already resist A (or about 10 resist B) before treatment. The drug kills the rest, and those survivors regrow a resistant infection. With both drugs, a survivor must resist both. The two mutations are independent, so the chances multiply to 10^-17 per cell, and the expected number of doubly resistant cells is 10^10 × 10^-17 = 10^-7. In practice no such cell exists to be selected, so the combination clears the infection. That is about 10^8 to 10^9 times less likely to fail than either drug alone, provided no single plasmid carries both resistance genes.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/none.json
new file mode 100644
index 0000000..7ce8aab
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/none.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "For a filter built from a set S, bit i is 1 exactly when at least one item of S has i among its k positions. Otherwise it stays 0.",
+      "part": "Section 2, 'The machinery: bits and hash functions' (the Add rule in the highlighted box)",
+      "idea": "Adding an item sets its k bits to 1. A bit that is already 1 stays 1, and bits never go back to 0. So the final array depends only on which positions the items hit, not on the order they were added."
+    },
+    {
+      "step": "Same size and same hash functions mean each item maps to the same positions in both filters, so their bit positions mean the same thing.",
+      "part": "Section 2 (k hash functions taken modulo m) and the script's kSel handler",
+      "idea": "An item's positions come from the hash functions and m. The script rebuilds the filter when k changes, because the old bits no longer mean anything. So the two filters can only be combined bit by bit if m and the hashes match."
+    },
+    {
+      "step": "Bitwise OR of filter A and filter B gives exactly the filter you would get by adding every item of A ∪ B.",
+      "part": "Steps 1 and 2 + background (Boolean OR)",
+      "idea": "In the OR, bit i is 1 if some item of A or some item of B hits i. That is the same as some item of A ∪ B hitting i, which is the rule from step 1. No items are needed, only the two bit arrays."
+    },
+    {
+      "step": "So the union is exact in the sense that it matches a directly built filter bit for bit. It still answers like any Bloom filter: no false negatives, some false positives. Its rate follows the fraction of 1s, with n = |A ∪ B|.",
+      "part": "Section 4, 'How it can be wrong', and Section 5, Step 2 (rate ≈ f^k)",
+      "idea": "It is the normal filter for A ∪ B, so it has the normal one-way error. Because it is more full than either input, its false positive rate is higher. If it is overfilled, the error rises steeply (Section 6)."
+    },
+    {
+      "step": "Bitwise AND sets bit i to 1 only when some item of A and some item of B both hit i.",
+      "part": "Step 1 + background (Boolean AND)",
+      "idea": "This applies the per-bit rule to both filters at once."
+    },
+    {
+      "step": "Every item in A ∩ B has all of its bits set in both filters, so the AND never gives a false negative for A ∩ B.",
+      "part": "Step 5 and Section 2 (bits never go back to 0)",
+      "idea": "A shared item set its k bits in each filter, so they are all 1 in the AND."
+    },
+    {
+      "step": "The AND can still have extra 1s compared with the filter built directly from A ∩ B. This happens where one item from A and a different item from B happen to share a position.",
+      "part": "Section 3, 'Try it' (last note: different words sometimes share positions) and Section 4 (false positives from other items covering bits)",
+      "idea": "Shared positions between different items can switch on a bit in both filters even when no common item exists. So the AND has at least as many 1s as the true intersection filter, often more."
+    },
+    {
+      "step": "So the AND is only an approximation of the A ∩ B filter. It still has no false negatives, but it may have more false positives than a filter built from A ∩ B.",
+      "part": "Steps 6 and 7 + Section 5, Step 2 (more 1s means a higher rate, about f^k)",
+      "idea": "Extra 1s raise f, and that raises the false positive rate."
+    }
+  ],
+  "result": "Combine the two bit arrays with a bitwise OR. Bit i is 1 if any item of A or B hit it, so the result is exactly, bit for bit, the filter you would get by adding all of A ∪ B. In that sense it is exact. It still behaves like any Bloom filter, though: no false negatives, and false positives at the rate for |A ∪ B| items, which is higher than either filter alone. A bitwise AND gives a filter for A ∩ B that never misses a common item (no false negatives). But it is not exact. It can keep 1s where a different item of A and a different item of B happened to share a position, so it may have more 1s and more false positives than a filter built directly from A ∩ B.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/principles.json
new file mode 100644
index 0000000..a077097
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Write down what a filter's bits are. Every bit starts at 0, and a bit is 1 exactly when at least one added item hashed to that position.",
+      "part": "The parts (Bit array; Add(x)) and 'Why it never misses an item it saw'",
+      "idea": "The array starts all 0. Add only sets the k positions of each item to 1, and nothing ever clears a bit. So the final array depends only on which positions the added items cover, not on the order they were added."
+    },
+    {
+      "step": "So filter(A) is the set of positions covered by items of A, and filter(B) is the set covered by items of B. They use the same m and the same hashes, so a given item hashes to the same positions in both.",
+      "part": "Step 1; The parts (Hash function: the same item always gives the same number)",
+      "idea": "Shared size and hashes mean position i means the same thing in both arrays."
+    },
+    {
+      "step": "Bitwise OR the two arrays. A bit is 1 in the OR exactly when some item of A or some item of B covers it, which means some item of A ∪ B covers it.",
+      "part": "Steps 1–2; background (what OR does)",
+      "idea": "The positions covered by A ∪ B are the positions covered by A together with those covered by B."
+    },
+    {
+      "step": "The OR is exact: it is bit-for-bit the filter you would get by adding every item of A ∪ B to an empty filter. An item in both sets just sets the same bits twice, which changes nothing. So it never misses an item, and its false-positive rate is that of a filter holding n = |A ∪ B| items.",
+      "part": "Step 3; 'Why it never misses an item it saw'; 'How often it is wrong' (p ≈ (1 − e^(−kn/m))^k)",
+      "idea": "The two arrays are identical, so the merged filter keeps all the usual guarantees. Its fill, and so its error rate, is set by how many distinct items it holds. The arrays must match in size and hashes, because 'The bits cannot be resized'."
+    },
+    {
+      "step": "Bitwise AND the two arrays. Every item of A ∩ B sets its k bits in both filters, so all its bits are 1 in the AND. A query for it says 'probably seen', so the AND never misses an item of A ∩ B.",
+      "part": "Step 2; 'Why it never misses an item it saw'",
+      "idea": "An item in both sets has all its bits set in both arrays."
+    },
+    {
+      "step": "But a bit can be 1 in filter(A) because of one item of A and 1 in filter(B) because of a different item of B, even when no item is in both sets. The AND keeps that bit, but a filter built from A ∩ B would have it at 0.",
+      "part": "Worked example, the 'owl' paragraph ('The filter has no record of which item set a bit')",
+      "idea": "Bits do not record which item set them, so a bit that is 1 in both arrays does not mean one shared item set it."
+    },
+    {
+      "step": "So the AND acts like a filter for A ∩ B with no false negatives. It is not exact: it can have more 1s than the filter built from A ∩ B, so its false-positive rate can be higher. That rate is driven by how full A's and B's filters are, not by the size of A ∩ B. If A and B share no items, it can still answer 'probably seen'.",
+      "part": "Steps 5–6; 'How often it is wrong' (the error rate depends on how full the array is)",
+      "idea": "Extra 1 bits make the array look fuller, and a fuller array gives more false positives."
+    }
+  ],
+  "result": "OR the two bit arrays bit by bit. The result is exactly the Bloom filter you would get by adding every item of A ∪ B, so it is exact. Like any Bloom filter, it never misses an item and can sometimes give a false 'yes', at the rate expected for n = |A ∪ B| items. A bitwise AND gives an approximate filter for A ∩ B. Every item in both sets still answers 'probably seen'. But the AND can keep bits that were set by different items in A and in B, so it may have more 1s than the true filter for A ∩ B. That gives it a false-positive rate that can be higher, and it is not exact.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/published.json
new file mode 100644
index 0000000..4445f7c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A filter's bits are fixed entirely by the items added to it. Bit i is 1 exactly when at least one added item has i among its k positions. The order of adds does not matter.",
+      "part": "How it works: add and query",
+      "idea": "Adding an item only sets its k positions (hash mod m) to 1 and keeps nothing else. Bits start at 0 and are never cleared (see also 'Why it is never wrong the other way')."
+    },
+    {
+      "step": "Because the two filters have the same m and the same k hash functions, any item gets the same positions in both. So bit i in filter A is 1 when some item of A maps to i, and bit i in filter B is 1 when some item of B maps to i.",
+      "part": "How it works: add and query; Not covered here (Growing: changing m changes every position)",
+      "idea": "Positions come from the hash output mod m. With the same hashes and the same m, the positions line up. With a different m they would not."
+    },
+    {
+      "step": "A bitwise OR of the two arrays gives bit i = 1 exactly when some item of A or some item of B maps to i. That is the same as when some item of A ∪ B maps to i. This is exactly the array you would get by adding every item of A ∪ B to an empty filter.",
+      "part": "Steps 1–2, plus background (OR logic)",
+      "idea": "Building from A ∪ B sets the union of the bits that A's items set and the bits that B's items set. OR computes that union of bits."
+    },
+    {
+      "step": "So the OR is exact: it matches the A ∪ B filter bit for bit. It has no false negatives, and its false-positive rate is that of a filter holding |A ∪ B| items. If the union goes over capacity, that rate rises.",
+      "part": "Step 3; Why it is never wrong the other way; How often it is wrong; Overfilling",
+      "idea": "The OR filter is a normal filter for A ∪ B, so the usual guarantee and the rate p ≈ f^k apply, with n equal to the number of items in the union."
+    },
+    {
+      "step": "A bitwise AND gives bit i = 1 when some item of A maps to i and some item of B maps to i. Every item in A ∩ B has all k of its bits set in both filters, so the AND keeps them. As a filter for A ∩ B, it never says 'definitely not seen' for an item that is in both sets.",
+      "part": "Steps 1–2; Why it is never wrong the other way",
+      "idea": "An item in both sets set its own bits in each filter, and bits never go back to 0."
+    },
+    {
+      "step": "The AND is not exact. A bit can be 1 in A because of one item and 1 in B because of a different item. For example, take A = {cat} with bits 1, 6, 11 and B = {owl} with bits 3, 6, 11. The AND has bits 6 and 11 on, but A ∩ B is empty, and its true filter is all 0s. So the AND can have more 1s than the A ∩ B filter, and it gives extra false positives.",
+      "part": "How it can be wrong: false positives (owl shares bits 6, 11 with cat); How it works (cat's positions)",
+      "idea": "Bits do not record which item set them. Two different items can share positions, so a shared 1 does not mean a shared item."
+    }
+  ],
+  "result": "OR the two bit arrays. You get exactly the filter you would have built from A ∪ B: every bit is the same, it has no false negatives, and it has the normal false-positive rate for |A ∪ B| items. A bitwise AND gives a filter that still has no false negatives for A ∩ B, but it is not exact. It can have 1s where different items of A and B happened to share a position, so it is at least as full as the real A ∩ B filter and gives more false positives. The explanation does not give a formula for how much more.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/quick.json
new file mode 100644
index 0000000..3784455
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/bloom-filter/quick.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "A filter's bits are exactly the union of the positions of all added items. A bit is 1 only if some added item hashes to it.",
+      "part": "How it works (Add step) and the cat/dog table",
+      "idea": "Adding an item sets its k positions to 1. Nothing else sets bits, and the array starts all 0. The table shows only the bits from cat and dog switched on."
+    },
+    {
+      "step": "The same item always lands on the same positions in both filters.",
+      "part": "The parts (hash functions)",
+      "idea": "A hash function always gives the same position for the same item. Both filters use the same m and the same hash functions, so position i means the same thing in each."
+    },
+    {
+      "step": "Adding items only turns bits from 0 to 1, so the order and grouping of adds do not matter.",
+      "part": "Why \"no\" is always right, first paragraph",
+      "idea": "Adding only changes bits from 0 to 1 and nothing clears them. So the final array is just the set of all positions the items hash to."
+    },
+    {
+      "step": "A bitwise OR of the two arrays gives the filter for A ∪ B, without needing the items.",
+      "part": "Steps 1–3",
+      "idea": "Building a filter from A ∪ B switches on (positions of A's items) ∪ (positions of B's items). By steps 1–2, that is the bits on in A's filter or in B's filter, which is exactly their bitwise OR."
+    },
+    {
+      "step": "The OR is exact: it matches, bit for bit, a filter built directly from A ∪ B, and it has the same false-positive behaviour as that filter.",
+      "part": "Step 4; How much memory, and how often wrong",
+      "idea": "Because the arrays are identical, queries give identical answers. The false-positive rate is the one for n = |A ∪ B| items. Items in both sets count once."
+    },
+    {
+      "step": "A bitwise AND keeps every bit of each item in A ∩ B, so it never gives a false negative for the intersection.",
+      "part": "Step 1; Why \"no\" is always right",
+      "idea": "An item in both sets has its bits set in both filters, so all its bits survive the AND."
+    },
+    {
+      "step": "The AND can also keep bits that no item of A ∩ B set: a bit that one item only in A turned on and a different item only in B also turned on.",
+      "part": "How \"yes\" can be wrong (the filter cannot tell which item set a bit); cat/dog example",
+      "idea": "Bits are shared without any record of who set them. For example, if A = {cat} and B = {dog}, both set bit 6. A ∩ B is empty, but the AND still has bit 6 = 1."
+    },
+    {
+      "step": "So the AND is only an approximation of the filter for A ∩ B. It has all the bits of the true intersection filter plus possibly extra ones, which gives more false positives.",
+      "part": "Steps 6–7; How \"yes\" can be wrong",
+      "idea": "Extra 1 bits make it likelier that an unseen item finds all its bits on. The AND still never says \"no\" wrongly, but it says \"probably yes\" too often."
+    }
+  ],
+  "result": "Take the bitwise OR of the two bit arrays. This works because the size and hash functions match. The result is exactly the filter you would get by adding every item of A ∪ B, bit for bit, so it is exact: it has no false negatives and the same false-positive rate as a filter built directly from A ∪ B. A bitwise AND gives a filter that contains everything in A ∩ B, so it never gives a false negative there. But it is not exact: a bit set by an item only in A and by a different item only in B also survives. The AND therefore has all the bits of the true A ∩ B filter, sometimes more, and gives more false positives.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/none.json
new file mode 100644
index 0000000..98e7f2d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A double holds a fraction exactly only if the fraction's binary form ends. In binary, that happens only when the denominator, after simplifying, is a power of 2.",
+      "part": "Section 2, 'The same problem in binary', first paragraph",
+      "idea": "Base 2 has only the prime factor 2, so 1/2, 1/4, 3/8, 5/16 and so on end in binary. Other fractions repeat forever."
+    },
+    {
+      "step": "Write each number as a simplified fraction: 0.375 = 3/8, 0.2 = 1/5, 0.0625 = 1/16, 0.3 = 3/10.",
+      "part": "background",
+      "idea": "Turning a decimal into a fraction and simplifying it is school arithmetic."
+    },
+    {
+      "step": "0.375 (3/8) and 0.0625 (1/16) have power-of-2 denominators, so their binary forms end (0.011 and 0.0001). Each needs only a few bits, well within the 53 that a double keeps, so both are stored exactly.",
+      "part": "Section 2 (power-of-2 rule) and Section 3, 'How much room the computer has' (53 significant binary digits)",
+      "idea": "A fraction that ends in binary and fits in 53 significant bits is stored with no rounding."
+    },
+    {
+      "step": "0.2 (1/5) and 0.3 (3/10) have a factor of 5 in the denominator, so their binary forms repeat forever. Each is rounded to the nearest double: 0.2 ends up slightly too big and 0.3 slightly too small.",
+      "part": "Section 2 table and Section 3 table of stored values",
+      "idea": "The table lists 0.2 and 0.3 as not exact and shows the slightly-off values that are actually stored."
+    },
+    {
+      "step": "0.125 = 1/8 is stored exactly. Each running total in 0.125 + 0.125 + ... is k/8 for k = 1 to 8. Every one has a power-of-2 denominator and needs only a few bits, so each is exactly a double.",
+      "part": "Steps 1 and 3; Section 3 (53-bit budget)",
+      "idea": "Every partial sum can be stored exactly, so nothing needs rounding."
+    },
+    {
+      "step": "Each addition gives the exact sum, correctly rounded to the nearest double. When the exact sum is already a double, the rounding changes nothing. So all eight additions are exact and the final total is exactly 8/8 = 1.0.",
+      "part": "Section 6, 'Bounded, predictable error' bullet",
+      "idea": "IEEE 754 returns the exact result correctly rounded. An exactly storable result comes back unchanged."
+    },
+    {
+      "step": "Adding 0.1 ten times starts from a stored value that is not 0.1. The stored value is slightly too big. Ten copies of it add up to slightly more than 1, so there is already an error before any addition. Each running total, such as 0.3, 0.7 or 0.9, is also not exactly storable, so each addition rounds again. These small errors don't cancel each other, so the total lands on a double close to 1.0 but not on 1.0 itself.",
+      "part": "Section 3 table (0.1 stored too big); Introduction point 2 ('rounding errors don't cancel out'); Section 4, 'The addition itself' (the sum is rounded again); Section 1 (0.3333 × 3 = 0.9999 analogy)",
+      "idea": "The error is built in the moment 0.1 is stored, and repeated additions build on it, the same way 0.3333 added three times gives 0.9999."
+    }
+  ],
+  "result": "A double can store 0.375 (3/8) and 0.0625 (1/16) exactly, because their denominators are powers of 2. It cannot store 0.2 (1/5) or 0.3 (3/10) exactly: both have a factor of 5 in the denominator, so they repeat forever in binary and get rounded. Adding 0.125 (1/8) eight times is exact because 0.125 and every running total k/8 can be stored exactly, so no addition ever rounds, and the total is exactly 1.0. Adding 0.1 ten times starts from a stored 0.1 that is slightly too big. The running totals also can't be stored exactly, so each addition rounds again. These errors don't cancel, and the total ends up near 1.0 but not equal to it. The explanation gives the reasons for this but never works out the exact final value of the ten-0.1 sum. So 'not exactly 1.0' is a conclusion from those reasons, not a number taken from the text.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/principles.json
new file mode 100644
index 0000000..9654607
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Set the test for exact storage: a double holds only numbers of the form (an integer of at most 53 bits) × (a power of 2). A fraction is exact only if its denominator in lowest terms has no prime factor other than 2. Otherwise its binary expansion repeats forever and has to be rounded.",
+      "part": "Section 2 'Why 0.1 has no exact binary form' and Section 3 'What the computer actually stores'",
+      "idea": "In base 2 the only prime factor allowed in the denominator is 2. A factor of 5 makes the expansion repeat, so the value is rounded to the nearest grid point."
+    },
+    {
+      "step": "Write each number as a fraction in lowest terms: 0.375 = 3/8 = 3 × 2⁻³; 0.0625 = 1/16 = 1 × 2⁻⁴; 0.2 = 1/5; 0.3 = 3/10 = 3/(2 × 5).",
+      "part": "background",
+      "idea": "Turning a decimal into a fraction and reducing it is school arithmetic."
+    },
+    {
+      "step": "So 0.375 and 0.0625 are stored exactly: they are grid points with small integers. 0.2 and 0.3 are not, because their denominators contain 5. The explanation's table confirms that 0.2 is stored slightly high and 0.3 slightly low.",
+      "part": "Steps 1–2; Section 3 table; Section 6 'When addition is exact'",
+      "idea": "Power-of-2 denominators are exact. The table gives the rounded stored values of 0.2 and 0.3."
+    },
+    {
+      "step": "Adding 0.125 eight times: 0.125 = 1/8 is exact. Every running total k/8 (0.25, 0.375, …, 1.0) also has a power-of-2 denominator and needs only a few bits, so each one is a grid point. No addition has to round, and the final total is exactly 8/8 = 1.0.",
+      "part": "Section 6 'When addition is exact' (0.5 + 0.25 == 0.75 example), Step 1",
+      "idea": "Sums of power-of-2 fractions are exact while they fit in 53 bits, because every result is already a grid point."
+    },
+    {
+      "step": "Adding 0.1 ten times: the stored 0.1 is not 1/10. It is slightly high (7205759403792794 × 2⁻⁵⁶). So the computer is adding a value that is already wrong. Running totals such as 0.3 are not grid points either, so each addition can round again. The rounding errors do not cancel, just as in the 4-digit calculator example and in 0.1 + 0.2, which ends up one step above the stored 0.3.",
+      "part": "Section 3 table; Section 1 'The same problem in decimal'; Section 4 'The addition, step by step'",
+      "idea": "Inputs are rounded and each sum may be rounded again. The errors build up and do not cancel, so the total is not guaranteed to be exactly 1."
+    },
+    {
+      "step": "To confirm that the ten-step total actually ends up different from 1.0, rather than just not being guaranteed, you would have to follow the rounding through all ten additions. The explanation says it does not cover this.",
+      "part": "Summary, 'Not covered: … how errors grow across long chains of operations'",
+      "idea": "The explanation works through only a single addition (0.1 + 0.2). It does not give the rounding for longer chains."
+    }
+  ],
+  "result": "Stored exactly: 0.375 (= 3/8) and 0.0625 (= 1/16), because their denominators are powers of 2. Not exact: 0.2 (= 1/5) and 0.3 (= 3/10), because the factor 5 makes their binary expansions repeat, so they get rounded. Adding 0.125 eight times is exact: 1/8 and every running total k/8 are grid points, so no step ever rounds and the result is exactly 1.0. Adding 0.1 ten times starts from a stored 0.1 that is already slightly too high, and running totals like 0.3 are not grid points, so each step can round again and the errors do not cancel. So nothing makes the total land exactly on 1.0. The explanation does not let me check the claim that it ends up somewhere other than 1.0, or say which way it misses.",
+  "gap": "The explanation leaves out how rounding errors build up across a chain of operations (its Summary says so). It works through only the single addition 0.1 + 0.2. So I can't work out from it what ten additions of 0.1 actually produce, or confirm that the total is different from 1.0. I can only show that it isn't guaranteed to be exact."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/published.json
new file mode 100644
index 0000000..fe5041b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/published.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "A double can hold a number exactly only if that number is a whole number of at most 53 binary digits times a power of two. Such a number is a fraction whose denominator is a power of two.",
+      "part": "'What the computer holds' and the first sentence of 'Why 0.1 must be rounded'",
+      "idea": "A double is a whole number times a power of two, so it can only be a fraction with a power-of-two denominator. Example: 0.75 = 3 × 2^-2."
+    },
+    {
+      "step": "A fraction whose lowest-terms denominator contains a factor of 5 can never be stored exactly.",
+      "part": "'Why 0.1 must be rounded' (1/10 has a factor 5, and no power of two is divisible by 5)",
+      "idea": "These fractions never end in binary, so the computer has to cut the digits off and round."
+    },
+    {
+      "step": "0.375 = 3/8 = 3 × 2^-3, so it is stored exactly.",
+      "part": "Step 1, plus the 3/8 = 0.011 example in 'Why 0.1 must be rounded'",
+      "idea": "The denominator is 8, a power of two, and the whole number 3 is tiny. The explanation even uses 3/8 as its example of a fraction that ends in binary."
+    },
+    {
+      "step": "0.0625 = 1/16 = 1 × 2^-4, so it is stored exactly.",
+      "part": "Step 1",
+      "idea": "The denominator is a power of two, so the number is a whole number times a power of two."
+    },
+    {
+      "step": "0.2 = 1/5 and 0.3 = 3/10 are not stored exactly.",
+      "part": "Step 2, and the table in 'The stored values'",
+      "idea": "Both denominators contain 5. The table confirms it: 0.2 is stored with error +1.11e-17 and 0.3 with error −1.11e-17."
+    },
+    {
+      "step": "Adding 0.125 eight times gives exactly 1.0, because no rounding ever happens.",
+      "part": "'When it works' and 'What `+` does'",
+      "idea": "0.125 = 1/8 is stored with error 0. Every running total k/8 (k = 1 to 8) has a power-of-two denominator and a small numerator, so it is itself a double. '+' rounds the exact sum, but here the exact sum is already a double, so nothing changes. After eight additions the total is exactly 8/8 = 1."
+    },
+    {
+      "step": "Adding 0.1 ten times starts from a stored value that is not 0.1, and each addition rounds its result.",
+      "part": "Table in 'The stored values'; 'What `+` does'",
+      "idea": "Stored 0.1 is 0.10000000000000000555, not 0.1. Each '+' rounds the exact sum to the nearest double, so ten small errors from the input, plus up to nine roundings, can each push the total away from 1.0."
+    },
+    {
+      "step": "Showing that the total really ends up different from 1.0 means following how these errors add up over the ten additions. The explanation leaves this out on purpose.",
+      "part": "'Not covered here' (second bullet: 'How errors grow over many operations, such as adding 0.1 ten times')",
+      "idea": "The explanation sends the reader to a numerical analysis text instead. It also gives no gap sizes for numbers above 0.5, so I can't track the running total step by step to see where it lands."
+    }
+  ],
+  "result": "0.375 (3/8) and 0.0625 (1/16) are stored exactly; 0.2 (1/5) and 0.3 (3/10) are not, because their denominators contain 5. Adding 0.125 eight times gives exactly 1.0: 1/8 and every running total k/8 are doubles, so no addition ever rounds. For 0.1 added ten times, the explanation only shows that the total can drift from 1.0: stored 0.1 is slightly too big, and each addition may round. It does not let me show that the final result is actually different from 1.0.",
+  "gap": "The explanation leaves out how rounding errors build up over repeated additions, and says so: 'Not covered here' lists 'adding 0.1 ten times'. It also gives no gap sizes for numbers above 0.5. So I can't follow the ten partial sums to show that the total ends up different from 1.0, rather than the errors cancelling out."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/quick.json
new file mode 100644
index 0000000..5f3722a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/float-sum/quick.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A double is a binary fraction with 53 significant bits, meaning a sum of powers of 2 (1/2, 1/4, 1/8, …). A number is stored exactly only if it has a short binary form. Otherwise the double holds the nearest binary fraction.",
+      "part": "'Why 0.1 has the same problem in base 2', first paragraph",
+      "idea": "Doubles are sums of powers of two. A value with no finite binary form gets rounded to a nearby stored value."
+    },
+    {
+      "step": "0.375 = 3/8 = 1/4 + 1/8, which is binary 0.011. That is a short binary fraction, so a double stores it exactly.",
+      "part": "Step 1, plus background arithmetic",
+      "idea": "3/8 can be written as a sum of two powers of two, so nothing needs rounding."
+    },
+    {
+      "step": "0.0625 = 1/16, a single power of 2 (binary 0.0001). It is stored exactly.",
+      "part": "Step 1, plus background arithmetic",
+      "idea": "Any power of two is a short binary fraction."
+    },
+    {
+      "step": "0.2 and 0.3 cannot be stored exactly. Their stored values are 0.2000000000000000111… and 0.2999999999999999888….",
+      "part": "'Why 0.1 has the same problem in base 2', the stored-value table and the sentence after it",
+      "idea": "The table shows the stored 0.2 is a little too high and the stored 0.3 a little too low, so neither is exact."
+    },
+    {
+      "step": "0.125 = 1/8 is exact. Each running total in 0.125+0.125+… is k/8 (0.25, 0.375, …, 1.0), which is also a short binary fraction. So no addition has to round, and the eighth one gives exactly 1.0.",
+      "part": "'When addition is exact' (the 0.5 + 0.25 == 0.75 example)",
+      "idea": "If the inputs and the sum are all short binary fractions, no step rounds and no error appears."
+    },
+    {
+      "step": "0.1 is stored as 0.1000000000000000055511…, a little too high, because its binary form 0.000110011… repeats forever. So the sum starts from inexact inputs. Each running total (0.2, 0.3, …) also lacks a short binary form, so each addition must round to the nearest double.",
+      "part": "'Why 0.1 has the same problem in base 2' (the table) and 'What happens in the addition', steps 1–2",
+      "idea": "The inputs are already slightly wrong, and the exact sum is usually not a double, so it gets rounded again."
+    },
+    {
+      "step": "These small input errors and rounding errors add up, so the final total can be a different double from 1.0, just as 0.1+0.2 lands one double above the stored 0.3. `==` compares the doubles bit for bit, so any difference makes it false.",
+      "part": "Opening bold paragraph; 'What happens in the addition', steps 3–4; 'The same problem in base 10' (0.333+0.333 ≠ 0.667)",
+      "idea": "Errors in the inputs plus rounding can push the result onto a neighbouring double, and the comparison then fails."
+    }
+  ],
+  "result": "A double can store 0.375 (= 1/4 + 1/8) and 0.0625 (= 1/16) exactly. It cannot store 0.2 or 0.3 exactly, because they have no finite binary form, so it keeps the nearest binary fraction instead. Adding 0.125 (= 1/8) eight times gives exactly 1.0: every running total k/8 is a short binary fraction, so no step rounds. Adding 0.1 ten times starts from a stored 0.1 that is slightly too high. The running totals are not short binary fractions either, so each addition rounds. The errors build up and the total ends on a double other than 1.0, so `== 1.0` is false.",
+  "gap": "The explanation works through only one case, 0.1 + 0.2, and never computes the ten-step sum of 0.1. It gives no rule for which way the roundings go or whether they partly cancel. So it explains why the sum can miss 1.0, but I can't confirm from it alone that the ten-step total actually ends on a double other than 1.0. I've taken that from the question."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/none.json
new file mode 100644
index 0000000..ccafd4c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/none.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Convert the satellite's 10 ns clock error into a distance error: 10 ns × about 30 cm/ns ≈ 3 m.",
+      "part": "Section 1, 'Distance from time' (the bold sentence: every nanosecond of timing error is about 30 cm of position error)",
+      "idea": "Range is c × (t_r − t_s), so an error in either timestamp turns straight into a range error of about 30 cm per nanosecond."
+    },
+    {
+      "step": "Find the direction of the error. A fast satellite clock stamps a send time t_s that is 10 ns too late, so the measured delay t_r − t_s is 10 ns too short. That makes the range to that satellite about 3 m too short.",
+      "part": "Section 1, the formula distance = c × (t_r − t_s); background arithmetic",
+      "idea": "If t_s is too large, the difference gets smaller, so the computed distance gets smaller."
+    },
+    {
+      "step": "Note a possible inconsistency. The explanation's own example calls a 10 ns fast satellite clock equivalent to the satellite being '3 m farther away'. That matches step 1 on size but seems to disagree with step 2 on direction.",
+      "part": "Section 3, final paragraph ('Note what the whole method assumes…')",
+      "idea": "The receiver cannot tell a 10 ns error in one satellite's clock from a change of about 3 m in that satellite's distance."
+    },
+    {
+      "step": "Explain why the receiver can absorb its own clock error. That error is the same for every satellite, so it adds the same b = c·δt to every pseudorange. The fourth unknown b models exactly that.",
+      "part": "Section 2 (pseudorange equation ρᵢ = |sᵢ − p| + b) and Section 3, Jacobian step ('For b it is simply 1')",
+      "idea": "b is one shared offset with the same effect (coefficient 1) on every satellite's equation, so the solver can separate it from position."
+    },
+    {
+      "step": "Explain why b cannot absorb the satellite's error. It belongs to one satellite only, so it is not a shared offset. The model has no unknown for it. The solver treats it as a real 3 m change in that one range and moves the computed position (x, y, z) to fit it.",
+      "part": "Section 3, final paragraph ('It cannot absorb errors that differ from satellite to satellite'); Section 4 note on the '11 km a day' claim (errors that differ from satellite to satellite go directly into your position)",
+      "idea": "Only the part of an error that is common to all satellites ends up in b. An error in one satellite becomes a position error."
+    }
+  ],
+  "result": "The range to that satellite is off by about 3 m (10 ns × 30 cm/ns). By the formula it should come out about 3 m too short, though the explanation's own example says 'farther'. The fourth unknown b is a single clock offset that adds the same amount to every pseudorange, so it can only absorb errors that all satellites share. A 10 ns error in one satellite's clock affects only that satellite's equation. To the receiver it looks exactly like that satellite being about 3 m nearer or farther, so the solver bends the computed position to fit it, and the error ends up in your position.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/principles.json
new file mode 100644
index 0000000..e760868
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/principles.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Distance is worked out from timing: distance = c × (time received − time sent), and the satellite's own clock supplies the 'time sent'.",
+      "part": "Short answer paragraph; Section 1 'Time becomes distance'",
+      "idea": "Each satellite broadcasts the time it sent its signal. The receiver turns the travel time into a distance by multiplying by the speed of light."
+    },
+    {
+      "step": "A 10 ns timing error gives a distance error of about 3 m.",
+      "part": "Section 1, paragraph on 'This conversion is unforgiving'",
+      "idea": "Light travels 30 cm in one nanosecond, and the section says outright that a 10 ns error gives 3 m."
+    },
+    {
+      "step": "Direction: the clock is 10 ns fast, so the 'time sent' stamp is 10 ns later than the true sending time. The difference (received − sent) then comes out about 10 ns too small, and the distance to that satellite is about 3 m too short.",
+      "part": "Step 1 formula plus background arithmetic",
+      "idea": "I worked out the sign by putting a sending time that is too late into the subtraction. The explanation itself only states the size, 3 m."
+    },
+    {
+      "step": "The fourth unknown b models one error, c·b, added equally to every measured distance.",
+      "part": "Section 3, equation and paragraph on treating the receiver clock error as a fourth unknown",
+      "idea": "The receiver's clock error enters every satellite's equation as the same term, c·b. This lets x, y, z and b be solved together from four satellites."
+    },
+    {
+      "step": "An error on one satellite only is not the same for every signal, so b cannot represent it. The solve cannot detect it either, and it distorts the position.",
+      "part": "Section 3, 'What this trick cannot fix'",
+      "idea": "The c·b term removes only an error that is the same for every signal. If one satellite's clock is off and the others are not, that distance is wrong and the solve cannot detect it. Section 5 makes the same point about per-satellite eccentricity terms."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × 30 cm/ns). Because the clock is fast, the time-sent stamp is too late, so the distance comes out about 3 m too short. The fourth unknown b can't absorb this because it stands for one offset, c·b, that is added equally to all four distances. That is exactly what the receiver's own clock error is. This error affects only one satellite's distance, so no single b can match it. The solve can't detect it, and the error ends up in the computed position instead. That's why every satellite clock has to agree with GPS time to within a few nanoseconds.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/published.json
new file mode 100644
index 0000000..f8ffd1e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Establish the conversion rate: 1 ns of timing error is about 0.3 m of distance error.",
+      "part": "Section 1, 'Time gives distance' (paragraph on light covering 300 m per µs and 0.3 m per ns)",
+      "idea": "Light travels 0.3 m in one nanosecond, so any timing error becomes a range error at that rate."
+    },
+    {
+      "step": "Apply the rate to the satellite clock: 10 ns × 0.3 m/ns ≈ 3 m of error in that satellite's pseudorange.",
+      "part": "Section 3, 'The satellite clocks must be almost perfect' (second paragraph) and step 1",
+      "idea": "Each nanosecond of satellite clock error gives 0.3 m of range error."
+    },
+    {
+      "step": "Find the direction of the error. The pseudorange is c × (receive time on the receiver clock − send time on the satellite clock). A fast satellite clock stamps a send time 10 ns later than the true one, so the computed travel time is 10 ns too short and the distance comes out about 3 m too short.",
+      "part": "Section 2, paragraph defining **pseudorange**",
+      "idea": "The pseudorange is light speed times the receive time minus the send time read from the satellite's clock, so an error in the send-time stamp goes straight into it."
+    },
+    {
+      "step": "Show why b can absorb the receiver's own clock error: one receiver clock makes every measurement, so its error adds the same b to every pseudorange, and b is solved for as a fourth unknown alongside x, y and z.",
+      "part": "Section 2, pseudorange paragraph, the worked example on a line, and the paragraph on four unknowns",
+      "idea": "b is shared by all pseudoranges. With four equations the shared offset can be solved for and subtracted, as the 1.5 km is in the beacon example."
+    },
+    {
+      "step": "Show why b cannot absorb the satellite's clock error: the 10 ns error is in only that one satellite's pseudorange, so it is not shared. A single b that shifts all four pseudoranges equally cannot fix one of them alone. The 3 m error stays in the equations and moves the position fix.",
+      "part": "Section 3, first paragraph; Section 5, 'Why the receiver's b does not cancel the drift'",
+      "idea": "A satellite clock error sits in only one pseudorange, so no unknown absorbs it. b can only absorb errors that are the same in every pseudorange at the same moment."
+    },
+    {
+      "step": "Check the size: 10 ns is within the roughly 17 ns limit for a fix within about 5 m, so the error is small but still not removed.",
+      "part": "Section 3, second paragraph",
+      "idea": "Satellite clocks must agree with GPS time to about 17 ns for a fix within about 5 m."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × 0.3 m/ns). Because the satellite stamps a send time that is too late, the measured travel time is too short, so the distance comes out about 3 m too short. The fourth unknown, b, works only because the receiver's single clock adds the same offset to every pseudorange. This satellite's clock error is in just one of the four pseudoranges, so it is not shared, and no single common offset can remove it. The 3 m stays in that one equation and shifts the position fix, though at 10 ns it is still inside the roughly 17 ns limit for a fix within about 5 m.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/quick.json
new file mode 100644
index 0000000..1b11bca
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/gps-relativity/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "The measured distance to a satellite is its travel time multiplied by c, where travel time is receive time minus the send time stamped by the satellite.",
+      "part": "Step 1: time becomes distance (paragraphs 2–3)",
+      "idea": "Each signal carries the satellite's own send time. The receiver subtracts it from the arrival time and multiplies by c, so any error in that time stamp turns straight into a distance error."
+    },
+    {
+      "step": "10 ns of clock error is about 3 m of distance (10 ns × 30 cm/ns).",
+      "part": "Step 1: time becomes distance (paragraph 3)",
+      "idea": "Light travels about 30 cm per nanosecond, so a timing error of a few nanoseconds gives an error of about a metre."
+    },
+    {
+      "step": "If the satellite clock is 10 ns fast, its send stamp is 10 ns too late. The computed travel time is then 10 ns too short, so that one distance comes out about 3 m too short.",
+      "part": "Step 1 (travel time = receive − send) and step 2; background arithmetic",
+      "idea": "A later send time subtracted from the correct receive time gives a smaller travel time, and so a shorter distance."
+    },
+    {
+      "step": "The fourth unknown b enters every pseudorange as the same term c·b.",
+      "part": "Step 2: why four satellites, not three (pseudorange equation ρᵢ = √(...) + c·b)",
+      "idea": "The receiver clock bias adds one shared offset to all four measured distances. That is how one extra unknown can soak up the error from the receiver's own clock."
+    },
+    {
+      "step": "b can absorb only an error that all satellites share. The 10 ns error is in just one satellite, so no single value of b can cancel it. The four equations then disagree, and the solution shifts the computed position (and b) by a few metres.",
+      "part": "Limits (first bullet: 'the bias b absorbs part of an error that all satellites share') and step 4",
+      "idea": "A shared error disappears into b. An error in one satellite alone is not shared, so it spreads into the position solution instead."
+    },
+    {
+      "step": "So every satellite clock must keep GPS time. The method works only on that condition.",
+      "part": "Step 2, last paragraph ('This method works only if the satellite clocks all keep GPS time')",
+      "idea": "The receiver's model assumes each satellite's time stamps are correct. Only the receiver's own clock is treated as unknown."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × 30 cm/ns). Because the clock is fast, the send time is stamped late, so the distance comes out about 3 m too short. The receiver's bias b adds the same amount, c·b, to all four pseudoranges, so it can only absorb an error that every satellite shares, like the receiver's own clock error. An error in one satellite alone does not fit that pattern. No single b can cancel it, so it pushes the computed position off by a few metres.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/none.json
new file mode 100644
index 0000000..d21ec20
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "What the planet sends to space depends on the temperature of the air that does the emitting.",
+      "part": "Section 3, last paragraph ('what a layer of air emits depends on how warm that layer is')",
+      "idea": "CO2 gives off infrared at a rate set by the local air temperature. Emission depends on how warm the layer is, not on how much CO2 it holds."
+    },
+    {
+      "step": "To balance its energy budget, the planet must radiate 238 W/m² to space. That takes emission at an effective temperature of 255 K.",
+      "part": "Section 1, 'Balance'; Section 5, paragraph 'Averaged over all wavelengths...'",
+      "idea": "σT⁴ = 238 gives T ≈ 255 K. On average the Earth radiates to space like a black body at 255 K."
+    },
+    {
+      "step": "Radiation reaches space from an effective emission height. It carries the temperature of that height, not the temperature of the surface.",
+      "part": "Section 5, fact 2 and the paragraph on effective emission height",
+      "idea": "Only photons emitted high enough, with little absorbing gas above them, get out to space."
+    },
+    {
+      "step": "The greenhouse warming of the surface comes from the fall in temperature with height: T_surface ≈ T_emission + Γ × H.",
+      "part": "Section 5, fact 1 (lapse rate) and the formula T_surface ≈ 255 + 6.5 × 5",
+      "idea": "The surface is warmer than the emission level by the lapse rate times the emission height."
+    },
+    {
+      "step": "If the atmosphere has the same temperature at every height, then Γ = 0, so T_surface = T_emission = 255 K. There is no greenhouse warming at any CO2 level.",
+      "part": "Step 4 with Γ set to 0",
+      "idea": "Put Γ = 0 into the lapse-rate formula. The surface is the same temperature as the emission level."
+    },
+    {
+      "step": "Adding CO2 still pushes the emission height up. But the air up there is no colder, so the planet radiates just as much as before. Outgoing radiation does not drop and there is no forcing.",
+      "part": "Section 5, 'Now add CO₂' paragraph; steps 1 and 5",
+      "idea": "Extra CO2 reduces outgoing energy only because the higher emission level is colder. With no change in temperature with height, the higher level radiates the same."
+    },
+    {
+      "step": "With no energy shortfall, the planet never needs to warm. In the explanation's own words, the surface ends up warmer by Γ × (rise in emission height), and that is 0 × Δh = 0.",
+      "part": "Section 5, end of 'Now add CO₂' paragraph; Section 6 (ΔT = ΔF/λ)",
+      "idea": "Warming equals forcing divided by the restoring strength. Zero forcing means zero warming. Equivalently, the warming is Γ times the rise in emission height, which is zero when Γ = 0."
+    }
+  ],
+  "result": "The surface temperature would not change. It would stay at about 255 K, the value with no greenhouse effect. Adding CO2 still lifts the height from which Earth radiates to space, but in an isothermal atmosphere that higher air is just as warm. It therefore sends out the same 238 W/m², so there is no radiative forcing and the planet does not need to warm. The effect depends on temperature falling with height (the lapse rate). One caveat: the one-layer model in Section 4 has the air colder than the surface (E_a = E_s/2), so it already assumes the temperature changes with height. It doesn't apply to this case.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/principles.json
new file mode 100644
index 0000000..621befd
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/principles.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "More CO2 raises the emission level, the height from which infrared escapes to space.",
+      "part": "Section 6, chain step 1; Section 5, Fact 1",
+      "idea": "Infrared reaches space mostly from the height above which little absorbing gas remains. Adding CO2 puts more absorber above every height, so the escape height moves up."
+    },
+    {
+      "step": "How much the planet emits depends only on the temperature at the emission level.",
+      "part": "Section 1 (Stefan–Boltzmann law); Section 5 diagram",
+      "idea": "Emission to space is σT⁴, where T is the temperature at the emission level. The planet must shed 238 W/m², which needs 255 K at that level."
+    },
+    {
+      "step": "If the atmosphere is the same temperature at every height, the raised emission level is no colder than the old one.",
+      "part": "Section 7, 'Breaks (isothermal air)'; Section 5, Fact 2",
+      "idea": "Warming normally comes from the lapse rate: higher air is colder. With no lapse rate, moving the emission level up leaves its temperature unchanged."
+    },
+    {
+      "step": "Outgoing emission stays the same, so no energy imbalance (radiative forcing) appears.",
+      "part": "Steps 2 and 3; Section 6, chain steps 2–3",
+      "idea": "Same temperature means the same σT⁴ output. Outgoing energy still equals the 238 W/m² coming in, so the planet does not gain energy."
+    },
+    {
+      "step": "The surface does not warm.",
+      "part": "Step 4; Section 6, chain steps 4–5; Section 7",
+      "idea": "Warming only happens when the troposphere and surface heat up to fix an imbalance, and there is none. Also, a surface 'further below' the emission level is no warmer on a flat temperature profile, so the surface stays where it was."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature. More CO2 still raises the height from which infrared escapes to space. But if the air is the same temperature at every height, that new height is just as warm as the old one. It therefore emits the same σT⁴, and the planet keeps shedding the 238 W/m² it absorbs. No energy imbalance arises, so nothing forces the surface to warm. The greenhouse warming from extra CO2 depends on air getting colder with height (the lapse rate).",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/published.json
new file mode 100644
index 0000000..6be6eb3
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "The Earth has to send 240 W/m² to space, so whatever does the emitting must be at 255 K.",
+      "part": "Section 1 (energy balance and the 255 K emission temperature)",
+      "idea": "Over the long run, energy in must equal energy out. The Earth absorbs about 240 W/m², and σT⁴ = 240 W/m² gives T = 255 K."
+    },
+    {
+      "step": "Infrared escapes to space from the emission height, and the air there must be at 255 K.",
+      "part": "Section 3, first two paragraphs",
+      "idea": "Infrared only gets out from air with little greenhouse gas above it. The air at that average height must emit 240 W/m², so it must be at 255 K."
+    },
+    {
+      "step": "Adding CO₂ raises the emission height.",
+      "part": "Section 4, item 1",
+      "idea": "With more gas, infrared has to start higher before little gas remains above it. For a doubling, the height rises by about 150 m."
+    },
+    {
+      "step": "Normally the higher air is colder, so it emits less, and that imbalance (the forcing) warms the Earth.",
+      "part": "Section 4, items 2–3",
+      "idea": "The air 150 m higher is about 1 K colder at 6.5 K/km. It emits about 236 W/m², not 240, which leaves a 3.7 W/m² imbalance."
+    },
+    {
+      "step": "If the temperature were the same at every height, the air at the new, higher emission height would still be 255 K.",
+      "part": "Section 5, second paragraph (the test case)",
+      "idea": "With a lapse rate of 0, going higher does not make the air colder."
+    },
+    {
+      "step": "So the emission to space stays at 240 W/m², with no imbalance and no warming.",
+      "part": "Section 5, second paragraph; step 1",
+      "idea": "Air at 255 K emits 240 W/m², which still matches what the Earth absorbs. With no forcing, the Earth gains no energy."
+    },
+    {
+      "step": "The surface temperature does not change.",
+      "part": "Section 5, third paragraph; Section 3 (255 K + lapse rate × height)",
+      "idea": "Warming needs two things together: the gas lifts the emission height, and the air is colder higher up. With no lapse rate, the surface is not warmer than the emitting air, so it stays at 255 K no matter how high the emission height is."
+    }
+  ],
+  "result": "Adding CO₂ would leave the surface temperature unchanged. CO₂ still raises the emission height, but the air up there is the same temperature as everywhere else, 255 K. So it still sends out 240 W/m², which matches the absorbed sunlight. There is no imbalance, so the Earth gains no energy and does not warm. In fact, with no fall in temperature with height, the surface would sit at 255 K whatever the amount of CO₂. The greenhouse warming only happens because the air gets colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/quick.json
new file mode 100644
index 0000000..548b19e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/greenhouse/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Infrared reaches space only from the emission height, the high air that has little gas above it. That air's temperature sets how much energy the planet sends to space.",
+      "part": "Level 2, paragraph starting 'Infrared that leaves near the ground…'",
+      "idea": "Infrared given off lower down is absorbed again. Only the upper air, about 5 km up, emits straight to space, and how much it emits depends on its temperature."
+    },
+    {
+      "step": "How much a layer emits depends only on its temperature, as σT⁴.",
+      "part": "Level 1, Stefan–Boltzmann paragraph",
+      "idea": "The power emitted per m² is σT⁴, so two layers at the same temperature emit the same amount."
+    },
+    {
+      "step": "Adding CO2 lifts the emission height.",
+      "part": "Level 2, flowchart boxes A→B and the paragraph 'Add gas, and the emission height rises'",
+      "idea": "More gas means you must go higher before little gas is left above, so the escape point moves up. Doubling CO2 lifts it about 150 m."
+    },
+    {
+      "step": "If temperature is the same at every height (no lapse rate), the higher emitting layer is exactly as warm as the old one.",
+      "part": "Level 2, final paragraph ('This works only because air gets colder with height…')",
+      "idea": "When there is no cooling with height, moving the emitter up does not change its temperature."
+    },
+    {
+      "step": "So the infrared sent to space does not fall, and energy balance is not broken.",
+      "part": "Steps 2 and 4; Level 2 flowchart boxes C–E",
+      "idea": "Warming starts only when the emitting air is colder and sends out less (3.8 W/m² less in the real case). With the same temperature there is no drop, so the planet does not gain energy."
+    },
+    {
+      "step": "So the surface does not warm.",
+      "part": "Level 2, final paragraph",
+      "idea": "The explanation says outright that in air of one temperature at every height, more gas would not warm the surface."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature. The extra gas would still lift the emission height, but every height has the same temperature, so the new emitting layer is just as warm as the old one. Emission depends only on temperature (σT⁴), so the infrared going to space stays the same. Energy balance is never broken, so nothing makes the surface warm. The effect only works because air gets colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/none.json
new file mode 100644
index 0000000..46ad70e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/none.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "An air conditioner moves heat in the same direction as a heat pump: it takes Q_cold from the cold side at T_cold, gets work W, and releases Q_hot at T_hot. The only difference is which side is 'useful'.",
+      "part": "Why this isn't too good to be true: 'Run backwards, it's an air conditioner' bullet; paragraph 'A fridge is exactly this machine'",
+      "idea": "It is the same machine with the coils swapped. Heat still goes from the cold side to the warm side, driven by the compressor. Indoors is now the cold side."
+    },
+    {
+      "step": "Energy balance: Q_hot = Q_cold + W.",
+      "part": "Section 3, 'Energy conservation gives Q_cold = Q_hot − W'; The short answer (1 + 2 = 3 kWh)",
+      "idea": "The heat released on the warm side is exactly the heat taken from the cold side plus the electrical work."
+    },
+    {
+      "step": "Second-law constraint: Q_hot/T_hot ≥ Q_cold/T_cold.",
+      "part": "Section 3, 'Entropy bookkeeping'",
+      "idea": "Heat Q at temperature T carries entropy Q/T, and work carries none. A cycling machine can't store entropy, so the entropy it gives out must be at least the entropy it takes in."
+    },
+    {
+      "step": "Define the cooling figure of merit as heat removed per unit of electricity: COP_cool = Q_cold / W.",
+      "part": "The short answer (definition of COP as useful heat / paid-for work); the question itself",
+      "idea": "COP compares the useful heat with the part you pay for. For cooling, the useful heat is the heat taken from inside."
+    },
+    {
+      "step": "Substitute Q_hot = Q_cold + W into the inequality: (Q_cold + W)/T_hot ≥ Q_cold/T_cold, so W/T_hot ≥ Q_cold(1/T_cold − 1/T_hot) = Q_cold(T_hot − T_cold)/(T_hot·T_cold). That gives Q_cold/W ≤ T_cold/(T_hot − T_cold).",
+      "part": "Steps 2, 3, 4; algebra (background)",
+      "idea": "This is the same rearrangement the explanation does for heating, but solved for Q_cold/W instead of Q_hot/W."
+    },
+    {
+      "step": "The heating limit for the same temperatures is Q_hot/W ≤ T_hot/(T_hot − T_cold).",
+      "part": "Section 3, Carnot limit formula",
+      "idea": "This is the ideal heating COP from the explanation."
+    },
+    {
+      "step": "Why the difference is exactly 1: from Q_hot = Q_cold + W, dividing by W gives Q_hot/W = Q_cold/W + 1, so COP_heat = COP_cool + 1 for any machine. For the limits: T_hot/(ΔT) − T_cold/(ΔT) = (T_hot − T_cold)/(T_hot − T_cold) = 1.",
+      "part": "Steps 2, 5, 6",
+      "idea": "The heat delivered on the warm side includes the electricity itself, but the heat removed on the cold side doesn't. So the two ratios always differ by exactly W/W = 1."
+    },
+    {
+      "step": "Example: with 0 °C (273 K) and 35 °C (308 K), the cooling limit is 273/35 ≈ 7.8, compared with 8.8 for heating.",
+      "part": "Section 3, 'Plugging in numbers'; step 5",
+      "idea": "Same numbers as the explanation's worked example; the cooling limit comes out 1 lower."
+    }
+  ],
+  "result": "The ideal air-conditioner limit is COP_cool = Q_cold/W ≤ T_cold/(T_hot − T_cold), with absolute temperatures. For example, 273/35 ≈ 7.8 for 273 K and 308 K. It is exactly one less than the heating limit T_hot/(T_hot − T_cold). Energy conservation gives Q_hot = Q_cold + W, so Q_hot/W = Q_cold/W + 1: the heat dumped on the warm side includes the electrical work, but the heat removed from the cold side doesn't. In the formulas, (T_hot − T_cold)/(T_hot − T_cold) = 1.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/principles.json
new file mode 100644
index 0000000..cc6264f
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "An air conditioner is the same loop as the heat pump. It takes heat Q_C from a cold body and gives heat Q_H to a warm body, and the compressor's electricity W is the only energy input.",
+      "part": "'A refrigerator is the same machine' paragraph, plus the loop diagram and step 2 (Compressor)",
+      "idea": "A refrigerator takes heat from the food box and dumps it into the kitchen through the coil at the back. Electricity enters the loop only at the compressor."
+    },
+    {
+      "step": "Energy balance: Q_H = Q_C + W, so the heat dumped outside is the heat removed from inside plus the electricity.",
+      "part": "Short answer equation; 'W = Q_H − Q_C' in 'Why the COP is not unlimited'",
+      "idea": "The heat coming out of the hot side equals the heat taken in on the cold side plus the electrical work. Energy is conserved."
+    },
+    {
+      "step": "Define the cooling figure of merit as heat removed per unit of electricity: COP_cool = Q_C / W.",
+      "part": "'Why this matters' (definition of COP as useful heat ÷ electrical work), adapted",
+      "idea": "COP is the useful heat divided by the electrical work. For cooling, the useful heat is the heat taken from the cold side."
+    },
+    {
+      "step": "Second-law constraint: Q_H/T_H ≥ Q_C/T_C, with temperatures in kelvin.",
+      "part": "'Why the COP is not unlimited' entropy paragraph",
+      "idea": "Heat Q at temperature T carries entropy Q/T, and total entropy cannot decrease. So the entropy dumped on the hot side must be at least the entropy taken from the cold side."
+    },
+    {
+      "step": "Algebra: Q_H ≥ Q_C·T_H/T_C, so W = Q_H − Q_C ≥ Q_C·(T_H − T_C)/T_C. That gives Q_C/W ≤ T_C/(T_H − T_C).",
+      "part": "Steps 2–4 + background (algebra)",
+      "idea": "Put the energy balance into the entropy inequality and rearrange."
+    },
+    {
+      "step": "Why it is exactly one less: Q_C/W = (Q_H − W)/W = Q_H/W − 1. The same holds for the limits: T_C/(T_H−T_C) = T_H/(T_H−T_C) − (T_H−T_C)/(T_H−T_C) = T_H/(T_H−T_C) − 1.",
+      "part": "Step 2 + heating bound COP ≤ T_H/(T_H − T_C) in 'Why the COP is not unlimited' + background algebra",
+      "idea": "The heat delivered on the hot side always includes the electricity itself, on top of the heat moved. Heating counts W as useful output and cooling does not, so the two ratios always differ by exactly W/W = 1."
+    },
+    {
+      "step": "Numerical check with the mild-day temperatures: ideal cooling COP = 268/50 = 5.36 ≈ 5.4, which is 6.4 − 1.",
+      "part": "Table in 'Why the COP is not unlimited' (268 K, 318 K, lift 50 K, ideal heating COP 6.4)",
+      "idea": "The table's temperatures give a heating limit of 6.4, and the cooling limit comes out one lower."
+    }
+  ],
+  "result": "The ideal limit for an air conditioner is COP_cool = Q_C/W ≤ T_C/(T_H − T_C), with temperatures in kelvin (for example, 268/50 ≈ 5.4). It is exactly one less than the heating limit T_H/(T_H − T_C). This is because the heat given to the hot side is Q_H = Q_C + W. A heater counts the electricity W as part of its useful output, but an air conditioner counts only the heat it removes, Q_C. So Q_C/W = Q_H/W − 1, and the same difference of one holds for the ideal limits.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/published.json
new file mode 100644
index 0000000..55a9678
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Set up the energy balance for one cycle: heat given to the warm side equals heat taken from the cold side plus the electricity, Q_hot = Q_cold + W.",
+      "part": "Level 1 diagram (1 kWh electricity + 2 kWh outdoor heat → 3 kWh delivered) and the 'Energy conservation gives Q_cold = Q_hot − W' line in 'Where the limit comes from'",
+      "idea": "The machine creates no energy. Everything it dumps on the hot side is the heat it picked up on the cold side plus the electricity it used."
+    },
+    {
+      "step": "The same loop can be used for cooling, with the cold coil on the side being cooled, so the same energy and entropy rules apply. For an air conditioner the useful output is Q_cold, so its figure of merit is Q_cold / W.",
+      "part": "Summary ('A fridge uses the same loop, with the cold coil inside the fridge') and the COP definition paragraph",
+      "idea": "COP means useful heat divided by electricity. For heating, the useful heat is what is delivered. For cooling, the question defines it as the heat removed from the cold side."
+    },
+    {
+      "step": "Entropy condition: Q_hot / T_hot ≥ Q_cold / T_cold, with temperatures in kelvin.",
+      "part": "'Where the limit comes from' (refrigerant stores no entropy, electricity carries none, entropy cannot be destroyed) and 'Use kelvin, not Celsius'",
+      "idea": "The warm side must gain at least as much entropy (Q/T) as the cold side loses. Which way the machine is used makes no difference to this."
+    },
+    {
+      "step": "Substitute Q_hot = Q_cold + W: (Q_cold + W)/T_hot ≥ Q_cold/T_cold, so W/T_hot ≥ Q_cold(T_hot − T_cold)/(T_hot·T_cold), so Q_cold/W ≤ T_cold/(T_hot − T_cold).",
+      "part": "Steps 1 and 3, using the same algebra as the 4-line derivation in 'Where the limit comes from'",
+      "idea": "The same rearrangement used for the heating limit, but solved for Q_cold/W instead of Q_hot/W."
+    },
+    {
+      "step": "Compare with the heating limit T_hot/(T_hot − T_cold): the difference is (T_hot − T_cold)/(T_hot − T_cold) = 1. Physically, Q_hot/W = (Q_cold + W)/W = Q_cold/W + 1. This holds for any machine, including the ideal one, so the two limits differ by exactly 1.",
+      "part": "'The ideal limit' formula, plus steps 1 and 4",
+      "idea": "When heating, the electricity itself ends up as delivered heat and counts as useful. When cooling, it is extra heat the machine must dump outside and does not count as heat removed. That is a difference of exactly one unit per unit of electricity."
+    },
+    {
+      "step": "Example: for 0 °C (273.15 K) and 35 °C (308.15 K), the cooling limit is 273.15/35 ≈ 7.8, one less than the heating limit of 8.8.",
+      "part": "'The ideal limit' (308.15/35 = 8.8) and step 4",
+      "idea": "A numerical check with the explanation's own temperatures."
+    }
+  ],
+  "result": "In its ideal limit, the air conditioner removes at most T_cold/(T_hot − T_cold) of heat per unit of electricity, with temperatures in kelvin. For 273.15 K and 308.15 K that is about 7.8. This is exactly one less than the heating limit T_hot/(T_hot − T_cold) because energy is conserved: Q_hot = Q_cold + W, so Q_hot/W = Q_cold/W + 1. A heat pump counts the electricity as part of its useful output, because the electricity ends up as heat delivered inside. An air conditioner cannot count it, because that electricity is extra heat it has to dump outside.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/quick.json
new file mode 100644
index 0000000..e700126
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/heat-pump/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "An air conditioner is the same machine doing the same job: heat goes in at the cold side (the evaporator) and comes out at the hot side (the condenser), with electricity driving the compressor. Only the useful output is different.",
+      "part": "Level 2 paragraph 'A refrigerator uses the same loop…' and the refrigerant-loop diagram",
+      "idea": "The same loop moves heat from a cold place to a warm one. In a fridge or an air conditioner, the evaporator is in the space being cooled and the condenser is outside where it is warm."
+    },
+    {
+      "step": "Energy balance for the machine: Q_hot = Q_cold + W, where W is the electricity.",
+      "part": "Level 1 diagram and the sentence 'heat delivered = heat taken from the air + electricity'",
+      "idea": "No energy is created. The heat given out on the warm side equals the heat taken in on the cold side plus the electricity (3 = 2 + 1)."
+    },
+    {
+      "step": "Define cooling COP = Q_cold / W, heat removed per unit of electricity. By comparison, heating COP = Q_hot / W.",
+      "part": "Level 1 definition of COP",
+      "idea": "COP is useful heat divided by the paid input (electricity). For heating, the useful heat is what reaches the house. For cooling, it is what is taken from the cold inside."
+    },
+    {
+      "step": "Divide the balance by W: Q_cold/W = Q_hot/W − 1, so COP_cool = COP_heat − 1. In the example, 2 kWh removed for 1 kWh of electricity gives 2, which is one less than 3.",
+      "part": "Steps 2 and 3 (algebra: background)",
+      "idea": "The heat delivered to the warm side always includes the electricity itself. The heat taken from the cold side does not. So the two ratios always differ by exactly 1."
+    },
+    {
+      "step": "Ideal heating limit for the same two temperatures: COP_heat,max = T_hot / (T_hot − T_cold), with temperatures in kelvin.",
+      "part": "Level 3, Carnot limit formula and table",
+      "idea": "Physics caps the ratio of heat delivered to work. The cap depends only on the hot and cold temperatures."
+    },
+    {
+      "step": "Ideal cooling limit: COP_cool,max = T_hot/(T_hot − T_cold) − 1 = T_cold/(T_hot − T_cold). Example: with 263 K and 313 K, 313/50 − 1 = 263/50 ≈ 5.3, against 6.3 for heating.",
+      "part": "Steps 4 and 5 (algebra: background)",
+      "idea": "Apply the 'minus one' relation at the ideal limit and simplify. The cooling limit is the cold temperature divided by the temperature lift."
+    }
+  ],
+  "result": "Ideal air-conditioner limit: heat removed per unit of electricity = T_cold / (T_hot − T_cold), with temperatures in kelvin. It is exactly one less than the heating limit T_hot / (T_hot − T_cold). The reason is energy conservation: the heat dumped on the warm side equals the heat taken from the cold side plus the electricity. So the heat delivered per kWh always includes that 1 kWh of electricity, and the heat removed per kWh does not. Dividing Q_hot = Q_cold + W by W gives COP_cool = COP_heat − 1, and T_hot/ΔT − 1 = T_cold/ΔT. Example: −10 °C and 40 °C give a heating limit of 6.3 and a cooling limit of 5.3. One assumption: the explanation states the Carnot limit only for heating. I took it to cover the same loop used for cooling because the explanation says a refrigerator uses the same loop.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/none.json
new file mode 100644
index 0000000..03f787d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/none.json
@@ -0,0 +1,51 @@
+{
+  "steps": [
+    {
+      "step": "Set the goal: all three need the same number, but only values computed from their secrets can be sent, never the secrets themselves.",
+      "part": "Opening section, 'Two ideas solve it' (idea 1)",
+      "idea": "Each person keeps a secret that is never sent. Only results computed from the secrets go over the public channel."
+    },
+    {
+      "step": "Each person picks a private secret: Alice a, Bob b, Carol c. Each publishes their own g^secret mod p, so the channel carries A = g^a, B = g^b and C = g^c.",
+      "part": "The protocol (table, steps 1–3); Summary, bullet 1",
+      "idea": "Pick a secret, compute g^secret mod p, and send only that. Computing it is fast, using repeated squaring."
+    },
+    {
+      "step": "Raising a public value to your own secret multiplies the exponents: (g^x)^y = g^(xy). Because multiplication order doesn't matter, the result is the same whoever applies their secret first.",
+      "part": "The protocol, 'Both get the same s' (B^a = (g^b)^a = g^(ba) = g^(ab)); paint analogy, step 4",
+      "idea": "Order of combining doesn't matter. Mod-p reduction doesn't change that. In paint terms, yellow+red+blue is the same colour in any mixing order."
+    },
+    {
+      "step": "The target key is s = g^(abc) mod p. Each person needs g raised to the product of the other two secrets, and then applies their own secret last.",
+      "part": "Step 3, extended from two to three people",
+      "idea": "Repeated exponentiation just keeps multiplying exponents, so a third secret can be added on top of g^(ab). In paint terms, a third secret colour is mixed in the same way."
+    },
+    {
+      "step": "Second round: Alice computes (g^b)^a = g^(ab) and publishes it. Bob computes (g^c)^b = g^(bc) and publishes it. Carol computes (g^a)^c = g^(ac) and publishes it. These are fresh public messages. The secrets themselves are still never sent.",
+      "part": "Step 3; The protocol, step 4; the code (pow(B, a, p))",
+      "idea": "Anyone can raise a value they received to their own secret with fast modular exponentiation, then pass the result on publicly."
+    },
+    {
+      "step": "Final round: Carol computes (g^(ab))^c, Alice computes (g^(bc))^a, and Bob computes (g^(ac))^b. All three get g^(abc) mod p, the same key.",
+      "part": "Step 3",
+      "idea": "The exponents multiply in any order, so abc = bca = acb and all three results are equal."
+    },
+    {
+      "step": "What Eve sees: p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ac). Multiplying public values together only adds exponents. For example, g^(ab) times g^c gives g^(ab+c), not g^(abc).",
+      "part": "The protocol, paragraph 'Eve knows p, g, A and B…'; paint analogy (orange + green has too much yellow)",
+      "idea": "Combining public values by multiplying gives the wrong exponent, just as mixing the public paints gives the wrong colour."
+    },
+    {
+      "step": "To turn any public value into g^(abc), Eve would have to raise it to a secret she doesn't have. For example, she needs c to turn g^(ab) into g^(abc). Getting c means recovering it from g^c, which is a discrete logarithm. That is infeasible when p is a well-chosen prime of about 2048 bits.",
+      "part": "The hard direction; Summary, bullet 3; HTML 'Eve's attack' brute-force button and scale note",
+      "idea": "Undoing g^x mod p is the discrete logarithm problem. Brute force doubles in cost with each extra bit, and even the best algorithms need about 2^110 operations at 2048 bits."
+    },
+    {
+      "step": "Limits: this only stops a listener. Someone who can change messages, like Mallory, could swap values in the middle. So the exchange also needs authentication, such as signatures and certificates. The final s should also be passed through a key derivation function before use.",
+      "part": "The catch: Eve vs. Mallory; HTML Mallory checkbox; After the exchange",
+      "idea": "Diffie–Hellman protects against eavesdroppers only, not attackers who change messages, and s is processed before it is used as a key."
+    }
+  ],
+  "result": "Each person picks a secret (a, b, c) and publishes g^a, g^b and g^c mod p. Round 2: each raises their neighbour's value to their own secret and publishes it: Alice sends g^(ab), Bob sends g^(bc), Carol sends g^(ca). Round 3: each raises the value they just received to their own secret. Carol computes (g^(ab))^c, Alice computes (g^(bc))^a, and Bob computes (g^(ca))^b. All three get g^(abc) mod p, because exponents multiply in any order. Eve sees g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). Multiplying these together only adds exponents, so it gives the wrong value. To reach g^(abc) she would have to raise some public value to a secret she doesn't know, which means solving a discrete logarithm. That is infeasible at real sizes of p. One caveat: the explanation only argues the hardness for two people (getting g^(ab) from g^a and g^b). I am assuming the same reasoning carries over to three people, but the explanation doesn't say so. As with two people, this protects only against listening. Stopping an attacker who changes messages needs authentication.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/principles.json
new file mode 100644
index 0000000..751ad59
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/principles.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "Set the target. All three must end up with the same number, and none of them may send it or anything that reveals it. That means each keeps a private exponent: Alice a, Bob b, Carol c.",
+      "part": "First attempt: send the key; The answer in one paragraph",
+      "idea": "Anything sent can be read, so the secret is never sent. Each person keeps a private number and sends only a public value made from it."
+    },
+    {
+      "step": "Use the same public setup: p = 23, g = 5. Alice sends A = g^a mod p, Bob sends B = g^b mod p and Carol sends C = g^c mod p. With a = 6, b = 15 and c = 3 (c is my own choice), this gives A = 8, B = 19 and C = 10.",
+      "part": "The working method table, step 2; the Mallory paragraph (5³ mod 23 = 10)",
+      "idea": "A public value is g raised to the private exponent, mod p. The explanation already gives 5⁶=8, 5¹⁵=19 and 5³=10 mod 23."
+    },
+    {
+      "step": "Choose a shared key that all three can reach: g^(a×b×c) mod p. Exponents can be applied one after another in any order, so each person can add their own exponent to a value that already holds the other two.",
+      "part": "Why the two results are equal",
+      "idea": "(g^b)^a = (g^a)^b = g^(a×b), because the order of the exponents does not matter. Reducing mod p at each step does not change the result."
+    },
+    {
+      "step": "Round 2, sent in public: each person raises the next person's value to their own exponent and sends the result on. Alice sends B^a = g^(ab). Bob sends C^b = g^(bc). Carol sends A^c = g^(ca). In numbers: 19⁶ mod 23 = 2, 10¹⁵ mod 23 = 5, and 8³ mod 23 = 512 mod 23 = 6.",
+      "part": "The working method table, step 3; step 3",
+      "idea": "Raising someone's public value to your private exponent gives g to the product of the two exponents. The table gives 19⁶ mod 23 = 2. I worked out the other two by hand."
+    },
+    {
+      "step": "Round 3, done privately: each person raises the two-exponent value they receive to their own exponent. Carol takes g^(ab) to the power c: 2³ = 8. Alice takes g^(bc) to the power a: 5⁶ = 8. Bob takes g^(ca) to the power b: 6¹⁵ mod 23 = 8. All three get g^(abc) mod p = 8.",
+      "part": "Why the two results are equal; step 4",
+      "idea": "Since the order of exponents does not matter, all three results equal g^(a×b×c) mod p. The explanation's table of powers gives 5⁶ = 8. I worked out 6¹⁵ mod 23 = 8 by hand."
+    },
+    {
+      "step": "Eve's view: she sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). These are 23, 5, 8, 19, 10, 2, 5 and 6. She never sees a, b, c or the key 8.",
+      "part": "The working method (what Eve sees); steps 2 and 4",
+      "idea": "Only public values travel on the channel. The private exponents and the final combination never do."
+    },
+    {
+      "step": "Why Eve is stuck: every value she has is missing at least one exponent. To add the missing one she needs that exponent, for example c from g^c. Getting it means solving 'g to what power gives this, mod p?', which is the discrete logarithm problem. For a 2048-bit p that takes about 2¹¹² operations, while the three honest users each do only a few thousand multiplications per power.",
+      "part": "Why Eve cannot do the same; Epistemic status",
+      "idea": "The explanation says that to get the secret Eve needs a private exponent. Getting one means undoing exponentiation mod p (the discrete logarithm), which is assumed to be infeasible for large p. Computing powers forward is fast."
+    },
+    {
+      "step": "Caveat: this only stops a passive eavesdropper. Someone who can change messages (Mallory) could replace the values, so all six messages would need authentication.",
+      "part": "Where the guarantee breaks: an attacker who can change messages",
+      "idea": "Diffie–Hellman defeats someone who only reads, not a man-in-the-middle. Public values must be signed."
+    }
+  ],
+  "result": "1. All three agree in public on p and g.\n2. Each person sends g^(own exponent) mod p.\n3. Each person raises one other person's public value to their own exponent and sends the result: g^(ab), g^(bc) and g^(ca).\n4. Each person raises the two-exponent value that lacks their own exponent to that exponent. All three get g^(abc) mod p, because the order of exponents doesn't matter. With p = 23, g = 5, a = 6, b = 15 and c = 3, all three get 8.\n\nEve sees only values that are each missing at least one exponent. To finish any of them she must recover a private exponent, which is a discrete logarithm, and that is infeasible for large p. This holds only for an eavesdropper who reads; against someone who changes messages, the messages must also be authenticated.",
+  "gap": "Minor: the explanation only describes the discrete logarithm with base g. It doesn't say that recovering b from g^a and g^(ab), which uses base g^a, is equally hard. It also doesn't rule out Eve combining g^(ab), g^(bc) and g^(ca) some other way. I extended its claim 'to find the secret, Eve needs a or b' to cover this case."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/published.json
new file mode 100644
index 0000000..21d3231
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/published.json
@@ -0,0 +1,51 @@
+{
+  "steps": [
+    {
+      "step": "Every public number has the form g^(something) mod p, and raising a received number to your own private exponent multiplies that exponent into it. (g^x)^y mod p = g^(xy) mod p, even when remainders are taken along the way.",
+      "part": "'Why both get 2' paragraph",
+      "idea": "(5^15)^6 and (5^6)^15 both equal 5^(6×15). Replacing a factor with its remainder only removes multiples of 23, so the final remainder does not change."
+    },
+    {
+      "step": "Choose the target key s = g^(abc) mod p. Alice, Bob and Carol each pick a private number (a, b, c) and never send it.",
+      "part": "'The exchange, with small numbers', items 1–2; step 1",
+      "idea": "Each person keeps a random private number and only ever sends g raised to private numbers, mod p. With three people, the natural shared value is the exponent product abc."
+    },
+    {
+      "step": "Round 1: each person sends g^(own private) mod p: Alice sends g^a, Bob sends g^b, Carol sends g^c. (Example with p=23, g=5, a=6, b=15, c=3: 8, 19, 10.)",
+      "part": "'The exchange', item 3; 'The limit' section (5^3 mod 23 = 10)",
+      "idea": "This is the same public-number step as in the two-person exchange."
+    },
+    {
+      "step": "Round 2: each person raises the number they received from the person before them in a cycle to their own private number and passes the result on. Bob turns g^a into g^(ab) and sends it to Carol. Carol turns g^b into g^(bc) and sends it to Alice. Alice turns g^c into g^(ca) and sends it to Bob. (Example: 2, 5, 6.)",
+      "part": "'The exchange', item 4; step 1",
+      "idea": "Raising to your private exponent multiplies it into the exponent. You never need to undo anything."
+    },
+    {
+      "step": "Round 3: each person raises the two-exponent value they received to their own private number. Carol computes (g^(ab))^c, Alice computes (g^(bc))^a, and Bob computes (g^(ca))^b. All three equal g^(abc) mod p. (Example: 2^3 = 8 and 5^6 = 8 mod 23.)",
+      "part": "Step 1 ('Why both get 2')",
+      "idea": "Multiplying exponents gives the same product in any order, so all three get the same s. They then hash it into the encryption key as described."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). Every one of these is missing at least one of the private exponents.",
+      "part": "'What Eve sees' table",
+      "idea": "Eve gets all the public numbers but none of the private ones."
+    },
+    {
+      "step": "Combining public numbers by multiplying only adds exponents. For example, g^(ab)·g^c = g^(ab+c), not g^(abc). So Eve cannot simply merge what she sees.",
+      "part": "'What Eve sees' paragraph (8 × 19 = 5^(6+15))",
+      "idea": "Multiplying powers adds exponents, but the secret needs the exponents multiplied."
+    },
+    {
+      "step": "From Eve's point of view, the pair g^(ab) and g^c is just a two-person exchange whose private numbers are ab and c. Getting g^(abc) is exactly the problem of getting s from A and B, which as far as anyone knows needs a discrete logarithm.",
+      "part": "'What Eve sees'; 'Why powers, and why mod'; 'Why real numbers are huge'",
+      "idea": "No known way from A and B to s other than finding a private exponent. With a 2048-bit p, finding one takes about 2^112 operations."
+    },
+    {
+      "step": "Limits: this security is an unproven assumption. It also only protects against someone who reads messages, not against someone who replaces them, so the messages need authentication.",
+      "part": "'Assumption, not proof'; 'The limit: an attacker who changes messages'",
+      "idea": "Hardness rests on decades of failed attacks. Mallory can swap public numbers unless they are signed."
+    }
+  ],
+  "result": "They use a three-round chain. (1) Each person publishes g^x mod p for their own private x. (2) Each person raises the previous person's number to their own private exponent and passes it on, which gives g^(ab), g^(bc) and g^(ca). (3) Each person raises the value they receive to their own exponent, so all three get g^(abc) mod p and hash it into the key. Example: p=23, g=5, a=6, b=15, c=3 gives a key of 8. Eve sees only powers that each lack at least one private exponent. Multiplying them only adds exponents. Getting g^(abc) from, say, g^(ab) and g^c is the two-person Diffie–Hellman problem again, and as far as anyone knows that needs a discrete logarithm, which has no known fast method for a large p. This rests on an assumption, not a proof, and it only stops eavesdroppers, not attackers who replace messages.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/quick.json
new file mode 100644
index 0000000..cc36f9c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/key-exchange/quick.json
@@ -0,0 +1,56 @@
+{
+  "steps": [
+    {
+      "step": "Set the public setup: everyone, Eve included, knows the prime p and the base g (for example p = 23, g = 5).",
+      "part": "How it works, step 1",
+      "idea": "p and g are agreed in public and are not secret."
+    },
+    {
+      "step": "Each of the three picks a private number and never sends it: Alice a, Bob b, Carol c (for example a = 6, b = 15, and c = 3, which I chose).",
+      "part": "How it works, step 2",
+      "idea": "Each person's secret is a random exponent that never goes on the channel."
+    },
+    {
+      "step": "Each sends a public value: A = g^a mod p, B = g^b mod p, C = g^c mod p. In the example A = 8, B = 19, C = 5^3 mod 23 = 10.",
+      "part": "How it works, step 3",
+      "idea": "A public value is g raised to your private number, mod p."
+    },
+    {
+      "step": "Raising someone else's public value to your own private number adds your exponent to theirs as a product: (g^b)^a = g^(ab). Doing this again gives g^(abc), whatever the order.",
+      "part": "How it works, paragraph after step 4 ('Order does not matter'), plus background exponent rules",
+      "idea": "Applied once, the rule gives g^(ab). Applied twice (background power rules, and taking mod p at each stage is fine because the explanation does it), it gives g^(abc). The order of a, b, c does not matter."
+    },
+    {
+      "step": "Second round: each person raises the value they just received to their own private number and publishes the result. Alice publishes B^a = g^(ab), Bob publishes C^b = g^(bc), Carol publishes A^c = g^(ac). In the example: 19^6 = 2, 10^15 = 19, and 8^3 = 6 (all mod 23).",
+      "part": "Step 4",
+      "idea": "Each new value carries the product of two private exponents. It is sent in public, like any other message."
+    },
+    {
+      "step": "Each person takes the second-round value that is missing their own exponent and raises it to their private number. Carol: (g^(ab))^c, which is 2^3 = 8. Alice: (g^(bc))^a, which is 19^6 = 2^... no, 19^6 = 8 when computed as 5^6 mod 23 from 19^3 → 5. Bob: (g^(ac))^b, which is 6^15 = 8. All three get g^(abc) = 8.",
+      "part": "Steps 4 and 5",
+      "idea": "Every path ends at g^(abc) mod p, because the order of the exponents does not matter. The shared key is 8, and it is never sent."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ac). Each of these is missing at least one of the three exponents. To add the missing one she would have to recover an exponent, such as c from g^c, or ab from g^(ab). That is a discrete logarithm.",
+      "part": "Why Eve fails, first paragraph",
+      "idea": "Getting an exponent back from g^x mod p is the discrete logarithm problem."
+    },
+    {
+      "step": "Eve cannot shortcut by combining the public values. Multiplying them adds exponents, so for example g^(ab)·g^c = g^(ab+c), not g^(abc).",
+      "part": "Why Eve fails, last paragraph (8 × 19 gives 5^(6+15))",
+      "idea": "Multiplying public values gives sums of exponents, never products."
+    },
+    {
+      "step": "With a large p (2048 bits) the discrete logarithm takes about 2^112 operations, so Eve is stuck. Each participant only needs fast repeated squaring.",
+      "part": "Why Eve fails, second paragraph; Limits ('Hardness is assumed, not proven')",
+      "idea": "Small p can be brute-forced, but large p is infeasible as far as anyone knows. This is an assumption, not a proof."
+    },
+    {
+      "step": "Caveat: this only holds if Eve can read but not change messages. Otherwise the public values need to be authenticated.",
+      "part": "Limits, first bullet (Mallory)",
+      "idea": "Someone who can replace messages can stand in the middle, so the public values must be signed."
+    }
+  ],
+  "result": "Use two rounds. Round 1: each person publishes g^x mod p from their private number x (a, b, c). Round 2: each raises the value they received to their own number and publishes it, giving g^(ab), g^(bc) and g^(ac). Each then raises the one second-round value missing their own exponent to their private number, so all three get the key g^(abc) mod p. In the example, with c = 3 chosen by me, the key is 8. The key itself is never sent. Eve sees only values with at least one exponent missing. Adding it would mean solving a discrete logarithm, which is infeasible for a 2048-bit p, and multiplying the public values only adds exponents. This assumes Eve only reads and does not change messages.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/none.json
new file mode 100644
index 0000000..cb96fb8
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a read to see the latest committed write, the read group must share at least one server with the write group that committed it.",
+      "part": "Why a majority, and not \"whoever is still up\"? (paragraph after 'Two majorities of the same group always share at least one member')",
+      "idea": "Consistency comes from overlap. A server that was in the earlier group and is also in the later group carries the earlier decision forward. With no shared server, the later group can't know about the earlier decision."
+    },
+    {
+      "step": "Two groups of sizes W and R taken from n servers are sure to share a server exactly when W + R > n.",
+      "part": "Same paragraph: 'together they would contain more than all of them, which is impossible unless some server is in both'",
+      "idea": "The explanation counts two majorities. The same counting works for groups of any size: if their sizes add up to more than n, they can't fit without sharing a server. If W + R ≤ n, they could be completely separate. This is a generalisation I made; the explanation itself only treats two equal majorities."
+    },
+    {
+      "step": "With n = 5 the condition is W + R > 5, so W + R ≥ 6.",
+      "part": "Step 2",
+      "idea": "Put n = 5 into the overlap condition."
+    },
+    {
+      "step": "W = 4, R = 2 meets the condition, since 4 + 2 = 6 > 5. Also, W = 4 is more than half of 5, so any two write groups overlap too and two conflicting writes can't both commit.",
+      "part": "Step 3; 'Why a majority…' (split brain) and 'Now count'",
+      "idea": "Check the sum. Separately, write groups must overlap each other, as majorities do, or split brain becomes possible. 4 > 2.5 satisfies that."
+    },
+    {
+      "step": "An operation can go ahead as long as enough servers are up to form its group, so the failures it tolerates are n minus the group size.",
+      "part": "Now count ('failures tolerated = n − quorum size')",
+      "idea": "The explanation gives this rule for one majority quorum. I apply it to each group size separately."
+    },
+    {
+      "step": "Writes tolerate 5 − 4 = 1 failure. Reads tolerate 5 − 2 = 3 failures.",
+      "part": "Step 5",
+      "idea": "Plug in W = 4 and R = 2."
+    }
+  ],
+  "result": "The rule is W + R > 5 (so W + R ≥ 6). This makes every read group share a server with every write group. W > 2.5 is also wanted so that two writes can't conflict. With W = 4 and R = 2, writes keep working with up to 1 failed server and reads keep working with up to 3.",
+  "gap": "The explanation only covers equal majority quorums. It never describes separate read and write groups or the W + R > n rule. I had to extend its overlap-counting argument and its 'n − quorum size' formula to unequal groups myself."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/principles.json
new file mode 100644
index 0000000..c340525
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a read to see the latest committed write, the read group must share at least one server with the write group that committed it. That shared server holds the write.",
+      "part": "The fix: any two deciding groups must share a server",
+      "idea": "Safety comes from making sure any two deciding groups share at least one server. That shared server carries what one group decided into the other group. The page applies this to two conflicting writes. I am applying the same idea to a write group and a read group, which the page does not do itself."
+    },
+    {
+      "step": "Two groups inside n servers must overlap when their sizes add up to more than n. With n = 5, the condition is W + R > 5, so W + R ≥ 6.",
+      "part": "The fix: any two deciding groups must share a server (the 'sizes add up to more than n' sentence and q + q > n)",
+      "idea": "The page states the overlap rule in terms of the sum of the two group sizes. Here the two sizes are W and R instead of q and q."
+    },
+    {
+      "step": "Two write groups must also overlap each other, or two conflicting writes could both pass. This needs W + W > 5, so W ≥ 3.",
+      "part": "The fix: any two deciding groups must share a server; Why 'half' is not enough",
+      "idea": "Write groups play the role of the page's deciding groups, so the rule q > n/2 applies to W. This is the split-brain protection."
+    },
+    {
+      "step": "Check W = 4, R = 2: 4 + 2 = 6 > 5, so every read group overlaps every write group. Also 4 + 4 = 8 > 5, so write groups overlap each other. The configuration is safe.",
+      "part": "Steps 2 and 3",
+      "idea": "Put the numbers into both conditions."
+    },
+    {
+      "step": "An operation can go ahead while at least as many servers as its group size are alive. So it tolerates n minus its group size failures.",
+      "part": "From quorum to failure tolerance (f = n − q)",
+      "idea": "Failures tolerated = n − q. I apply this to the write group size and the read group size separately."
+    },
+    {
+      "step": "Writes: 5 − 4 = 1 failure. Reads: 5 − 2 = 3 failures. With more failures than that, the operation stops (becomes unavailable) but stays correct.",
+      "part": "Step 5; What 'survive' means, and where it stops",
+      "idea": "Above the limit the cluster refuses to act rather than risk giving a wrong answer."
+    }
+  ],
+  "result": "W and R must satisfy W + R > 5 (so W + R ≥ 6), so that every read group shares a server with the latest write group. To stop conflicting writes, W + W > 5 is also needed, so W ≥ 3. W = 4 and R = 2 meet both conditions (4 + 2 = 6 > 5 and 4 + 4 = 8 > 5). Writes survive 5 − 4 = 1 failure and reads survive 5 − 2 = 3 failures. Caveat: the explanation never discusses separate read and write groups. These answers come from applying its overlap rule and its formula f = n − q to read and write groups myself.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/published.json
new file mode 100644
index 0000000..888c664
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Any two groups of servers whose sizes add up to more than n must have at least one server in common.",
+      "part": "Why more than half works, paragraph 2 (overlap)",
+      "idea": "If two quorums together list more than n servers, some server has to appear in both. The page uses this for two majorities (3 + 3 = 6 > 5), but the counting works for any two group sizes."
+    },
+    {
+      "step": "A server that belongs to both groups is what carries a decided change from one group to the next.",
+      "part": "Why more than half works, paragraph 3, and Limits, 'Simplified' bullet",
+      "idea": "The shared server already accepted x = 1. In real protocols it reports x = 1 to the new group, so the new group learns about the earlier decision. Limits says reads are 'not covered', so I am treating a read group as one more group that must contain such a server."
+    },
+    {
+      "step": "For a read to see the latest committed write, every read group of R servers must share a server with every write group of W servers. So W + R > 5.",
+      "part": "Steps 1 and 2",
+      "idea": "By the counting in step 1, the groups are certain to overlap only if W + R > n = 5. If W + R ≤ 5, a read group can be completely separate from the write group and miss the write. That is the same failure as the {A,B} / {C,D} split in 'Why not let the survivors go on?'."
+    },
+    {
+      "step": "Two write groups must also overlap so that two different writes cannot both be decided. So W + W > 5, which means W ≥ 3.",
+      "part": "Why not let the survivors go on? (split brain table) and step 1",
+      "idea": "Two write groups with no server in common can each decide a different change 7. Requiring 2W > n rules that out."
+    },
+    {
+      "step": "Check W = 4 and R = 2: 4 + 2 = 6 > 5, and 4 + 4 = 8 > 5. Both conditions hold.",
+      "part": "Steps 3 and 4",
+      "idea": "Simple arithmetic against the two conditions."
+    },
+    {
+      "step": "An operation that needs a group of size Q can survive n − Q failures.",
+      "part": "Counting failures (tolerance = n − majority size), and 'Why more than half works', paragraph 1",
+      "idea": "If fewer than the needed number of servers answer, the operation stops. A larger group is still safe but lets fewer servers fail. So the tolerance is n minus the group size."
+    },
+    {
+      "step": "Writes survive 5 − 4 = 1 failure. Reads survive 5 − 2 = 3 failures.",
+      "part": "Steps 5 and 6",
+      "idea": "Apply tolerance = n − group size to W = 4 and R = 2."
+    }
+  ],
+  "result": "W and R must satisfy W + R > 5, so that every read group shares at least one server with every write group. To stop two writes from both being decided, W must also be more than half of 5 (2W > 5, so W ≥ 3). W = 4 and R = 2 meet both conditions (4 + 2 = 6 > 5). Writes can survive 5 − 4 = 1 failure and reads can survive 5 − 2 = 3 failures. One caveat: the explanation says it does not cover reads. Applying the overlap argument to read groups is my extension of its counting argument and its 'Simplified' note.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/quick.json
new file mode 100644
index 0000000..2cf18ee
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/quorum/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "A committed write is on all W servers of its write group. A failure is a server that does not reply, and an operation can only go ahead while enough of its group can still reply.",
+      "part": "The setup (definitions of quorum and failure, and the tolerance paragraph)",
+      "idea": "An operation needs its quorum of servers to reply. The number of failures it survives is servers minus quorum."
+    },
+    {
+      "step": "For a read to see the latest committed write, its read group must share at least one server with that write group. That shared server holds the write.",
+      "part": "Why the quorum must be a majority (the paragraph on fixing split brain)",
+      "idea": "Safety comes from forcing any two quorums to share a server. The shared server links the two groups."
+    },
+    {
+      "step": "A group of W servers and a group of R servers can avoid sharing a server only if W + R ≤ 5. So we need W + R > 5, which means W + R ≥ 6. With five servers, W = 4 and R = 2 just meets this (4 + 2 = 6 > 5).",
+      "part": "Why the quorum must be a majority ('Two groups of size q fit into n servers without a shared server only if 2q ≤ n'), extended to two different sizes with simple counting (background)",
+      "idea": "Two groups can be kept apart only if their sizes add up to no more than n. To force a shared server, the sizes must add up to more than n."
+    },
+    {
+      "step": "Two writes must not both succeed without seeing each other, so write groups must also overlap: 2W > 5, which means W ≥ 3. W = 4 meets this (8 > 5).",
+      "part": "Why the quorum must be a majority (split brain example and the 2q > n rule)",
+      "idea": "Two decision-making groups that do not overlap can commit conflicting values."
+    },
+    {
+      "step": "Writes survive 5 − 4 = 1 failure. Reads survive 5 − 2 = 3 failures.",
+      "part": "The setup (tolerance claim: failures tolerated = servers − quorum)",
+      "idea": "An operation keeps working while at least its quorum can still reply."
+    }
+  ],
+  "result": "W + R > 5, which here means W + R ≥ 6. Writes also need 2W > 5 so that two writes cannot conflict. With W = 4 and R = 2: 4 + 2 = 6 > 5 and 2·4 = 8 > 5, so both hold. Writes survive 1 failure (5 − 4) and reads survive 3 failures (5 − 2). One assumption is not in the explanation: that a reader can tell which reply is the newest, for example by a version number.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/none.json
new file mode 100644
index 0000000..d7f8e2d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Each body raises two bulges along its own line, with lows at 90° to that line.",
+      "part": "Section 2 (table, bullets and rugby-ball diagram) and Section 6, first paragraph",
+      "idea": "The leftover pull stretches water along the line to the body and squeezes it across that line. The Sun makes its own pair of bulges, lined up with the Sun."
+    },
+    {
+      "step": "The lows are half as deep as the highs are high, so the high-to-low range for one body is 1.5 × its high-point height A.",
+      "part": "Section 3 (the sideways squeeze is about GMR/d³, half the 2GMR/d³ stretch), Section 4 (equilibrium tide +0.36 m / −0.18 m) and the script's height() function in index.html",
+      "idea": "The code's water height is A(1.5cos²a − 0.5): +A under the body and −0.5A at 90° to it, so the range is 1.5A."
+    },
+    {
+      "step": "Sun's strength compared with the Moon's: A_Sun ≈ 0.46 × A_Moon. In metres, A_Moon = 0.36 and A_Sun = 0.165.",
+      "part": "Section 6 ('about 46% of the Moon's') and the constants AM = 0.36, AS = 0.165 in index.html's script",
+      "idea": "Tidal effect goes as mass/distance³, so the Sun's tide is about 46% of the Moon's."
+    },
+    {
+      "step": "At spring tides (Sun and Moon in line), the highs add and the lows add. High = 0.36 + 0.165 = 0.525 m, low = −0.2625 m, range ≈ 0.79 m = 1.5 × (A_Moon + A_Sun).",
+      "part": "Section 6 (spring tides) and the 'Add the Sun' control at 0 or 14.8 days in index.html; steps 2–3",
+      "idea": "When the two sets of bulges line up, their heights simply add."
+    },
+    {
+      "step": "At the quarter moons, the Sun is at 90°, so the Sun's high falls where the Moon's low is, and the Sun's low falls under the Moon's high. Under the Moon: 0.36 − 0.0825 = 0.2775 m. At 90°: −0.18 + 0.165 = −0.015 m. Range ≈ 0.29 m = 1.5 × (A_Moon − A_Sun).",
+      "part": "Section 6 ('the Sun's bulges partly fill in the Moon's lows' → neap tides), the 'Add the Sun' control at about 7.4 or 22 days, and height(), which adds the two terms; steps 1–3",
+      "idea": "At right angles the two patterns work against each other, so the tide is the Moon's pattern reduced by the Sun's."
+    },
+    {
+      "step": "Neap compared with spring: (A_Moon − A_Sun)/(A_Moon + A_Sun) = 0.54/1.46 ≈ 0.37.",
+      "part": "Steps 4–5",
+      "idea": "Divide the neap range by the spring range."
+    }
+  ],
+  "result": "At the quarter moons you get neap tides, which are much smaller than spring tides. Under the explanation's idealised equilibrium tide, the high-to-low range at neap is (1 − 0.46)/(1 + 0.46) ≈ 0.37 of the spring range. That is about 0.29 m against about 0.79 m, so roughly a third. High water at neap reaches about 0.28 m, against about 0.53 m at springs. The Moon still dominates because the Sun's tide is only about 46% of the Moon's, so the Sun only partly cancels it. Real coasts change these numbers (section 7).",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/principles.json
new file mode 100644
index 0000000..0be02fd
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Take the Moon's tidal effect as 1 unit and the Sun's as 0.46 units.",
+      "part": "The Sun does the same thing",
+      "idea": "The Sun makes bulges in the same way as the Moon. Tides depend on M/d³, so the Sun's effect is about 46% of the Moon's."
+    },
+    {
+      "step": "Each body makes a pattern with two parts: high water (bulges) along its own line to the Earth, and low water (squeeze) at 90° from that line.",
+      "part": "Step 2: compute the pull at three points (the squeeze paragraph and the bulge/squeeze diagram)",
+      "idea": "The two bulges point toward and away from the body. The sides at 90° are squeezed, and water flows from the squeezed sides to the stretched ends."
+    },
+    {
+      "step": "At spring tides the two patterns line up, so the height ranges add: 1 + 0.46 = 1.46 units.",
+      "part": "The Sun does the same thing",
+      "idea": "At new and full moon the Sun and Moon line up, their bulges add, and the result is large spring tides."
+    },
+    {
+      "step": "At first and third quarter, the Sun's bulges fall where the Moon squeezes, and the Sun squeezes where the Moon's bulges are. The Sun raises water where the Moon lowers it, so the two ranges subtract: 1 − 0.46 = 0.54 units. The Moon's pattern still wins, so high water still follows the Moon.",
+      "part": "Steps 1 and 2; 'The Sun does the same thing' (at 90° they partly cancel: neap tides)",
+      "idea": "With the bodies at right angles, each one's high-water direction is the other's low-water direction. This gives the partial cancellation the explanation calls neap tides. I assume the two effects simply add or subtract, which the text implies when it says the bulges 'add' at spring tides."
+    },
+    {
+      "step": "Compare: 0.54 / 1.46 ≈ 0.37.",
+      "part": "Steps 3 and 4 (background arithmetic)",
+      "idea": "Ratio of the neap range to the spring range."
+    },
+    {
+      "step": "Put it in metres for the ideal ocean: the Moon alone gives about 0.5 m. That makes spring tides about 0.73 m and neap tides about 0.27 m.",
+      "part": "Step 3: what the number means",
+      "idea": "For an ideal ocean covering the whole Earth, the Moon's equilibrium tide is about half a metre from bulge to squeeze."
+    }
+  ],
+  "result": "At quarter moons you get neap tides. The Sun's bulges sit where the Moon squeezes the water, so the Sun's effect is subtracted from the Moon's instead of added. The tidal range is about (1 − 0.46)/(1 + 0.46) ≈ 0.37 of the spring range, so roughly a third. For the ideal ocean that is about 0.27 m against about 0.73 m. This assumes the two effects simply add, and it holds only for the idealized model; real coasts change the numbers.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/published.json
new file mode 100644
index 0000000..ac2b0c6
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "The Moon's tidal acceleration stretches the ocean along the Earth–Moon line, making two bulges. It squeezes the ocean across that line, giving low water at the side points.",
+      "part": "Section 'Only the part that differs from the centre's pull acts' (side-point paragraph) and the text diagram",
+      "idea": "The tidal acceleration is about +1.1 µm/s² outward at both ends of the line and 0.55 µm/s² inward at the 90° points. So high water lies on the line and low water lies 90° from it."
+    },
+    {
+      "step": "The Sun produces the same kind of stretch along the Earth–Sun line, at about 0.46 times the Moon's strength.",
+      "part": "Section 'Why subtract: two tests', second test (the Sun)",
+      "idea": "The tidal acceleration is roughly the pull × 2R/d. For the Sun this gives 179/389 ≈ 0.46 of the Moon's value, and observed solar tides are about half the Moon's."
+    },
+    {
+      "step": "Accelerations from the two bodies add as vectors, so the two stretch patterns add on top of each other.",
+      "part": "background",
+      "idea": "Vector addition of accelerations (school physics)."
+    },
+    {
+      "step": "Spring tides: when the Sun and Moon are in line, their bulges coincide and add. The tide's strength is about 1 + 0.46 = 1.46 Moon-units.",
+      "part": "Steps 2 and 3, plus the question's framing (the explanation never defines 'spring tide'; I take it as the in-line case)",
+      "idea": "Both bodies stretch along the same line and squeeze across the same line, so the effects reinforce."
+    },
+    {
+      "step": "Quarter Moon: the Sun's line is 90° from the Moon's. The Sun's bulges sit where the Moon makes low water, and the Sun's low water sits under the Moon's bulges. So the two partly cancel.",
+      "part": "Steps 1, 2 and 3",
+      "idea": "Along the Moon line the Moon stretches (+1) and the Sun squeezes. Across it the Moon squeezes and the Sun stretches. The difference between high and low is about 1 − 0.46 = 0.54 Moon-units, and high water stays under the Moon because the Moon is stronger."
+    },
+    {
+      "step": "Compare the two cases.",
+      "part": "Steps 4 and 5",
+      "idea": "0.54 / 1.46 ≈ 0.37."
+    }
+  ],
+  "result": "At quarter Moon the Sun's bulges fall where the Moon makes low water, so the solar tide partly cancels the lunar one. The tides are about (1 − 0.46) of the Moon's tide alone, versus (1 + 0.46) at spring tides. That makes them roughly a third (about 37%) of the size of spring tides. High water still follows the Moon. This holds in the explanation's ideal-ocean picture; real coasts differ.",
+  "gap": "Minor: the explanation never defines spring tides and never says that the Sun's and Moon's tides add together. I took spring tides to mean Sun and Moon in line, and used vector addition of accelerations as background."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/quick.json
new file mode 100644
index 0000000..d5f955b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/two-tides/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "The Moon's tide is two bulges lined up with the Moon, one on the side facing it and one on the far side.",
+      "part": "Opening summary paragraph and the section 'Only the difference in pull moves water' (bullets and diagram)",
+      "idea": "Water on the near side is pulled more than Earth's centre and water on the far side is pulled less, so the water bulges out at both ends of the Earth–Moon line."
+    },
+    {
+      "step": "Between the two lunar bulges, at 90° from the Earth–Moon line, the water is lowest.",
+      "part": "Opening summary paragraph, the diagram, and the section 'Why two highs, and why not exactly every 12 hours'",
+      "idea": "A coast point meets a high a quarter turn before and after each low, so it meets a low halfway between the bulges. This is my own geometric inference: the text never says where low water is."
+    },
+    {
+      "step": "The Sun makes the same kind of tide: a smaller pair of bulges lined up with the Sun, about 0.46 the size of the Moon's.",
+      "part": "Section 'Evidence that the difference is what counts: the Sun', plus the Limits bullet 'Not covered'",
+      "idea": "Only the difference in pull across Earth matters, and it falls off as 1/d³. So the Sun's tide is 0.46 of the Moon's, and the Limits bullet calls it the Sun's 'smaller pair of bulges'."
+    },
+    {
+      "step": "At spring tides the two pairs of bulges add.",
+      "part": "Limits bullet 'Not covered: spring and neap tides…adds to'",
+      "idea": "When the Sun and Moon lie on one line, the two pairs of bulges sit in the same places and add, giving a range of about 1 + 0.46 = 1.46 times the Moon's tide alone. Assumption: the sizes add simply. The text says 'adds' but does not say how."
+    },
+    {
+      "step": "At first and third quarter the Sun's bulges sit at the Moon's lows, so they partly cancel.",
+      "part": "Steps 2–3 and Limits bullet '…or partly cancels the Moon's'",
+      "idea": "With the Sun at 90° to the Moon, the Sun raises water where the Moon's tide is low and lowers it under the Moon's bulges. The range is about 1 − 0.46 = 0.54 times the Moon's tide alone."
+    },
+    {
+      "step": "Compare the two cases.",
+      "part": "Steps 4 and 5",
+      "idea": "0.54 / 1.46 ≈ 0.37."
+    }
+  ],
+  "result": "The tides are smaller. At quarter Moon the Sun's bulges partly cancel the Moon's, so the range is about 1 − 0.46 = 0.54 of the Moon's tide alone, compared with about 1.46 at spring tides. That makes these tides (neap tides) roughly 0.37 of spring tides, a bit over a third, in the idealized single-ocean model. One caution: the explanation says spring and neap tides are 'not covered'. It only says the Sun's bulges 'add to or partly cancel' the Moon's. That the right-angle case is the cancelling one, and that the sizes simply add or subtract, are my own inferences.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/none.json
new file mode 100644
index 0000000..0be91eb
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated division, so their number doubles at a fixed rate.",
+      "part": "Step 3: Amplify and refine — 'Amplify: clonal expansion' paragraph",
+      "idea": "A selected cell divides about once every 6 to 12 hours for days, and one cell becomes thousands of identical copies. That makes the 'double every 12 hours' model reasonable."
+    },
+    {
+      "step": "Vaccination means the response starts from many more matching cells than a first infection does.",
+      "part": "Step 4: Keep copies — memory, the naive-vs-memory table",
+      "idea": "Before any exposure only a handful of cells fit the antigen. Memory leaves hundreds to thousands of times more, which matches the factor of 1,000 in the question."
+    },
+    {
+      "step": "Time needed to reach 'enough' cells, N, starting from N0 cells: t = 12 h × log2(N/N0).",
+      "part": "background",
+      "idea": "Doubling arithmetic: after k doublings you have N0 × 2^k cells, so you need k = log2(N/N0) doublings."
+    },
+    {
+      "step": "Time saved = 12 h × [log2(N/N0) − log2(N/(1000·N0))] = 12 h × log2(1000).",
+      "part": "3 (with background log rules)",
+      "idea": "Take the difference of the two times. N cancels, so the saving depends only on the starting ratio and the doubling time."
+    },
+    {
+      "step": "log2(1000) ≈ 10, because 2^10 = 1024. So the saving is about 10 doublings × 12 h = 120 h, which is about 5 days.",
+      "part": "4",
+      "idea": "Starting 1,000 times bigger is the same as having already done about 10 doublings."
+    },
+    {
+      "step": "Check against the explanation's timings.",
+      "part": "Step 4 paragraph and antibody-level diagram; 'So what does a vaccine do?'",
+      "idea": "The primary response takes about 1–2 weeks to reach useful levels and the secondary one starts within days. A head start of about 5 days fits that."
+    }
+  ],
+  "result": "It reaches full strength about 5 days sooner: 1000 ≈ 2^10, so the vaccinated person skips about 10 doublings of 12 h each, about 120 h. This doesn't depend on the threshold because growth is by multiplication. The time to reach any target N is 12 h × log2(N/start), so the difference between the two starts is 12 h × log2(1000) and N cancels out. Whatever counts as 'enough', the bigger starting group is always the same 10 doublings ahead. (If the doubling time were 6 h, the low end the explanation gives, the saving would be about 2.5 days.)",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/principles.json
new file mode 100644
index 0000000..63e3184
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by doubling: after n doublings, a starting count S becomes S × 2^n.",
+      "part": "Step 3: the selected cells multiply, then most die (clonal expansion and the worked example 100 × 2¹⁵)",
+      "idea": "Activated lymphocytes divide over and over and all their descendants carry the same receptor, so the count grows exponentially. The worked example multiplies the starting count by 2 for each doubling."
+    },
+    {
+      "step": "The number of doublings needed to reach a target N from a start S is log₂(N/S).",
+      "part": "Step 3, the 'second encounter' paragraph (log₂(20) ≈ 4.3 doublings)",
+      "idea": "The explanation works out the time to reach 3.3 million cells from 164,000 as log₂ of the ratio between the target and the starting count, then turns those doublings into days."
+    },
+    {
+      "step": "First infection: doublings = log₂(N/S). After vaccination: doublings = log₂(N/(1000S)) = log₂(N/S) − log₂(1000).",
+      "part": "steps 1–2; background (rules of logarithms)",
+      "idea": "Starting with 1,000 times as many cells removes a fixed number of doublings, log₂(1000), whatever N is."
+    },
+    {
+      "step": "log₂(1000) ≈ 9.97, so about 10 doublings are saved (2¹⁰ = 1024).",
+      "part": "background (arithmetic)",
+      "idea": "1000 is very close to 2¹⁰."
+    },
+    {
+      "step": "Time saved ≈ 10 × 12 h ≈ 120 h ≈ 5 days.",
+      "part": "step 4; question's 12-hour doubling time",
+      "idea": "Each doubling saved cuts 12 hours from the time it takes to reach full strength."
+    },
+    {
+      "step": "The threshold N cancels out: it appears in both doubling counts, so the difference is log₂(1000) whatever N is. Only the ratio of starting counts matters.",
+      "part": "step 3; Step 3's comparison of first vs second encounter",
+      "idea": "With exponential growth, a head start multiplies the count by a fixed factor. That equals a fixed number of doublings, so it saves the same amount of time for any finish line."
+    }
+  ],
+  "result": "The response reaches full strength about 5 days sooner: log₂(1000) ≈ 10 doublings × 12 h ≈ 120 h. The answer doesn't depend on how many cells count as 'enough' because the doublings needed are log₂(enough/start). Starting 1,000 times higher always subtracts the same log₂(1000) ≈ 10 doublings, so the threshold cancels out.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/published.json
new file mode 100644
index 0000000..2b67046
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Number of doublings needed: starting count × 2^n = target count, so n = log2(target / starting count).",
+      "part": "The first meeting is slow (paragraph: 100 × 2^n = 1,000,000)",
+      "idea": "The explanation works out response time by counting the doublings from the precursor count up to the target number of effector cells, then multiplying by the doubling time."
+    },
+    {
+      "step": "Each doubling of the starting count removes exactly one division.",
+      "part": "What stays behind (rule under the table)",
+      "idea": "If the precursor count doubles, one division is saved. The worked numbers show this: 100 cells need 13.3 divisions, 10,000 cells need 6.6, and the 100× head start saves about log2(100) ≈ 6.6 divisions."
+    },
+    {
+      "step": "A 1,000× larger starting count saves log2(1000) ≈ 9.97, or about 10, divisions.",
+      "part": "Step 2 + background",
+      "idea": "1,000 is about 2^10 (1,024), so 1,000 times as many cells is about 10 doublings already done."
+    },
+    {
+      "step": "At 12 hours per doubling, 10 divisions are about 120 hours, or about 5 days.",
+      "part": "Step 3 + question's 12-hour doubling time",
+      "idea": "Time saved = divisions saved × doubling time. The question uses 12 hours instead of the explanation's 8."
+    },
+    {
+      "step": "The saving does not depend on the target count N.",
+      "part": "Step 1 + background (logarithms)",
+      "idea": "Vaccinated n = log2(N/1000P) = log2(N/P) − log2(1000). The difference from the unvaccinated case is log2(1000) whatever N is. Both cases have to reach the same target, and the extra 1,000× just means the first ~10 doublings are already done."
+    },
+    {
+      "step": "This simple model leaves out activation delays.",
+      "part": "What stays behind (memory cells activate in under a day vs about 2.5 days)",
+      "idea": "The explanation adds a separate activation delay, which also shortens after a first exposure. The question's model counts only doublings, so this is not included."
+    }
+  ],
+  "result": "About 10 doublings sooner (2^10 ≈ 1,000), so about 10 × 12 h ≈ 120 hours, or about 5 days earlier. The number of doublings needed is log2(target / starting cells). Multiplying the starting cells by 1,000 always subtracts log2(1000) ≈ 10 doublings, whatever the target is, so the size of 'enough' cancels out.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/quick.json
new file mode 100644
index 0000000..61713a0
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-1/read/vaccine-memory/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated division, so a bigger starting population reaches a working clone sooner.",
+      "part": "How it works, item 3 (Clonal expansion), and item 4 (Memory cells remain)",
+      "idea": "A lymphocyte that binds the antigen divides into a clone of thousands of identical cells. After vaccination, memory cells leave more matching cells than before, so the response starts from a larger population."
+    },
+    {
+      "step": "A head start in cell numbers turns into a head start in time.",
+      "part": "Why it works: a race (table rows 'Matching cells at the start' and 'Useful antibody after')",
+      "idea": "With more matching cells at the start, useful antibody comes after 2–4 days instead of 7–14 days. Starting larger means getting there sooner."
+    },
+    {
+      "step": "Write the model: cells at time t = N0 × 2^(t/12 h). Full strength is reached when this equals the 'enough' level K, so t = 12 h × log2(K/N0).",
+      "part": "background (the question's model; exponentials and logarithms from school maths)",
+      "idea": "Doubling every 12 hours means growth by a factor of 2 for each 12 hours."
+    },
+    {
+      "step": "Compare the two starts: N0 for a first infection and 1000·N0 after vaccination. The time difference is 12 h × [log2(K/N0) − log2(K/1000N0)] = 12 h × log2(1000).",
+      "part": "Step 3; background (algebra of logarithms)",
+      "idea": "K appears in both times and cancels in the difference, so the threshold does not matter."
+    },
+    {
+      "step": "log2(1000) ≈ 9.97, so about 10 doublings: 10 × 12 h ≈ 120 h ≈ 5 days.",
+      "part": "Step 4; background (2^10 = 1024 ≈ 1000)",
+      "idea": "A 1000-fold head start is worth about ten doubling times."
+    },
+    {
+      "step": "Check against the explanation: a gain of about 5 days fits the move from 7–14 days to 2–4 days.",
+      "part": "Why it works: a race (table)",
+      "idea": "The table's typical first and second response times differ by about 5–10 days."
+    }
+  ],
+  "result": "The response reaches full strength about 5 days sooner, because 1000 ≈ 2^10 is about 10 doublings of 12 hours each, which is about 120 hours. The 'enough' level does not matter because of how doubling works. Each doubling period multiplies the cell count by 2, so any starting count needs a fixed number of doublings to reach any target. The vaccinated start is the unvaccinated start 10 doublings further along. Both groups then follow the same curve to whatever count is 'enough', so the vaccinated group always arrives the same 10 doublings, about 5 days, earlier. In symbols, the threshold K cancels: 12 h × log2(K/N0) − 12 h × log2(K/1000N0) = 12 h × log2(1000). The explanation does not state this model; the steps above that rely on it come from the question and school maths.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/antibiotic-resistance.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/antibiotic-resistance.json
new file mode 100644
index 0000000..cb12730
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/antibiotic-resistance.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "none",
+    "B": "published",
+    "C": "principles",
+    "D": "quick"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/bloom-filter.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/bloom-filter.json
new file mode 100644
index 0000000..ac9c12a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/bloom-filter.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "none",
+    "B": "principles",
+    "C": "quick",
+    "D": "published"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/float-sum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/float-sum.json
new file mode 100644
index 0000000..a78bbd4
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/float-sum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "quick",
+    "B": "none",
+    "C": "principles",
+    "D": "published"
+  },
+  "grades": {
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": false,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": false,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/gps-relativity.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/gps-relativity.json
new file mode 100644
index 0000000..85392d1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/gps-relativity.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "quick",
+    "C": "published",
+    "D": "none"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/greenhouse.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/greenhouse.json
new file mode 100644
index 0000000..6dc1c8d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/greenhouse.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "quick",
+    "C": "none",
+    "D": "principles"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/heat-pump.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/heat-pump.json
new file mode 100644
index 0000000..a52bfb5
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/heat-pump.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "none",
+    "B": "principles",
+    "C": "published",
+    "D": "quick"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/key-exchange.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/key-exchange.json
new file mode 100644
index 0000000..9647ec2
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/key-exchange.json
@@ -0,0 +1,54 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "none",
+    "C": "published",
+    "D": "quick"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/quorum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/quorum.json
new file mode 100644
index 0000000..b1ff287
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/quorum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "published",
+    "C": "none",
+    "D": "quick"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/two-tides.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/two-tides.json
new file mode 100644
index 0000000..383362f
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/two-tides.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "published",
+    "C": "quick",
+    "D": "none"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "missing"
+      ],
+      "result_right": false,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/vaccine-memory.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/vaccine-memory.json
new file mode 100644
index 0000000..9e4cb48
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/grades/vaccine-memory.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "principles",
+    "C": "none",
+    "D": "quick"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/none.json
new file mode 100644
index 0000000..749017d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "If you give one drug, the resistant cells are already there before treatment starts. The drug doesn't create them.",
+      "part": "Section 3a 'Mutation', the paragraph after the bullets ('very likely already contains... It reveals them')",
+      "idea": "Resistance mutations happen at random as cells divide. In a big population a few resistant cells exist before any drug arrives, and the drug simply removes everyone else."
+    },
+    {
+      "step": "Drug A alone: about 10^10 / 10^8 = 100 cells already resist A.",
+      "part": "Section 3a, the 'Quick estimate' box",
+      "idea": "Expected number of resistant cells = population size × the fraction that resists. The box works this exact case: 10^10 cells at 1 in 10^8 gives 100."
+    },
+    {
+      "step": "Drug B alone: about 10^10 / 10^9 = 10 cells already resist B.",
+      "part": "Step 2 plus the page's 'Lower the mutation rate' tip ('Resistance is a numbers game: (population size) × (mutation rate)')",
+      "idea": "Use the same population × rate calculation with B's rate."
+    },
+    {
+      "step": "Even 10 or 100 survivors are enough for one drug to fail.",
+      "part": "Section 4, 'A toy calculation'",
+      "idea": "Once the drug removes the susceptible cells, 100 resistant cells dividing every 30 minutes reach about 10^8 in 10 hours. How rare they were at the start hardly matters, because exponential growth makes up the difference."
+    },
+    {
+      "step": "With both drugs, a cell survives only if it resists both. Because the mutations are unrelated, multiply the chances: 1/10^8 × 1/10^9 = 1 in 10^17.",
+      "part": "Section 8, the 'Combine drugs, sometimes' bullet (plus background: multiplying independent probabilities)",
+      "idea": "The explanation multiplies the two single-drug rates to get the chance of a cell resisting both by chance. In its example, 1 in 10^8 times 1 in 10^8 gives 1 in 10^16, more cells than are in the infection."
+    },
+    {
+      "step": "Expected number of cells resisting both = 10^10 / 10^17 = 10^-7. Almost certainly no such cell exists when treatment starts.",
+      "part": "Step 5 plus the population × rate rule from step 2",
+      "idea": "The infection has 10 million times fewer cells than you would need to expect even one double-resistant cell."
+    },
+    {
+      "step": "With no double-resistant cell present, nothing survives to multiply, so the treatment succeeds. A single-resistant cell is still killed by the other drug.",
+      "part": "The page's 'Lower the mutation rate to 10⁻¹⁰' tip; Section 4's 'Above MIC_R' bullet",
+      "idea": "If no resistant cell exists when the drug arrives, treatment succeeds. To escape, a survivor would need a second resistance step, and here that means a separate rare mutation."
+    }
+  ],
+  "result": "Each drug alone fails because resistant cells already exist before treatment starts: about 100 resist A (10^10/10^8) and about 10 resist B (10^10/10^9). The drug kills the rest, and those few multiply to take over. With both drugs, a cell survives only if it carries both unrelated mutations. Multiplying the chances gives 1 in 10^17, so the infection is expected to hold only about 10^-7 such cells, which in practice means none. Any cell that resists one drug is still killed by the other, so there are no survivors for selection to work on. Resistance would need two separate rare events to happen in the same lineage.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/principles.json
new file mode 100644
index 0000000..e6874e0
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/principles.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "Resistant cells for one drug are already there before treatment, in proportion to population × rate. With A: 10^10 × 1/10^8 ≈ 100 cells. With B: 10^10 × 1/10^9 ≈ 10 cells.",
+      "part": "Section 3, Mutation: worked example",
+      "idea": "The expected number of resistant cells is about the number of divisions times the mutation rate, and they exist before the first dose. The drug does not create them."
+    },
+    {
+      "step": "With either drug alone, the few resistant cells survive and multiply until they make up most of the infection.",
+      "part": "Section 4: How the drug makes resistance common",
+      "idea": "The drug kills the susceptible cells but not the resistant ones. These double about once an hour (the 100 cells reach about 1.7×10^9 in a day), so treatment fails."
+    },
+    {
+      "step": "With both drugs at once, only a cell resistant to both survives. Because the mutations are unrelated (independent), the chance a cell has both is the product of the two rates: 1/10^8 × 1/10^9 = 1 in 10^17.",
+      "part": "Section 4, 'Dose controls which cells survive', last paragraph (two drugs)",
+      "idea": "Combination therapy needs two independent mutations in one cell, so you multiply the probabilities. The explanation's own example is 1 in 10^8 × 1 in 10^8 = 1 in 10^16."
+    },
+    {
+      "step": "Expected double-resistant cells: 10^10 × 10^-17 = 10^-7, which is effectively none. A cell resistant to only A is killed by B, and a cell resistant to only B is killed by A.",
+      "part": "Steps 1 and 3; Section 4 two-drug paragraph",
+      "idea": "The combined rate needs far more divisions (10^17) than the whole infection makes (10^10). So almost certainly no cell can survive both drugs, and selection has nothing to work on."
+    }
+  ],
+  "result": "Alone, drug A leaves about 100 resistant cells and drug B about 10. Those survivors take over the infection. Together, a survivor would need both unrelated mutations, so the odds multiply: 10^-8 × 10^-9 = 10^-17 per cell. Among 10^10 cells that means an expected 10^-7 double-resistant cells, which is almost certainly none. A cell that resists only one drug is killed by the other. That makes a resistant outcome roughly 10 million times less likely. (Caveat: the explanation notes that a plasmid passed between bacteria can carry several resistance genes at once, which could get around this protection.)",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/published.json
new file mode 100644
index 0000000..f647090
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For drug A alone: 10^10 cells × 10^-8 = about 100 cells resistant to A exist before any drug is given.",
+      "part": "Resistant cells are there before the drug",
+      "idea": "Growing to 10^10 cells takes about 10^10 divisions. At one mutation per 10^8 divisions, you expect about 100 resistant mutants already present before treatment."
+    },
+    {
+      "step": "For drug B alone: 10^10 × 10^-9 = about 10 cells resistant to B exist beforehand.",
+      "part": "Resistant cells are there before the drug",
+      "idea": "The same count of mutations, now using B's rate of one in 10^9."
+    },
+    {
+      "step": "With either drug alone, those few resistant cells survive and regrow the infection, so it comes back resistant.",
+      "part": "The drug selects them",
+      "idea": "The drug removes the susceptible cells, and the resistant ones keep doubling (100 cells reach 10^10 in about 27 doublings, roughly 13 hours). This is selection, not something the drug causes. Even 10 cells would regrow, needing only a few more doublings."
+    },
+    {
+      "step": "With both drugs together, a cell survives only if it resists both, so it needs two separate mutations.",
+      "part": "What this predicts (combination bullet)",
+      "idea": "With two drugs that hit independent targets, a surviving cell needs both mutations at once."
+    },
+    {
+      "step": "The chance of one cell having both is 10^-8 × 10^-9 = 10^-17. Across 10^10 cells, that gives about 10^-7 double-resistant cells, roughly a one-in-ten-million chance that even one exists.",
+      "part": "What this predicts (combination bullet); steps 1–2",
+      "idea": "The mutations are unrelated, so their chances multiply. The explanation works the same sum with 10^-8 × 10^-8, gets 10^-6 cells (one in a million), and concludes that the treatment clears the infection."
+    },
+    {
+      "step": "This only holds while the two resistances really are independent.",
+      "part": "What this predicts (combination bullet); Genes from other bacteria",
+      "idea": "If one event gives resistance to both drugs (for example, a plasmid carrying both genes, or one pump that exports both), the chances no longer multiply. The question says the mutations are unrelated, so the multiplication applies."
+    }
+  ],
+  "result": "Giving one drug alone fails because resistant cells are already there before treatment: about 100 resist A and about 10 resist B among the 10^10 cells. The drug kills the susceptible cells, and those few resistant ones regrow the infection. With both drugs, a cell must resist both to survive. The two mutations are unrelated, so their chances multiply: 10^-8 × 10^-9 = 10^-17 per cell. That means about 10^-7 double-resistant cells are expected in the whole infection, roughly a 1-in-10-million chance that even one exists. So almost certainly no cell survives both drugs, and the infection is cleared. This depends on the resistances being separate events, not one plasmid or pump that covers both drugs.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/quick.json
new file mode 100644
index 0000000..a21d3d9
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/antibiotic-resistance/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Getting either drug alone leaves resistant cells already present: 10^10 × 10^-8 = 100 cells resistant to A, and 10^10 × 10^-9 = 10 resistant to B.",
+      "part": "Step 2: the antibiotic selects the resistant cells (worked numbers)",
+      "idea": "The expected number of resistant cells before treatment is population × chance per cell. Resistance comes from random variation that happens before the drug arrives."
+    },
+    {
+      "step": "With one drug, those survivors grow back into a resistant infection.",
+      "part": "Step 2 (the doubling bullet and the paragraph on selection); Why selection, and not adaptation",
+      "idea": "The drug kills the susceptible cells. The few resistant ones keep dividing, and about 30 doublings rebuild 10^10 cells, nearly all resistant. The drug does not cause resistance; it picks out the cells that already had it."
+    },
+    {
+      "step": "With both drugs, a cell survives only if it resists both. Because the two mutations are unrelated, the chances multiply: 10^-8 × 10^-9 = 10^-17 per cell.",
+      "part": "What follows from this: 'Two drugs at once help'",
+      "idea": "Two independent rare events must both happen in the same cell, so their probabilities multiply (the page's example uses 10^-9 × 10^-9)."
+    },
+    {
+      "step": "Expected number of doubly resistant cells: 10^10 × 10^-17 = 10^-7, so almost certainly none exists.",
+      "part": "Step 1, 'Two drugs at once help', and the small-population prediction in Step 2",
+      "idea": "When the expected count is far below 1, usually no resistant cell exists. Then there is nothing to select, and the drugs clear the infection."
+    },
+    {
+      "step": "Caveat: this only holds if the two resistances arise separately. A plasmid that carries both genes would defeat it.",
+      "part": "Step 1 (Gene transfer); 'Two drugs at once help'",
+      "idea": "One plasmid can carry several resistance genes, so a single transfer could give resistance to both drugs. The page says the argument fails in that case."
+    }
+  ],
+  "result": "Each drug alone leaves resistant cells that already exist: about 100 resist A and about 10 resist B. The drug then lets those cells regrow the infection. With both drugs, a cell must carry both unrelated mutations. The chance of that is 10^-8 × 10^-9 = 10^-17 per cell, so a population of 10^10 is expected to hold only 10^-7 such cells, which in practice means none. With no doubly resistant cell to select, the combination clears the infection. This holds unless a single plasmid carries both resistance genes.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/none.json
new file mode 100644
index 0000000..2b39381
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A filter's bit array is fully determined by the items added and the hash functions: each item turns on its k positions, and a bit that is already 1 stays 1. So bit i is 1 exactly when at least one added item hashes to position i.",
+      "part": "Section 2 key box ('Add an item … If a bit is already 1, it stays 1'), plus the paragraph 'The filter never stores the item itself. It only stores the bits that items have switched on.'",
+      "idea": "Adding only ever switches bits on, so the final array is the OR over all added items of each item's set of k positions. Because adding only switches bits on, the order of adding doesn't matter."
+    },
+    {
+      "step": "The two filters can only be combined position by position if they share m and the same k hash functions.",
+      "part": "Section 2 (each hash is taken modulo m to pick a position) and the script's kSel handler comment ('Changing k changes every item's positions, so the old bits no longer mean anything: rebuild')",
+      "idea": "Position i means the same thing in both arrays only if every item maps to the same positions in both. The question gives us this condition."
+    },
+    {
+      "step": "Filter for A ∪ B: take the bitwise OR of the two arrays.",
+      "part": "Steps 1 and 2",
+      "idea": "In the A filter, bit i is 1 if some item of A hits i. In the B filter, bit i is 1 if some item of B hits i. The OR is 1 if some item of A ∪ B hits i, which is exactly the rule from step 1 for a filter built by adding every item of A ∪ B. No items are needed."
+    },
+    {
+      "step": "The OR is exact: it is bit-for-bit the same as the filter you would get by inserting A ∪ B directly.",
+      "part": "Step 3; Section 4 table; Section 5 Step 2",
+      "idea": "Because the arrays are identical, the union filter behaves like a normal filter. It gives no false negatives for any item in A or B. Its false positive rate is about f^k, where f is the fraction of 1s, which is the same as for a filter of n = |A ∪ B| items. Like any filter, it can be overfilled if m was sized for fewer items."
+    },
+    {
+      "step": "A bitwise AND gives a 1 at position i only where some item of A and some item of B both hit i.",
+      "part": "Step 1",
+      "idea": "AND keeps a bit only if it is on in both arrays."
+    },
+    {
+      "step": "Every item in A ∩ B still passes the check in the AND filter, so it has no false negatives for the intersection.",
+      "part": "Step 5; Section 2 check rule; Section 4 'Impossible' cell",
+      "idea": "An item in both sets set all k of its bits in both filters, so all k bits survive the AND and the check says 'probably yes'."
+    },
+    {
+      "step": "The AND is not exact. It can have 1s that a filter built directly from A ∩ B would have as 0, so its false positive rate can be higher than a filter built directly from A ∩ B.",
+      "part": "Section 3 'Things to notice' (different words share positions; sharing causes false positives); Steps 1 and 5",
+      "idea": "A bit can be 1 in A's filter because of an item only in A, and 1 in B's filter because of a different item only in B. That bit survives the AND even though no item of A ∩ B set it. The AND array therefore contains every bit of the true A ∩ B filter, and possibly more. More 1s means more false positives (f^k)."
+    }
+  ],
+  "result": "Union: OR the two bit arrays. This is exact: the result is identical, bit for bit, to a filter built by inserting every item of A ∪ B. That is because a bit is 1 exactly when some added item hashes to it, and bits never go back to 0. It still has no false negatives, and its false positive rate is that of a filter holding |A ∪ B| items. Intersection: the AND gives a filter that still says 'probably yes' for every item in A ∩ B, so it has no false negatives. But it is only an approximation. A bit can stay on because one item only in A and a different item only in B happen to share that position. So the AND can contain extra 1s compared with a filter built directly from A ∩ B, and can give more false positives than that filter. Both operations need the same m and the same hash functions.",
+  "gap": "The explanation never covers combining filters with OR or AND. Both answers are worked out from its rule for adding items and its points about shared bits."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/principles.json
new file mode 100644
index 0000000..674c09b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/principles.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "A filter's contents depend only on which bit positions have been set to 1. Adding an item sets that item's k positions to 1 and changes nothing else.",
+      "part": "The parts (Add(x) and Query(x) operations; Hash function: the same item always gives the same number)",
+      "idea": "Add computes k positions from the item alone and sets them to 1. Because the hashes are deterministic, an item lands on the same positions in any filter that has the same m and the same hash functions."
+    },
+    {
+      "step": "A bit is 1 in a filter exactly when at least one added item maps to it. Adding the same item twice, or adding items in a different order, gives the same array.",
+      "part": "Why it never misses an item it saw (Add only changes bits from 0 to 1; nothing clears a bit)",
+      "idea": "Bits only go from 0 to 1 and never back. So the final array is the union of every added item's positions, whatever the order and however many repeats."
+    },
+    {
+      "step": "The filter you would build from A ∪ B has a 1 at bit i exactly when some item in A or some item in B maps to i. That is the same as: bit i is 1 in filter A, or bit i is 1 in filter B.",
+      "part": "Steps 1–2",
+      "idea": "Each item in A ∪ B lies in A or in B, and it sets the same positions in either filter. So the union filter's set bits are exactly the bits set in A's filter together with those set in B's filter."
+    },
+    {
+      "step": "Taking the bitwise OR of the two arrays therefore gives the A ∪ B filter, with no access to the items. The result is exact: it is the same bit array you would get by adding every item of A ∪ B to an empty filter.",
+      "part": "Step 3; background (bitwise OR)",
+      "idea": "OR is 1 exactly when either input bit is 1, which is the condition from step 3."
+    },
+    {
+      "step": "The merged filter works like a filter holding all of A ∪ B, so its error rate follows from that larger number of items.",
+      "part": "How often it is wrong; What happens when the filter fills up",
+      "idea": "The false-positive rate p ≈ (1 − e^(−kn/m))^k uses the total number of items in the filter, here |A ∪ B|. The merge itself adds no error, but a fuller array means more false positives."
+    },
+    {
+      "step": "Bitwise AND gives 1 only where both filters have a 1. Every item in A ∩ B sets its k bits in both filters, so all of its bits survive the AND. A query for such an item still says 'probably seen': there are no false negatives for the intersection.",
+      "part": "Steps 1–2; Why it never misses an item it saw",
+      "idea": "An item in both sets maps to the same positions in both arrays, and those bits are 1 in each, so they are 1 after the AND."
+    },
+    {
+      "step": "AND is not exact for A ∩ B. A bit can be 1 in both filters because one item of A and a different item of B happen to share it, even when no common item maps there. So the AND result can have more 1s than the filter you would build from A ∩ B directly.",
+      "part": "A worked example (\"cat\" and \"dog\" share bit 6; the filter has no record of which item set a bit)",
+      "idea": "Different items can share bits, and the filter cannot tell who set a bit. So 'set in both filters' does not mean 'set by an item that is in both sets'."
+    },
+    {
+      "step": "The AND result therefore contains every bit of the true A ∩ B filter, plus possibly some extra bits. It still gives no false negatives, but its false-positive rate can be higher than that of a filter built directly from A ∩ B.",
+      "part": "Steps 6–7; How often it is wrong",
+      "idea": "Extra 1s make it more likely that all k bits of an absent item are 1, which is exactly the false-positive condition."
+    }
+  ],
+  "result": "Take the bitwise OR of the two bit arrays. Because every item sets the same positions in both filters and bits only ever go from 0 to 1, the OR is exactly the filter you would get by adding every item of A ∪ B, so the union is exact. Its error rate is the normal one for |A ∪ B| items in m bits. The bitwise AND gives a filter that says 'probably seen' for every item in A ∩ B, so it has no false negatives, but it is not exact. Bits set by different items in A and in B can collide and survive the AND, so it may have extra 1s compared with the true A ∩ B filter, and therefore more false positives. It is a safe approximation, not the true intersection filter.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/published.json
new file mode 100644
index 0000000..da526ca
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A filter's bit array is exactly the set of positions turned on by its added items. Adding only ever sets bits to 1, and the order of adds doesn't matter.",
+      "part": "How it works: add and query",
+      "idea": "To add an item, set its k positions (hash mod m) to 1 and keep nothing else. The final bits are just the union of the positions of every item added."
+    },
+    {
+      "step": "Both filters use the same m and the same hash functions, so any item maps to the same k positions in either one.",
+      "part": "How it works: add and query",
+      "idea": "Positions depend only on the hash functions and m. Matching m and k means matching positions."
+    },
+    {
+      "step": "A filter built directly from A ∪ B would have a 1 exactly at the positions set by items of A or items of B. That is a bitwise OR of the two arrays.",
+      "part": "Steps 1, 2",
+      "idea": "The union of A's positions and B's positions is the OR of A's bit array and B's bit array."
+    },
+    {
+      "step": "The OR is exact: it is bit-for-bit the same as adding every item of A and B into one fresh filter. So it has no false negatives and the same false-positive behaviour as that filter. Its fill comes from n = |A ∪ B|.",
+      "part": "Step 3; Why it is never wrong the other way; How often it is wrong",
+      "idea": "Same bits means same answers. The rate p ≈ f^k uses the fill from all the items, so if |A ∪ B| is well above the capacity, p rises."
+    },
+    {
+      "step": "A bitwise AND keeps only the positions that are 1 in both filters. Every item in A ∩ B set its k positions in both, so all of those bits survive. The AND therefore has no false negatives for A ∩ B.",
+      "part": "Step 1; Why it is never wrong the other way",
+      "idea": "Every item in both sets has all its bits on in both arrays, so its bits are still on after the AND."
+    },
+    {
+      "step": "The AND is not exact. A position can be 1 in A's filter because of one item and 1 in B's filter because of a different item. Then it stays on even though no item of A ∩ B set it.",
+      "part": "How it can be wrong: false positives",
+      "idea": "Bits don't record which item set them (like owl's bits coming from cat and dog). So the AND can have extra 1s that a filter built from A ∩ B would not have."
+    },
+    {
+      "step": "So the AND is a valid but noisier filter for A ∩ B. It has the same or more 1s than the true one, so its false-positive rate is the same or higher.",
+      "part": "Step 6; How often it is wrong",
+      "idea": "More 1 bits means a higher fill f, and p ≈ f^k rises with f."
+    }
+  ],
+  "result": "OR the two bit arrays position by position. This gives exactly the filter you would get by adding every item of A ∪ B to one fresh filter, so it is exact. Its false-positive rate is that of a filter holding |A ∪ B| items, which is higher if that goes past capacity. A bitwise AND gives a filter for A ∩ B that never says 'definitely not seen' for an item in both sets. But it isn't exact: a bit can be on in A's filter from one item and in B's from a different item. So the AND can have extra 1s compared with a filter built from A ∩ B, and its false-positive rate is the same or higher.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/quick.json
new file mode 100644
index 0000000..a85fa4d
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/bloom-filter/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A filter's bits are fixed entirely by which positions its items hash to: a bit is 1 exactly when at least one added item has a hash position there. The order of adding does not matter.",
+      "part": "How it works (Add step and the cat/dog table)",
+      "idea": "Adding an item sets its k positions to 1, starting from all zeros. So the final array is just the set of positions hit by any item."
+    },
+    {
+      "step": "Because both filters use the same m and the same hash functions, a given item maps to the same positions in either one, so their bit positions line up.",
+      "part": "The parts (hash function definition)",
+      "idea": "The same item always gives the same position, so the two arrays are directly comparable."
+    },
+    {
+      "step": "Bit i is 1 in the filter for A ∪ B exactly when some item of A or some item of B hits i. That is the same as: bit i is 1 in filter A OR bit i is 1 in filter B. So a bitwise OR of the two arrays gives the union filter, and the items are not needed.",
+      "part": "Steps 1–2",
+      "idea": "A union of 'some item hits this bit' conditions is a logical OR of the two bit arrays."
+    },
+    {
+      "step": "The OR result is bit-for-bit the same as a filter built by adding every item of A ∪ B, so the union is exact. It keeps the no-false-negative guarantee, and its false-positive rate is that of a filter holding |A ∪ B| items.",
+      "part": "Step 3; Why 'no' is always right; How much memory (formula in n)",
+      "idea": "An identical array behaves identically. The rate depends on how many items are in it, so the merged filter is fuller and has a higher p."
+    },
+    {
+      "step": "AND keeps a bit only if it is 1 in both filters. Every item in A ∩ B has all its bits set in both, so AND never gives a false 'no' for an item in the intersection.",
+      "part": "Why 'no' is always right; Step 1",
+      "idea": "Added items keep all their bits at 1. Being in both sets means the item's bits are 1 in both arrays."
+    },
+    {
+      "step": "But a bit can be 1 in both arrays because of different items: for example, cat in A and dog in B both set bit 6, even though neither is in both sets. So AND can leave extra 1s that a filter built from A ∩ B would not have.",
+      "part": "How 'yes' can be wrong (the filter cannot tell which item set a bit); cat/dog sharing bit 6",
+      "idea": "Bits do not record which item set them, so overlaps between different items survive the AND."
+    }
+  ],
+  "result": "To get the union, take the bitwise OR of the two arrays. It is exact: the result is identical to a filter built directly from A ∪ B, with no false negatives and the false-positive rate of a filter holding |A ∪ B| items. Bitwise AND gives an approximate filter for A ∩ B. It never says 'no' to an item in the intersection, but it is not exact. Bits that different items set in A and in B (like cat and dog sharing bit 6) stay on, so its bits include the true intersection filter's bits plus possibly more. Its false-positive rate can therefore be higher than that of a filter built from A ∩ B itself.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/none.json
new file mode 100644
index 0000000..fc9f3f0
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/none.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "Rule for which numbers a double can store exactly: a fraction (in lowest terms) has a finite binary form only if its denominator is a power of 2. Any other fraction repeats forever and has to be rounded.",
+      "part": "Section 2, 'The same problem in binary' (first paragraph and the table)",
+      "idea": "The only prime factor of base 2 is 2, so 1/2, 1/4, 3/8, 5/16 end in binary. 1/10 and 1/5 do not, because their denominators contain the factor 5."
+    },
+    {
+      "step": "A double keeps 53 significant binary digits. A number whose binary form ends within that budget is stored exactly. Anything longer is rounded to the nearest double.",
+      "part": "Section 3, 'How much room the computer has'",
+      "idea": "A double is ±1.xxx × 2^exponent with 53 significant bits. Digits that don't fit are rounded off to the nearest storable value."
+    },
+    {
+      "step": "0.375 = 3/8 and 0.0625 = 1/16. Both denominators are powers of 2, and the binary forms (0.011 and 0.0001) are tiny. So both are stored exactly.",
+      "part": "Steps 1–2, plus background arithmetic (turning decimals into fractions)",
+      "idea": "A denominator that is a power of 2 gives a short binary form that fits easily in 53 bits."
+    },
+    {
+      "step": "0.2 = 1/5 and 0.3 = 3/10. Both denominators contain 5, so the binary forms repeat forever and get rounded. The stored values are 0.20000000000000001110… (a little too big) and 0.29999999999999998889… (a little too small).",
+      "part": "Section 2 table and Section 3 table of stored values",
+      "idea": "The explanation lists 0.2 and 0.3 as not exact and gives the values a double actually holds for them."
+    },
+    {
+      "step": "0.125 = 1/8 is stored exactly. Every partial sum when adding it eight times (0.25, 0.375, 0.5, …, 1.0) is k/8, which also has a power-of-2 denominator and very few binary digits, so each one is exactly a double.",
+      "part": "Steps 1–2 and background arithmetic",
+      "idea": "Every intermediate result can be stored exactly, not just the starting value."
+    },
+    {
+      "step": "Each addition gives the exact mathematical sum, correctly rounded to the nearest double. When the exact sum is already a double, the rounding changes nothing. So no error enters at any of the eight additions, and the final result is exactly 1.0.",
+      "part": "Section 6, 'Bounded, predictable error' bullet; Section 4 ('That result also has to be stored as a double, so it gets rounded again')",
+      "idea": "IEEE 754 returns the exact result rounded to the nearest double. An exactly storable result is returned unchanged."
+    },
+    {
+      "step": "With 0.1 the starting value is already wrong. The stored 0.1 is 0.1000000000000000055511… rather than 1/10. Also, the partial sums (0.2, 0.3, …, 0.9) are not powers-of-2 fractions, so most additions have to round again.",
+      "part": "Section 2 (0.1 repeats as 0.000110011…), Section 3 table, Section 4",
+      "idea": "Each sum of inexact tenths has to be rounded to a neighbouring double, just as 0.1 + 0.2 was."
+    },
+    {
+      "step": "These small rounding errors don't cancel out, so the total drifts away from 1.0, just as 0.3333 + 0.3333 + 0.3333 = 0.9999 in four-place decimal.",
+      "part": "Introduction, fact 2 ('Those three small rounding errors don't cancel out'); Section 1, the 1/3 analogy",
+      "idea": "Errors from rounding at the start and at each addition carry through to the final result."
+    }
+  ],
+  "result": "0.375 (3/8) and 0.0625 (1/16) are stored exactly. 0.2 (1/5) and 0.3 (3/10) are not, because their denominators contain the factor 5, so their binary forms repeat forever and get rounded. Adding 0.125 eight times gives exactly 1.0 for two reasons: 0.125 = 1/8 is exact, and every partial sum k/8 can also be stored exactly. Since IEEE 754 returns the correctly rounded exact result, no rounding error ever appears. With 0.1, the stored value is already slightly too big, and most partial sums are tenths that can't be stored exactly, so each addition rounds again. Those errors don't cancel, so the total ends up next to 1.0 rather than on it. The explanation doesn't work out the ten-step sum itself (for example, what it prints), so the fact that it misses 1.0 comes from the question, not from the text.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/principles.json
new file mode 100644
index 0000000..b60bbf5
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A fraction has a finite binary expansion only if its denominator in lowest terms has no prime factor other than 2. If it has another factor, the expansion repeats and the stored value must be rounded.",
+      "part": "Section 2, 'Why 0.1 has no exact binary form'",
+      "idea": "In base 10 the allowed prime factors of the denominator are 2 and 5. In base 2 only 2 is allowed. A factor of 5 makes the binary expansion repeat forever, so the computer has to cut it off and round."
+    },
+    {
+      "step": "A double holds values of the form (an integer of at most 53 bits) × (a power of 2). These values form a grid, and fractions with power-of-2 denominators are grid points, so they are stored exactly.",
+      "part": "Section 3, 'What the computer actually stores', and Section 6, 'When addition is exact'",
+      "idea": "Values on the grid are stored with no error. Any other value is rounded to the nearest grid point."
+    },
+    {
+      "step": "0.375 = 3/8 and 0.0625 = 1/16. Both denominators are powers of 2, so a double stores both exactly.",
+      "part": "Step 2 plus background (converting a decimal to a fraction in lowest terms)",
+      "idea": "3 × 2⁻³ and 1 × 2⁻⁴ are small integers times powers of 2, so they are grid points."
+    },
+    {
+      "step": "0.2 = 1/5 and 0.3 = 3/10. Both denominators contain the factor 5, so neither can be stored exactly. The table confirms this: stored 0.2 ≈ 0.20000000000000001110 and stored 0.3 ≈ 0.29999999999999998890.",
+      "part": "Section 2 and the table in Section 3",
+      "idea": "A factor of 5 in the denominator means a repeating binary expansion, so the value is rounded to a nearby grid point."
+    },
+    {
+      "step": "0.125 = 1/8 is stored exactly. Every running total k/8 (k = 1…8) has a power-of-2 denominator and needs only a few bits, so each one is a grid point. No addition ever rounds, and the eighth sum is exactly 8/8 = 1.0.",
+      "part": "Section 6, 'When addition is exact' (sums of power-of-2 fractions are exact while they fit in 53 bits), plus Step 2",
+      "idea": "When every input and every result is a grid point, nothing is rounded, so the sum is exact. The 0.5 + 0.25 == 0.75 example works the same way."
+    },
+    {
+      "step": "0.1 is stored slightly high (≈ 0.1000000000000000055511). So the stored 0.1 is not 1/10, and ten copies of it add up exactly to about 1 + 5.55×10⁻¹⁷, not 1. Each running total (0.2, 0.3, …) is also not a grid point, so it is rounded again, as with 0.1 + 0.2. That sum already lands one grid step away from the stored 0.3.",
+      "part": "Section 1 (separate roundings do not cancel), the table in Section 3, and Section 4 (the sum is rounded again)",
+      "idea": "Every addition can add its own rounding error, and these errors do not cancel neatly. So there is no reason for the total to land exactly on 1.0."
+    },
+    {
+      "step": "To show that the tenth sum is definitely not 1.0, and to find which double it is, I would need to follow the rounding through all ten additions. The explanation does this for only one addition and says it does not cover longer chains.",
+      "part": "Summary ('Not covered: … how errors grow across long chains of operations')",
+      "idea": "The explanation does not give the rounded result of each running total from 0.3 up to 1.0."
+    }
+  ],
+  "result": "Stored exactly: 0.375 (3/8) and 0.0625 (1/16), because their denominators are powers of 2. Not exact: 0.2 (1/5) and 0.3 (3/10), because the factor 5 makes the binary expansion repeat. Adding 0.125 eight times gives exactly 1.0 because 1/8 and every running total k/8 are grid points, so no step rounds. Adding 0.1 ten times starts from a value that is already slightly wrong, and most of the running totals have to be rounded again. Those separate errors do not cancel, so there is no reason to expect exactly 1.0. The explanation cannot show the exact final value, though (see gap).",
+  "gap": "The explanation follows the rounding through only one addition (0.1 + 0.2) and says it does not cover how errors grow across long chains of operations. So it does not let me confirm that ten additions of 0.1 end on a double other than 1.0, or say which double that is."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/published.json
new file mode 100644
index 0000000..565d5da
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "A double holds a value exactly only if that value is a whole number (at most 53 bits) times a power of two, which makes it a fraction whose denominator is a power of two.",
+      "part": "What the computer holds; Why 0.1 must be rounded (first paragraph)",
+      "idea": "A double is an integer times 2^k, so it can only be a fraction with a power-of-two denominator. Such fractions end in binary, for example 3/8 = 0.011."
+    },
+    {
+      "step": "0.375 = 3/8 and 0.0625 = 1/16 have power-of-two denominators, so a double stores them exactly.",
+      "part": "Step 1; background (turning decimals into fractions)",
+      "idea": "3/8 = 3 × 2^-3 and 1/16 = 1 × 2^-4. Both are small whole numbers times a power of two."
+    },
+    {
+      "step": "0.2 = 1/5 and 0.3 = 3/10 have a factor 5 in their denominators, so they never end in binary and must be rounded.",
+      "part": "Why 0.1 must be rounded; The stored values (table)",
+      "idea": "No power of two is divisible by 5. The table shows 0.2 stored as 0.20000000000000001110 and 0.3 as 0.29999999999999998890."
+    },
+    {
+      "step": "0.125 = 1/8 is stored with error 0. Every running total 0.25, 0.375, …, 1.0 is k/8, which has a power-of-two denominator, so it is also a double.",
+      "part": "When it works; Step 1",
+      "idea": "If the inputs have power-of-two denominators, they are stored exactly. Their exact sum is itself a double, so the rounding in + changes nothing."
+    },
+    {
+      "step": "So every one of the eight additions is exact, and the final total is exactly 8/8 = 1.0.",
+      "part": "What `+` does; Step 4",
+      "idea": "+ rounds the exact sum to the nearest double. When the exact sum is already a double, the result equals it."
+    },
+    {
+      "step": "When adding 0.1 ten times, the input is not 0.1. It is stored 0.1 = 0.10000000000000000555 (error +5.55e-18), and each running total such as 0.3 or 0.7 is not a double, so each addition may round.",
+      "part": "The stored values (table); What `+` does",
+      "idea": "The starting value is already off, and every + rounds its exact sum. As with 0.1 + 0.2, the result can land on a different double than the decimal you meant. So reaching exactly 1.0 is not guaranteed, unlike the 0.125 case."
+    },
+    {
+      "step": "Showing that the final result is actually different from 1.0, and by how much, needs the ten rounding steps worked out, including the gap sizes above 0.5. The explanation does not cover this.",
+      "part": "Not covered here",
+      "idea": "It says outright that how errors grow over many operations, 'such as adding 0.1 ten times', is not covered."
+    }
+  ],
+  "result": "A double stores 0.375 (3/8) and 0.0625 (1/16) exactly. It cannot store 0.2 or 0.3, because their denominators have a factor 5, so they are rounded. Adding 0.125 eight times is exact: 1/8 and every running total k/8 have power-of-two denominators, so each is stored with no error and no addition needs to round. Adding 0.1 ten times starts from a value that is already rounded (stored 0.1 is slightly above 0.1), and the running totals are not doubles, so each addition rounds. That is why the total is not guaranteed to be 1.0. The explanation does not go far enough to show the exact final value.",
+  "gap": "The explanation says that 'adding 0.1 ten times' is not covered. It does not trace the ten roundings, and it gives no gap sizes above 0.5, so I can't show that the total actually comes out different from 1.0. I can only show why it isn't guaranteed to be exact."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/quick.json
new file mode 100644
index 0000000..fcf692e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/float-sum/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A double can hold a number exactly only if it is a short sum of powers of 2 (1/2, 1/4, 1/8, …) that fits in 53 bits. A number whose binary form repeats forever is stored as the nearest binary fraction instead.",
+      "part": "Why 0.1 has the same problem in base 2 (paragraph defining a double and the stored value)",
+      "idea": "A double is a binary fraction with 53 significant bits. If a number's binary digits go on forever, the computer keeps the closest value it can, which is slightly off."
+    },
+    {
+      "step": "0.375 = 3/8 = 1/4 + 1/8, so it is a short binary fraction (0.011 in binary). A double stores it exactly.",
+      "part": "Step 1, plus the 'When addition is exact' section (0.5 = 1/2 and 0.25 = 1/4 are short binary fractions)",
+      "idea": "A number made of a few powers of 2 has a short binary form, so nothing is rounded. Converting 0.375 to a fraction is school arithmetic."
+    },
+    {
+      "step": "0.0625 = 1/16, a single power of 2 (0.0001 in binary). A double stores it exactly.",
+      "part": "Step 1 and 'When addition is exact'",
+      "idea": "Powers of 2 are the building blocks of binary fractions, so they are stored without error."
+    },
+    {
+      "step": "0.2 and 0.3 cannot be stored exactly. The stored values are 0.2000000000000000111… and 0.2999999999999999888….",
+      "part": "Table under 'Why 0.1 has the same problem in base 2', and the closing line of 'When addition is exact'",
+      "idea": "The explanation names 0.1, 0.2 and 0.3 as numbers with no short binary form and gives their slightly wrong stored values."
+    },
+    {
+      "step": "0.125 = 1/8 is exact. Each running total 2/8, 3/8, …, 8/8 = 1.0 is also a short binary fraction, so no addition ever needs rounding. The result is exactly 1.0.",
+      "part": "When addition is exact (0.5 + 0.25 == 0.75)",
+      "idea": "If the inputs and the sum are all short binary fractions, no step rounds and no error appears."
+    },
+    {
+      "step": "0.1 is already wrong when it is stored (0.1000000000000000055…, slightly too high). Many of the running totals (0.3, 0.7, …) are not doubles either, so they get rounded to the nearest double, much as 0.1 + 0.2 did. These small errors add up, and the final double is not the double 1.0, so == says false.",
+      "part": "Table (stored 0.1); 'What happens in the addition' steps 1–4; 'The same problem in base 10' (the calculator adds correctly but the inputs were wrong)",
+      "idea": "Errors come from inputs that are already wrong and from rounding each sum that is not a double. == compares bit for bit, so any leftover error makes it false."
+    }
+  ],
+  "result": "A double stores 0.375 (= 1/4 + 1/8) and 0.0625 (= 1/16) exactly. It cannot store 0.2 or 0.3 exactly, because their binary forms repeat forever, so it keeps the nearest binary fraction. Adding 0.125 (= 1/8) eight times gives exactly 1.0 because the input and every running total (k/8) are short binary fractions, so nothing is ever rounded. Adding 0.1 ten times starts from a stored value slightly above 0.1, and the running totals that aren't doubles get rounded too. The small errors add up to a double that differs from 1.0, so == is false.",
+  "gap": "The explanation never works through the ten additions of 0.1. It gives no running totals and doesn't say which way each one rounds, so it doesn't show why the errors fail to cancel. I took 'does not equal 1.0' from the question and could only explain it in general terms."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/none.json
new file mode 100644
index 0000000..9b2037e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Range is computed from a timing difference, so any error in a timestamp turns directly into a distance error.",
+      "part": "Section 1, 'Distance from time': the formula distance = c × (t_r − t_s)",
+      "idea": "The receiver multiplies the delay between the satellite's stated send time t_s and its own arrival time t_r by the speed of light."
+    },
+    {
+      "step": "A 10 ns clock error is about 3 m of range error.",
+      "part": "Section 1, bold line 'Every nanosecond of timing error is about 30 cm of position error'",
+      "idea": "1 ns is about 30 cm, so 10 ns × 30 cm/ns ≈ 3 m."
+    },
+    {
+      "step": "Direction of the error: if the satellite's clock is fast, the send time it stamps on the signal is about 10 ns too late. The worked-out delay t_r − t_s is then about 10 ns too short, so this one range comes out about 3 m too short.",
+      "part": "Step 1 and step 2, plus background arithmetic",
+      "idea": "Making t_s larger makes t_r − t_s smaller by the same amount. (The end of section 3 frames the same mix-up as the satellite looking '3 m farther away'. The size is the same either way. Only the sign depends on how you set it up.)"
+    },
+    {
+      "step": "The receiver's fourth unknown b can only stand for an error that is the same in every pseudorange.",
+      "part": "Section 2, 'Why four satellites': ρᵢ = |sᵢ − p| + b, where the error is the 'same for every satellite'",
+      "idea": "The receiver's clock error affects every measurement by the same b = c·δt, because one clock times them all. So one extra unknown is enough to absorb it."
+    },
+    {
+      "step": "In the solver, b enters every equation with the same weight.",
+      "part": "Section 3, step 3 and the Jacobian column of ones in solve_position",
+      "idea": "Changing b moves every predicted pseudorange by the same amount. It cannot move just one satellite's range."
+    },
+    {
+      "step": "A clock error on one satellite affects only that satellite's pseudorange, so b cannot soak it up. The fit treats it as real geometry and moves the position away from the truth.",
+      "part": "Section 3, closing note ('Note what the whole method assumes…')",
+      "idea": "The receiver can only absorb errors that are the same for every satellite. It cannot tell one satellite's clock being 10 ns off from that satellite really being about 3 m nearer or farther. So the error ends up in x, y and z, giving a position error of metres."
+    }
+  ],
+  "result": "The range to that satellite is wrong by about 3 m (10 ns × 30 cm/ns). Using distance = c(t_r − t_s), a fast satellite clock makes t_s too late, so this range comes out about 3 m too short. The explanation itself calls it '3 m farther away', so it is the size, not the sign, that matters there. The receiver's fourth unknown b is a single offset added equally to every pseudorange (a column of ones in the solver). It works for the receiver's own clock because that one clock times every measurement. A 10 ns error on one satellite changes only that satellite's pseudorange. No single common b can fix one equation without spoiling the others, and the receiver cannot tell a clock error from extra distance. So the error is wrongly read as geometry and shifts the computed position by metres.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/principles.json
new file mode 100644
index 0000000..4925856
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/principles.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "A 10 ns timing error becomes a distance error of about 3 m.",
+      "part": "1. Time becomes distance (paragraph 'This conversion is unforgiving')",
+      "idea": "Distance is c times the travel time, and light covers 30 cm per nanosecond, so 10 ns × 30 cm/ns = 3 m. The section gives this exact case."
+    },
+    {
+      "step": "Direction of the error: the distance comes out about 3 m too short.",
+      "part": "1. Time becomes distance (formula distance = c × (time received − time sent)); background arithmetic",
+      "idea": "The satellite stamps its send time from its own clock. If that clock is 10 ns fast, the stamped send time is 10 ns too late. The receiver's clock is right, so received − sent comes out 10 ns too small, and the distance is about 3 m too small."
+    },
+    {
+      "step": "The receiver's fourth unknown b only stands for an error that is added equally to every distance.",
+      "part": "3. The receiver's clock is the weak link (equation measured_distanceᵢ = √(...) + c·b)",
+      "idea": "The receiver's own clock error shifts every satellite's measured distance by the same amount c·b. One extra unknown can therefore soak it up in all four equations at once."
+    },
+    {
+      "step": "A clock error on one satellite affects only that satellite's distance, so it does not fit the shared c·b term and the solve cannot pull it out.",
+      "part": "3. 'What this trick cannot fix' paragraph",
+      "idea": "c·b removes only an error that is the same for every signal. An error in one satellite's clock (their example is 30 ns → 9 m) cannot be detected by the solve. Instead it gets mixed into the position, and possibly into b, as a wrong answer."
+    },
+    {
+      "step": "So satellite clocks must be held to a shared GPS time to within nanoseconds, by other means.",
+      "part": "3. last sentences; 5. 'From the ground'",
+      "idea": "Each satellite clock must match GPS time to within a few ns. Ground stations track the clocks and upload corrections. Here that correction is missing, so the 3 m error stays."
+    }
+  ],
+  "result": "The range to that satellite is off by about 3 m (10 ns × 30 cm/ns). Because the satellite's clock is fast, its send-time stamp is too late, so the measured distance comes out about 3 m too short. The receiver's fourth unknown b can only remove an error that adds the same c·b to every distance. That is true of the receiver's own clock error. This error belongs to one satellite only, so it does not match the shared term. The solve cannot detect it or separate it out, and it turns into an error of a few metres in the computed position.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/published.json
new file mode 100644
index 0000000..275cab2
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Pseudorange is light speed × (receive time on the receiver clock − send time on the satellite clock), so any error in the satellite's send timestamp goes straight into that satellite's pseudorange.",
+      "part": "Section 2, paragraph defining pseudorange (claim def-pseudorange)",
+      "idea": "The measured distance is a time difference multiplied by c. One of the two times comes from the satellite's clock."
+    },
+    {
+      "step": "Each nanosecond of timing error gives 0.3 m of range error, so a 10 ns error gives about 10 × 0.3 m = 3 m.",
+      "part": "Section 1, paragraph on 300 m per µs and 0.3 m per ns; Section 3, 'Each nanosecond of satellite clock error is 0.3 m of range error'",
+      "idea": "A timing error becomes a range error at the rate c, which is 0.3 m per ns."
+    },
+    {
+      "step": "Direction: a clock that is 10 ns fast stamps the send time 10 ns too late. Receive time minus send time then comes out 10 ns too small, so the pseudorange to that satellite is about 3 m too short.",
+      "part": "Step 1 plus background arithmetic",
+      "idea": "A send time that is too large shrinks the time difference."
+    },
+    {
+      "step": "The receiver's clock error b can be solved for only because one clock makes every measurement, so b is the same in all four pseudoranges.",
+      "part": "Section 2, pseudorange paragraph and the worked example on a line",
+      "idea": "An error shared by every measurement can be found and removed as one extra unknown, next to x, y, z."
+    },
+    {
+      "step": "The satellite's error is in only one pseudorange. No single shared unknown can absorb it, so it shows up as a wrong position.",
+      "part": "Section 3, first paragraph (claim mech-clock-to-range); Section 5",
+      "idea": "b absorbs only errors that are the same in every pseudorange. An error that differs between satellites, like the different drifts in Section 5, cannot be absorbed."
+    },
+    {
+      "step": "3 m is within the 17 ns (about 5 m) budget, so this error would degrade the fix only slightly.",
+      "part": "Section 3, second paragraph",
+      "idea": "Satellite clocks need to stay within about 17 ns of GPS time for a fix within about 5 m."
+    }
+  ],
+  "result": "The pseudorange to that satellite is off by about 3 m (10 ns × 0.3 m/ns). It comes out about 3 m too short, because the fast clock stamps the send time too late. The receiver's fourth unknown b can absorb only an error that is the same in every pseudorange, as its own clock error is, since one receiver clock times them all. This satellite's clock error appears in just one of the four pseudoranges. It is not shared, so no single b can remove it, and it goes straight into the position. It stays within the roughly 17 ns (about 5 m) budget.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/quick.json
new file mode 100644
index 0000000..a9f3453
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/gps-relativity/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Time error converts to distance error at about 30 cm per nanosecond.",
+      "part": "Step 1: time becomes distance (paragraph 'Distance = travel time × c… about 30 cm per nanosecond')",
+      "idea": "Distance is travel time multiplied by c, and light covers about 30 cm in each nanosecond. Any timing error therefore becomes a distance error at that rate."
+    },
+    {
+      "step": "A satellite clock that is 10 ns fast puts a wrong send time on its signal, so the travel time to that one satellite is wrong by 10 ns.",
+      "part": "Step 1 (the signal says 'I sent this at time t'; travel time = receive time − send time) and Step 2's last line ('This method works only if the satellite clocks all keep GPS time')",
+      "idea": "The receiver works out travel time from the satellite's time stamp. If the stamp is 10 ns off, the travel time to that satellite is 10 ns off as well."
+    },
+    {
+      "step": "The distance to that satellite is wrong by about 10 × 30 cm ≈ 3 m. Taking the sign literally: a fast clock stamps a later send time, so the travel time looks shorter and the distance comes out about 3 m too short.",
+      "part": "Steps 1 and 2 of this answer",
+      "idea": "10 ns × 0.3 m/ns ≈ 3 m. The error affects the pseudorange to that one satellite only."
+    },
+    {
+      "step": "The fourth unknown b can only absorb an error that is the same in every equation.",
+      "part": "Step 2: why four satellites (pseudorange equation ρᵢ = √(...) + c·b)",
+      "idea": "b is the receiver's clock offset, and it enters every satellite's equation as the same added term c·b. That is how one unknown can soak up the receiver's own clock error."
+    },
+    {
+      "step": "A single satellite's clock error is different in each equation, so b cannot cancel it. The four equations no longer agree on one point, and the solution shifts the position (and b) to spread the error out.",
+      "part": "Step 2 (one shared c·b term in all four equations); Limits ('the bias b absorbs part of an error that all satellites share')",
+      "idea": "The equations have room for only one shared offset. An error that appears in one pseudorange and not the others does not fit that form, so it ends up as a position error rather than being absorbed."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × about 30 cm/ns). Read literally, a fast clock gives a later send time, so the distance comes out about 3 m too short. b cannot absorb this because it is one offset added equally to all four pseudoranges (c·b in every equation), which is why it can cancel the receiver's own clock error. The 10 ns error sits in one satellite's equation only. The four equations then don't meet at the true point, and the solution comes out wrong by metres. The explanation doesn't say exactly how this error splits between position and b.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/none.json
new file mode 100644
index 0000000..86faf5b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For the planet to stay at a steady temperature, the energy radiated to space must equal the absorbed sunlight, about 238 W/m². How much a body radiates depends only on its temperature (σT⁴).",
+      "part": "Section 1, 'The planet is a budget: energy in = energy out'",
+      "idea": "Energy in equals energy out sets the temperature. Emission goes as σT⁴, so the amount emitted is fixed by temperature."
+    },
+    {
+      "step": "What a layer of air sends out depends on how warm that layer is.",
+      "part": "Section 3, last paragraph ('what a layer of air emits depends on how warm that layer is')",
+      "idea": "CO₂ emits at a rate set by the temperature of the air around it, not by how much CO₂ there is or how high it sits."
+    },
+    {
+      "step": "Infrared reaches space from an effective emission height, and space receives radiation at the temperature of that height.",
+      "part": "Section 5, fact 2 and the paragraph on effective emission height",
+      "idea": "At wavelengths that are strongly absorbed, only radiation from high up gets out. What escapes is set by the temperature at that level."
+    },
+    {
+      "step": "Adding CO₂ raises the emission height. This cuts outgoing radiation only because the higher level is colder, which is due to the lapse rate.",
+      "part": "Section 5, 'Now add CO₂' paragraph, and Model 2 on index.html (CO₂ slider; the readout line 'before warming, the air there is … K → planet emits … too little')",
+      "idea": "Forcing exists because the raised emission level sits in colder air (temperature falls about 6.5 K/km), so it radiates less than 238 W/m²."
+    },
+    {
+      "step": "If the atmosphere had the same temperature at every height, the lapse rate would be zero. The higher emission level would then be exactly as warm as the old one.",
+      "part": "Steps 2–4; Section 5 formula T_surface ≈ T_emission + Γ×H",
+      "idea": "With Γ = 0, raising the level by any amount does not change its temperature."
+    },
+    {
+      "step": "So outgoing radiation does not change: there is no shortfall and no forcing. The planet keeps no extra energy, and the surface warming Γ × (rise in emission height) is zero.",
+      "part": "Steps 1 and 5; Section 5 ('the surface ends up warmer by about Γ × (rise in emission height)')",
+      "idea": "With Γ = 0 the surface warming is 0 × rise = 0. Also, with Γ = 0 the surface is at the same temperature as the emission level (255 K), so there is no greenhouse warming in the first place."
+    }
+  ],
+  "result": "Adding CO₂ would do nothing to the surface temperature. The extra CO₂ would still lift the emission height, but in an atmosphere at the same temperature at every height, the new level is just as warm as the old one. It would send out the same σT⁴ ≈ 238 W/m², so no forcing or energy shortfall appears, and nothing pushes the surface to warm. Surface warming is Γ × (rise in emission height), and Γ = 0 here. The greenhouse effect depends on the air getting colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/principles.json
new file mode 100644
index 0000000..63bad46
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Earth must shed about 238 W/m² to space, and this sets the temperature the emitting layer must have: 255 K.",
+      "part": "Section 1 and Section 8 ('238 W/m²', '255 K')",
+      "idea": "Absorbed sunlight sets the energy that must leave. By σT⁴, the layer that emits it must be at 255 K. Greenhouse gases decide where that layer is, not its temperature."
+    },
+    {
+      "step": "The infrared that reaches space comes from an emission level high in the air, not from the surface.",
+      "part": "Section 5, Fact 1",
+      "idea": "A photon escapes only if little absorbing gas lies above it, so the emission comes from a certain altitude."
+    },
+    {
+      "step": "The surface is warmer than the emission level only because temperature changes with height (the lapse rate).",
+      "part": "Section 5, Fact 2 and the altitude diagram",
+      "idea": "Surface temperature = emission-level temperature + lapse rate × height of the emission level."
+    },
+    {
+      "step": "Adding CO2 raises the emission level.",
+      "part": "Section 6, chain step 1",
+      "idea": "More absorbing gas above each altitude means a photon must start higher to escape."
+    },
+    {
+      "step": "In air with the same temperature at every height, the higher emission level has the same temperature, so it emits the same amount (σT⁴ unchanged).",
+      "part": "Section 7, 'Breaks (isothermal air)' bullet; step 3",
+      "idea": "With no lapse rate, moving up does not make the emitting air colder."
+    },
+    {
+      "step": "So no energy imbalance appears, and nothing pushes the surface to warm. The surface is also at the same temperature as the emission level (255 K), however high that level is.",
+      "part": "Step 5; Section 6 chain steps 2–5; step 3",
+      "idea": "Warming needs the emission to drop. Here it does not drop, and the gap between surface and emission level is zero at any height."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature. More CO2 still raises the emission level, but in air that is the same temperature at every height, the new level is no colder. It emits the same 238 W/m², so no energy imbalance (forcing) appears, and the surface does not need to warm. The surface would stay at the same temperature as the emission level (about 255 K) wherever that level is. So there would be no greenhouse warming from this mechanism.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/published.json
new file mode 100644
index 0000000..ed7f493
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "The Earth has to emit as much as it absorbs, about 240 W/m². Whatever does the emitting must therefore be at 255 K.",
+      "part": "Section 1, 'Without greenhouse gases: 255 K' (energy balance, Stefan–Boltzmann law, emission temperature)",
+      "idea": "Absorbed sunlight is 340 × 0.70 ≈ 240 W/m². Setting σT⁴ = 240 W/m² gives T = 255 K for the emitter."
+    },
+    {
+      "step": "Infrared escapes to space from the emission height, and the air there must be at 255 K.",
+      "part": "Section 3, 'Where the infrared escapes: 5 km up', first two paragraphs",
+      "idea": "Infrared only reaches space from air with little greenhouse gas above it. That air has to emit 240 W/m², so it sits at the emission temperature."
+    },
+    {
+      "step": "Adding CO2 raises the emission height.",
+      "part": "Section 4, 'Adding CO₂', point 1",
+      "idea": "With more gas, the infrared has to start from higher up before little gas is left above it. For a doubling, the rise is about 150 m."
+    },
+    {
+      "step": "Normally the higher air is colder and so emits less. That shortfall (the forcing) is what warms the planet.",
+      "part": "Section 4, points 2–5",
+      "idea": "With a lapse rate of 6.5 K/km, 150 m higher is about 1 K colder (254 K). That air emits about 236 W/m², roughly 3.7 W/m² too little, so the Earth warms until the new emission height is back at 255 K."
+    },
+    {
+      "step": "If every height has the same temperature, the higher emission height is still at 255 K. It still emits 240 W/m², so there is no imbalance.",
+      "part": "Section 5, 'The condition: colder air above', test-case paragraph",
+      "idea": "With a lapse rate of 0, raising the emission height doesn't change the temperature of the emitting air. Emission stays at 240 W/m², the forcing is zero, and nothing pushes the system to warm."
+    },
+    {
+      "step": "So the surface temperature doesn't change. In a uniform atmosphere the surface would also be at 255 K, with no greenhouse warming either before or after adding CO2.",
+      "part": "Section 3, the step 255 K + 6.5 K/km × 5 km ≈ 288 K; Step 5; Section 5, last paragraph",
+      "idea": "The surface is warmer than the emitting air only by lapse rate × emission height. With a lapse rate of 0 that difference is zero however high the emission height goes. Warming needs both a rising emission height and air that gets colder with height."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature. The emission height would still rise, but the air up there would be at the same temperature as everywhere else. With the whole column at 255 K, that air still emits 240 W/m², which matches the 240 W/m² absorbed. So there is no radiative forcing, no build-up of energy, and no warming. Since the surface is warmer than the emitting air only by lapse rate × emission height, and the lapse rate here is 0, the surface would just be at the emission temperature of about 255 K, before and after the CO2 is added. Greenhouse warming needs the gas to lift the emission height and the air to get colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/quick.json
new file mode 100644
index 0000000..50eef13
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/greenhouse/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Infrared escapes to space only from air near the emission height. Adding greenhouse gas raises that height.",
+      "part": "Level 2, paragraph tagged mech-emission-height, and the Level 2 flowchart (A→B)",
+      "idea": "Infrared sent out lower down gets absorbed again higher up, so what reaches space comes from air with little gas above it. More gas pushes that air higher, by about 150 m for doubled CO2."
+    },
+    {
+      "step": "How much the planet sends to space depends on the temperature of the emitting air.",
+      "part": "Level 1, Stefan–Boltzmann paragraph; Level 2, second paragraph",
+      "idea": "Emission per m² is σT⁴, so colder emitting air sends out less power."
+    },
+    {
+      "step": "Today a higher emitter is colder only because of the lapse rate.",
+      "part": "Level 2, mech-emission-height paragraph (lapse rate 6.5 K/km) and flowchart step C",
+      "idea": "Air normally cools by about 6.5 K per km of height. Raising the emitter 150 m therefore makes it about 1 K colder, and that cuts the output by 3.8 W/m²."
+    },
+    {
+      "step": "If the atmosphere has one temperature at every height, the emitter is no colder after it rises.",
+      "part": "Step 3 plus the Level 2 paragraph tagged guar-lapse-rate",
+      "idea": "With no lapse rate, the air at the new, higher emission height is as warm as the air at the old height."
+    },
+    {
+      "step": "So the planet's output to space does not fall, and energy balance is never broken.",
+      "part": "Step 2, Level 1 energy-balance paragraph, guar-lapse-rate paragraph",
+      "idea": "The same T gives the same σT⁴, so outgoing infrared stays at 240 W/m², matching the sunlight absorbed. The planet gains no energy, so nothing pushes the column to warm."
+    },
+    {
+      "step": "So the surface temperature does not change.",
+      "part": "Steps 4–5; guar-lapse-rate paragraph ('more gas would not warm the surface'); Level 2 flowchart E→F",
+      "idea": "Surface warming in this mechanism comes only from the imbalance that makes the whole column warm. With no imbalance, the surface stays where it was."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature. More CO2 still raises the height from which infrared escapes to space. But when every height has the same temperature, the higher emitting air is just as warm as before. Its output (σT⁴) stays at 240 W/m², which still equals the sunlight absorbed. Energy balance is never broken, so nothing makes the column or the surface warm up. The extra warming from more gas depends on air getting colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/none.json
new file mode 100644
index 0000000..3acd218
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For the air conditioner, the useful output is the heat taken from the cold inside, Q_cold. So the figure to find is Q_cold / W, where W is the electrical work.",
+      "part": "Run backwards, it's an air conditioner (in 'Why this isn't too good to be true'), and the COP definition in 'The short answer'",
+      "idea": "The same machine with its coils swapped moves heat out of the house. COP is a ratio of a useful heat to the paid-for electricity. When cooling, the useful heat is the heat removed, not the heat delivered."
+    },
+    {
+      "step": "Energy balance: Q_hot = Q_cold + W.",
+      "part": "Energy conservation line in section 3 (Q_cold = Q_hot − W), plus the 1 + 2 = 3 kWh box in 'The short answer'",
+      "idea": "The heat dumped at the warm side equals the heat picked up at the cold side plus the electricity. Nothing is created."
+    },
+    {
+      "step": "Entropy condition: Q_hot / T_hot ≥ Q_cold / T_cold.",
+      "part": "Entropy bookkeeping in section 3",
+      "idea": "Heat Q at temperature T carries entropy Q/T, and work carries none. A steady cycle can't store entropy, so it must give out at least as much as it takes in. This applies whichever coil is indoors."
+    },
+    {
+      "step": "Put step 2 into step 3: (Q_cold + W)/T_hot ≥ Q_cold/T_cold. This gives W ≥ Q_cold (T_hot − T_cold)/T_cold, so Q_cold/W ≤ T_cold/(T_hot − T_cold).",
+      "part": "Steps 2 and 3 (background algebra)",
+      "idea": "The same rearrangement the explanation does for heating, solved for Q_cold instead of Q_hot. This is the ideal (Carnot) cooling limit."
+    },
+    {
+      "step": "Why it is exactly one less: Q_cold/W = (Q_hot − W)/W = Q_hot/W − 1. In the ideal case, T_hot/(T_hot − T_cold) − 1 = T_cold/(T_hot − T_cold).",
+      "part": "Step 2 and the heating Carnot limit COP ≤ T_hot/(T_hot − T_cold) in section 3",
+      "idea": "The heat delivered includes the electricity itself, but the heat removed does not. For the same heat moved, the two ratios always differ by exactly W/W = 1."
+    },
+    {
+      "step": "Example: with 273 K and 308 K, the cooling limit is 273/35 ≈ 7.8, compared with 308/35 ≈ 8.8 for heating.",
+      "part": "Plugging in numbers (section 3)",
+      "idea": "The explanation's worked numbers, shifted down by one."
+    }
+  ],
+  "result": "The ideal cooling limit is heat removed per unit of electricity ≤ T_cold/(T_hot − T_cold), using absolute temperatures. For example, 273/35 ≈ 7.8 for 0 °C and 35 °C. It is exactly one less than the heating limit T_hot/(T_hot − T_cold) because of energy conservation: the heat released at the warm side is the heat taken from the cold side plus the electricity (Q_hot = Q_cold + W). So Q_cold/W = Q_hot/W − 1. The heating figure counts the electricity's own energy as delivered heat, and the cooling figure does not.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/principles.json
new file mode 100644
index 0000000..e6f3b0e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "In cooling mode the useful output is the heat taken from the cold side, Q_C. The input is still the electrical work W. So the figure of merit is Q_C / W.",
+      "part": "Paragraph after 'A refrigerator is the same machine' in 'The trick: boiling point depends on pressure', plus the COP definition in 'Why this matters'",
+      "idea": "A refrigerator is the same loop: it takes heat from the cold box and dumps it at the warm side. COP is useful heat divided by electrical work. For cooling, the useful heat is the heat removed from the cold side."
+    },
+    {
+      "step": "Energy balance: Q_H = Q_C + W, so Q_C = Q_H − W.",
+      "part": "Short answer (heat delivered = heat taken from outside + electrical work) and the line W = Q_H − Q_C in 'Why the COP is not unlimited'",
+      "idea": "The heat dumped on the hot side equals the heat picked up on the cold side plus the compressor work. Energy is conserved."
+    },
+    {
+      "step": "Divide by W: Q_C/W = Q_H/W − 1. So for any machine the cooling COP is exactly one less than the heating COP, because the work itself ends up as part of the heat dumped on the hot side but is not heat removed from the cold side.",
+      "part": "Step 2",
+      "idea": "Q_H counts the electrical work as delivered heat. Q_C does not include it. The difference W/W is exactly 1."
+    },
+    {
+      "step": "Second-law limit: Q_H/T_H ≥ Q_C/T_C, so Q_C/Q_H ≤ T_C/T_H.",
+      "part": "'Why the COP is not unlimited' (entropy Q/T, total entropy cannot decrease)",
+      "idea": "The entropy dumped on the hot side must be at least the entropy taken from the cold side. Temperatures are in kelvin."
+    },
+    {
+      "step": "Cooling limit: Q_C/W = Q_C/(Q_H − Q_C) = 1/(Q_H/Q_C − 1) ≤ 1/(T_H/T_C − 1) = T_C/(T_H − T_C).",
+      "part": "Steps 2 and 4, background algebra",
+      "idea": "Q_H/Q_C ≥ T_H/T_C. A larger denominator gives a smaller ratio, which gives the upper bound."
+    },
+    {
+      "step": "Check: T_H/(T_H − T_C) − 1 = (T_H − (T_H − T_C))/(T_H − T_C) = T_C/(T_H − T_C). This matches the heating limit minus one.",
+      "part": "Formula COP ≤ T_H/(T_H − T_C) in 'Why the COP is not unlimited', plus step 3",
+      "idea": "The two ideal limits differ by exactly 1, just as the actual COPs do. Example: with 268 K and 318 K, the heating limit is 6.4 and the cooling limit is 268/50 = 5.4."
+    }
+  ],
+  "result": "The ideal cooling COP is Q_C/W ≤ T_C/(T_H − T_C), with temperatures in kelvin: the cold temperature divided by the temperature lift. It is exactly one less than the heating limit T_H/(T_H − T_C) because Q_H = Q_C + W. The electrical work ends up as heat dumped on the hot side, so it counts towards heating output. It does not count as heat removed from the cold side. So Q_H/W = Q_C/W + 1, and the same relation holds between the two ideal limits.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/published.json
new file mode 100644
index 0000000..347e961
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "When run in reverse, the machine has the same three energy flows. W is the electricity. Q_cold is the heat taken from the cold side, which is now the indoor air. Q_hot is the heat given to the warm side, which is now the outdoor air. The same loop can have its cold coil inside the cooled space.",
+      "part": "Level 2 loop diagram and the Summary line 'A fridge uses the same loop, with the cold coil inside the fridge'",
+      "idea": "The loop takes in heat at the cold coil, takes in electricity at the compressor, and gives out heat at the hot coil. Which side counts as 'inside' does not change these flows."
+    },
+    {
+      "step": "Energy balance: Q_hot = Q_cold + W. Rearranged, Q_cold = Q_hot − W.",
+      "part": "Level 1 diagram (2 + 1 = 3 kWh), and 'Energy conservation gives Q_cold = Q_hot − W' in 'Where the limit comes from'",
+      "idea": "All the heat taken from the cold side plus all the electricity comes out as heat on the hot side."
+    },
+    {
+      "step": "Entropy condition: Q_hot / T_hot ≥ Q_cold / T_cold, with temperatures in kelvin.",
+      "part": "'Where the limit comes from' (entropy paragraph and inequality); 'Use kelvin, not Celsius'",
+      "idea": "The refrigerant stores no entropy over a cycle and electricity carries none. Entropy cannot be destroyed, so the hot side must receive at least as much entropy as the cold side loses."
+    },
+    {
+      "step": "Put Q_hot = Q_cold + W into the condition: (Q_cold + W)/T_hot ≥ Q_cold/T_cold. Multiply by T_hot·T_cold to get Q_cold·T_cold + W·T_cold ≥ Q_cold·T_hot. Then W·T_cold ≥ Q_cold·(T_hot − T_cold). So the cooling COP Q_cold/W ≤ T_cold / (T_hot − T_cold).",
+      "part": "Steps 2 and 3; the algebra follows the same pattern as the explanation's four-line derivation",
+      "idea": "The same rearrangement, solved for heat removed per unit of electricity instead of heat delivered."
+    },
+    {
+      "step": "Why it is exactly one less: Q_cold/W = (Q_hot − W)/W = Q_hot/W − 1. Every kWh of electricity becomes heat dumped on the hot side, not heat removed. So the heat removed per kWh is always the heat delivered per kWh minus 1, both for the ideal limit and for any real machine. Check: T_hot/(T_hot − T_cold) − 1 = T_cold/(T_hot − T_cold).",
+      "part": "Step 2; ideal limit formula T_hot/(T_hot − T_cold) in 'The ideal limit'",
+      "idea": "Energy conservation, with the electricity ending up as heat on the hot side (Level 1, and compressor step 3: 'The compressor's 1 kWh is in the vapour too')."
+    },
+    {
+      "step": "Numerical example using the explanation's temperatures (308.15 K and 273.15 K, 35 K lift): heating limit 308.15/35 = 8.8, cooling limit 273.15/35 = 7.8. The explanation's COP-3 heating example would cool with 2 kWh removed per 1 kWh.",
+      "part": "'The ideal limit' (8.8) and Level 1 (2 kWh outdoor heat for 1 kWh)",
+      "idea": "The numbers confirm the cooling value is one less than the heating value."
+    }
+  ],
+  "result": "The ideal cooling limit is heat removed ÷ electricity ≤ T_cold / (T_hot − T_cold), with temperatures in kelvin. For example, a 35 K lift with the cold side at 273.15 K gives 273.15/35 ≈ 7.8, compared with 8.8 for heating. It is exactly one less because energy is conserved: heat delivered = heat removed + electricity. So heat removed per kWh = heat delivered per kWh − 1, which means T_hot/(T_hot − T_cold) − 1 = T_cold/(T_hot − T_cold). The electricity ends up as heat on the warm side, so it counts toward heating but not toward cooling.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/quick.json
new file mode 100644
index 0000000..22d2130
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/heat-pump/quick.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "In the reversed machine (an air conditioner), the cold indoors plays the outdoor air's role: heat is taken in at the cold side. Electricity drives the compressor, and heat is released at the warm outdoor side.",
+      "part": "Level 2, the line 'A refrigerator uses the same loop', together with the refrigerant-loop diagram",
+      "idea": "The same loop can serve different purposes. Its evaporator is wherever heat is taken from the cold place, and its condenser is wherever heat is given to the warm place. So an air conditioner is this loop with the cold side indoors and the warm side outdoors."
+    },
+    {
+      "step": "Energy balance for the loop: heat given out at the hot side = heat taken in at the cold side + electricity, so Q_hot = Q_cold + W.",
+      "part": "Level 1, the energy-conservation sentence (3 kWh = 2 kWh + 1 kWh); Level 2, step 3 (Condenser)",
+      "idea": "No energy is created. The heat released at the condenser is the heat taken in at the evaporator plus the compressor work."
+    },
+    {
+      "step": "Define the air conditioner's figure of merit as useful heat removed per unit of electricity, Q_cold ÷ W. This is the counterpart of heating COP = Q_hot ÷ W.",
+      "part": "Level 1, the paragraph defining COP",
+      "idea": "COP is the useful output divided by the paid input (electricity). For heating the useful output is the heat delivered. For cooling it is the heat removed from the cold space."
+    },
+    {
+      "step": "Divide the balance by W: Q_cold/W = Q_hot/W − 1. So cooling COP = heating COP − 1, for the same machine running between the same temperatures.",
+      "part": "Step 2 and step 3, plus background algebra",
+      "idea": "The heat delivered is bigger than the heat removed by exactly the electricity used. Per unit of electricity, that difference is exactly 1."
+    },
+    {
+      "step": "Ideal heating limit for the same two temperatures: T_hot ÷ (T_hot − T_cold), with temperatures in kelvin.",
+      "part": "Level 3, the Carnot limit formula",
+      "idea": "No machine can beat COP_max = T_hot/(T_hot − T_cold) for moving heat from T_cold up to T_hot."
+    },
+    {
+      "step": "Ideal cooling limit = T_hot/(T_hot − T_cold) − 1 = [T_hot − (T_hot − T_cold)]/(T_hot − T_cold) = T_cold ÷ (T_hot − T_cold).",
+      "part": "Steps 4 and 5, plus background algebra",
+      "idea": "Subtract 1 from the heating limit and put it over a common denominator."
+    },
+    {
+      "step": "Example: with the cold side at 263 K and the hot side at 313 K (lift 50 K), the ideal heating COP is 313/50 ≈ 6.3, so the ideal cooling COP is 263/50 ≈ 5.3. That is exactly 1 less.",
+      "part": "Level 3 table, the Typical row",
+      "idea": "The table gives the temperatures and the heating Carnot limit to check against."
+    }
+  ],
+  "result": "The ideal air-conditioner limit is heat removed ÷ electricity = T_cold ÷ (T_hot − T_cold), with temperatures in kelvin. It is exactly 1 less than the heating limit T_hot ÷ (T_hot − T_cold) because of energy conservation. The heat sent out to the warm side is the heat removed from the cold side plus the electricity (Q_hot = Q_cold + W). So Q_cold/W = Q_hot/W − 1. A heater gets to count the compressor work as useful heat; an air conditioner doesn't, because that work only adds to what must be dumped outside. One assumption: the Carnot limit is stated only for heating, and I've taken it to apply to the same loop running the other way. The explanation's 'a refrigerator uses the same loop' supports this but doesn't say it outright.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/none.json
new file mode 100644
index 0000000..92830cc
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/none.json
@@ -0,0 +1,51 @@
+{
+  "steps": [
+    {
+      "step": "Two properties are needed: everyone combining in any order reaches the same value, and an outsider can't undo a combination. Each person keeps a secret that is never sent.",
+      "part": "Opening section ('Two ideas solve it') and 'An analogy: mixing paint'",
+      "idea": "Only results computed from secrets go over the channel. The method relies on a calculation that is easy to do and very hard to undo, and on the order of combining not mattering."
+    },
+    {
+      "step": "Raising a public value to your own secret power mod p is the basic move, and it is fast.",
+      "part": "'The easy direction' and 'The protocol' table",
+      "idea": "g^x mod p is cheap to compute with repeated squaring. Raising someone else's public value to your secret gives a shared power of g, e.g. (g^b)^a = g^(ab)."
+    },
+    {
+      "step": "Exponents multiply in any order, and reducing mod p along the way doesn't change the result. So (g^x)^y mod p = g^(xy) mod p for any x and y.",
+      "part": "'The protocol' (paragraph 'Since ab = ba…') and 'Modular arithmetic' (reduce at every step)",
+      "idea": "Order of mixing doesn't matter, and reducing mod p at any stage gives the same final value."
+    },
+    {
+      "step": "Round 1: Alice, Bob and Carol pick secrets a, b, c and publish A = g^a, B = g^b, C = g^c (all mod p).",
+      "part": "'The protocol' step 1–2 pattern, extended to three people; step 1",
+      "idea": "Same as two-party Diffie–Hellman: each person publishes g^secret mod p and never sends the secret."
+    },
+    {
+      "step": "Round 2: each person raises one neighbour's public value to their own secret and publishes the result. Alice publishes C^a = g^(ca), Bob publishes A^b = g^(ab), Carol publishes B^c = g^(bc).",
+      "part": "Step 3; 'The protocol' step 4",
+      "idea": "This is the two-party computation of s, but its result is published, not kept. It is a combination of two secrets that still lacks the third."
+    },
+    {
+      "step": "Each person raises the round-2 value that is missing their own secret to their own secret. Alice computes (g^(bc))^a, Bob computes (g^(ca))^b, Carol computes (g^(ab))^c. All three get g^(abc) mod p.",
+      "part": "Step 3",
+      "idea": "abc = bca = cab, so the three results are equal. This is the paint analogy with three secret colours added to yellow."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). Every value she has is missing at least one secret. Multiplying values together only adds exponents (e.g. g^(ab)·g^c = g^(ab+c)), which is not g^(abc).",
+      "part": "'The protocol' paragraph 'Multiplying A by B gives her g^(a+b), not g^(ab)…' and the paint analogy (orange + green has too much yellow)",
+      "idea": "Combining public values gives the wrong mixture. To get the key you have to remove a secret from a published value."
+    },
+    {
+      "step": "Getting g^(abc) from g^(ab) and g^c is a two-party exchange in disguise: g^(ab) acts as one public value with secret ab, and g^c as the other with secret c. So Eve faces the same problem as in the two-party case: find a secret exponent from a public value. That is a discrete logarithm.",
+      "part": "Steps 5 and 7; 'The hard direction'; Summary bullet 3; page section 'Eve's attack: undo the exponent'",
+      "idea": "Undoing g^x mod p is the discrete logarithm problem. It is infeasible for well-chosen primes of about 2048 bits (roughly 2^110 operations even for the best known algorithms). The brute-force control shows it works only for tiny p."
+    },
+    {
+      "step": "Limits: this holds only against a listener. Someone who can change messages could swap values, as in the two-party case, so the messages would need to be authenticated.",
+      "part": "'The catch: Eve who only listens vs. Mallory who interferes' and the Mallory checkbox on the page",
+      "idea": "Diffie–Hellman alone protects against eavesdropping only. Stopping someone who swaps messages needs signatures or certificates."
+    }
+  ],
+  "result": "All three use the public p and g, and it takes two rounds of public messages. Round 1: Alice, Bob and Carol pick secrets a, b, c and publish g^a, g^b, g^c mod p. Round 2: Alice publishes (g^c)^a = g^(ca), Bob publishes (g^a)^b = g^(ab), and Carol publishes (g^b)^c = g^(bc). Then each person raises the round-2 value that doesn't include their own secret to their own secret: Alice computes (g^(bc))^a, Bob computes (g^(ca))^b, Carol computes (g^(ab))^c. Because exponents multiply in any order, and reducing mod p doesn't change that, all three get the same key, g^(abc) mod p. Eve sees p, g and six public values, but each one is missing at least one secret. Multiplying them only adds exponents, which gives the wrong 'colour'. To get g^(abc) she would have to pull a secret exponent out of a published value, for example getting c from g^c to raise g^(ab) to it. That is a discrete logarithm, which is infeasible for large, well-chosen p. Caveats: this protects only against a listener. Someone who can change messages could swap values, so the messages need authentication. The explanation says outright that the two-party problem (getting g^(ab) from g^a and g^b) appears to need a discrete log. Applying that to three people is my own step: I treat g^(ab) and g^c as a two-party exchange with secrets ab and c.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/principles.json
new file mode 100644
index 0000000..c10a434
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Alice, Bob and Carol agree on p and g in public, and each picks a private exponent (a, b, c) that they never send.",
+      "part": "Summary, points 1–2; 'The answer in one paragraph'",
+      "idea": "The public settings p and g can be known to everyone. Each person's private number stays with them and is never sent."
+    },
+    {
+      "step": "Round 1: each person sends a public value. A = g^a mod p, B = g^b mod p, C = g^c mod p. Using the explanation's numbers (p=23, g=5, a=6, b=15, and c=3 for Carol), these are A=8, B=19, C=10.",
+      "part": "'The working method' table, step 2; Mallory section (5³ mod 23 = 10)",
+      "idea": "Raising g to a private exponent mod p makes a public value. This is fast to compute and hard to undo."
+    },
+    {
+      "step": "Round 2: each person raises one neighbour's public value to their own exponent and sends the result. Bob sends A^b = g^(ab) = 8^15 mod 23 = 2. Carol sends B^c = g^(bc) = 19^3 mod 23 = 5. Alice sends C^a = g^(ca) = 10^6 mod 23 = 6.",
+      "part": "'The working method' table, step 3; 'Why the two results are equal'",
+      "idea": "The 'combine' step (raise someone else's public value to your private exponent) also works on an intermediate value, and it gives g to the product of the exponents."
+    },
+    {
+      "step": "Round 3: each person raises the value they just received, which is missing only their own exponent, to their exponent. Alice: (g^(bc))^a = 5^6 = 8. Bob: (g^(ca))^b = 6^15 mod 23 = 8. Carol: (g^(ab))^c = 2^3 = 8. All three get g^(abc) mod p = 8.",
+      "part": "'Why the two results are equal'",
+      "idea": "The order of the exponents does not matter, and taking mod p at each step does not change this. So every route gives g^(a×b×c). Check: 5^270 mod 23 = 5^6 = 8, because the powers of 5 mod 23 repeat every 22 and 270 mod 22 = 6."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca), but never a, b, c or g^(abc).",
+      "part": "'The working method' (what Eve sees); 'First attempt'",
+      "idea": "Only public values go over the channel. Neither the private numbers nor the key itself are ever sent."
+    },
+    {
+      "step": "To get the key, Eve would have to recover a private exponent from a public value (for example c from g^c) and then raise g^(ab) to it. That is a discrete logarithm problem, which is infeasible when p is large.",
+      "part": "'Why Eve cannot do the same'; Summary point 4; Epistemic status",
+      "idea": "Undoing exponentiation mod a large p is believed to be infeasible, at about 2^112 operations for a 2048-bit p. The two-person argument (Eve needs a private number) carries over by analogy. The explanation only argues this for two people, and the hardness is an assumption, not a proof."
+    },
+    {
+      "step": "Caveat: this protects against someone who only reads the messages, not against someone who can change them.",
+      "part": "'Where the guarantee breaks'",
+      "idea": "An active attacker can sit in the middle unless the public values are authenticated, for example with signatures."
+    }
+  ],
+  "result": "All three use the same p and g. Round 1: each sends g^own mod p (8, 19 and 10 in the example). Round 2: each raises one neighbour's value to their own exponent and sends it on: g^(ab)=2, g^(bc)=5, g^(ca)=6. Round 3: each raises the value that lacks only their own exponent to that exponent. All three get g^(abc) mod p, which is 8 in the example, because the order of the exponents doesn't matter. Eve sees only g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). To build g^(abc) she would need one private exponent, which means solving a discrete logarithm. That is assumed infeasible for a large p. This only protects against someone reading the messages: without authentication, an attacker who can change messages can still sit in the middle.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/published.json
new file mode 100644
index 0000000..27e49db
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Each of the three picks a private number at random and never sends it. Example: a = 6 (Alice), b = 15 (Bob), c = 3 (Carol). Everyone uses p = 23 and g = 5, which are public.",
+      "part": "The exchange, with small numbers (steps 1–2)",
+      "idea": "The two-person exchange works by giving each person a private number that is never sent, plus public p and g. Nothing in it limits it to two people."
+    },
+    {
+      "step": "Round 1: each person sends g^(own private) mod p. Alice sends 5^6 mod 23 = 8, Bob sends 5^15 mod 23 = 19, and Carol sends 5^3 mod 23 = 10. Each of these goes to the next person around a circle: Alice→Bob, Bob→Carol, Carol→Alice.",
+      "part": "The exchange, with small numbers (step 3); The limit section (5^3 mod 23 = 10)",
+      "idea": "A public number is g raised to the private number, mod p. The explanation already gives 8 and 19, and the Mallory section shows 5^3 mod 23 = 10."
+    },
+    {
+      "step": "Round 2: each person raises the number they just got to their own private number and passes the result on around the circle. Bob computes 8^15 mod 23 = 2 (= g^(ab)) and sends it to Carol. Carol computes 19^3 mod 23 = 5 (= g^(bc)) and sends it to Alice. Alice computes 10^6 mod 23 = 6 (= g^(ca)) and sends it to Bob.",
+      "part": "The exchange, with small numbers (step 4); The limit section (8^3 = 6, 19^3 = 5, 10^6 = 6)",
+      "idea": "Raising someone's public number to your own private number finishes half of a calculation without undoing it. The explanation's examples give these values directly."
+    },
+    {
+      "step": "Final step: each person raises the round-2 number they received to their own private number. Carol computes 2^3 = 8. Alice computes 5^6 mod 23 = 8. Bob computes 6^15 mod 23 = 8. All three get s = 8, and each feeds it into the hash function to get the key.",
+      "part": "Why both get 2; the 5^x mod 23 table in 'Why powers, and why mod'; the paragraph after the exchange steps (hash)",
+      "idea": "By the exponent rule, ((g^a)^b)^c, ((g^b)^c)^a and ((g^c)^a)^b all equal g^(abc). Taking remainders along the way doesn't change the final remainder. The table gives 5^6 mod 23 = 8. Then s goes through the hash to make the key."
+    },
+    {
+      "step": "Eve sees p, g, 8, 19, 10, 2, 5 and 6, which are g^a, g^b, g^c, g^ab, g^bc and g^ca. She does not see a, b, c or s.",
+      "part": "What Eve sees (table)",
+      "idea": "The eavesdropper has every public number and none of the private ones."
+    },
+    {
+      "step": "Combining public numbers by multiplying doesn't work. For example, g^ab × g^c mod p = g^(ab+c), which adds the exponents. The secret needs them multiplied: g^(ab·c).",
+      "part": "What Eve sees (multiplying fails)",
+      "idea": "Multiplying powers adds exponents, but the shared secret needs the product of the exponents."
+    },
+    {
+      "step": "Each pair Eve could use, such as g^ab with g^c or g^bc with g^a, is the same problem Eve faces in the two-person exchange: two public powers whose exponents must be multiplied. The only known way is to find an exponent (a, b, c or ab) from its power, which is the discrete logarithm. With a 2048-bit p that takes about 2^112 operations.",
+      "part": "What Eve sees; Why powers, and why mod; Why real numbers are huge; Assumption, not proof",
+      "idea": "g^x mod p is one-way, and no fast discrete-log method is known for a large p. Security rests on that assumption, which has not been proven."
+    }
+  ],
+  "result": "Use a ring of three rounds. (1) Each person sends g^(own private) mod p to the next person: Alice→Bob→Carol→Alice. (2) Each raises what they got to their own private number and passes it on, so Bob sends g^ab to Carol, Carol sends g^bc to Alice, and Alice sends g^ca to Bob. (3) Each raises what they got to their own private number. All three get g^(abc) mod p (8 in the p = 23, g = 5, a = 6, b = 15, c = 3 example), and they hash it to make the key. Eve sees only g^a, g^b, g^c, g^ab, g^bc and g^ca. Multiplying them only adds exponents. Getting g^(abc) from any pair is the same two-person problem: in effect she must take a discrete logarithm to find a hidden exponent, and no fast method is known for a large p. This is an assumption, not a proof. As with two people, this stops only someone who reads messages, not someone who changes them, unless the messages are authenticated.",
+  "gap": "The explanation only covers two people. The three-party ring of rounds is my own extension, built from the explanation's exponent rule and mod-power steps. The claim that Eve can't get g^(abc) from the six public values also goes beyond the text. The explanation argues only that A and B alone don't give s, so treating g^ab as just another public number is my step, not its claim."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/quick.json
new file mode 100644
index 0000000..d38c324
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/key-exchange/quick.json
@@ -0,0 +1,51 @@
+{
+  "steps": [
+    {
+      "step": "All three agree in public on p and g (for example p = 23, g = 5). Eve knows these too.",
+      "part": "How it works, step 1",
+      "idea": "The prime and the base are public. Only the private numbers are kept secret."
+    },
+    {
+      "step": "Each person picks a private number and never sends it: Alice picks a, Bob picks b, Carol picks c.",
+      "part": "How it works, step 2",
+      "idea": "Each person's private number stays secret. Every message is built from it but never contains it directly."
+    },
+    {
+      "step": "Round 1: each person sends a public value. Alice sends g^a mod p, Bob sends g^b mod p, Carol sends g^c mod p.",
+      "part": "How it works, step 3",
+      "idea": "A public value is g raised to your private number, mod p, and you send it openly."
+    },
+    {
+      "step": "Round 2: each person raises the public value they got from a neighbour to their own private number, then sends the result on. Bob takes Alice's g^a and sends (g^a)^b = g^(ab). Carol takes Bob's g^b and sends g^(bc). Alice takes Carol's g^c and sends g^(ca). All of these are still mod p.",
+      "part": "How it works, step 4 and the paragraph under it",
+      "idea": "Raising someone else's public value to your own private number gives g to the product of the two exponents, (g^b)^a = g^(ab). This result can itself be sent openly as a new value."
+    },
+    {
+      "step": "Final step: each person raises the two-exponent value that is missing their own number to their private number. Carol computes (g^(ab))^c, Alice computes (g^(bc))^a, and Bob computes (g^(ca))^b. Each gets g^(abc) mod p, so all three hold the same key, and the key itself is never sent.",
+      "part": "Paragraph under How it works ('Order does not matter') plus background exponent rules",
+      "idea": "The order of exponents does not matter, so every route gives g to the product abc. Example with a = 6, b = 15: g^(ab) mod 23 = 2. If Carol picks c = 3, she gets 2^3 mod 23 = 8."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). To get g^(abc) she must put one more private exponent onto one of these values. For example, she needs c to turn g^(ab) into the key, and finding c from g^c means solving g^c mod p = value. That is the discrete logarithm.",
+      "part": "Why Eve fails, paragraph 1",
+      "idea": "Getting the key needs a private exponent, and recovering an exponent from a public value is the discrete logarithm problem."
+    },
+    {
+      "step": "Eve cannot just combine the public values she sees. Multiplying them only adds exponents. For example, g^(ab)·g^c = g^(ab+c), not g^(abc).",
+      "part": "Why Eve fails, last paragraph",
+      "idea": "Multiplying public values adds their exponents. It never multiplies them."
+    },
+    {
+      "step": "With a large p (2048 bits), solving the discrete logarithm takes about 2^112 operations, which is out of reach. The honest parties need only fast exponentiation, about two exponentiations each.",
+      "part": "Why Eve fails, paragraph 2",
+      "idea": "Going forward is easy and going backward is infeasible, as long as p is large."
+    },
+    {
+      "step": "This holds only if Eve can read messages but not change them, and only if the discrete logarithm really is hard.",
+      "part": "Limits",
+      "idea": "An attacker who can swap messages (man-in-the-middle) breaks the scheme unless the values are authenticated. Also, the hardness is assumed, not proven."
+    }
+  ],
+  "result": "They take two rounds of public messages. First, each person sends g^x mod p for their own private x. Second, each person raises a neighbour's value to their own private number and passes it on (giving g^ab, g^bc, g^ca). Finally, each person raises the value that lacks their own number to their private number, so all three get g^(abc) mod p. Eve sees only values of the form g^(one or two exponents). To turn any of them into the key she needs a missing private exponent, which means solving a discrete logarithm. That is infeasible for a large p, and multiplying the values she sees only adds exponents. This assumes Eve can only listen, cannot change messages, and that the discrete logarithm is hard. The explanation covers only two people, so the three-person version is my own extension of its exponent rule. Its claim that the extra round-2 values give Eve nothing useful also goes a little beyond what the explanation's argument directly covers.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/none.json
new file mode 100644
index 0000000..d4b2feb
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a later group of servers to know about an earlier decision, the two groups must have at least one server in common.",
+      "part": "Why a majority, and not \"whoever is still up\"? (paragraph after 'Two majorities of the same group always share at least one member')",
+      "idea": "Because any two quorums overlap, every decision is seen by at least one server that also took part in the previous decision. That shared server is what keeps later decisions consistent with earlier ones."
+    },
+    {
+      "step": "The overlap guarantee comes from counting, not from the groups being majorities as such: if two groups together hold more servers than exist, they must share one.",
+      "part": "Same section: 'If each of two groups contained more than half the servers, together they would contain more than all of them, which is impossible unless some server is in both'",
+      "idea": "Two groups share a member whenever their sizes add up to more than n. This is the pigeonhole principle, which I also know as background."
+    },
+    {
+      "step": "Apply this to a read group and a write group: for a read to see the latest committed write, every read group of R servers must share a server with every write group of W servers. With n = 5 this means W + R > 5, so W + R ≥ 6.",
+      "part": "Steps 1 and 2",
+      "idea": "The latest write is held by its W servers, and the read asks R servers. If W + R > 5, at least one server the read asks holds the write. If W + R ≤ 5, the two groups can be completely separate, and the read can miss the write."
+    },
+    {
+      "step": "Check W = 4, R = 2: 4 + 2 = 6 > 5, so every read group overlaps every write group.",
+      "part": "Step 3",
+      "idea": "The condition holds."
+    },
+    {
+      "step": "An operation can still go ahead as long as enough servers are up to form its group, so the number of failures it survives is n minus the group size.",
+      "part": "Now count ('failures tolerated = n − quorum size')",
+      "idea": "Failures tolerated equals the total number of servers minus the number that must respond."
+    },
+    {
+      "step": "Writes need 4 of 5 servers, so they survive 5 − 4 = 1 failure. Reads need 2 of 5, so they survive 5 − 2 = 3 failures.",
+      "part": "Step 5",
+      "idea": "Substitute W = 4 and R = 2 into n − group size."
+    }
+  ],
+  "result": "The rule is W + R > 5 (that is, W + R ≥ 6), so every read group overlaps every write group. With W = 4 and R = 2 the rule holds (6 > 5). Writes survive 1 failure (5 − 4) and reads survive 3 failures (5 − 2).",
+  "gap": "Small gap: the explanation only covers one majority quorum used for every decision. It never talks about separate read and write groups or groups smaller than a majority. I got W + R > n by applying its counting argument for why groups overlap. The explanation doesn't state that rule itself, and it doesn't say whether two write groups must also overlap (which would need W > n/2)."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/principles.json
new file mode 100644
index 0000000..eac2a39
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A read can only see the latest committed write if its read group shares at least one server with the write group that committed that write. The shared server holds the write.",
+      "part": "The fix: any two deciding groups must share a server",
+      "idea": "Safety comes from overlap. Two groups that must not act independently need a common server, and that server connects what one group did to what the other group sees. The page applies this to two write groups. I apply the same reasoning to one write group and one read group."
+    },
+    {
+      "step": "A write group of W servers and a read group of R servers, chosen from n = 5, always overlap only if W + R > 5, which means W + R ≥ 6.",
+      "part": "The fix: any two deciding groups must share a server (the line 'must overlap when their sizes add up to more than n')",
+      "idea": "Two groups inside n servers must overlap when their sizes add up to more than n. If the sizes add up to n or less, the groups can be disjoint, as the 2|2 example shows. The page uses q + q, but the rule depends only on the sum of the sizes, so W + R works the same way."
+    },
+    {
+      "step": "Writes should also satisfy W + W > 5, so W ≥ 3. Otherwise two conflicting writes could each succeed in separate groups.",
+      "part": "The fix: any two deciding groups must share a server; Why 'half' is not enough",
+      "idea": "Two write groups must overlap, or split brain returns. This gives the strict-majority condition W > n/2."
+    },
+    {
+      "step": "Check W = 4 and R = 2: 4 + 2 = 6 > 5, and 4 + 4 = 8 > 5. Both overlap conditions hold.",
+      "part": "steps 2 and 3",
+      "idea": "Plug the numbers into the inequalities."
+    },
+    {
+      "step": "An operation that needs a group of size k keeps working while at least k servers are alive, so it survives n − k failures.",
+      "part": "From quorum to failure tolerance (f = n − q)",
+      "idea": "Failure tolerance is total servers minus the group size needed. I apply this separately to the write size and the read size."
+    },
+    {
+      "step": "Writes survive 5 − 4 = 1 failure. Reads survive 5 − 2 = 3 failures. With more failures than that, the operation stops instead of returning a wrong result.",
+      "part": "step 5; What 'survive' means, and where it stops",
+      "idea": "With fewer than the needed number of servers alive, the operation is unavailable but still correct."
+    }
+  ],
+  "result": "The condition is W + R > 5 (W + R ≥ 6), so every read group shares a server with every write group. To stop conflicting writes, you also need W + W > 5 (W ≥ 3). With W = 4 and R = 2 (4 + 2 = 6 > 5), writes survive 1 failure and reads survive 3. One caveat: the page never says how a reader tells which of the replies it gets is the latest. I assumed the overlapping server's copy can be recognised as the newest.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/published.json
new file mode 100644
index 0000000..5573ee1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/published.json
@@ -0,0 +1,21 @@
+{
+  "steps": [
+    {
+      "step": "A change is decided once a quorum of servers has accepted it, and the cluster stops if fewer than a quorum answer.",
+      "part": "The rule",
+      "idea": "The quorum size is the number of accepts needed. If fewer than that many servers answer, nothing new is decided, but nothing already decided is lost."
+    },
+    {
+      "step": "Two groups are certain to share a server only when their sizes add up to more than n.",
+      "part": "Why more than half works (overlap paragraph: 3 + 3 = 6 > 5, so C is in both)",
+      "idea": "The page argues by counting: if two groups together list more than n servers, some server must be in both. The page applies this to two majorities, but the count works for any two sizes. So a W-group and an R-group must share a server for sure when W + R > n, that is W + R > 5. With W = 4 and R = 2, 4 + 2 = 6 > 5, so every read group contains at least one server that accepted the latest write."
+    },
+    {
+      "step": "Why the shared server matters: it carries the decided value from one group to the other.",
+      "part": "Why more than half works (shared-server paragraph) and Limits ('Simplified': the shared server reports x = 1 to the new group)",
+      "idea": "The page only shows this for two write groups competing for the same position. There, the shared server refuses the second change, or in real protocols reports the decided value. It never shows a read group asking servers for a value and using the shared server's reply to find the latest write."
+    }
+  ],
+  "result": "Only partly worked out. Applying the page's counting argument to groups of different sizes says a W-group and an R-group always share a server exactly when W + R > 5, and W = 4, R = 2 meets that (6 > 5). By the page's rule (tolerance = n minus the group size), writes would survive 5 − 4 = 1 failure and reads 5 − 2 = 3. Both answers depend on the read mechanism that the page leaves out.",
+  "gap": "The page says plainly that it does not cover 'how reads work' (Limits). It also only treats a single quorum size used for every decision, not separate write and read groups. It never says that a read is correct when its group shares a server with the last write group, or how a reader tells which reply holds the latest write. So W + R > n as the condition for 'every read sees the latest write' cannot be fully derived from it. The same applies to tolerance = n − W for writes and n − R for reads, which needs the page's rule carried over to the two kinds of group."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/quick.json
new file mode 100644
index 0000000..ba68cdd
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/quorum/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Each group can keep working only while enough servers reply. The number of failures a group size survives is servers minus group size.",
+      "part": "The setup (claim: tolerance)",
+      "idea": "The cluster keeps going while at least a quorum of servers reply, so it tolerates (servers − quorum) failures."
+    },
+    {
+      "step": "A read sees the latest committed write only if at least one server in the read group was also in the write group. Only such a server holds that write.",
+      "part": "Why the quorum must be a majority (claim: why-majority)",
+      "idea": "Safety comes from making any two quorums share at least one server, so that a shared server links the two groups. I apply the same idea to a write group and a read group. The explanation itself only covers two deciding groups of the same size."
+    },
+    {
+      "step": "A write group of W servers and a read group of R servers can avoid sharing a server only if W + R ≤ n. So they must satisfy W + R > n, which here is W + R > 5.",
+      "part": "Why the quorum must be a majority, the counting sentence (two groups of size q fit into n servers without overlap only if 2q ≤ n), plus background arithmetic",
+      "idea": "Two disjoint groups need room for both in n servers. Using sizes W and R in place of q and q gives W + R ≤ n for disjoint groups, so overlap needs W + R > n."
+    },
+    {
+      "step": "Check W = 4, R = 2: 4 + 2 = 6 > 5, so every read group overlaps every write group.",
+      "part": "Step 3",
+      "idea": "Apply the condition."
+    },
+    {
+      "step": "Writes need 4 replies out of 5, so they survive 5 − 4 = 1 failure. Reads need 2 replies, so they survive 5 − 2 = 3 failures.",
+      "part": "Steps 1 and 4",
+      "idea": "Tolerance is servers minus group size."
+    }
+  ],
+  "result": "W + R > 5 (in general W + R > n, so any read group shares a server with any write group). With W = 4 and R = 2 (4 + 2 = 6 > 5): writes survive 1 failure and reads survive 3. Caveat: the explanation only shows overlap for two equal-sized majority groups that make decisions. Applying it to separate read and write groups is my own extension of its counting argument. It also doesn't say whether two write groups need to overlap each other (2W > n). Here 2·4 = 8 > 5, so they do.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/none.json
new file mode 100644
index 0000000..11bef57
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Each body raises two bulges along its own line to Earth, with low water at 90° to that line.",
+      "part": "Section 2, 'Gravity weakens with distance, so the pull is uneven' (bullets and the rugby-ball diagram)",
+      "idea": "The leftover pull stretches the water along the Earth–body line and squeezes it at the two sides 90° away. So there are two highs on the line and lows across it."
+    },
+    {
+      "step": "For the Moon alone, the equilibrium tide is +0.36 m at the high points and −0.18 m at the lows, so the range is about 0.54 m.",
+      "part": "Section 4, the 'equilibrium tide' paragraph; index.html script, AM = 0.36 and height(a) = AM(1.5cos²a − 0.5)",
+      "idea": "The idealised ocean gives a high of 0.36 m above average and a low of 0.18 m below average."
+    },
+    {
+      "step": "The Sun's tide has the same shape but is about 46% as strong: amplitude 0.165 m, so +0.165 m high and −0.0825 m low.",
+      "part": "Section 6, 'The Sun does the same thing, more weakly'; index.html script, AS = 0.165 and the Sun term in height()",
+      "idea": "Tidal effect goes as mass/distance³, so the Sun gives about 46% of the Moon's effect, with its bulges lined up with the Sun."
+    },
+    {
+      "step": "Spring tide (Sun in line with the Moon): high = 0.36 + 0.165 = 0.525 m, low = −0.18 − 0.0825 = −0.2625 m, range ≈ 0.79 m.",
+      "part": "Section 6 (the bulges add at new and full moon); index.html control 4 'Add the Sun', days 0 or 14.8; steps 2–3",
+      "idea": "When the bulges line up, highs add to highs and lows add to lows."
+    },
+    {
+      "step": "Quarter moon (Sun at 90° to the Moon): under the Moon, 0.36 − 0.0825 = 0.2775 m; at 90°, −0.18 + 0.165 = −0.015 m; range ≈ 0.29 m.",
+      "part": "Section 6 (the Sun's bulges partly fill the Moon's lows); index.html control 4, days about 7.4 or 22; height() with the sun angle at ±90°; steps 2–3",
+      "idea": "The Sun's highs fall on the Moon's lows and the Sun's lows fall on the Moon's highs, so the two tides partly cancel."
+    },
+    {
+      "step": "Compare: 0.29 / 0.79 ≈ 0.37. Equivalently (1 − 0.46)/(1 + 0.46) ≈ 0.37.",
+      "part": "Steps 4 and 5",
+      "idea": "Spring range is the Moon's tide plus the Sun's; neap range is the Moon's tide minus the Sun's."
+    }
+  ],
+  "result": "At the quarter moons you get neap tides. The Sun's tide works against the Moon's, so the tidal range is about the Moon's alone minus the Sun's 46%. In the idealised whole-planet ocean that is about 0.29 m, against about 0.79 m at spring tides. So neap tides are a bit over a third the size of spring tides (about 37%), or roughly 2.7 times smaller. They still come twice a day, with the highs lined up with the Moon. Real coasts scale these numbers up or down, as section 7 explains.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/principles.json
new file mode 100644
index 0000000..95f0071
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Each body stretches the water along its own line to Earth. It makes bulges at the points facing toward and away from it, and squeezes the water at the two points 90° from that line.",
+      "part": "Step 2: compute the pull at three points (the squeeze/bulge diagram and the paragraph about the sides at 90°)",
+      "idea": "The difference in pull gives about +2GMR/d³ at the ends of the line and an inward squeeze of about GMR/d³ at the sides. Water flows from the sides to the ends, so there are high points at the ends and low points at the sides."
+    },
+    {
+      "step": "The tide height scales with the tidal acceleration, so the size of each body's effect can be measured by its bulge-to-squeeze range.",
+      "part": "Step 3: what the number means",
+      "idea": "A larger tidal acceleration gives taller bulges. The ideal-ocean result is a difference of about 0.5 m between bulge and squeeze for the Moon."
+    },
+    {
+      "step": "The Sun's tidal effect is about 0.46 of the Moon's, made by the same mechanism.",
+      "part": "The Sun does the same thing",
+      "idea": "Tides go as M/d³. For the Sun this comes to about 46% of the Moon's effect."
+    },
+    {
+      "step": "Spring tides: the Sun and Moon line up, so the bulges sit in the same places and the squeezes sit in the same places. Range ≈ 1 + 0.46 = 1.46 (in units of the Moon's tide).",
+      "part": "The Sun does the same thing (spring tides) plus steps 1–3",
+      "idea": "When the bulges line up, their effects add."
+    },
+    {
+      "step": "Quarter Moon: with the Sun at 90°, the Sun's bulges fall where the Moon squeezes the water, and the Sun's squeezes fall under the Moon's bulges. Range ≈ 1 − 0.46 = 0.54.",
+      "part": "Step 1 (the squeeze is at 90°) plus The Sun does the same thing ('at 90° they partly cancel: neap tides')",
+      "idea": "The Sun raises water where the Moon lowers it, and the reverse. The Moon's tide wins because it is larger, but it is reduced."
+    },
+    {
+      "step": "Compare the two: 0.54 / 1.46 ≈ 0.37.",
+      "part": "Steps 4 and 5",
+      "idea": "Divide the quarter-Moon range by the spring range."
+    }
+  ],
+  "result": "At the quarter Moons the tides are small 'neap tides'. The Sun's tide partly cancels the Moon's, so the range is about 1 − 0.46 = 0.54 of the Moon's tide alone. That is about 37% of the spring-tide range (1 + 0.46 = 1.46), so spring tides are roughly 2.7 times larger. In the ideal-ocean model, if the Moon alone gives about 0.5 m, neap tides are about 0.27 m and spring tides about 0.73 m. This is the idealized model only. Real coasts change these numbers a lot.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/published.json
new file mode 100644
index 0000000..d152e1b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/published.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "The Sun also raises tides. Its tidal acceleration is about 0.46 times the Moon's.",
+      "part": "Why subtract: two tests (second test, the Sun)",
+      "idea": "Tidal acceleration is about the pull times 2R/d. The Sun pulls 179 times harder than the Moon but is 389 times farther away, so its tidal effect is 179/389 ≈ 0.46 of the Moon's. Observed solar tides are about half the Moon's."
+    },
+    {
+      "step": "Each body's tide stretches the ocean along its own line to Earth and squeezes it across that line.",
+      "part": "Only the part that differs from the centre's pull acts (side-point paragraph) and the ASCII diagram",
+      "idea": "Along the line the tidal acceleration points outward (+1.13 and −1.07, both away from the centre), raising two bulges. At the side points, 90° away, it points inward (0.55 µm/s²), giving low water."
+    },
+    {
+      "step": "At first and third quarter, the Sun's line is 90° from the Moon's line, so the Sun squeezes where the Moon stretches.",
+      "part": "Step 2 plus the question's statement that the Sun and Moon are at right angles; adding accelerations is background",
+      "idea": "The Sun's low-water points fall under the Moon's bulges, and the Sun's bulges fall where the Moon gives low water. So the solar tide works against the lunar tide. Roughly, the tide would be about (1 − 0.46) of the Moon's alone."
+    },
+    {
+      "step": "Compare this with spring tides.",
+      "part": "none: the explanation never mentions spring tides",
+      "idea": "The explanation never defines 'spring tides'. It never says they happen when the Sun and Moon line up, so the two tides add to about 1 + 0.46. It also never discusses how the solar and lunar tides combine. Without that, I can't name the reference the question asks me to compare against. If spring tides do mean the aligned case, the ratio would be about 0.54/1.46 ≈ 0.37, but that meaning comes from outside the explanation."
+    }
+  ],
+  "result": "I can't complete the comparison from the explanation alone. It does show that at quarter Moon the Sun's tide (about 0.46 of the Moon's) squeezes where the Moon's tide stretches, so the two partly cancel. That gives a tide of roughly 0.54 of the Moon's tide alone, smaller than usual.",
+  "gap": "The explanation never defines 'spring tides': it doesn't say they come when the Sun and Moon are lined up and their tides add. It also never says how the solar and lunar tides combine, so the comparison to spring tides can't be finished from the text."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/quick.json
new file mode 100644
index 0000000..ae3faf4
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/two-tides/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Water is moved only by the tidal acceleration, which is the pull at a point minus the pull at Earth's centre. This raises two bulges on the line to the attracting body: one facing it and one facing away.",
+      "part": "Only the difference in pull moves water (claim mech-bulges and the bulge diagram)",
+      "idea": "The near water is pulled more than Earth's centre and the far water less, so the bulges sit along the Earth–body line. Water is lower on the sides, 90° from that line."
+    },
+    {
+      "step": "The Sun raises its own pair of bulges in the same way, with a height 0.46 times that of the Moon's.",
+      "part": "Evidence that the difference is what counts: the Sun",
+      "idea": "Tidal effects fall off as 1/d³, so solar tides are 0.46 of lunar tides even though the Sun's raw pull is 179 times the Moon's."
+    },
+    {
+      "step": "The two pairs of bulges add or partly cancel. Spring tides happen when they add.",
+      "part": "Limits ('Not covered: spring and neap tides…')",
+      "idea": "The Sun's smaller pair of bulges either adds to the Moon's or partly cancels it. Adding gives spring tides, and partly cancelling gives neap tides."
+    },
+    {
+      "step": "Spring tides happen when the Sun, Earth and Moon are in a line. Their size is 1 + 0.46 = 1.46 lunar tides.",
+      "part": "Steps 1 and 3",
+      "idea": "When the bodies line up, both pairs of bulges point the same way, so their heights add."
+    },
+    {
+      "step": "When the Sun and Moon are at right angles, the Sun's bulges fall where the Moon's low water is. The two effects partly cancel, giving 1 − 0.46 = 0.54 lunar tides. This is the neap tide.",
+      "part": "Steps 1, 2 and 3",
+      "idea": "The pairs of bulges are 90° apart, so the Sun's high water fills the Moon's low water. This reduces the range, which is the 'partly cancels' case. I inferred the link between the quarter Moon and neap tides from the bulge geometry. The explanation does not state it."
+    },
+    {
+      "step": "Compare with spring tides: 0.54 / 1.46 ≈ 0.37.",
+      "part": "Steps 4 and 5",
+      "idea": "This is the ratio of the neap range to the spring range."
+    }
+  ],
+  "result": "At first and third quarter the tides are neap tides. They are about 0.54 of the Moon-only tide, compared with 1.46 at spring tides. So they are roughly 0.37 of spring tides, a bit over a third. This assumes the bulge heights simply add or subtract.",
+  "gap": "The explanation lists spring and neap tides as 'not covered'. It never says that the quarter Moon gives neap tides, or that at right angles the Sun's bulge heights simply subtract from the Moon's. I inferred both from the bulge geometry and the phrase 'adds to or partly cancels'."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/none.json
new file mode 100644
index 0000000..d8a1245
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated division, so their number doubles at a steady rate.",
+      "part": "Step 3: Amplify and refine — Amplify: clonal expansion",
+      "idea": "A selected cell divides about every 6 to 12 hours for days, so one cell becomes thousands of identical copies. The question fixes the doubling time at 12 hours."
+    },
+    {
+      "step": "After vaccination, the starting number of matching cells is much larger than before any exposure.",
+      "part": "Step 4: Keep copies — memory (table of naive vs memory cells)",
+      "idea": "Memory leaves hundreds to thousands of times more cells that fit the antigen than the handful of naive cells. The question uses a factor of 1,000."
+    },
+    {
+      "step": "Both responses climb the same doubling curve. The only difference is where they start, so the vaccinated response skips the doublings needed to go from N0 to 1000·N0.",
+      "part": "background (exponential growth), using steps 1–2",
+      "idea": "The cell count is N0·2^(t/12). To reach a threshold T you need t = 12·log2(T/N0) hours. Starting at 1000·N0 gives t' = 12·log2(T/(1000·N0)) = t − 12·log2(1000)."
+    },
+    {
+      "step": "Work out how many doublings are saved.",
+      "part": "background (arithmetic), step 3",
+      "idea": "log2(1000) ≈ 9.97, so about 10 doublings, because 2^10 = 1024."
+    },
+    {
+      "step": "Turn the saved doublings into time.",
+      "part": "step 4, step 1",
+      "idea": "10 doublings × 12 hours = about 120 hours, or about 5 days."
+    },
+    {
+      "step": "The time saved does not depend on the threshold T.",
+      "part": "step 3 (background: logarithms)",
+      "idea": "When you subtract t' from t, the log2(T) terms cancel and only 12·log2(1000) is left. With constant doubling, being ahead by a factor of 1,000 always means being the same 10 doublings ahead, wherever the finish line is."
+    },
+    {
+      "step": "Check that this fits the observed timing.",
+      "part": "Step 4 (primary vs secondary response paragraph and diagram); So what does a vaccine do?",
+      "idea": "The primary response takes about 1–2 weeks, and the secondary response starts within days. Saving about 5 days fits that gap. The explanation also says memory cells respond to less stimulus, which could shorten the delay further, but this simple model ignores that."
+    }
+  ],
+  "result": "About 5 days sooner. A factor of 1,000 is about 2^10, so the vaccinated response skips about 10 doublings, and 10 × 12 h ≈ 120 h. The saving doesn't depend on how many cells count as 'enough' because growth is exponential. The time to reach any threshold T is 12·log2(T/N0) hours. Raising the start by 1,000× takes off the same 12·log2(1000) ≈ 120 h whatever T is, since the T term cancels.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/principles.json
new file mode 100644
index 0000000..5f1e923
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/principles.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated doubling, so the number of doublings needed is log2(target count ÷ starting count).",
+      "part": "Step 3: the selected cells multiply, then most die (worked example: 100 × 2^15, and log2(20) ≈ 4.3 doublings to get from 164,000 to 3.3 million)",
+      "idea": "Clonal expansion is exponential doubling. The time to reach a target is the number of doublings, found with log base 2 of the ratio, multiplied by the time per doubling."
+    },
+    {
+      "step": "A first infection needs log2(N/S) doublings to reach a target of N cells from S starting cells. After vaccination the pool starts at 1000S, so it needs log2(N/(1000S)) = log2(N/S) − log2(1000) doublings.",
+      "part": "Step 1 + 1 + Summary of the chain (memory pool ~1000× naive pool)",
+      "idea": "Vaccination leaves a memory pool about 1000 times the naive pool, so the vaccinated response starts 1000 times higher on the same doubling curve."
+    },
+    {
+      "step": "The difference is log2(1000) ≈ 9.97, so about 10 doublings are saved. The target N cancels when one count is subtracted from the other.",
+      "part": "Step 2 + background (logarithms)",
+      "idea": "log(a/b) = log a − log b. The term with N appears in both counts and cancels, so the head start depends only on the ratio of the starting pools."
+    },
+    {
+      "step": "10 doublings × 12 hours ≈ 120 hours ≈ 5 days sooner.",
+      "part": "Step 3 + background (arithmetic)",
+      "idea": "Multiply the doublings saved by the doubling time given in the question (12 h; the explanation itself uses about 8 h)."
+    }
+  ],
+  "result": "The response reaches full strength about 5 days sooner, because log2(1000) ≈ 10 doublings × 12 h ≈ 120 h. The answer doesn't depend on how many cells count as 'enough'. With exponential growth, the time to any target is log2(target ÷ start) × doubling time. Both responses grow toward the same target, so when you subtract one time from the other the target cancels. Only the 1000-fold head start is left. A 1000-fold head start is always about 10 doublings behind the finish line, wherever that line is. The explanation adds that in reality the gap is even larger, because memory cells activate more easily and some antibody is already present on day 0.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/published.json
new file mode 100644
index 0000000..43e77e8
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/published.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Model growth as starting count × 2^n = target, where n is the number of doublings needed to reach the target.",
+      "part": "The first meeting is slow (paragraph: 100 × 2^n = 1,000,000)",
+      "idea": "The response grows by repeated doubling from the precursor count until it reaches the number of cells that controls the infection. You find n by solving start × 2^n = target."
+    },
+    {
+      "step": "Each doubling of the starting count saves exactly one division.",
+      "part": "What stays behind (the rule under the table)",
+      "idea": "If you start with twice as many cells, you need one fewer doubling to reach the same target. The 100× memory head start cut 13.3 divisions to 6.6."
+    },
+    {
+      "step": "A 1,000× head start saves log2(1000) ≈ 10 doublings.",
+      "part": "Step 2 + background (logarithms)",
+      "idea": "1000 is about 2^10 (1024), so 1,000× more cells is about 10 doublings' worth of head start."
+    },
+    {
+      "step": "At 12 hours per doubling, the response reaches full strength about 10 × 12 h ≈ 120 h ≈ 5 days sooner.",
+      "part": "Step 3 + the question's 12-hour doubling time",
+      "idea": "Multiply the doublings saved by the time each doubling takes."
+    },
+    {
+      "step": "The target cancels out. n = log2(target/start), so the difference between the two cases is log2(target/P) − log2(target/1000P) = log2(1000), whatever the target is.",
+      "part": "Steps 1–2 + background (algebra of logarithms)",
+      "idea": "Both cases aim for the same target, and the explanation uses one target for both. So only the ratio of the starting counts matters. The doublings saved are the same whether 'enough' is 1 million cells or 1 billion."
+    }
+  ],
+  "result": "About 10 doublings fewer (2^10 ≈ 1000), so about 120 hours, or roughly 5 days sooner, counting doubling time only. In the explanation, memory cells also activate faster, which would save a little more. The answer does not depend on what counts as 'enough' because the number of doublings needed is log2(target ÷ start). Both cases have the same target, so when you subtract one from the other the target cancels. The saving is log2(1000) doublings whatever the target is: each doubling of the head start removes one division.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/quick.json
new file mode 100644
index 0000000..630c5f8
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-2/read/vaccine-memory/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells build up by dividing, so the response grows by multiplication, starting from the cells that match.",
+      "part": "How it works, item 3 (Clonal expansion)",
+      "idea": "A lymphocyte that binds the antigen and gets an alarm signal divides over and over, making a clone of thousands of identical cells."
+    },
+    {
+      "step": "Vaccination means the response starts from a larger population of matching cells, so it reaches useful strength sooner.",
+      "part": "How it works, item 4 (Memory cells remain), and the table in 'Why it works: a race'",
+      "idea": "Memory cells leave more matching cells than before (the explanation says 10–100 times; the question uses 1,000 times), and with this head start useful antibody arrives in 2–4 days instead of 7–14."
+    },
+    {
+      "step": "Write the model: with N0 starting cells doubling every 12 h, the time to reach a threshold N is t = 12 h × log2(N/N0).",
+      "part": "background",
+      "idea": "Exponential growth and logarithms from school maths, using the 12-hour doubling time given in the question."
+    },
+    {
+      "step": "Subtract the two times: t_first − t_vaccinated = 12 h × [log2(N/N0) − log2(N/(1000·N0))] = 12 h × log2(1000). The threshold N cancels out.",
+      "part": "step 3",
+      "idea": "The threshold is the same in both cases, so it drops out of the difference. Only the ratio of starting sizes matters."
+    },
+    {
+      "step": "log2(1000) ≈ 9.97, about 10 doublings, and 10 × 12 h = 120 h ≈ 5 days.",
+      "part": "step 4",
+      "idea": "2^10 = 1024 ≈ 1000."
+    }
+  ],
+  "result": "About 5 days sooner. A 1,000-fold head start is worth about 10 doublings (2^10 ≈ 1000), and 10 × 12 hours = 120 hours. The answer does not depend on how many cells count as 'enough' because in exponential growth, the time to reach any level is the doubling time × log2(target/start). Both responses aim at the same target, so the target cancels when you subtract the two times. The vaccinated population simply passes every level 10 doublings earlier. The explanation itself gives typical figures of about 10–100 times more memory cells and useful antibody after 2–4 days instead of 7–14. The 1,000-fold figure and 12-hour doubling time come from the question.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/antibiotic-resistance.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/antibiotic-resistance.json
new file mode 100644
index 0000000..a617b33
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/antibiotic-resistance.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "none",
+    "C": "quick",
+    "D": "published"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/bloom-filter.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/bloom-filter.json
new file mode 100644
index 0000000..2599bc7
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/bloom-filter.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "none",
+    "B": "published",
+    "C": "quick",
+    "D": "principles"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/float-sum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/float-sum.json
new file mode 100644
index 0000000..2c89e06
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/float-sum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "quick",
+    "C": "published",
+    "D": "none"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/gps-relativity.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/gps-relativity.json
new file mode 100644
index 0000000..e56eaed
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/gps-relativity.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "none",
+    "C": "quick",
+    "D": "principles"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/greenhouse.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/greenhouse.json
new file mode 100644
index 0000000..c8e1c65
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/greenhouse.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "principles",
+    "C": "none",
+    "D": "quick"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "stated"
+      ],
+      "result_right": true,
+      "result_stated": true
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/heat-pump.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/heat-pump.json
new file mode 100644
index 0000000..856214a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/heat-pump.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "quick",
+    "B": "none",
+    "C": "principles",
+    "D": "published"
+  },
+  "grades": {
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/key-exchange.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/key-exchange.json
new file mode 100644
index 0000000..4db491a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/key-exchange.json
@@ -0,0 +1,54 @@
+{
+  "key": {
+    "A": "principles",
+    "B": "published",
+    "C": "quick",
+    "D": "none"
+  },
+  "grades": {
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/quorum.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/quorum.json
new file mode 100644
index 0000000..adb928c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/quorum.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "published",
+    "B": "none",
+    "C": "quick",
+    "D": "principles"
+  },
+  "grades": {
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/two-tides.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/two-tides.json
new file mode 100644
index 0000000..913a32b
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/two-tides.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "quick",
+    "B": "none",
+    "C": "principles",
+    "D": "published"
+  },
+  "grades": {
+    "quick": {
+      "marks": [
+        "supported",
+        "missing",
+        "missing",
+        "missing"
+      ],
+      "result_right": false,
+      "result_stated": false
+    },
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "stated",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "unsupported",
+        "supported",
+        "unsupported"
+      ],
+      "result_right": false,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/vaccine-memory.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/vaccine-memory.json
new file mode 100644
index 0000000..a52bfb5
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/grades/vaccine-memory.json
@@ -0,0 +1,50 @@
+{
+  "key": {
+    "A": "none",
+    "B": "principles",
+    "C": "published",
+    "D": "quick"
+  },
+  "grades": {
+    "none": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "principles": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "published": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    },
+    "quick": {
+      "marks": [
+        "supported",
+        "supported",
+        "supported",
+        "supported"
+      ],
+      "result_right": true,
+      "result_stated": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/none.json
new file mode 100644
index 0000000..360f548
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Before any drug is given, resistant mutants are already in the population because of random mutation. The drug doesn't create them; it picks them out.",
+      "part": "Section 3a (Mutation) and 'The short answer'",
+      "idea": "A particular resistance mutation turns up about once in 10^8–10^9 divisions. Infections hold 10^9–10^11 cells, so a few resistant cells are probably there before treatment starts."
+    },
+    {
+      "step": "With drug A alone, about 10^10/10^8 = 100 cells are already resistant. With drug B alone, about 10^10/10^9 = 10 are.",
+      "part": "Section 3a, 'Quick estimate' box",
+      "idea": "Expected number of resistant cells = population size × the fraction that carry the mutation."
+    },
+    {
+      "step": "A single drug kills the susceptible cells, and those 100 (or 10) resistant cells grow until they make up most of the infection.",
+      "part": "Section 4, 'A toy calculation'",
+      "idea": "Exponential growth turns 100 survivors into about 10^8 within roughly 10 hours, however rare they were to begin with."
+    },
+    {
+      "step": "With both drugs, a cell survives only if it resists both, so it needs both mutations. The mutations are unrelated, so the chance of having both is the product of the two chances: 10^-8 × 10^-9 = 10^-17.",
+      "part": "Section 8, 'Combine drugs, sometimes'",
+      "idea": "Being resistant to both by chance is the product of the separate odds. The example there, 1 in 10^8 × 1 in 10^8 = 1 in 10^16, is more cells than an infection holds. Multiplying independent chances is background maths."
+    },
+    {
+      "step": "Expected number of cells resistant to both = 10^10 × 10^-17 = 10^-7. Most likely there are none.",
+      "part": "Steps 2 and 4; index.html 'What to try', point on lowering the mutation rate",
+      "idea": "Resistance is a numbers game: population size × mutation rate. When that product is far below 1, usually no resistant cell exists when the drug arrives, and treatment succeeds."
+    },
+    {
+      "step": "With no cell resistant to both, there is nothing for selection to pick out. Each drug kills the cells that resist only the other one, and the infection can be cleared.",
+      "part": "'The short answer' (the drug selects; survivors multiply); Section 4",
+      "idea": "Selection can only multiply variants that already exist. If the starting number is zero, exponential growth has nothing to work with."
+    }
+  ],
+  "result": "Alone, drug A starts out facing about 100 resistant cells (10^10/10^8) and drug B about 10 (10^10/10^9). Those cells survive and multiply until they take over. To survive both drugs together, a cell needs both unrelated mutations, which happens with odds of about 10^-8 × 10^-9 = 10^-17. In 10^10 cells that means an expected 10^-7 doubly resistant cells, about 1 chance in 10 million that even one exists. Each drug kills the cells that resist only the other, so selection has nothing to multiply. The odds of ending with a resistant infection drop from near certain to tiny.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/principles.json
new file mode 100644
index 0000000..629ebf2
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/principles.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "About 10^10 cell divisions happen as the infection grows to 10^10 cells, so the expected number of mutants is 10^10 times the mutation rate.",
+      "part": "Section 3, Mutation: worked example",
+      "idea": "Growing from one cell to 10^10 cells takes about 10^10 divisions. Each division has a small chance of producing a given resistance mutation."
+    },
+    {
+      "step": "Before treatment, about 10^10 × 10^-8 = 100 cells resist A, and about 10^10 × 10^-9 = 10 cells resist B.",
+      "part": "Section 3, Mutation: worked example; step 1",
+      "idea": "Expected mutants equal divisions times rate. In a large population, resistant cells are usually already there before the first dose. The drug does not create them."
+    },
+    {
+      "step": "If only one drug is given, those few resistant cells survive and regrow the infection.",
+      "part": "Section 4, How the drug makes resistance common",
+      "idea": "The drug kills the susceptible cells. The roughly 100 resistant cells double about every hour and reach about 1.7 × 10^9 in a day. This is selection: the drug removes their competition."
+    },
+    {
+      "step": "With both drugs, a cell survives only if it resists both, so it needs both mutations. The mutations are unrelated, so the chance that one cell carries both is the product of the two rates: 10^-8 × 10^-9 = 10^-17.",
+      "part": "Section 4, Dose controls which cells survive: last two sentences",
+      "idea": "Two drugs at once mean a cell needs two independent mutations. The text multiplies the two rates (its example is 10^-8 × 10^-8 = 10^-16), and the result is far rarer than the size of the infection."
+    },
+    {
+      "step": "Expected double-resistant cells: 10^10 × 10^-17 = 10^-7. That is about a 1-in-10-million chance that even one such cell exists.",
+      "part": "Steps 1 and 4; background (arithmetic)",
+      "idea": "Expected count equals divisions times probability per division. Here the count is far below one."
+    },
+    {
+      "step": "Each drug kills the cells that resist only the other drug. So the 100 A-resistant cells and the 10 B-resistant cells all die, and there is almost certainly no cell left to be selected.",
+      "part": "Section 4 (selection); step 4",
+      "idea": "Selection can only make a resistant group common if at least one resistant cell exists to start it."
+    },
+    {
+      "step": "Caveat: this argument holds only for independent mutations. A plasmid passed from another bacterium can carry genes for several mechanisms, so one transfer can give resistance to both drugs at once.",
+      "part": "Section 3, Gene transfer",
+      "idea": "One transfer event can make a cell resistant to several drugs, which gets around the multiplication."
+    }
+  ],
+  "result": "Given alone, each drug leaves cells that were already resistant before treatment: about 100 for drug A (10^10 × 10^-8) and about 10 for drug B (10^10 × 10^-9). Selection then lets those survivors take over the infection. Given together, a cell survives only if it carries both unrelated mutations. The chance of that per division is 10^-8 × 10^-9 = 10^-17, so you expect 10^10 × 10^-17 = 10^-7 such cells: about a 1-in-10-million chance that even one exists. Each drug kills the cells that resist only the other drug, so almost certainly nothing is left to regrow. The one exception is gene transfer: a plasmid carrying both resistance genes would get around this.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/published.json
new file mode 100644
index 0000000..51ae713
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Drug A alone: you'd expect about 10^10 × 10^-8 = 100 cells already resistant to A before treatment starts.",
+      "part": "Resistant cells are there before the drug",
+      "idea": "Growing to 10^10 cells takes about 10^10 divisions. With one mutation per 10^8 divisions, that gives about 100 resistant mutants before any drug is given."
+    },
+    {
+      "step": "Drug B alone: you'd expect about 10^10 × 10^-9 = 10 cells already resistant to B.",
+      "part": "Resistant cells are there before the drug",
+      "idea": "The same counting (number of divisions times mutation rate) works with B's rate of 10^-9. So at least one B-resistant cell is almost certainly there."
+    },
+    {
+      "step": "With either drug alone, those few resistant cells survive and grow back into a resistant infection.",
+      "part": "The drug selects them",
+      "idea": "The drug removes the susceptible cells, and the resistant ones keep doubling until they fill the infection again (100 cells take 27 doublings, about 13 hours). The drug selects resistance; it does not create it."
+    },
+    {
+      "step": "To survive both drugs given together, one cell must carry both mutations. The chance of that is 10^-8 × 10^-9 = 10^-17 per cell.",
+      "part": "What this predicts (combination bullet)",
+      "idea": "With independent targets, two mutations are needed in the same cell. Independent events multiply their chances. The explanation's example uses 10^-8 × 10^-8; here I put in the question's 10^-9 for B."
+    },
+    {
+      "step": "Expected number of double-resistant cells: 10^10 × 10^-17 = 10^-7. That is about a 1-in-10-million chance that even one exists.",
+      "part": "What this predicts (combination bullet); step 4",
+      "idea": "Multiply the population by the per-cell chance. A cell resistant to only A is killed by B, and one resistant to only B is killed by A, so the treatment clears the infection."
+    },
+    {
+      "step": "This holds only because the two mutations are unrelated. If a single event gave resistance to both drugs, the protection would be lost.",
+      "part": "What this predicts (combination bullet)",
+      "idea": "If one plasmid carried both genes, or one pump exported both drugs, the chances would not multiply and about as many survivors as with one drug would come back."
+    }
+  ],
+  "result": "With one drug, cells resistant to it are almost certainly already present before treatment: about 100 for drug A and about 10 for drug B. The drug kills the susceptible cells, and those few resistant ones regrow the infection. With both drugs, a surviving cell needs both unrelated mutations. Their chances multiply to 10^-8 × 10^-9 = 10^-17 per cell, so in 10^10 cells you'd expect only 10^-7 double-resistant cells, about a 1-in-10-million chance that even one exists. Any cell resistant to just one drug is killed by the other, so the infection is cleared. This works only while no single gene, plasmid or pump gives resistance to both drugs.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/quick.json
new file mode 100644
index 0000000..ebe27ac
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/antibiotic-resistance/quick.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Before any drug, the infection already contains a few cells resistant to A or to B by random mutation. These cells were not created by the drug.",
+      "part": "Step 1: random variation makes a few resistant cells (Mutation item); Why selection, and not adaptation",
+      "idea": "Resistance comes from rare random copying errors that happen before the drug arrives. The drug only selects the cells that already resist it."
+    },
+    {
+      "step": "Drug A alone: expected A-resistant cells = 10^10 × 10^-8 = 100. Drug B alone: 10^10 × 10^-9 = 10. Both are well above 1, so resistant cells almost certainly exist.",
+      "part": "Step 2: the antibiotic selects the resistant cells (worked numbers)",
+      "idea": "Expected number of resistant cells = population size × chance per cell."
+    },
+    {
+      "step": "With one drug, those survivors divide and rebuild a resistant infection.",
+      "part": "Step 2 worked numbers and the paragraph defining selection",
+      "idea": "The drug kills susceptible cells. The roughly 10 resistant cells double about 30 times, which brings them back to about 10^10, and the new population is almost all resistant."
+    },
+    {
+      "step": "To survive both drugs, one cell must carry both unrelated mutations. Because the two are independent, the chance per cell is 10^-8 × 10^-9 = 10^-17.",
+      "part": "What follows from this: 'Two drugs at once help'",
+      "idea": "Two independent rare events must both happen in the same cell, so their chances multiply. The explanation's example uses 10^-9 × 10^-9 = 10^-18."
+    },
+    {
+      "step": "Expected double-resistant cells = 10^10 × 10^-17 = 10^-7, so almost certainly none exist.",
+      "part": "Step 2 'Predict before you read on' paragraph; 'Two drugs at once help'",
+      "idea": "When the expected number is far below 1, usually no resistant cell exists, so the drugs clear the infection."
+    },
+    {
+      "step": "Cells resistant to only one drug are killed by the other drug, so selection has nothing to work on.",
+      "part": "Steps 3 and 5; What an antibiotic does (definition of resistant)",
+      "idea": "Surviving means resisting every drug that is present. A cell resistant only to A is still susceptible to B."
+    },
+    {
+      "step": "Limitation: this fails if a single plasmid carries both resistance genes.",
+      "part": "'Two drugs at once help' (last sentence); Step 1 Gene transfer",
+      "idea": "One gene transfer can give resistance to several drugs at once, so the two events are no longer independent. The question rules this out by saying the mutations are unrelated."
+    }
+  ],
+  "result": "Each drug alone leaves resistant survivors: about 100 cells resist A and about 10 resist B. These cells already existed before treatment, and once the drug kills the rest they regrow into a resistant infection. With both drugs, a cell survives only if it resists both. The two mutations are independent, so their chances multiply: 10^-8 × 10^-9 = 10^-17 per cell. Across 10^10 cells that gives about 10^-7 expected cells, which in practice means none. Cells resistant to just one drug are killed by the other, so a resistant infection is roughly a million to a billion times less likely. This holds unless one plasmid carries both resistance genes.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/none.json
new file mode 100644
index 0000000..f8e4f03
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Each bit of a filter is a record of whether any added item hashed to that position. Bit i is 1 exactly when at least one added item has i among its k positions. Adding only ever sets bits to 1, and setting a bit that is already 1 changes nothing.",
+      "part": "Section 2, 'The machinery: bits and hash functions' (the Add/Check box and the line 'The filter never stores the item itself')",
+      "idea": "Adding an item sets its k positions to 1. A bit that is already 1 stays 1, and bits never go back to 0. So the array depends only on which items were added, not on their order or on repeats."
+    },
+    {
+      "step": "Because the two filters have the same m and the same hash functions, any given item maps to the same k positions in both. So bit i means the same thing in both filters, and they can be combined bit by bit.",
+      "part": "Section 2 (hash functions give the same number for the same input, taken modulo m) and the k selector in the section 3 demo",
+      "idea": "An item's positions depend only on the item, the hash functions and m. The demo's script points the other way too: changing k changes every word's positions and forces a rebuild, so filters built with different settings could not be combined."
+    },
+    {
+      "step": "A bitwise OR of the two arrays gives the filter for A ∪ B. Bit i of the OR is 1 exactly when some item of A or some item of B hits i. That is the same as some item of A ∪ B hitting i, which is the rule for a filter built directly from A ∪ B.",
+      "part": "Steps 1 and 2",
+      "idea": "Building from A ∪ B means adding every item of A and every item of B to an empty array. Since the result does not depend on order, it is just the union of the bit sets that A and B switch on."
+    },
+    {
+      "step": "The OR is exact. It is bit-for-bit the same as a filter built from A ∪ B, so it has no false negatives and the same false positive rate as building directly. That rate is about (1 − e^(−kn/m))^k, where n = |A ∪ B|. An item in both sets counts only once.",
+      "part": "Step 3; Section 5, Steps 1–2 (the false positive formula); Section 4 (no false negatives)",
+      "idea": "Two identical arrays answer every check identically, so all the properties of a directly built filter carry over. The OR also fills the array more than either filter alone, so the combined filter needs to be sized for |A ∪ B| (Section 6, on overfilling)."
+    },
+    {
+      "step": "A bitwise AND sets bit i to 1 exactly when some item of A hits i and some item of B hits i. Those may be two different items.",
+      "part": "Step 1",
+      "idea": "Apply the 'bit is 1 if and only if some added item hits it' rule to each filter, then require both."
+    },
+    {
+      "step": "Every bit that a filter built from A ∩ B would set is also set in the AND. An item in both sets switches on its own bits in both filters. So the AND never gives a false negative for A ∩ B.",
+      "part": "Step 5 and Section 4 (no false negatives)",
+      "idea": "An item in A ∩ B was added to both filters, so all its k positions are 1 in both, and therefore 1 in the AND."
+    },
+    {
+      "step": "The AND is not exact. It can have extra 1s where an item that is only in A and a different item that is only in B share a position. A filter built directly from A ∩ B would leave those bits at 0.",
+      "part": "Section 3, 'Things to notice' (different words sometimes share positions), and the 'Hunt for a false positive' explanation of which words set which bits",
+      "idea": "Different items share positions. So 'some item of A hits i and some item of B hits i' does not mean 'some single item in both sets hits i'. The AND therefore has at least as many 1s as the true A ∩ B filter, which can only raise the false positive rate (about f^k, Section 5)."
+    }
+  ],
+  "result": "Take the bitwise OR of the two bit arrays. Bit i of the OR is 1 exactly when some item of A or of B set it, which is the rule for a filter built directly from A ∪ B. So the OR is identical to that filter. It is exact, with the same answers and the same false positive rate as building from A ∪ B (sized for |A ∪ B| items). A bitwise AND gives a filter that answers 'probably yes' for every item in A ∩ B, so it has no false negatives. But it is not exact. It can keep 1s that were set by an item only in A and a different item only in B landing on the same position. So it is a superset of the true A ∩ B filter, and its false positive rate is at least as high and usually higher.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/principles.json
new file mode 100644
index 0000000..eda5937
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A filter's state is just the set of bit positions that are 1. Building it means setting to 1 every position that any added item hashes to. The items themselves are not stored.",
+      "part": "The parts (Add(x)); the short answer",
+      "idea": "Add computes k positions for x and sets them to 1. Nothing else changes the bits, and the filter keeps no items."
+    },
+    {
+      "step": "Bits never go back to 0, and the order of adds makes no difference. So the filter built from a set S has bit i = 1 exactly when at least one item of S hashes to i.",
+      "part": "Why it never misses an item it saw",
+      "idea": "Add only changes bits from 0 to 1, and nothing clears a bit. The final array is the union of all the items' positions."
+    },
+    {
+      "step": "The filters for A and B use the same m and the same hash functions, so each item maps to the same positions in both. Bit i of the filter for A∪B is 1 exactly when some item of A or some item of B hashes to i. That means bit i is 1 in filter A or in filter B.",
+      "part": "Steps 1–2; The parts (hash function: same item always gives same number)",
+      "idea": "Same hashes give the same positions, so the positions for A∪B are the positions for A together with the positions for B."
+    },
+    {
+      "step": "Union: take the bitwise OR of the two arrays. The result is bit-for-bit identical to the filter you would get by adding every item of A∪B to an empty filter. So the union is exact: it is a true filter for A∪B, with no false negatives, and its error rate follows the usual formula with n = |A∪B|.",
+      "part": "Step 3; background (bitwise OR); How often it is wrong",
+      "idea": "OR sets a bit when either input has it set, which is the rule from step 3. The false-positive rate depends only on how full the array is, and here it is exactly as full as a directly built filter."
+    },
+    {
+      "step": "AND keeps a bit only if it is 1 in both filters. Every item in A∩B set its k bits in both filters, so all of its bits survive. A query for any item of A∩B therefore answers 'probably seen': there are no false negatives for the intersection.",
+      "part": "Why it never misses an item it saw; background (bitwise AND)",
+      "idea": "The bits of an added item stay 1. An item in both sets has its bits at 1 in both arrays."
+    },
+    {
+      "step": "A bit can be 1 in both filters for different reasons: one item in A only and another item in B only may both hash to it. AND keeps that bit, even though a filter built directly from A∩B would have it at 0. So the AND has every bit of the true A∩B filter and possibly extra 1s. It is not exact: it gives more false positives than a filter built directly from A∩B.",
+      "part": "A worked example (cat and dog share bit 6; 'owl' false positive); Step 2",
+      "idea": "Different items can share bits, and the filter does not record which item set a bit. So AND cannot tell a shared item apart from two different items that happen to hit the same position."
+    }
+  ],
+  "result": "For the union, take the bitwise OR of the two bit arrays. Because the size and hash functions are the same, the OR is exactly the filter you would get by adding every item of A∪B directly. It is exact: no false negatives, and the same false-positive rate as a filter built normally with n = |A∪B|. A bitwise AND gives an approximate filter for A∩B. Every item in both sets still answers 'probably seen', so there are no false negatives. But a bit can be 1 in both filters because of different items, one in A and one in B. So the AND can have extra 1s compared with a filter built directly from A∩B, and its false-positive rate can be higher. The explanation gives no formula for how much higher.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/published.json
new file mode 100644
index 0000000..afa6a35
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "The filter built from a set is just the bits switched on by its items. Adding an item only sets its k positions to 1, and nothing else is kept. So bit i is 1 exactly when at least one added item has a hash position at i.",
+      "part": "How it works: add and query",
+      "idea": "Adding sets an item's k positions (hash mod m) to 1 and stores nothing else. The table shows each 1 bit was set by some item."
+    },
+    {
+      "step": "The order in which items are added does not matter. Setting a bit that is already 1 changes nothing, and no bit ever goes back to 0.",
+      "part": "Why it is never wrong the other way",
+      "idea": "Nothing ever sets a bit back to 0, so a bit stays 1 once any item has turned it on."
+    },
+    {
+      "step": "Both filters have the same m and the same hash functions, so an item gets the same positions in either filter. A ∪ B's filter would have bit i = 1 exactly when some item of A or some item of B hits position i. That is the same as (bit i of A's filter) OR (bit i of B's filter).",
+      "part": "Steps 1–2, plus the setup in 'How it works' (same k hashes, same m)",
+      "idea": "Positions come only from the hash functions and m, so the bits line up position by position between the two filters."
+    },
+    {
+      "step": "So the bitwise OR of the two filters is bit-for-bit the filter you would get by adding every item of A ∪ B. That makes it exact: it has the same answers and the same no-false-negative guarantee as building the union filter directly. Its false-positive rate is the normal one for n = |A ∪ B|, which could be high if that exceeds the capacity.",
+      "part": "Step 3; 'How often it is wrong'; 'Overfilling'",
+      "idea": "The rate depends on the fill, which comes from the number of items, so a large union fills the array more."
+    },
+    {
+      "step": "AND keeps a bit only when it is 1 in both filters. Every item in A ∩ B set its bits in both filters, so all its bits survive. The AND filter therefore never says 'definitely not seen' for an item in A ∩ B: there are no false negatives for the intersection.",
+      "part": "Step 1; 'Why it is never wrong the other way'",
+      "idea": "An added item's bits are all 1 in every filter it was added to."
+    },
+    {
+      "step": "But AND is not the filter of A ∩ B. A bit can be 1 in A's filter because of one item that is only in A, and 1 in B's filter because of a different item that is only in B. Then it is 1 in the AND even though no shared item set it. For example, if cat is in A only and owl is in B only, bits 6 and 11 survive the AND even though the intersection is empty.",
+      "part": "How it can be wrong: false positives (owl and cat share bits 6 and 11)",
+      "idea": "Bits do not record which item set them, and different items share bits."
+    },
+    {
+      "step": "So the AND has every bit of the true A ∩ B filter, possibly with extra 1 bits. Using the AND gives an approximate filter for A ∩ B with no false negatives but a false-positive rate at least as high as, and usually higher than, building it from A ∩ B directly.",
+      "part": "Steps 5–6; 'How often it is wrong' (more 1s means higher fill f, so a higher p ≈ f^k)",
+      "idea": "Extra 1 bits raise the fill, and a higher fill raises the false-positive rate."
+    }
+  ],
+  "result": "Take the bitwise OR of the two filters. Each bit is 1 if it was set by an item of A or of B, which is exactly what adding all of A ∪ B would produce. So the OR is identical to the filter built from A ∪ B: it is exact. It still has the usual false-positive rate for |A ∪ B| items, which rises if that number is more than the filter was sized for. A bitwise AND gives a filter with no false negatives for A ∩ B, but it is only approximate. It can keep bits that were set by an item only in A and a different item only in B, so it can have extra 1s compared with the true A ∩ B filter. That gives more false positives than a filter built directly from A ∩ B.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/quick.json
new file mode 100644
index 0000000..38fe5e0
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/bloom-filter/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A bit in a filter is 1 exactly when at least one added item hashes to that position. Otherwise it stays 0.",
+      "part": "The parts; How it works (step 1, Add); Why \"no\" is always right",
+      "idea": "All bits start at 0. Adding an item sets its k positions to 1, and nothing ever sets a bit back to 0. So the final array is just the union of all the positions the added items hash to."
+    },
+    {
+      "step": "The two filters are comparable position by position, and an item's positions are the same in both.",
+      "part": "The parts (hash functions: the same item always gives the same position)",
+      "idea": "Same m and same hash functions means each item maps to the same k positions in either filter."
+    },
+    {
+      "step": "A bitwise OR of the two arrays gives a bit of 1 exactly where some item of A or some item of B set it. That is the set of positions covered by A ∪ B.",
+      "part": "Steps 1 and 2; background (what OR does)",
+      "idea": "OR switches a bit on if either input bit is on, and that matches 'some item in A ∪ B hashes here'."
+    },
+    {
+      "step": "So the OR is exactly the same array you would get by adding every item of A ∪ B to an empty filter. It is exact: no information is lost compared with building it from the items. It still has the normal false-positive behaviour of a filter holding |A ∪ B| items.",
+      "part": "Step 3; How \"yes\" can be wrong; How much memory, and how often wrong",
+      "idea": "Same bits means same answers. False positives come from bit overlap and grow with how full the filter is, and the union filter holds more items."
+    },
+    {
+      "step": "A bitwise AND keeps a bit on only where it is on in both filters. Every item in A ∩ B has all its bits on in both filters, so AND keeps them all. A query for an item in A ∩ B is still 'probably yes', so there are no false negatives for the intersection.",
+      "part": "Step 1; Why \"no\" is always right; background (AND)",
+      "idea": "Bits of items in both sets are 1 in both arrays, so they survive the AND."
+    },
+    {
+      "step": "But a bit can be on in both filters because of different items: some a in A only and some b in B only can share a position, just as cat and dog share bit 6. The AND then keeps bits that no item of A ∩ B ever set. So the result can have more 1s than a filter built directly from A ∩ B. It is not exact, and its false-positive rate can be higher. An item in only one set can even pass if each of its bits is on in both filters.",
+      "part": "How it works (cat and dog both set bit 6); How \"yes\" can be wrong (the filter cannot tell which item set a bit)",
+      "idea": "Bits do not record which item set them, so the AND cannot separate 'set by a shared item' from 'set by different items that happen to collide'."
+    }
+  ],
+  "result": "To get A ∪ B, take the bitwise OR of the two arrays. This is exact: it is bit for bit the filter you would get by adding all items of A ∪ B, with that filter's usual false-positive rate. The bitwise AND gives a filter for A ∩ B that never says 'no' to an item really in both sets. It is not exact, though: bits set by different items in A and in B can coincide, so it may have extra 1s compared with a filter built from A ∩ B. That means more false positives. It is a superset approximation of the true intersection filter.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/none.json
new file mode 100644
index 0000000..c2161a1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/none.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "Turn each decimal into a simplified fraction: 0.375 = 3/8, 0.2 = 1/5, 0.0625 = 1/16, 0.3 = 3/10.",
+      "part": "background",
+      "idea": "Turning a decimal into a fraction is school arithmetic."
+    },
+    {
+      "step": "A fraction can be written with a finite number of binary digits only if its simplified denominator is a power of 2.",
+      "part": "Section 2, 'The same problem in binary' (first paragraph)",
+      "idea": "Base 2 has only one prime factor, 2, so only power-of-2 denominators give binary forms that end (1/2, 1/4, 3/8, 5/16...)."
+    },
+    {
+      "step": "3/8 and 1/16 have power-of-2 denominators, so their binary forms end: 0.375 = 0.011 and 0.0625 = 0.0001 in binary. 1/5 and 3/10 have a factor of 5, so their binary forms repeat forever.",
+      "part": "Step 2, plus the table in Section 2 and the repeated-doubling method",
+      "idea": "The table marks 0.2 and 0.3 'no'. Repeated doubling on 0.375 gives 0.75→0, 1.5→1 (keep 0.5), 1.0→1 and then stops, so 0.011."
+    },
+    {
+      "step": "A double keeps 53 significant binary digits and rounds anything longer to the nearest storable value. So 0.375 (2 significant bits) and 0.0625 (1 bit) are stored exactly, while 0.2 and 0.3 are rounded.",
+      "part": "Section 3, 'How much room the computer has', and its table of stored values",
+      "idea": "53-digit budget with round-to-nearest. The table shows 0.2 stored slightly too big and 0.3 slightly too small."
+    },
+    {
+      "step": "0.125 = 1/8 = 0.001 in binary is exact. Every partial sum k/8 (0.25, 0.375, ..., 1.0) is also a fraction over 8 that needs only a few bits, so each one is itself a double.",
+      "part": "Steps 2–4",
+      "idea": "Power-of-2 denominator with few significant digits fits easily in 53 bits."
+    },
+    {
+      "step": "Each addition gives the exact result rounded to the nearest double. When the exact result already is a double, rounding leaves it unchanged. So none of the eight additions adds any error, and the sum is exactly 1.0.",
+      "part": "Section 6, 'Bounded, predictable error' bullet",
+      "idea": "IEEE 754 makes +, −, ×, ÷ and √ exact results correctly rounded. Rounding only causes error when the exact result is not storable."
+    },
+    {
+      "step": "For 0.1: the stored starting value is already wrong (0.1000000000000000055...). The partial sums (0.2, 0.3, ...) are not exact doubles, so each addition gets rounded again, and these errors don't cancel out.",
+      "part": "Section 2 table and binary expansion of 0.1; Section 3 table; Section 4 'The addition itself'; intro fact 2",
+      "idea": "1/10 repeats forever in binary, so it gets rounded. Section 4 shows that adding stored tenths gives a sum that has to be rounded again (0.1+0.2 lands on a different double from 0.3). Rounding errors pile up instead of cancelling."
+    },
+    {
+      "step": "So after ten additions the result carries piled-up rounding error and can land on a neighbouring double instead of 1.0.",
+      "part": "Steps 6–7; Section 5 example (0.1+0.7 prints 0.7999999999999999)",
+      "idea": "Unlike the 0.125 case, nothing guarantees the exact answer. Section 5 shows that sums of stored tenths can land just off the 'nice' value."
+    }
+  ],
+  "result": "A double can store 0.375 (= 3/8 = 0.011 in binary) and 0.0625 (= 1/16 = 0.0001 in binary) exactly. It cannot store 0.2 (= 1/5) or 0.3 (= 3/10) exactly: their denominators have a factor of 5, so their binary digits repeat forever and get rounded to 53 bits. Adding 0.125 eight times gives exactly 1.0 because 0.125 and every partial sum k/8 are exact doubles. Each addition is correctly rounded, and when the exact answer is already a double, rounding changes nothing. Adding 0.1 ten times starts from a value that is already rounded, and the result of each addition has to be rounded again. These errors don't cancel, so the total can miss 1.0. One limit: the explanation shows how the miss happens, but it gives no way to work out the ten-step sum itself. You have to take the fact that it actually lands just below 1.0 (0.9999999999999999) on trust; the explanation doesn't show it.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/principles.json
new file mode 100644
index 0000000..fc0142c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/principles.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "A double can store a value exactly only if that value is a grid point: an integer of at most 53 bits times a power of 2. Any other value is rounded to the nearest grid point.",
+      "part": "Section 3, 'What the computer actually stores'",
+      "idea": "A double is (an integer of at most 53 bits) × (a power of 2), so the values it can hold form a grid. Any literal that is not on the grid gets rounded."
+    },
+    {
+      "step": "A fraction has a finite binary expansion only if its denominator, in lowest terms, has no prime factor other than 2. A factor of 5 makes the binary expansion repeat forever, so the value must be rounded.",
+      "part": "Section 2, 'Why 0.1 has no exact binary form'",
+      "idea": "In base 10 the allowed prime factors are 2 and 5. In base 2 only 2 is allowed. The 5 in 1/10 = 1/(2×5) makes the binary form repeat."
+    },
+    {
+      "step": "Write each number as a fraction in lowest terms: 0.375 = 3/8, 0.0625 = 1/16, 0.2 = 1/5, 0.3 = 3/10.",
+      "part": "background",
+      "idea": "Turning a decimal into a fraction is school arithmetic."
+    },
+    {
+      "step": "0.375 = 3 × 2⁻³ and 0.0625 = 1 × 2⁻⁴. Both have power-of-2 denominators and small integers, so both are grid points and are stored exactly.",
+      "part": "Section 6, 'When addition is exact', with steps 1-3",
+      "idea": "Fractions with power-of-2 denominators are stored exactly. 1/2, 1/4 and 3/4 are given as examples of grid points."
+    },
+    {
+      "step": "0.2 (denominator 5) and 0.3 (denominator 10 = 2×5) are not stored exactly. The table confirms this: stored 0.2 ≈ 0.20000000000000001110 (slightly high) and stored 0.3 ≈ 0.29999999999999998890 (slightly low).",
+      "part": "Section 2 and the table in Section 3",
+      "idea": "A factor of 5 forces a repeating binary expansion, so the value is rounded. The table shows the exact stored values and their errors."
+    },
+    {
+      "step": "0.125 = 1/8 = 2⁻³ is stored exactly. Every running total 0.125 × k = k/8 (k = 1…8) is a small integer times 2⁻³, which is a grid point. So no addition needs rounding, and the eighth sum is exactly 8/8 = 1.0.",
+      "part": "Section 6 and Section 3",
+      "idea": "Sums of power-of-2 fractions are exact while they fit in 53 bits. If the exact sum is already a grid point, nothing is rounded."
+    },
+    {
+      "step": "The stored 0.1 is not 1/10. It is 7205759403792794 × 2⁻⁵⁶, slightly high. So even an exact sum of ten copies would be ten times that value, not exactly 1.",
+      "part": "Section 3 table and Section 2",
+      "idea": "0.1 is rounded when it is stored, so the starting value already carries an error."
+    },
+    {
+      "step": "Also, a running total of the stored 0.1 is generally not a grid point. Each addition must be rounded again, and each rounding is done on its own, so the errors need not cancel. In 0.1 + 0.2, one such rounding pushed the result to a different double from the stored 0.3.",
+      "part": "Section 1 (4-digit calculator), Section 4 (the addition, step by step), and the Summary",
+      "idea": "Each number and each result is rounded separately, and the errors do not cancel. Section 4 shows an exact sum that fell between grid points and was rounded by round-half-to-even."
+    }
+  ],
+  "result": "Stored exactly: 0.375 (3/8) and 0.0625 (1/16). Their denominators are powers of 2, so both are grid points (integer × power of 2). Not stored exactly: 0.2 (1/5) and 0.3 (3/10). The factor 5 in each denominator makes the binary expansion repeat, so each is rounded to the nearest double (stored 0.2 is slightly high, stored 0.3 slightly low). Adding 0.125 eight times gives exactly 1.0 because 0.125 = 2⁻³ is exact, and every running total k/8 is also a grid point. No step ever rounds. Adding 0.1 ten times starts from a stored value that is already slightly more than 1/10, and the running totals land between grid points, so each addition is rounded again. Those separate errors do not cancel out, so the final double is not 1.0.",
+  "gap": "The explanation does not trace a chain of ten additions. It says 'how errors grow across long chains of operations' is not covered. So it gives the reason the sum can miss 1.0, but not the actual result after ten additions or which direction it misses in. That the sum is not 1.0 comes from the question itself, not from anything shown in the explanation."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/published.json
new file mode 100644
index 0000000..5c2e4ce
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/published.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "A double can only hold a whole number (at most 53 binary digits) times a power of two.",
+      "part": "What the computer holds",
+      "idea": "A double is an integer of up to 53 bits times 2^k. For example, 0.75 = 3 × 2^-2 is held exactly."
+    },
+    {
+      "step": "A decimal can be stored exactly only if, written as a fraction in lowest terms, its denominator is a power of two. A factor of 5 in the denominator forces rounding.",
+      "part": "Why 0.1 must be rounded",
+      "idea": "An integer times a power of two is a fraction with a power-of-two denominator, and such a fraction ends in binary. A denominator with a factor of 5 never ends in binary, so it has to be cut off and rounded."
+    },
+    {
+      "step": "0.375 = 3/8 = 3 × 2^-3 and 0.0625 = 1/16 = 1 × 2^-4, so both are stored exactly with error 0.",
+      "part": "Step 2; Why 0.1 must be rounded (3/8 = 0.011 in binary)",
+      "idea": "Both denominators are powers of two, and the numerators are tiny."
+    },
+    {
+      "step": "0.2 = 1/5 and 0.3 = 3/10 both have a factor of 5 in the denominator, so neither can be stored exactly. The table gives stored 0.2 as 0.2 + 1.11e-17 and stored 0.3 as 0.3 − 1.11e-17.",
+      "part": "Step 2; The stored values (table)",
+      "idea": "These are rounded to the nearest double, so they carry a nonzero error."
+    },
+    {
+      "step": "0.125 = 1/8 = 2^-3 is stored exactly. Every running total when adding it up is k/8 = k × 2^-3 for k = 1 to 8. Each of these is a small whole number times a power of two, so each is a double.",
+      "part": "What the computer holds; When it works",
+      "idea": "When the inputs have power-of-two denominators, they are stored with error 0 and the exact sum is itself a double."
+    },
+    {
+      "step": "Each + finds the exact sum and then rounds it to a double. Since every exact sum here is already a double, no rounding ever happens, and the eighth sum is exactly 8/8 = 1.0.",
+      "part": "What + does; Step 5",
+      "idea": "Rounding an exact sum that is already a double leaves it unchanged."
+    },
+    {
+      "step": "With 0.1, the input is not 0.1 at all. It is the stored value 0.1 + 5.55e-18. Each of the ten additions then rounds its exact sum to the nearest double, which can add a new error each time.",
+      "part": "The stored values (table); What + does",
+      "idea": "The start value already carries an error, and every addition can round again, unlike the 0.125 case."
+    },
+    {
+      "step": "To show that the final result is not 1.0, you would have to follow the rounding at each of the ten steps. The explanation explicitly leaves this out. Ten times the stored 0.1 is about 1 + 5.55e-17. The gaps near 1 are not given, so the explanation can't say which double that becomes or where the intermediate roundings land.",
+      "part": "Not covered here (adding 0.1 ten times); The stored values",
+      "idea": "The explanation only gives gaps below 0.5 and refers error build-up over many operations to a numerical analysis text."
+    }
+  ],
+  "result": "A double stores 0.375 (3/8) and 0.0625 (1/16) exactly, because their denominators are powers of two. It cannot store 0.2 (1/5) or 0.3 (3/10) exactly, because of the factor of 5. Adding 0.125 eight times gives exactly 1.0: 0.125 is stored exactly, and every running total k/8 is itself a double, so no addition ever has to round. Adding 0.1 starts from a value that is already slightly wrong (0.1 + 5.55e-18), and each of the ten additions may round again, so the total can drift away from 1.0. The explanation does not show that the drift really ends somewhere other than 1.0.",
+  "gap": "The explanation leaves out what happens to errors over many operations, and it names adding 0.1 ten times as out of scope. It also gives no gaps for numbers between 0.5 and 1 or above 1. So it can't show, step by step, that ten additions of 0.1 end at a double other than 1.0. It only shows why they might, while adding 0.125 can't."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/quick.json
new file mode 100644
index 0000000..e095535
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/float-sum/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A double can store a number exactly only if it is a finite sum of powers of 2 (1/2, 1/4, 1/8, …) that fits in 53 significant bits. Any other number is replaced by the nearest such binary fraction.",
+      "part": "Why 0.1 has the same problem in base 2 (first paragraph and the paragraph above the table)",
+      "idea": "A double is a binary fraction with 53 significant bits. A number whose binary form repeats forever is stored as the nearest binary fraction, called the stored value."
+    },
+    {
+      "step": "0.375 = 3/8 = 1/4 + 1/8, which is binary 0.011. That is a short binary fraction, so a double stores it exactly.",
+      "part": "Step 1 + background (fraction arithmetic)",
+      "idea": "Write 0.375 as a fraction and break it into powers of 2. It needs only a few bits."
+    },
+    {
+      "step": "0.0625 = 1/16 = 2^-4, which is binary 0.0001. It is exact.",
+      "part": "Step 1 + background",
+      "idea": "A single power of 2 is the simplest binary fraction there is."
+    },
+    {
+      "step": "0.2 and 0.3 are not exact. The stored 0.2 is 0.2000000000000000111… and the stored 0.3 is 0.2999999999999999888….",
+      "part": "Why 0.1 has the same problem in base 2 (table of stored values) and When addition is exact (last sentence)",
+      "idea": "The table shows that the stored values differ from the written ones. The text names 0.1, 0.2 and 0.3 as numbers with no short binary form."
+    },
+    {
+      "step": "0.125 = 1/8 is exact. Each running total k/8 (1/8, 2/8, …, 8/8 = 1) is also a short binary fraction, so no addition ever has to round, and the eighth sum is exactly 1.0.",
+      "part": "When addition is exact (0.5 + 0.25 example) + Step 1 + background",
+      "idea": "If the inputs and the sum are all short binary fractions, no step rounds and no error appears. Every k/8 is a short binary fraction."
+    },
+    {
+      "step": "0.1 is stored as 0.1000000000000000055…, so the input is wrong before any adding starts. Most of the running totals (0.2, 0.3, …) are not short binary fractions either, so each addition rounds its exact sum to the nearest double. These input and rounding errors build up, and the final double can differ from the double for 1.0. Since == compares bit for bit, the comparison fails.",
+      "part": "Why 0.1 has the same problem in base 2 (table); What happens in the addition (steps 1–4); The same problem in base 10 (calculator analogy)",
+      "idea": "The adding is done correctly, but the inputs are already wrong and each sum is rounded to the nearest double. The small errors add up to a different double, and == then reports false."
+    }
+  ],
+  "result": "Exact: 0.375 (= 1/4 + 1/8) and 0.0625 (= 1/16). Not exact: 0.2 and 0.3, because their binary forms repeat forever and get rounded. Adding 0.125 = 1/8 eight times is exact because 1/8 and every running total k/8 are short binary fractions, so no step rounds and the total is exactly 1.0. Adding 0.1 ten times starts from a stored 0.1 that is slightly too high. Most running totals then need rounding to the nearest double, and the errors build up to a double that is not 1.0, so == is false. The explanation does not give the final value (whether it ends up just above or just below 1.0). For that you would have to work through the ten roundings yourself, but you don't need it for the 'why'.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/none.json
new file mode 100644
index 0000000..b3e6163
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "A timing error turns into a distance error through the speed of light: 1 ns is about 30 cm.",
+      "part": "Section 1 'Distance from time': the formula distance = c × (t_r − t_s) and the bold line 'Every nanosecond of timing error is about 30 cm of position error.'",
+      "idea": "Range is the speed of light times the travel time, so any error in the time stamps becomes a range error at about 30 cm per nanosecond."
+    },
+    {
+      "step": "A 10 ns satellite clock error makes the range to that satellite wrong by about 3 m.",
+      "part": "Step 1; the last paragraph of Section 3 ('...10 ns fast from that satellite being 3 m farther away')",
+      "idea": "10 ns × 30 cm/ns ≈ 3 m. The explanation itself pairs a 10 ns satellite clock error with a 3 m range error."
+    },
+    {
+      "step": "Direction of the error: the satellite stamps a send time t_s that is 10 ns too late, so the measured delay t_r − t_s is 10 ns too short.",
+      "part": "Section 1, the formula distance = c × (t_r − t_s); background (simple arithmetic)",
+      "idea": "If the satellite clock reads 10 ns ahead, t_s is too large by 10 ns. Putting that into the formula gives a range about 3 m too short. The text's phrase '3 m farther away' only makes the point that the two cases look the same; the size, about 3 m, is what matters."
+    },
+    {
+      "step": "The receiver's fourth unknown b can absorb its own clock error because that error adds the same amount to every pseudorange.",
+      "part": "Section 2: the pseudorange equation ρᵢ = |sᵢ − p| + b and 'That error is the same for every satellite'",
+      "idea": "One receiver clock error δt shifts every measured distance by the same b = c·δt, so solving for one extra number b removes it completely."
+    },
+    {
+      "step": "A single satellite's clock error affects only that satellite's equation, so it does not fit the shared b term.",
+      "part": "Section 2 pseudorange equation; Section 3 Jacobian (the derivative with respect to b is 1 for every satellite); last paragraph of Section 3",
+      "idea": "b enters every equation the same way, so it can only soak up an offset that all satellites share. The 3 m error shows up in one equation only. The receiver can't tell it from that satellite really being at a different distance, so the solver treats it as true geometry and shifts the computed position (x, y, z). The text says: 'It cannot absorb errors that differ from satellite to satellite.'"
+    },
+    {
+      "step": "So the method depends on the satellite clocks agreeing with one another, which is why satellite clock errors have to be corrected by the system itself.",
+      "part": "Section 3 last paragraph ('the satellites' clocks agree with each other and with GPS system time'); Section 4 note on the '11 km a day' claim",
+      "idea": "Errors that differ from satellite to satellite go straight into the position, not into b. That is why ground stations broadcast clock corrections and relativistic effects are designed out."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × 30 cm/ns). By the timing formula it comes out about 3 m too short, because the fast clock makes the delay look 10 ns shorter. The receiver's clock unknown b is one number added equally to every pseudorange. That lets it absorb an error shared by all satellites, such as the receiver's own clock error, but not an error in just one satellite's equation. The receiver can't tell this clock error from that satellite really being 3 m nearer or farther, so the error goes into the computed position.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/principles.json
new file mode 100644
index 0000000..47832eb
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "The receiver works out each satellite's distance from the time sent, which the satellite stamps using its own clock, and the time received, which the receiver reads on its own clock.",
+      "part": "Short answer paragraph; Section 1 'Time becomes distance' (distance = c × (time received − time sent))",
+      "idea": "Distance is c times the gap between the two timestamps, so an error in either timestamp turns straight into a distance error."
+    },
+    {
+      "step": "A 10 ns timing error gives a distance error of about 3 m.",
+      "part": "Section 1, paragraph 'This conversion is unforgiving'",
+      "idea": "Light travels 30 cm per nanosecond, and the text gives 10 ns → 3 m as its own example."
+    },
+    {
+      "step": "Direction of the error: a fast satellite clock stamps a send time 10 ns later than the true one. That makes (received − sent) 10 ns too short, so this satellite's distance comes out about 3 m too short.",
+      "part": "Step 1 (the formula) plus background arithmetic",
+      "idea": "If the time sent is too large, the subtraction is too small. The receiver's clock is correct, so it adds no error of its own."
+    },
+    {
+      "step": "The fourth unknown b adds the same amount, c·b, to every measured distance.",
+      "part": "Section 3, the equation and the sentence 'The receiver's error adds the same amount, c·b, to every measured distance'",
+      "idea": "b can only model an offset that is shared by all the signals."
+    },
+    {
+      "step": "A clock error on one satellite affects only that satellite's distance, so it is not shared. b cannot absorb it, and the solve cannot even detect it. The leftover 3 m error goes into the position fix.",
+      "part": "Section 3, 'What this trick cannot fix'",
+      "idea": "If only one satellite's clock is off, only its distance is wrong (30 ns → 9 m), so satellite clocks must all agree with GPS time to within a few ns."
+    },
+    {
+      "step": "This matches how the explanation treats other errors that differ from satellite to satellite.",
+      "part": "Section 5 'In the receiver'; Section 6, second bullet",
+      "idea": "The eccentricity term is different for each satellite, so the fourth-satellite trick cannot absorb it and it has to be calculated and removed separately."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m, because 10 ns × 30 cm/ns = 3 m. Since the fast clock stamps a send time that is too late, the measured travel time is too short, so the distance comes out about 3 m too short. The receiver's fourth unknown b adds the same c·b to every distance, so it can only cancel an error that all the signals share, such as the receiver's own clock error. This error affects one satellite only, so b cannot absorb it and the solve cannot detect it. It goes straight into the position as an error of a few metres. That is why every satellite clock must agree with GPS time to within a few nanoseconds.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/published.json
new file mode 100644
index 0000000..5370223
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Pseudorange = c × (receive time on the receiver clock − send time on the satellite clock), so an error in either clock carries straight into the measured distance.",
+      "part": "Section 2, paragraph defining pseudorange (claim def-pseudorange)",
+      "idea": "The send time comes from the satellite's own clock stamp, so the satellite clock's error enters that satellite's pseudorange."
+    },
+    {
+      "step": "Each nanosecond of timing error is 0.3 m of range error, so 10 ns gives about 3 m.",
+      "part": "Section 1, paragraph on light covering 0.3 m per ns; Section 3, 'Each nanosecond of satellite clock error is 0.3 m of range error'",
+      "idea": "Range error = c × timing error, at 0.3 m per ns."
+    },
+    {
+      "step": "Which way: a fast satellite clock stamps a send time 10 ns later than the true time. The receiver clock is right, so receive − send comes out 10 ns too small. The pseudorange to that satellite is therefore about 3 m too short.",
+      "part": "Step 1 plus background arithmetic",
+      "idea": "Subtracting a send time that is too large gives a travel time that is too small."
+    },
+    {
+      "step": "The receiver's unknown b works only because the receiver's clock makes every measurement, so the same b sits in every pseudorange.",
+      "part": "Section 2, pseudorange paragraph and the worked example on a line (claim mech-bias-1d)",
+      "idea": "A shared offset can be solved as one extra unknown. In the example, the excess over the known total is b counted twice."
+    },
+    {
+      "step": "A satellite clock error sits in only one pseudorange. A single shared b cannot match an error that appears in one equation and not the others, so no unknown absorbs it and it skews the position fix.",
+      "part": "Section 3, first paragraph (claim mech-clock-to-range); Section 5 (claim guar-bias-absorbs-shared)",
+      "idea": "b absorbs only errors that are the same in every pseudorange. An error that is not shared remains in the solution."
+    },
+    {
+      "step": "Check against the error budget: 10 ns is within the roughly 17 ns allowed for a fix within about 5 m, so the error is tolerable but not cancelled.",
+      "part": "Section 3, second paragraph",
+      "idea": "About 17 ns ≈ 5 m is the stated limit."
+    }
+  ],
+  "result": "The distance to that satellite is wrong by about 3 m (10 ns × 0.3 m/ns). Because the satellite clock runs fast, the send time looks later and the pseudorange comes out about 3 m too short. The receiver's fourth unknown b can only absorb an error that is the same in all four pseudoranges. The receiver's own clock error is like that, because one clock times every signal. This satellite's clock error appears in only one pseudorange, so no single shared b can cancel it, and it passes into the computed position. The error is still within the roughly 17 ns (about 5 m) budget.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/quick.json
new file mode 100644
index 0000000..9968fe7
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/gps-relativity/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "The receiver works out distance from the travel time: travel time = receive time − the send time stamped by the satellite, and distance = travel time × c.",
+      "part": "Step 1: time becomes distance (paragraphs 2–3)",
+      "idea": "The satellite's time stamp feeds straight into the travel time, so any error in the satellite clock becomes an error in the travel time."
+    },
+    {
+      "step": "Light travels about 30 cm per nanosecond, so a 10 ns timing error gives a distance error of about 10 × 30 cm = 3 m.",
+      "part": "Step 1, paragraph 3 (\"Light travels about 30 cm per nanosecond\")",
+      "idea": "Each nanosecond of clock error is worth about 30 cm of distance. This matches Step 4's figure of 26 ns ≈ 8 m."
+    },
+    {
+      "step": "Which way the error goes: a fast satellite clock stamps a send time that is too late, so receive − send comes out about 10 ns too short. The distance to that satellite is then about 3 m too short.",
+      "part": "Step 1 paragraph 2 (travel time = receive − send) plus background arithmetic",
+      "idea": "Subtracting a send time that is too large gives a travel time that is too small."
+    },
+    {
+      "step": "The receiver's clock bias b adds the same amount, c·b, to every pseudorange. That is why one extra unknown can soak it up when four satellites are used.",
+      "part": "Step 2: why four satellites, not three (pseudorange equation ρᵢ = √(...) + c·b)",
+      "idea": "The receiver's clock error is common to all four measurements, and the term for it is identical in every equation."
+    },
+    {
+      "step": "The 10 ns error is in one satellite's clock, so only that one pseudorange is off by about 3 m. The other three are correct. One shared b cannot match an error that appears in a single equation. The solver instead finds a compromise that pulls the position (and b) away from the true values.",
+      "part": "Step 2 (\"plus the same error c·b\"); Limits, first bullet (\"b absorbs part of an error that all satellites share\"); Step 2 paragraph 3 (\"This method works only if the satellite clocks all keep GPS time\")",
+      "idea": "b can only absorb an error that is the same for every satellite. An error that belongs to one satellite breaks the model's assumption that all satellite clocks keep GPS time."
+    }
+  ],
+  "result": "The distance to that satellite is off by about 3 m (10 ns × about 30 cm/ns). Because the fast clock stamps a send time that is too late, the measured distance comes out about 3 m too short. The receiver's fourth unknown, b, cannot absorb this. b enters every pseudorange as the same term, c·b, so it can only cancel an error that all satellites share, such as the receiver's own clock offset. This 3 m error is in only one of the four equations, so no single value of b fits all four. The solver ends up shifting the position estimate, and b, by a few metres instead. This is why the method needs every satellite clock to keep GPS time.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/none.json
new file mode 100644
index 0000000..b729a86
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "In this picture, the planet's surface temperature is set by matching the energy coming in with the energy going out.",
+      "part": "Section 1, 'The planet is a budget: energy in = energy out'",
+      "idea": "The planet absorbs about 238 W/m² of sunlight and gives off σT⁴. It warms or cools until the two are equal. Giving off 238 W/m² needs a temperature of 255 K."
+    },
+    {
+      "step": "What a layer of air gives off depends only on that layer's own temperature.",
+      "part": "Section 3, last paragraph ('what a layer of air emits depends on how warm that layer is')",
+      "idea": "CO₂ gives off infrared at a rate set by the temperature of the air around it. Radiation from air at a given temperature has a fixed strength, wherever that air is."
+    },
+    {
+      "step": "Space receives radiation from the 'effective emission height', at the temperature found at that height.",
+      "part": "Section 5, fact 2 and the paragraph on 'effective emission height'",
+      "idea": "The infrared that escapes comes from the level above which there is too little gas to absorb it. Space sees the temperature of that level, not the temperature of the surface."
+    },
+    {
+      "step": "Adding CO₂ only has an effect because a higher level is colder.",
+      "part": "Section 5, 'Now add CO₂' paragraph",
+      "idea": "More CO₂ lifts the emission height. Forcing (energy going out falling below 238 W/m²) happens only because the higher air is colder and so gives off less (T⁴)."
+    },
+    {
+      "step": "If temperature is the same at every height, the lapse rate Γ is 0.",
+      "part": "Section 5, fact 1 (definition of lapse rate) + the question's assumption",
+      "idea": "The lapse rate is how fast temperature falls with height. In an atmosphere at one temperature throughout, it falls by 0 K per km."
+    },
+    {
+      "step": "With Γ = 0, raising the emission height leaves its temperature unchanged, so the energy going out does not change and there is no forcing.",
+      "part": "Steps 2, 3, 4, 5",
+      "idea": "The new, higher level is just as warm as the old one. It gives off the same σT⁴, so the outgoing radiation still matches the incoming 238 W/m², and the planet has no shortfall to warm up from."
+    },
+    {
+      "step": "The surface temperature formula gives no greenhouse warming and no change.",
+      "part": "Section 5 formula T_surface ≈ T_emission + Γ × H, and 'surface ends up warmer by about Γ × (rise in emission height)'",
+      "idea": "With Γ = 0: T_surface = T_emission = 255 K whatever the height H, and the warming Γ × Δh = 0. Model 2 on the page shows the same thing. Its profile lines are drawn using slope Γ and the surface temperature is 255 + Γ·H0, so a flat profile would leave nothing to shift."
+    }
+  ],
+  "result": "Adding CO₂ would leave the surface temperature unchanged. In the explanation's emission-height picture, the planet radiates to space from a level whose temperature sets how much energy leaves. More CO₂ lifts that level, but if every height has the same temperature, the higher level is no colder. It gives off the same amount, so there is no forcing and no reason to warm. Using the explanation's formula, the warming is Γ × (rise in emission height) = 0 × Δh = 0. The surface would also have no greenhouse warming to begin with: it would sit at the emission temperature, about 255 K. The effect depends on air getting colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/principles.json
new file mode 100644
index 0000000..db3b7ba
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/principles.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "More CO2 means more absorbing gas above each altitude, so the emission level (the height from which infrared escapes to space) moves higher.",
+      "part": "Section 6, chain item 1, and Section 5, Fact 1",
+      "idea": "A photon can reach space only if little absorbing gas lies above it. Adding CO2 adds gas above every height, so photons must start higher before they can escape."
+    },
+    {
+      "step": "How much a layer emits depends only on its temperature, through P = σT⁴.",
+      "part": "Section 1, Stefan–Boltzmann law",
+      "idea": "Emission per square metre is fixed by the absolute temperature. The same temperature gives the same emission."
+    },
+    {
+      "step": "In an isothermal atmosphere, the higher emission level has the same temperature as the old one, so its emission to space stays the same.",
+      "part": "Steps 1–2 and Section 7, 'Breaks (isothermal air)' bullet",
+      "idea": "With no fall in temperature with height, raising the emission level does not make it colder, so σT⁴ does not change."
+    },
+    {
+      "step": "Outgoing energy still equals the 238 W/m² absorbed from the Sun, so there is no imbalance (no radiative forcing) and the planet gains no energy.",
+      "part": "Step 3, Section 6 chain items 2–4, and Section 8 (238 W/m² is fixed by sunlight and reflectivity)",
+      "idea": "Warming happens only when less energy leaves than arrives. That requires the emission level to emit less, which needs it to be colder."
+    },
+    {
+      "step": "The surface temperature does not change. With no lapse rate, the surface is at the same temperature as the emission level (about 255 K), however high that level sits.",
+      "part": "Step 4, Section 5 (diagram: surface = emission-level temperature + lapse rate × height), Section 7",
+      "idea": "The surface's excess warmth comes from lapse rate × emission height. With a lapse rate of 0, that excess is 0 and stays 0 when the height increases."
+    }
+  ],
+  "result": "Adding CO2 would not change the surface temperature, because there would be no warming. The extra CO2 still raises the emission level. But at the same temperature everywhere, the new level is as warm as the old one, so by σT⁴ it sends the same 238 W/m² to space. Energy in still equals energy out, so there is no forcing and nothing pushes the surface to warm. The greenhouse effect described here depends on air getting colder with height. Without that, the surface would stay at the same temperature as the emitting layer (about 255 K), whatever the amount of CO2.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/published.json
new file mode 100644
index 0000000..318313c
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Energy balance requires whatever emits to space to give off 240 W/m², which means it must be at 255 K.",
+      "part": "Section 1 (Without greenhouse gases: 255 K)",
+      "idea": "Absorbed sunlight is 1361/4 × 0.70 ≈ 240 W/m². Setting σT⁴ = 240 gives T = 255 K for the emitter."
+    },
+    {
+      "step": "Infrared escapes to space from the emission height, and the air there must be at 255 K.",
+      "part": "Section 3, first two paragraphs",
+      "idea": "Infrared only escapes from air with little greenhouse gas above it. That emitting air has to emit 240 W/m², so it must be at 255 K."
+    },
+    {
+      "step": "In the real atmosphere the surface is warmer than the emitting air only because air cools with height.",
+      "part": "Section 3, lapse rate paragraph and table",
+      "idea": "With a fall of 6.5 K per km, the surface 5 km below the emitting air is 33 K warmer (255 K up there, 288 K at the ground)."
+    },
+    {
+      "step": "Adding CO₂ raises the emission height.",
+      "part": "Section 4, item 1",
+      "idea": "With more gas, infrared has to start higher before little gas remains above it (about 150 m higher for a doubling)."
+    },
+    {
+      "step": "If the temperature is the same at every height (lapse rate 0), the air at the new, higher emission height is just as warm as before.",
+      "part": "Section 5, test-case paragraph; steps 3–4",
+      "idea": "With no cooling with height, the higher emitting air is still 255 K and still emits 240 W/m²."
+    },
+    {
+      "step": "So there is no imbalance and nothing makes the Earth warm up.",
+      "part": "Section 4, items 3–4; Section 5",
+      "idea": "Warming comes from a forcing: the Earth emitting less than it absorbs. Here outgoing power stays at 240 W/m², so the forcing is zero and the Earth gains no energy."
+    },
+    {
+      "step": "The surface temperature does not change.",
+      "part": "Section 4, item 5; Section 5, last paragraph; step 3",
+      "idea": "Normally the surface warms because it ends up further below colder emitting air. With no cooling with height, being further below adds no warmth. Warming needs both a rising emission height and air that is colder higher up."
+    }
+  ],
+  "result": "Nothing would happen to the surface temperature. Adding CO₂ still lifts the emission height. But with the same temperature at every height, the air at the new height is still 255 K and still emits 240 W/m², matching the absorbed sunlight. There is no radiative forcing, the Earth gains no energy, and the surface does not warm. Greenhouse warming needs both a rising emission height and air that gets colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/quick.json
new file mode 100644
index 0000000..79a63bb
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/greenhouse/quick.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "Adding greenhouse gas makes the height at which infrared escapes to space go up.",
+      "part": "Level 2, paragraph on emission height (claim mech-emission-height) and the paragraph after it ('Add gas, and the emission height rises')",
+      "idea": "Infrared escapes to space only from air that has little gas above it. More gas puts that air higher: doubling CO2 lifts it by about 150 m."
+    },
+    {
+      "step": "In the real atmosphere, a higher emission height means colder emitting air, so less energy goes out to space and the planet warms.",
+      "part": "Level 2 flowchart and the paragraph 'Add gas, and the emission height rises...'",
+      "idea": "Air cools by about 6.5 K per km, so the higher emitting air is about 1 K colder. Emission goes as T⁴, so the output falls by about 3.8 W/m². The planet then takes in more than it gives out and warms until balance returns."
+    },
+    {
+      "step": "If the temperature were the same at every height, the higher emitting air would be just as warm as the old emitting air.",
+      "part": "Level 2, final paragraph (claim guar-lapse-rate)",
+      "idea": "The warming works only because air gets colder with height. With no lapse rate, moving the emitter up does not change its temperature."
+    },
+    {
+      "step": "So the energy going out to space would not fall, energy balance would not be broken, and nothing would push the surface to warm.",
+      "part": "Step 3; Level 1 paragraph on Stefan–Boltzmann; Level 2, final paragraph",
+      "idea": "Emission depends only on the emitter's temperature through σT⁴. Same temperature means the same 240 W/m² goes out, so there is no energy imbalance and the column does not warm."
+    }
+  ],
+  "result": "Adding CO2 would not warm the surface. It would still raise the emission height, but in air with the same temperature at every height, the new higher emitting air is just as warm as before. It therefore sends out the same amount of infrared (σT⁴), outgoing energy still matches the 240 W/m² absorbed, and nothing breaks the balance that would force the surface to warm. The greenhouse warming from extra gas depends on air getting colder with height.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/none.json
new file mode 100644
index 0000000..8d02530
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For the air conditioner, the useful output is the heat taken from the cold inside, Q_cold. Its performance ratio is therefore Q_cold / W, the heat removed per unit of electrical work.",
+      "part": "'Run backwards, it's an air conditioner' bullet; COP definition in 'The short answer'; the question's wording",
+      "idea": "It is the same machine with the coils swapped. COP means useful heat divided by the work you pay for, and here the useful heat is the heat removed from the cold side."
+    },
+    {
+      "step": "Energy balance: Q_hot = Q_cold + W, so Q_cold = Q_hot − W.",
+      "part": "Section 3, 'Energy conservation gives Q_cold = Q_hot − W'; 'It's not perpetual motion' bullet",
+      "idea": "The heat released on the warm side is exactly the heat taken in on the cold side plus the electrical work."
+    },
+    {
+      "step": "Second law: Q_hot / T_hot ≥ Q_cold / T_cold, so Q_hot ≥ Q_cold × T_hot / T_cold.",
+      "part": "Section 3, 'Entropy bookkeeping'",
+      "idea": "Heat Q at absolute temperature T carries entropy Q/T, and work carries none. A machine running in a steady cycle must give out at least as much entropy as it takes in. This holds whichever room is the cold one."
+    },
+    {
+      "step": "W = Q_hot − Q_cold ≥ Q_cold × (T_hot/T_cold − 1) = Q_cold × (T_hot − T_cold)/T_cold. So the cooling COP is Q_cold / W ≤ T_cold / (T_hot − T_cold).",
+      "part": "Steps 2 and 3; background algebra",
+      "idea": "Put the energy balance into the entropy inequality and rearrange to get heat removed over work. This is the same algebra Section 3 uses for the heating limit."
+    },
+    {
+      "step": "For any machine, Q_cold / W = (Q_hot − W)/W = Q_hot/W − 1. So the cooling COP is always the heating COP minus 1. At the ideal limit, T_cold/(T_hot − T_cold) = T_hot/(T_hot − T_cold) − 1, because T_hot − (T_hot − T_cold) = T_cold.",
+      "part": "Step 2; Section 3 Carnot limit 'COP ≤ T_hot/(T_hot − T_cold)'",
+      "idea": "The heat delivered on the hot side is the heat removed plus the work. The heating ratio counts the work as useful output, and the cooling ratio does not. Dividing by W, that difference is exactly W/W = 1."
+    },
+    {
+      "step": "Example for 0 °C and 35 °C (273 K and 308 K): the cooling limit is 273/35 ≈ 7.8, compared with the heating limit of 308/35 ≈ 8.8.",
+      "part": "Section 3, 'Plugging in numbers'",
+      "idea": "These are the same absolute temperatures the explanation uses for its heating example."
+    }
+  ],
+  "result": "The ideal air-conditioner limit is heat removed per unit of electricity ≤ T_cold / (T_hot − T_cold), using absolute temperatures. For 273 K and 308 K that is about 7.8. It is exactly one less than the heating limit T_hot/(T_hot − T_cold) because of energy conservation, Q_hot = Q_cold + W. The heat delivered to the warm side includes the electrical work itself, which turns into heat. Heating counts that work as useful output, and cooling doesn't. So Q_cold/W = Q_hot/W − W/W = COP_heat − 1.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/principles.json
new file mode 100644
index 0000000..4ac284a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a machine moving heat from cold to hot, energy conservation gives Q_H = Q_C + W, where Q_C is the heat taken from the cold side, W the electrical work and Q_H the heat released on the hot side.",
+      "part": "Short answer (heat delivered = heat taken from outside + electrical work) and the 'Why the COP is not unlimited' formula W = Q_H − Q_C",
+      "idea": "Electricity does not create heat; the heat released on the hot side is the heat collected plus the work. This energy balance holds for any such loop."
+    },
+    {
+      "step": "Running the machine in reverse means it collects heat from the cold inside and releases heat to the warm outside. The useful output is Q_C, so its performance ratio is Q_C / W.",
+      "part": "'A refrigerator is the same machine' paragraph (end of 'The trick' section), plus the question's own framing",
+      "idea": "A refrigerator is the same loop, taking heat from the cold box and dumping it into the warmer room. For a cooler the useful quantity is the heat removed from the cold side, not the heat delivered."
+    },
+    {
+      "step": "The second law requires Q_H/T_H ≥ Q_C/T_C, which gives Q_H ≥ Q_C·T_H/T_C.",
+      "part": "'Why the COP is not unlimited': entropy Q/T and total entropy cannot decrease",
+      "idea": "The entropy dumped on the hot side must be at least the entropy taken from the cold side. This applies whichever side we call 'useful'."
+    },
+    {
+      "step": "W = Q_H − Q_C ≥ Q_C(T_H/T_C − 1) = Q_C(T_H − T_C)/T_C. So Q_C/W ≤ T_C/(T_H − T_C), with temperatures in kelvin.",
+      "part": "Steps 1 and 3, plus background algebra",
+      "idea": "Substitute the entropy inequality into the energy balance and rearrange to get the upper limit on the cooling ratio."
+    },
+    {
+      "step": "From step 1, Q_H/W = (Q_C + W)/W = Q_C/W + 1. So the heating COP is always exactly one more than the cooling ratio. Applying this to the limits: T_H/(T_H−T_C) − 1 = (T_H − (T_H−T_C))/(T_H−T_C) = T_C/(T_H−T_C), which agrees with step 4.",
+      "part": "Step 1 and the heating limit COP ≤ T_H/(T_H−T_C) in 'Why the COP is not unlimited'",
+      "idea": "The heat delivered includes the electricity itself, but the heat removed does not. That difference of one W is exactly 1 in the ratio."
+    },
+    {
+      "step": "Worked check: with the fluid boiling at 268 K and condensing at 318 K (50 K lift), the ideal cooling ratio is 268/50 ≈ 5.4, compared with the heating limit of 318/50 = 6.4.",
+      "part": "Table in 'Why the COP is not unlimited' (mild day row)",
+      "idea": "The table gives the fluid temperatures and the lift, so the cooling limit is the heating limit minus 1."
+    }
+  ],
+  "result": "The ideal limit for heat removed per unit of electricity is T_C/(T_H − T_C), with temperatures in kelvin (the cold-side temperature divided by the lift). It is exactly one less than the heating limit T_H/(T_H − T_C) because energy is conserved: Q_H = Q_C + W. The heat delivered on the hot side includes the electricity, so Q_H/W = Q_C/W + 1, and the same holds for the limits. For example, with 268 K and 318 K the limits are about 5.4 for cooling and 6.4 for heating.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/published.json
new file mode 100644
index 0000000..e3724c6
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/published.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "An air conditioner is the same loop with the cold coil inside the house. It takes heat Q_cold from the cold side, uses electricity W, and gives heat Q_hot to the warm side. What it is useful for is Q_cold, so its figure of merit is Q_cold / W.",
+      "part": "Summary (\"A fridge uses the same loop, with the cold coil inside the fridge\") and the COP definition in the introduction",
+      "idea": "The same four-part loop can cool a space by putting the cold coil where you want heat removed. COP is useful heat divided by electricity used."
+    },
+    {
+      "step": "Energy balance: Q_hot = Q_cold + W. All the electricity ends up as heat on the hot side.",
+      "part": "Level 1 diagram and Level 2 step 3 (Condenser); 'Energy conservation gives Q_cold = Q_hot − W'",
+      "idea": "The heat delivered to the hot side is the heat taken from the cold side plus the compressor's electricity (2 + 1 = 3)."
+    },
+    {
+      "step": "Entropy condition: Q_hot / T_hot ≥ Q_cold / T_cold, with temperatures in kelvin.",
+      "part": "Where the limit comes from",
+      "idea": "Heat Q at temperature T carries entropy Q/T. Electricity carries none, the refrigerant stores none over a cycle, and entropy cannot be destroyed. So the hot side must gain at least the entropy the cold side loses. This does not depend on which side is the house."
+    },
+    {
+      "step": "Substitute Q_hot = Q_cold + W: (Q_cold + W)/T_hot ≥ Q_cold/T_cold. Multiply both sides by T_hot·T_cold: W·T_cold ≥ Q_cold·(T_hot − T_cold). So Q_cold / W ≤ T_cold / (T_hot − T_cold).",
+      "part": "Steps 2 and 3; algebra is background (same steps as the explanation's 4-line derivation, solved for Q_cold instead of Q_hot)",
+      "idea": "The ideal cooling limit is the cold temperature divided by the temperature lift."
+    },
+    {
+      "step": "Why it is exactly one less: Q_cold / W = (Q_hot − W)/W = Q_hot/W − 1. This holds for any machine, ideal or not. At the limit: T_hot/(T_hot − T_cold) − 1 = (T_hot − (T_hot − T_cold))/(T_hot − T_cold) = T_cold/(T_hot − T_cold).",
+      "part": "Step 2 and the ideal limit formula in 'The ideal limit'",
+      "idea": "The heat delivered to the hot side always includes the electricity itself. Heat removed from the cold side is that amount minus the electricity, so per kWh of electricity it is always exactly 1 less."
+    },
+    {
+      "step": "Worked number: for 308.15 K and 273.15 K (lift 35 K), the heating limit is 8.8, so the cooling limit is 273.15/35 ≈ 7.8.",
+      "part": "The ideal limit (308.15/35 = 8.8)",
+      "idea": "These are the same two temperatures as the explanation's example, used for an illustration."
+    }
+  ],
+  "result": "The ideal cooling limit is Q_cold/W ≤ T_cold/(T_hot − T_cold), with temperatures in kelvin. For example, 273.15/35 ≈ 7.8, compared with 8.8 for heating between the same two temperatures. It is exactly one less because by energy conservation Q_hot = Q_cold + W. The heat dumped outside always includes the 1 unit of electricity on top of the heat taken from the cold side, so Q_cold/W = Q_hot/W − 1, and T_hot/ΔT − 1 = T_cold/ΔT.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/quick.json
new file mode 100644
index 0000000..b727b42
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/heat-pump/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "An air conditioner is the same refrigerant loop, with its parts placed the other way round: the evaporator is in the cold space being cooled and the condenser is in the warm place.",
+      "part": "Level 2, the paragraph 'A refrigerator uses the same loop...' (also the question's premise)",
+      "idea": "A fridge uses the same loop. Its evaporator is inside the cold box and its condenser is the warm grille at the back. So the cold side is where heat is picked up and the hot side is where heat is given off."
+    },
+    {
+      "step": "Energy balance for the machine: heat given off on the hot side = heat taken from the cold side + electricity. In symbols, Q_hot = Q_cold + W.",
+      "part": "Level 1, the sentence 'heat delivered = heat taken from the air + electricity' and the first diagram (3 = 2 + 1); Level 2, step 3 (Condenser)",
+      "idea": "No energy is created. The condenser gives off the heat picked up at the evaporator plus the compressor work."
+    },
+    {
+      "step": "For heating, the useful output is Q_hot, so COP_heat = Q_hot / W. For cooling, the useful output is the heat removed, Q_cold, so COP_cool = Q_cold / W.",
+      "part": "Level 1, the COP definition paragraph",
+      "idea": "COP is useful heat divided by the electricity paid for. For an air conditioner, the useful heat is the heat removed from the inside."
+    },
+    {
+      "step": "COP_cool = (Q_hot − W)/W = Q_hot/W − 1 = COP_heat − 1. This holds for any machine of this kind, including an ideal one. In the example: heat removed 2 kWh for 1 kWh of electricity gives 2, which is 3 − 1.",
+      "part": "Steps 2 and 3; background (algebra)",
+      "idea": "The heat removed is the heat delivered minus the electricity. That is the electricity counted once, so dividing by the electricity takes away exactly 1."
+    },
+    {
+      "step": "Ideal heating limit: COP_heat,max = T_hot / (T_hot − T_cold), with temperatures in kelvin.",
+      "part": "Level 3, the Carnot limit formula",
+      "idea": "Physics caps the heating COP at T_hot divided by the temperature lift."
+    },
+    {
+      "step": "Ideal cooling limit: COP_cool,max = T_hot/(T_hot − T_cold) − 1 = T_cold/(T_hot − T_cold). For example, with 263 K and 313 K: 6.3 − 1 ≈ 5.3, which equals 263/50.",
+      "part": "Steps 4 and 5; background (algebra)",
+      "idea": "Take 1 away from the heating limit and put it over the common denominator (the lift) to get T_cold over the lift."
+    }
+  ],
+  "result": "The ideal limit for an air conditioner is T_cold/(T_hot − T_cold), with temperatures in kelvin. For example, with 263 K and 313 K it is about 5.3, against 6.3 for heating. It is exactly one less because energy is conserved: heat dumped outside = heat removed from inside + electricity. Heating counts all the dumped heat, but cooling counts only the heat removed, which leaves out the electricity. Since COP divides by the electricity, leaving it out of the top takes away exactly 1: COP_cool = COP_heat − 1, so T_hot/(T_hot−T_cold) − 1 = T_cold/(T_hot−T_cold).",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/none.json
new file mode 100644
index 0000000..e628c67
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/none.json
@@ -0,0 +1,51 @@
+{
+  "steps": [
+    {
+      "step": "Set up the public values: everyone, Eve included, knows p and g. Each of Alice, Bob and Carol privately picks a secret a, b or c and never sends it.",
+      "part": "Two ideas solve it (idea 1); The protocol (public p and g, step 1)",
+      "idea": "Each person keeps a secret that never goes over the channel. Only results computed from the secrets are sent."
+    },
+    {
+      "step": "Round 1: each person publishes g^secret mod p, so A = g^a, B = g^b and C = g^c (all mod p).",
+      "part": "The protocol, step 2–3; Summary bullet 1",
+      "idea": "Publishing g^x mod p is safe and quick to compute. Fast repeated squaring makes it cheap even for huge numbers."
+    },
+    {
+      "step": "Key fact: raising a public value to your own secret multiplies the exponents, and the order does not matter: (g^x)^y = (g^y)^x = g^(xy) mod p. This works again on a value that already holds two exponents: (g^(ab))^c = g^(abc).",
+      "part": "The protocol: 'Both get the same s' (B^a = g^(ba), A^b = g^(ab), ab = ba, and mod-p reduction doesn't change it); Modular arithmetic (you can reduce at every step); background (multiplying numbers is commutative and associative)",
+      "idea": "Exponents stack by multiplication in any order, so whoever adds the last secret gets the same result."
+    },
+    {
+      "step": "Round 2: arrange the three in a ring. Alice takes Carol's C and computes C^a = g^(ac). Bob takes A and computes A^b = g^(ab). Carol takes B and computes B^c = g^(bc). Each one publishes this two-secret value.",
+      "part": "Step 3; paint analogy (step 4: adding your own secret colour to someone else's mixture)",
+      "idea": "Each person 'adds their colour' to a mixture they received and passes it on. Only results go over the channel, never the secrets."
+    },
+    {
+      "step": "Round 3: each person adds their own secret to the two-secret value that is missing it. Alice computes (g^(bc))^a, Bob computes (g^(ac))^b and Carol computes (g^(ab))^c. All three equal g^(abc) mod p, the shared key s.",
+      "part": "Step 3; The protocol ('Since ab = ba, the two values are equal')",
+      "idea": "Every product of a, b and c in any order is the same number, so all three get the same g^(abc). It would then go through a key derivation function, as in 'After the exchange'."
+    },
+    {
+      "step": "What Eve sees: p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ac). None of these is g^(abc).",
+      "part": "The protocol: what Eve knows ('Eve knows p, g, A and B')",
+      "idea": "She has every public message but no secret."
+    },
+    {
+      "step": "Combining public values doesn't help her. Multiplying them only adds exponents, for example g^(ab) · g^c = g^(ab+c), which is not g^(abc). This is the 'too much yellow' wrong colour.",
+      "part": "The protocol ('Multiplying A by B gives her g^(a+b), not g^(ab)'); paint analogy (mixing orange and green gives the wrong colour)",
+      "idea": "Putting public values together gives sums of exponents. The key needs a product of all three secrets."
+    },
+    {
+      "step": "To make g^(abc), Eve would have to raise some public value such as g^(ab) to a missing secret like c. Getting c from g^c (or a from g^a, and so on) is a discrete logarithm problem, which can't be done in practice for a well-chosen ~2048-bit p. The page's brute-force control shows the search only works for tiny p.",
+      "part": "The hard direction (discrete logarithm problem); index.html 'Run Eve's brute-force search' button and its scale note; Summary bullet 3",
+      "idea": "Undoing g^x mod p is infeasible at real sizes. The work doubles with each extra bit, while the honest parties' work only grows with the number of bits."
+    },
+    {
+      "step": "Limits: this protects only against someone who listens. With three people there are more messages that someone like Mallory could swap, so every public value would need to be authenticated, for example with signatures and certificates.",
+      "part": "The catch: Eve who only listens vs. Mallory who interferes",
+      "idea": "Diffie–Hellman alone does not prove who sent a value. Someone who swaps messages can break it unless the messages are authenticated."
+    }
+  ],
+  "result": "Alice, Bob and Carol each keep a secret (a, b, c) and publish g^a, g^b and g^c mod p. Next, in a ring, each raises the value they received to their own secret and publishes the result: g^(ac), g^(ab) and g^(bc). Finally, each raises the two-secret value that lacks their secret to their own secret. Alice computes (g^(bc))^a, Bob computes (g^(ac))^b and Carol computes (g^(ab))^c. All three get g^(abc) mod p, because exponents multiply in any order. Eve sees only g^a, g^b, g^c, g^(ab), g^(bc) and g^(ac). Multiplying these only adds exponents and never gives abc. To get g^(abc) she would have to recover one of the missing secrets from its public power, which is a discrete logarithm and can't be done in practice for a large, well-chosen p. One caveat: the explanation only says this hardness 'appears to' hold for the two-person case. That it holds for three people is my extension by the same reasoning, not something the text proves. As with two people, this is safe only against listening. Stopping someone who swaps messages needs authentication.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/principles.json
new file mode 100644
index 0000000..a5602cb
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/principles.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "All three agree in public on p and g (e.g. p = 23, g = 5) and each picks a private exponent that is never sent: a for Alice, b for Bob, c for Carol (e.g. a = 6, b = 15, c = 3).",
+      "part": "Summary, points 1–2; 'The working method' table, step 1",
+      "idea": "The public settings p and g can be shared openly. Each person's private number stays at home."
+    },
+    {
+      "step": "Round 1: each person broadcasts g^(own private number) mod p. With the example numbers that is A = 5^6 mod 23 = 8, B = 5^15 mod 23 = 19 and C = 5^3 mod 23 = 10.",
+      "part": "'The working method' table, step 2; Mallory section (5^3 mod 23 = 10)",
+      "idea": "A public value is g raised to the private exponent, mod p. It is quick to compute and hard to undo."
+    },
+    {
+      "step": "Target: the shared key will be g^(a×b×c) mod p. Raising a public value to your own exponent adds your exponent to the product in the exponent, and the order does not matter.",
+      "part": "'Why the two results are equal'",
+      "idea": "(g^b)^a = (g^a)^b = g^(ab), and taking mod p at each step does not change this. The same rule applies again: (g^(ab))^c = g^(abc)."
+    },
+    {
+      "step": "Round 2: each person raises a neighbour's public value to their own exponent and broadcasts the result. Bob sends A^b = g^(ab) = 8^15 mod 23 = 2. Carol sends B^c = g^(bc) = 19^3 mod 23 = 5. Alice sends C^a = g^(ca) = 10^6 mod 23 = 6.",
+      "part": "Step 3; 'The working method' table, step 3; Mallory section (10^6 mod 23 = 6)",
+      "idea": "Combining a received value with your own exponent is the same operation used in the two-person method. Here the result is passed on instead of kept."
+    },
+    {
+      "step": "Final step: each person raises the round-2 value that is missing their own exponent to that exponent. Alice computes 5^6 mod 23 = 8. Bob computes 6^15 mod 23 = 8. Carol computes 2^3 mod 23 = 8. All three get 8 = g^(abc) mod 23.",
+      "part": "Steps 3–4; 'Why the two results are equal'",
+      "idea": "Because exponents can be applied in any order, all three reach the same g^(abc)."
+    },
+    {
+      "step": "What Eve sees: p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). She never sees a, b, c or g^(abc). Every value she sees is missing at least one person's exponent.",
+      "part": "'The working method' (Eve saw only the public values); 'First attempt' (never send the secret itself)",
+      "idea": "Only public values go over the channel. The secret itself is never sent."
+    },
+    {
+      "step": "To add the missing exponent herself, Eve would have to recover one of a, b or c from a public value such as g^a mod p. That is the discrete logarithm problem.",
+      "part": "'Why Eve cannot do the same'",
+      "idea": "Getting an exponent back from g^x mod p means solving a discrete logarithm. With p = 23 she can try all exponents, but for a 2048-bit p the best known methods need about 2^112 operations."
+    },
+    {
+      "step": "So the method is safe against Eve only if p is large, and it still rests on an unproven assumption. It does not protect against an attacker who changes messages.",
+      "part": "'Why Eve cannot do the same' (size of p, epistemic status); 'Where the guarantee breaks'",
+      "idea": "Security depends on the size of p and on the assumption that discrete logs are hard. Messages also need authentication, or a man in the middle can take part in the exchange."
+    }
+  ],
+  "result": "They use two public rounds. In round 1, each person broadcasts g^x mod p using their own private x. In round 2, each person raises one neighbour's value to their own exponent and broadcasts the result: Bob sends g^(ab), Carol sends g^(bc) and Alice sends g^(ca). Then each person raises the value that lacks their own exponent to that exponent, so all three get g^(abc) mod p. With p = 23, g = 5, a = 6, b = 15 and c = 3, the key is 8. Eve sees g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca), and each of these is missing at least one exponent. To finish the key she would need a private exponent, which means solving a discrete logarithm. That is infeasible for a large p, though it is an assumption, not a proof. One point is stretched: the explanation says only for two people that Eve 'needs a or b'. It does not show that combining several public values (for example g^(ab) with g^c) gives Eve no shortcut. I extend its claim to three people here. As in the two-person case, the public values must be authenticated to stop a man-in-the-middle attack.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/published.json
new file mode 100644
index 0000000..34f0edd
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/published.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "Everyone, Eve included, knows the public p and g. Each of Alice, Bob and Carol picks a private number (a, b, c) and never sends it.",
+      "part": "The exchange, with small numbers (steps 1–2); The problem (each side needs its own private number)",
+      "idea": "The key is never sent. Each person keeps a random private exponent and agrees only p and g in public."
+    },
+    {
+      "step": "Round 1: each person publishes g^own mod p. Alice sends A = g^a, Bob sends B = g^b, Carol sends C = g^c (all mod p).",
+      "part": "The exchange, with small numbers (step 3)",
+      "idea": "A public number is g raised to the private number, mod p. With p=23, g=5, a=6, b=15, it gives A=8 and B=19. I add c=3, which gives C=5^3 mod 23=10 (the same number Mallory sends in the attack section)."
+    },
+    {
+      "step": "Round 1, second half: arrange the three in a ring. Each raises the previous person's public number to their own private number. Bob gets A^b = g^(ab). Carol gets B^c = g^(bc). Alice gets C^a = g^(ca). Each publishes the result.",
+      "part": "The exchange, with small numbers (step 4); Why both get 2",
+      "idea": "Raising someone's public number to your private number multiplies the exponents: (g^x)^y = g^(xy). Taking remainders along the way does not change the final remainder. Using the explanation's own numbers: 8^15 mod 23 = 2 = g^(ab), 19^3 mod 23 = 5 = g^(bc), and 10^6 mod 23 = 6 = g^(ca)."
+    },
+    {
+      "step": "Round 2: each raises the two-exponent number they receive to their own private number. Carol computes (g^(ab))^c, Alice computes (g^(bc))^a, and Bob computes (g^(ca))^b. All three equal g^(abc) mod p, the shared secret.",
+      "part": "Why both get 2 (exponent rule); step 3",
+      "idea": "The same exponent rule, used a second time, gives one product of all three exponents whatever the order. In the example, Carol gets 2^3 = 8, Alice gets 5^6 mod 23 = 8 (the table lists 8 for exponent 6), and Bob's 6^15 mod 23 must also be 8 because it equals 5^(6·15·3). All of them hash s=8 into the key."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca), but none of a, b, c or g^(abc).",
+      "part": "What Eve sees (the table); steps 2–4",
+      "idea": "The table extends to three people. Only the private numbers and the final s are never sent."
+    },
+    {
+      "step": "Combining public numbers does not give Eve the secret. Multiplying them adds exponents, but s needs the product a·b·c.",
+      "part": "What Eve sees (multiplying fails)",
+      "idea": "8×19 gives g^(a+b), not g^(ab). In the same way, multiplying any of the six public values gives g to a sum of exponents, never g^(abc)."
+    },
+    {
+      "step": "Getting s means solving a two-person problem Eve already can't solve. Take g^(ab) and g^c: they look exactly like a two-party exchange with private numbers ab and c, and s = g^((ab)·c).",
+      "part": "What Eve sees (no known way from A and B to s except finding a or b); Why powers, and why mod; Why real numbers are huge",
+      "idea": "To go further, Eve must in effect find an exponent from a public number. That is the discrete logarithm, which has no known fast method for a 2048-bit p (about 2^112 operations)."
+    },
+    {
+      "step": "Limits: this rests on an assumption, and it only stops a reader.",
+      "part": "Assumption, not proof; The limit: an attacker who changes messages",
+      "idea": "Hardness is not proven, and the explanation does not discuss whether having six public values instead of two helps Eve. Mallory, who can replace messages, could still sit in the middle unless the messages are authenticated."
+    }
+  ],
+  "result": "They use two rounds over a ring Alice→Bob→Carol→Alice. First, each person publishes g^own mod p. Next, each raises the previous person's public number to their own private number and publishes that (g^(ab), g^(bc), g^(ca)). Finally, each raises the number they receive to their own private number. All three get s = g^(abc) mod p and hash it into the key. With p=23, g=5, a=6, b=15, c=3, everyone gets 8. Eve sees only g to single exponents and g to pairs of exponents. Multiplying these adds exponents and never gives the triple product. Getting g^(abc) from g^(ab) and g^c is the same as the two-person Diffie–Hellman problem, which in effect needs a discrete logarithm. No fast method for that is known for large p. This is an unproven assumption, and it gives no protection against an attacker who changes messages unless they are authenticated.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/quick.json
new file mode 100644
index 0000000..06256c9
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/key-exchange/quick.json
@@ -0,0 +1,46 @@
+{
+  "steps": [
+    {
+      "step": "All three agree in public on p and g (for example p = 23, g = 5). Each person picks a private number and never sends it: Alice a, Bob b, Carol c (for example a = 6, b = 15, c = 3).",
+      "part": "How it works, steps 1–2",
+      "idea": "p and g are public and Eve knows them too. Each person's private number stays secret."
+    },
+    {
+      "step": "Round 1: each person sends their public value g^x mod p. Alice sends g^a, Bob sends g^b, Carol sends g^c. In the example these are 8, 19 and 5^3 mod 23 = 10.",
+      "part": "How it works, step 3",
+      "idea": "A public value is g raised to your private number, mod p, and you send it openly."
+    },
+    {
+      "step": "Raising someone else's public value to your own private number adds your exponent to theirs: (g^b)^a = g^(ab). Doing it again adds a third exponent: (g^(ab))^c = g^(abc). The order makes no difference.",
+      "part": "How it works, paragraph after step 4",
+      "idea": "Order does not matter: (g^b)^a = (g^a)^b = g^(ab). I apply the same rule one more time to get three exponents."
+    },
+    {
+      "step": "Round 2, passed around in a ring: Alice raises Bob's g^b to a and sends g^(ab) to Carol. Bob raises Carol's g^c to b and sends g^(bc) to Alice. Carol raises Alice's g^a to c and sends g^(ca) to Bob. Example: Alice sends 19^6 mod 23 = 2.",
+      "part": "Steps 2–3; How it works, step 4",
+      "idea": "This is the same step as in the two-person method, done once more on a value that already carries two exponents. The results g^(ab), g^(bc) and g^(ca) are sent in public."
+    },
+    {
+      "step": "Each person raises what they received to their own private number. Carol gets (g^(ab))^c, Alice gets (g^(bc))^a, Bob gets (g^(ca))^b. All three equal g^(abc) mod p, which is the shared key, and nobody ever sends it. Example: Carol computes 2^3 mod 23 = 8, and Alice gets 5^(6·45) mod 23, which also comes to 8.",
+      "part": "Step 3",
+      "idea": "Every path multiplies all three private numbers into the exponent, so all three people get the same key."
+    },
+    {
+      "step": "Eve sees p, g, g^a, g^b, g^c, g^(ab), g^(bc) and g^(ca). To raise any of these to the missing private number, she would first have to recover a, b or c from a public value such as g^c mod p = 10. That is the discrete logarithm problem.",
+      "part": "Why Eve fails, paragraph 1",
+      "idea": "Getting a private number back from g^x mod p is the discrete logarithm, which is what blocks Eve."
+    },
+    {
+      "step": "Eve also cannot just combine the public values. Multiplying g^(ab) by g^c gives g^(ab+c), not g^(abc). Every value she sees has at most two of the three exponents.",
+      "part": "Why Eve fails, final paragraph",
+      "idea": "Multiplying public values adds exponents; it does not multiply them, so it does not give the key."
+    },
+    {
+      "step": "With a large p (2048 bits), solving the discrete logarithm takes about 2^112 operations, while the honest users still compute quickly. This rests on two assumptions: the hardness is assumed, not proven, and Eve can only read messages. Anyone who can replace messages could use the man-in-the-middle attack, so the public values need authentication.",
+      "part": "Why Eve fails, paragraph 2; Limits",
+      "idea": "p must be large. Security depends on discrete logs being hard and on an eavesdropper who only reads."
+    }
+  ],
+  "result": "Each person picks a secret number (a, b, c) and sends g^x mod p. In a second round, each one raises the value from the next person to their own secret and passes it on: g^(ab) goes to Carol, g^(bc) to Alice, g^(ca) to Bob. Each then raises what they received to their own secret, and all three get g^(abc) mod p. In the example with p = 23, g = 5 and secrets 6, 15, 3, the key is 8. Eve sees only values with at most two of the exponents: g^a, g^b, g^c, g^(ab), g^(bc), g^(ca). To add the third exponent she would need a secret number, which means solving a discrete logarithm; that is infeasible for a 2048-bit p. Multiplying the public values only adds exponents, so it does not help her. This assumes Eve can only read; the public values must be authenticated against someone who can replace messages.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/none.json
new file mode 100644
index 0000000..34677d1
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a read to see the latest committed write, every possible read group has to share at least one server with every possible write group. That shared server holds the write and reports it to the reader.",
+      "part": "Why a majority, and not \"whoever is still up\"? (the paragraph after 'Two majorities of the same group always share at least one member')",
+      "idea": "Safety comes from groups overlapping. Because any two quorums share a member, every decision is seen by at least one server that took part in the earlier decision, and that server keeps later actions consistent with earlier ones."
+    },
+    {
+      "step": "Two groups of sizes W and R, taken from n servers, must overlap whenever W + R > n.",
+      "part": "Why a majority, and not \"whoever is still up\"? (the counting argument: 'together they would contain more than all of them, which is impossible unless some server is in both')",
+      "idea": "If two groups together contain more servers than exist, some server must be in both. The explanation uses this for two majorities, but the same counting works for any two sizes. If W + R ≤ n, the two groups can be picked with no server in common, and the read could miss the write."
+    },
+    {
+      "step": "With n = 5, the condition is W + R > 5, which means W + R ≥ 6. Writes also need to overlap each other, so that two writes can't both commit on separate sides of a split: W + W > 5, which means W ≥ 3.",
+      "part": "Step 2; 'The setting' and the split-brain paragraph",
+      "idea": "Applying the overlap count to read–write pairs gives R + W > n. Applying it to write–write pairs stops two sides from both accepting conflicting writes (split brain)."
+    },
+    {
+      "step": "W = 4 and R = 2 meet the conditions: 4 + 2 = 6 > 5, and 2·4 = 8 > 5.",
+      "part": "Step 3",
+      "idea": "Plugging the numbers into the conditions."
+    },
+    {
+      "step": "A group of size q can still form as long as at least q servers are up, so it survives n − q failures.",
+      "part": "Now count ('failures tolerated = n − quorum size')",
+      "idea": "Failures tolerated equals the total number of servers minus the size of the group that must still be reachable."
+    },
+    {
+      "step": "Writes survive 5 − 4 = 1 failure. Reads survive 5 − 2 = 3 failures.",
+      "part": "Step 5",
+      "idea": "Applying n − q separately to the write group size and the read group size."
+    }
+  ],
+  "result": "W and R must satisfy W + R > 5, so W + R ≥ 6, which makes every read group share a server with every write group. To keep two writes from both committing, W must also be more than half: 2W > 5, so W ≥ 3. With W = 4 and R = 2, both conditions hold. Writes survive 1 failure (5 − 4) and reads survive 3 failures (5 − 2).",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/principles.json
new file mode 100644
index 0000000..c705600
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "For a read to see the latest committed write, the read group must share at least one server with the write group that accepted that write. That shared server holds the latest write and passes it to the reader.",
+      "part": "The fix: any two deciding groups must share a server",
+      "idea": "Two deciding groups that share a server cannot act independently, because the shared server links them. Here I apply that idea to one write group and one read group."
+    },
+    {
+      "step": "Two groups inside n servers must overlap when their sizes add up to more than n. With a write group of W and a read group of R in 5 servers, every read overlaps every committed write when W + R > 5, which is the same as W + R ≥ 6.",
+      "part": "The fix: any two deciding groups must share a server (the line 'must overlap when their sizes add up to more than n')",
+      "idea": "The overlap condition depends only on the sum of the two group sizes. The page uses it for two groups of equal size q (q + q > n), and I use it here with two different sizes."
+    },
+    {
+      "step": "Two writes must not both be accepted when they conflict, so any two write groups must also overlap. That needs W + W > 5, so W ≥ 3.",
+      "part": "The fix: any two deciding groups must share a server; Why 'half' is not enough",
+      "idea": "If two deciding groups can fit side by side with no overlap, split brain becomes possible. For a store that takes conflicting writes, this sets a lower limit on W."
+    },
+    {
+      "step": "Check W = 4 and R = 2. W + R = 6 > 5, so every read overlaps the latest write. Also 4 + 4 = 8 > 5, so write groups overlap each other too.",
+      "part": "Steps 2 and 3",
+      "idea": "Put the numbers into both overlap conditions."
+    },
+    {
+      "step": "An operation can still go ahead while at least as many servers are alive as its group needs. So it survives (n minus group size) failures.",
+      "part": "From quorum to failure tolerance (f = n − q); What 'survive' means, and where it stops",
+      "idea": "Failures tolerated equals the total number of servers minus the number of live servers the group needs."
+    },
+    {
+      "step": "Writes survive 5 − 4 = 1 failure. Reads survive 5 − 2 = 3 failures.",
+      "part": "Step 5",
+      "idea": "Apply f = n − q to each group size separately."
+    }
+  ],
+  "result": "For every read to see the latest committed write, W + R > 5, so W + R ≥ 6. If writes can conflict, two write groups must also overlap, which needs 2W > 5, so W ≥ 3. With W = 4 and R = 2 both conditions hold: 4 + 2 = 6 > 5 and 2 × 4 = 8 > 5. Writes survive 1 failure (5 − 4) and reads survive 3 failures (5 − 2). The explanation only covers two groups of equal size q, so I applied its general rule (overlap whenever the sizes add up to more than n) to groups of different sizes.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/published.json
new file mode 100644
index 0000000..d995248
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/published.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Set up the problem: a write is committed once W of the 5 servers accept it. A read asks R servers. To see the latest committed write, the read group must include at least one server that accepted that write.",
+      "part": "The rule (definitions of accept, decided, quorum, quorum size)",
+      "idea": "A change is final once a group of the required size has accepted it and stored it on disk. Each server in that group holds the change."
+    },
+    {
+      "step": "Any two groups whose sizes add up to more than n must share a server. So if W + R > 5, every read group overlaps every write group.",
+      "part": "Why more than half works (the overlap paragraph: 3 + 3 = 6 > 5, so C is in both)",
+      "idea": "The counting argument is general. If two groups together list more than n servers, at least one server has to appear in both. The explanation uses it for two majorities, and the same counting works for groups of sizes W and R."
+    },
+    {
+      "step": "The condition is W + R > n, so W + R ≥ 6 for n = 5. If W + R ≤ 5, the two groups can be disjoint and the read can miss the write.",
+      "part": "Why not let the survivors go on (two groups of 2 among 4 need not share a server)",
+      "idea": "When the sizes add up to n or less, two groups can be chosen with no server in common, as {A,B} and {C,D} are in the split-brain table."
+    },
+    {
+      "step": "The shared server holds the committed write and can pass it to the read group. This is only partly supported: the explanation says it does not cover how reads work, so I assume the reader takes the newest value it receives.",
+      "part": "Limits (Simplified bullet: the shared server reports x = 1 to the new group; Not covered: how reads work)",
+      "idea": "The server in the overlap passes on the decided value. How a reader picks the newest value from the replies is not explained."
+    },
+    {
+      "step": "Two writes must not both be decided for the same position, so two write groups must also overlap: 2W > 5. W = 4 satisfies this (8 > 5).",
+      "part": "Why more than half works / Why not let the survivors go on",
+      "idea": "Two groups that need not share a server can decide different changes (split brain). Overlap between them prevents this."
+    },
+    {
+      "step": "Check W = 4, R = 2: 4 + 2 = 6 > 5, so every read overlaps the latest committed write.",
+      "part": "Step 3",
+      "idea": "Apply the condition W + R > n."
+    },
+    {
+      "step": "Failures survived = n − group size. Writes: 5 − 4 = 1. Reads: 5 − 2 = 3.",
+      "part": "Counting failures (tolerance = n − majority size; the cluster stops when fewer than a quorum answer)",
+      "idea": "An operation that needs k servers can go ahead as long as k servers still answer, so it survives n − k failures. Here k is W for writes and R for reads, not the majority size."
+    }
+  ],
+  "result": "W and R must satisfy W + R > 5 (so W + R ≥ 6), so that every read group shares a server with every write group. To stop two writes from both being decided, the write groups must also overlap: 2W > 5. With W = 4 and R = 2 (4 + 2 = 6 > 5), writes survive 5 − 4 = 1 failure and reads survive 5 − 2 = 3 failures. One assumption is not covered by the explanation: that a reader recognises and takes the newest value among the replies it gets.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/quick.json
new file mode 100644
index 0000000..a1a3848
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/quorum/quick.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Every decision needs a group of servers to agree, and a server that does not reply counts as a failure. The cluster keeps working while at least a quorum of servers can reply, so it tolerates (servers − quorum) failures.",
+      "part": "The setup (the tolerance paragraph and the 5-server and 4-server examples)",
+      "idea": "The number of failures survived equals the total number of servers minus the size of the group that must reply."
+    },
+    {
+      "step": "Safety comes from overlap. Two groups of sizes a and b can fit inside n servers without sharing a server only if a + b ≤ n. If a + b > n, they must share at least one server.",
+      "part": "Why the quorum must be a majority (the paragraph on 2q ≤ n vs 2q > n)",
+      "idea": "The explanation proves this for two groups of the same size q. Counting servers works the same way when the two groups have different sizes; that step is plain arithmetic."
+    },
+    {
+      "step": "For a read to see the latest committed write, every read group must share at least one server with every write group. That shared server holds the write. So W + R > 5, which means W + R ≥ 6.",
+      "part": "Step 2, plus 'Any two majorities then share at least one server' in Why the quorum must be a majority",
+      "idea": "The shared server links the two groups. Here the pair is a read group and a write group instead of two decision groups. The explanation only says this server refuses conflicting decisions; that it gives the read the latest value is my inference."
+    },
+    {
+      "step": "Two write groups must also overlap, or split brain could happen between writes: W + W > 5, so W ≥ 3.",
+      "part": "Why the quorum must be a majority (the split-brain paragraph)",
+      "idea": "Two separate groups that each make a decision can commit conflicting values."
+    },
+    {
+      "step": "Check W = 4 and R = 2: 4 + 2 = 6 > 5, so reads and writes overlap. 4 + 4 = 8 > 5, so writes overlap with each other.",
+      "part": "Steps 3 and 4",
+      "idea": "Both overlap conditions hold."
+    },
+    {
+      "step": "Failures survived: writes 5 − 4 = 1, reads 5 − 2 = 3.",
+      "part": "Step 1 (the tolerance paragraph in The setup)",
+      "idea": "For each operation, failures tolerated = servers − size of the group needed."
+    }
+  ],
+  "result": "W and R must satisfy W + R > 5 (that is, W + R ≥ 6) so that every read group overlaps every write group. Writes should also satisfy 2W > 5 so that two writes cannot conflict. With W = 4 and R = 2, both conditions hold. Writes survive 5 − 4 = 1 failure, and reads survive 5 − 2 = 3 failures.",
+  "gap": "The explanation never talks about separate read and write groups. It proves the overlap rule only for two groups of the same size, so I extended it to W + R > n with arithmetic. It also never says that the shared server lets a read see the latest write; I inferred that from 'any two majorities share at least one server'."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/none.json
new file mode 100644
index 0000000..ba800a6
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/none.json
@@ -0,0 +1,41 @@
+{
+  "steps": [
+    {
+      "step": "Spring and neap tides come from the Sun's pair of bulges adding to the Moon's pair. Quarter moons, when the Sun and Moon are at right angles, give the smaller neap tides.",
+      "part": "Section 6, 'The Sun does the same thing, more weakly' (second paragraph)",
+      "idea": "At new and full moon the two pairs of bulges line up and add, giving spring tides. At the quarter moons the Sun's bulges partly fill in the Moon's lows, giving neap tides."
+    },
+    {
+      "step": "The Sun's tidal effect is about 0.46 times the Moon's.",
+      "part": "Section 6, first paragraph; the Summary ('about 2 to 1')",
+      "idea": "Tidal effect goes as mass/distance³, so the Sun's tide is about 46% of the Moon's."
+    },
+    {
+      "step": "For the Moon alone, the tide is +0.36 m under the bulges and −0.18 m at 90° from them.",
+      "part": "Section 4, equilibrium tide paragraph; index.html script, height(): AM=0.36 with the shape (1.5cos²−0.5)",
+      "idea": "Each body's tide is +A along its own line and −A/2 at right angles to it, where A is the amplitude."
+    },
+    {
+      "step": "The page uses a Sun amplitude of 0.165 m, which is about 0.46 × 0.36. So the Sun's tide is +0.165 m on the Sun line and about −0.0825 m at right angles to it.",
+      "part": "index.html script: AS=0.165, added in height() at the angle given by sunAngle(); steps 2 and 3",
+      "idea": "The Sun's tide has the same shape, lined up with the Sun's direction, and the two heights simply add."
+    },
+    {
+      "step": "Spring tide (Sun lined up with Moon): high = 0.36 + 0.165 = 0.525 m, low = −0.18 − 0.0825 = −0.2625 m. The range is about 0.79 m.",
+      "part": "Steps 3 and 4; the phase slider in section 4 of index.html (days = 0 or 14.8)",
+      "idea": "When the Sun and Moon are lined up, both highs fall in the same place and both lows fall in the same place."
+    },
+    {
+      "step": "Neap tide (Sun at 90°): under the Moon the height is 0.36 − 0.0825 = 0.2775 m. At 90° from the Moon it is −0.18 + 0.165 = −0.015 m. The range is about 0.29 m.",
+      "part": "Steps 3 and 4; Section 6 ('the Sun's bulges partly fill in the Moon's lows'); the phase slider at about 7.4 or 22 days",
+      "idea": "The Sun's high falls where the Moon's low is, and the Sun's low falls where the Moon's high is, so they partly cancel."
+    },
+    {
+      "step": "Neap range ÷ spring range = 0.2925 ÷ 0.7875 ≈ 0.37. This equals (1 − 0.46)/(1 + 0.46) = 0.54/1.46.",
+      "part": "Steps 5 and 6; background arithmetic",
+      "idea": "Dividing the two ranges gives the ratio."
+    }
+  ],
+  "result": "At the quarter moons you get neap tides, which are the smallest of the month. In the idealised whole-planet ocean, the range from high to low is roughly 0.29 m, compared with about 0.79 m at spring tides. That makes neap tides only about 37% of spring tides, a bit over a third, or (1−0.46)/(1+0.46). Put another way, a neap tide is about half the size of the Moon's tide alone, and a spring tide is about 1.5 times it. Real coasts change these figures (section 7).",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/principles.json
new file mode 100644
index 0000000..127a6ba
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Each body stretches the water into two bulges along the line to that body, and squeezes it at the points 90° away from that line.",
+      "part": "Step 2: compute the pull at three points (the bulge/squeeze diagram and the paragraph on the sides at 90°)",
+      "idea": "The tidal acceleration is outward at the near and far sides and inward at the sides 90° away, so water flows from the squeezed sides to the stretched ends."
+    },
+    {
+      "step": "The size of a tide (bulge minus squeeze) grows with the tidal acceleration.",
+      "part": "Step 3: what the number means",
+      "idea": "A larger tidal acceleration gives taller bulges. The ideal ocean's difference of about 0.5 m between bulge and squeeze is set by how strong the tidal pull is."
+    },
+    {
+      "step": "The Sun's tidal effect is about 0.46 of the Moon's, and it works the same way.",
+      "part": "The Sun does the same thing",
+      "idea": "Tides depend on M/d³. For the Sun this comes to about 46% of the Moon's effect, made by the same two-bulge mechanism."
+    },
+    {
+      "step": "Spring tides: with the Sun and Moon lined up, the bulges sit in the same places and add. Size ≈ 1 + 0.46 = 1.46 times the Moon's tide alone.",
+      "part": "The Sun does the same thing; steps 1–3",
+      "idea": "When the Sun and Moon line up, their bulges add, giving spring tides."
+    },
+    {
+      "step": "Quarter Moons: with the Sun at 90°, the Sun's bulges fall where the Moon squeezes the water, and the Sun's squeeze falls on the Moon's bulges. So the two effects subtract: size ≈ 1 − 0.46 = 0.54 times the Moon's tide alone.",
+      "part": "The Sun does the same thing ('partly cancel'); step 1",
+      "idea": "At 90° the two patterns are offset by a quarter turn, so the Sun lowers the Moon's bulges and fills in its lows. This gives small neap tides."
+    },
+    {
+      "step": "Ratio of neap to spring: 0.54 / 1.46 ≈ 0.37.",
+      "part": "steps 4 and 5; background (arithmetic)",
+      "idea": "Divide the two combined sizes."
+    }
+  ],
+  "result": "At the quarter Moons you get neap tides. Their range is about (1 − 0.46)/(1 + 0.46) ≈ 0.37 of a spring tide's range, so a bit more than a third. Put another way, spring tides are about 2.7 times larger. In the ideal ocean that would be roughly 0.5 × 0.54 ≈ 0.27 m against 0.5 × 1.46 ≈ 0.73 m, if the explanation's ~0.5 m is the Moon's effect alone. This is the idealized model; real coasts differ.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/published.json
new file mode 100644
index 0000000..4c51f6a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/published.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "The Sun's tidal acceleration is about 0.46 times the Moon's, so solar tides are about half the size of lunar tides.",
+      "part": "Why subtract: two tests (second test, the Sun)",
+      "idea": "Tidal acceleration is roughly the pull times 2R/d. The Sun pulls 179 times harder than the Moon but is 389 times farther away, so its tidal effect is 179/389 ≈ 0.46 of the Moon's. Observed solar tides are about half the Moon's."
+    },
+    {
+      "step": "Each body stretches the Earth along its own line, so the Sun raises its own pair of bulges on the Earth–Sun line.",
+      "part": "Only the part that differs from the centre's pull acts (side-point paragraph); How a tiny acceleration moves an ocean",
+      "idea": "The tidal acceleration stretches the Earth along the line to the attracting body and squeezes it across that line. The water gathers into two bulges on that line, with low water at the 90° side points."
+    },
+    {
+      "step": "At quarter Moon the Sun's line is at 90° to the Moon's line. So where the Moon makes high water, the Sun makes low water, and the two effects work against each other.",
+      "part": "Step 2, with the question's statement that the Sun and Moon are at right angles",
+      "idea": "The Moon's bulge points sit at the Sun's side points, where the Sun squeezes instead of stretching. This suggests a reduced tide of roughly 1 − 0.46 of the Moon's tide, compared with 1 + 0.46 when the Sun and Moon line up."
+    },
+    {
+      "step": "Compare with spring tides.",
+      "part": "none: the explanation never mentions spring tides",
+      "idea": "The explanation does not define spring tides. It also never says that the Sun's and Moon's tides add together, or how they combine at an angle. So it does not support the comparison the question asks for."
+    }
+  ],
+  "result": "",
+  "gap": "The explanation does not define spring tides. It also never says how the Sun's and Moon's bulges combine: that they add when the two bodies line up and partly cancel when they are at right angles. It only gives the Sun's tide as about 0.46 of the Moon's. If you assume the tides simply add, the quarter-Moon tides would be about (1 − 0.46)/(1 + 0.46) ≈ 0.37 of spring tides. But both that assumption and the meaning of 'spring tide' have to come from outside the explanation."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/quick.json
new file mode 100644
index 0000000..65ccf00
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/two-tides/quick.json
@@ -0,0 +1,26 @@
+{
+  "steps": [
+    {
+      "step": "The Moon raises a pair of bulges along the Earth–Moon line.",
+      "part": "Only the difference in pull moves water (bullets and diagram)",
+      "idea": "The near side is pulled more than Earth's centre and the far side less, so one bulge points toward the Moon and one points away."
+    },
+    {
+      "step": "The Sun raises a weaker pair of bulges, 0.46 the size of the Moon's.",
+      "part": "Evidence that the difference is what counts: the Sun",
+      "idea": "Solar tides are 0.46 of lunar tides, because tidal acceleration falls off as 1/d³."
+    },
+    {
+      "step": "The two pairs of bulges combine, and how much depends on where the Sun is relative to the Moon.",
+      "part": "Limits, 'Not covered' bullet",
+      "idea": "With spring and neap tides, the Sun's smaller pair of bulges adds to the Moon's or partly cancels it. The explanation names this effect but says it does not cover it."
+    },
+    {
+      "step": "Try to say what happens at right angles.",
+      "part": "Steps 1–3",
+      "idea": "At quarter Moon the Sun's bulge line is 90° from the Moon's. The explanation never says where low water sits relative to the bulges. It also never says which alignment makes spring tides and which makes neap tides, or how bulges at 90° combine. So I can't establish from the text that the Sun's highs fall on the Moon's lows and cut the tide, rather than add to it."
+    }
+  ],
+  "result": "No firm answer from the explanation. A guess, not supported by the text: if the right-angle position is the 'partly cancels' case and spring tides are the 'adds' case, the tides would be about (1 − 0.46)/(1 + 0.46), roughly 0.37 of spring tides, or about a third. I'm not claiming this, because the needed geometry isn't given.",
+  "gap": "The explanation says outright that spring and neap tides are not covered. It doesn't say that spring tides come when the Sun and Moon line up. It doesn't say that at right angles the Sun's bulges fall where the Moon's low water is, so they partly cancel. And it doesn't say how the two tides combine in size (lunar minus solar, versus lunar plus solar)."
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/none.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/none.json
new file mode 100644
index 0000000..187762e
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/none.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated division, so the number doubles at each step.",
+      "part": "Step 3, 'Amplify: clonal expansion'",
+      "idea": "A selected cell divides about once every 6 to 12 hours for days, so one cell becomes thousands of copies. The question fixes the doubling time at 12 hours."
+    },
+    {
+      "step": "A first infection starts with only a handful of matching cells, while memory after vaccination leaves hundreds to thousands of times more.",
+      "part": "Step 1, 'Each match is rare' bullet; Step 4 table (Naive vs Memory)",
+      "idea": "Naive matching cells are rare. Memory leaves a much larger matching pool. The question sets that factor at 1,000."
+    },
+    {
+      "step": "A vaccine supplies the first encounter, so the real infection begins from the memory-sized pool.",
+      "part": "'So what does a vaccine do?' section",
+      "idea": "The real pathogen meets a secondary response that starts from memory cells, not from the few naive cells."
+    },
+    {
+      "step": "Doublings needed = log2(enough ÷ starting count). Starting with 1,000 times more cells removes log2(1000) ≈ 9.97, or about 10, doublings.",
+      "part": "background (exponential growth and logarithms), applied to steps 1–3",
+      "idea": "log2(N/s) − log2(N/(1000s)) = log2(1000). N cancels out, so the size of 'enough' does not matter."
+    },
+    {
+      "step": "Time saved ≈ 10 doublings × 12 h ≈ 120 h ≈ 5 days.",
+      "part": "4, 1",
+      "idea": "Multiply the doublings saved by the doubling time."
+    },
+    {
+      "step": "Check this against the explanation's timescales.",
+      "part": "Step 4 paragraph after the table, and the antibody-level diagram",
+      "idea": "The primary lag is about 1–2 weeks and the secondary starts within days, so a gap of a few days fits."
+    }
+  ],
+  "result": "About 10 doublings sooner (2^10 ≈ 1000), which is about 10 × 12 h ≈ 120 hours, or roughly 5 days. Getting from a starting count s to a target N takes log2(N/s) doublings. Starting 1,000 times higher changes that by exactly log2(1000) whatever N is, because the target cancels. In multiplicative growth, a head start by a fixed factor always saves the same number of doublings, so it saves the same amount of time.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/principles.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/principles.json
new file mode 100644
index 0000000..82043ca
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/principles.json
@@ -0,0 +1,36 @@
+{
+  "steps": [
+    {
+      "step": "Matching cells grow by repeated doubling, so after d doublings a starting pool S becomes S × 2^d.",
+      "part": "Step 3: the selected cells multiply, then most die (clonal expansion and the worked example)",
+      "idea": "An activated lymphocyte divides again and again, and all its descendants carry the same receptor. The example works this out as 100 × 2^15 ≈ 3.3 million."
+    },
+    {
+      "step": "The number of doublings needed to grow from S to a target N is log2(N/S).",
+      "part": "Step 3, the second-encounter paragraph",
+      "idea": "Going from 164,000 to 3.3 million takes log2(20) ≈ 4.3 doublings. The count depends only on the ratio between the target and the starting pool."
+    },
+    {
+      "step": "A first infection starting from S needs log2(N/S) doublings. After vaccination the start is 1000S, so it needs log2(N/(1000S)) = log2(N/S) − log2(1000) doublings.",
+      "part": "2 + background (logarithm rules)",
+      "idea": "Multiplying the starting pool by 1000 subtracts log2(1000) doublings, whatever N is."
+    },
+    {
+      "step": "The saving is log2(1000) ≈ 9.97, so about 10 doublings.",
+      "part": "3 + background",
+      "idea": "2^10 = 1024 ≈ 1000."
+    },
+    {
+      "step": "With one doubling every 12 hours (the question's figure, not the explanation's 8 hours), 10 doublings take about 120 hours, which is about 5 days.",
+      "part": "4 + question's data",
+      "idea": "Time saved = number of doublings saved × time per doubling."
+    },
+    {
+      "step": "N, the number of cells that counts as 'enough', cancels out of the difference.",
+      "part": "3; Step 3 worked example",
+      "idea": "Both responses must reach the same N. Each response's doubling count is log2(N/start), so the difference is the log of the ratio of the two starting pools, and N drops out. The 1,000× head start is always 10 doublings, wherever the finish line is. This matches the summary's note that the memory pool is about 1000× the naive pool."
+    }
+  ],
+  "result": "In this model the response reaches full strength about 5 days sooner: log2(1000) ≈ 10 doublings × 12 h ≈ 120 h. The answer doesn't depend on what counts as 'enough' because the number of doublings to reach a threshold N is log2(N/start). Subtracting the vaccinated count from the first-infection count leaves log2(1000), and N cancels. A 1,000-fold head start always saves the same 10 doublings. The explanation adds that memory cells also activate more easily, so the real gap is larger than this arithmetic shows.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/published.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/published.json
new file mode 100644
index 0000000..6a0e0e9
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/published.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "The matching cells grow by doubling: start count × 2^n = target, where n is the number of divisions.",
+      "part": "The first meeting is slow (paragraph: 100 × 2^n = 1,000,000)",
+      "idea": "The time to reach a full response is set by how many doublings it takes to get from the starting (precursor) count up to the target number of effector cells."
+    },
+    {
+      "step": "Each doubling of the starting count saves exactly one division.",
+      "part": "What stays behind (the table and 'The rule behind the table')",
+      "idea": "Starting with 100× more cells (10,000 instead of 100) cut 13.3 divisions to 6.6. In general, each doubling of the starting count removes one division."
+    },
+    {
+      "step": "Starting with 1,000× more cells saves log2(1000) ≈ 9.97, so about 10 divisions.",
+      "part": "Step 2 + background",
+      "idea": "1,000 is about 2^10, so 1,000× more starting cells is worth about 10 doublings, and each one saves a division."
+    },
+    {
+      "step": "At 12 hours per division, 10 divisions are about 120 hours, which is about 5 days sooner.",
+      "part": "Step 3 + the question's 12-hour doubling time",
+      "idea": "The time saved is the number of divisions saved times the time per division."
+    },
+    {
+      "step": "The saving does not depend on the target number.",
+      "part": "Step 1 + background (logarithms)",
+      "idea": "n = log2(target/start), so the difference between the two cases is log2(target/start1) − log2(target/start2) = log2(start2/start1) = log2(1000). The target cancels out. Only the ratio of the starting counts matters. The explanation's own table shows this: both cases use the same 1,000,000 target, and the saving still follows from the 100× ratio alone."
+    }
+  ],
+  "result": "In this model the response reaches full strength about 10 doublings sooner, which at 12 hours each is about 120 hours, or about 5 days. The number of doublings needed is log2(enough ÷ starting cells). When you compare the two cases, the 'enough' number cancels out, so the saving is log2(1000) ≈ 10 doublings whatever the target is. This counts only the multiplying stage. Faster activation of memory cells, which the explanation mentions, would save some extra time.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/quick.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/quick.json
new file mode 100644
index 0000000..cc0ad9a
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/pass-3/read/vaccine-memory/quick.json
@@ -0,0 +1,31 @@
+{
+  "steps": [
+    {
+      "step": "The response depends on matching cells multiplying from a starting number up to a working population.",
+      "part": "How it works, item 3 (Clonal expansion)",
+      "idea": "A lymphocyte that binds the antigen and gets an alarm signal starts dividing. Over about a week it becomes a clone of thousands of identical cells, and the clone makes antibodies."
+    },
+    {
+      "step": "Vaccination gives the second response a larger starting number of matching cells, so it reaches full strength sooner.",
+      "part": "How it works, item 4 (Memory cells remain), and the table in 'Why it works: a race'",
+      "idea": "Memory cells leave more matching cells than before (the explanation says 10–100 times; the question uses 1,000 times). Useful antibody then comes after 2–4 days instead of 7–14."
+    },
+    {
+      "step": "Under the question's model, the time to reach a target N from a start S is the number of doublings, log2(N/S), times 12 hours.",
+      "part": "background",
+      "idea": "With doubling growth, the count after k doublings is S·2^k. Reaching N takes k = log2(N/S) doublings."
+    },
+    {
+      "step": "The time saved is 12 h × [log2(N/S) − log2(N/(1000S))] = 12 h × log2(1000), and N cancels out.",
+      "part": "Step 3 (background algebra on logarithms)",
+      "idea": "Both responses must reach the same threshold N, so N drops out of the difference. Only the 1,000-fold head start matters. In other words, the vaccinated response simply skips the first log2(1000) doublings."
+    },
+    {
+      "step": "log2(1000) ≈ 9.97, which is about 10 doublings, so the time saved is about 10 × 12 h = 120 h, or about 5 days.",
+      "part": "Step 4 (background arithmetic: 2^10 = 1024 ≈ 1000)",
+      "idea": "Ten doublings at 12 hours each add up to about 5 days. This roughly fits the explanation's gap between 7–14 days and 2–4 days."
+    }
+  ],
+  "result": "The response reaches full strength about 5 days sooner. A 1,000-fold head start is about 10 doublings (2^10 = 1024), and 10 × 12 h is about 120 h. The threshold doesn't matter because both responses grow by the same doubling until they reach the same 'enough' level. That level cancels when you subtract the two times, so only the ratio of starting numbers (1,000) sets the gap. The vaccinated population is just 10 doublings further along on the same curve. The explanation itself gives only 10–100 times more memory cells, not 1,000, and it never states the doubling model; both of those come from the question.",
+  "gap": ""
+}
\ No newline at end of file
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/source.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/source.json
new file mode 100644
index 0000000..5770998
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/source.json
@@ -0,0 +1 @@
+{"builds": "evals/artifact/results/2026-10-04-dev"}
diff --git a/evals/artifact/results/2026-10-20-dev-rederive/rederive/targets.json b/evals/artifact/results/2026-10-20-dev-rederive/rederive/targets.json
new file mode 100644
index 0000000..36cfc49
--- /dev/null
+++ b/evals/artifact/results/2026-10-20-dev-rederive/rederive/targets.json
@@ -0,0 +1,226 @@
+{
+  "antibiotic-resistance": {
+    "q": "In an infection of 10^10 bacteria, one in 10^8 resists drug A and one in 10^9 resists drug B, by unrelated mutations. Why is giving both drugs together much less likely to end with a resistant infection than giving either alone?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Resistance comes from random mutations that already exist before the drug is used."
+      },
+      {
+        "kind": "block",
+        "text": "A drug kills the susceptible bacteria, and the resistant ones survive and multiply (selection)."
+      },
+      {
+        "kind": "derived",
+        "text": "With unrelated mutations, a bacterium resists both with probability about 10^-8 × 10^-9 = 10^-17."
+      },
+      {
+        "kind": "derived",
+        "text": "The infection holds about 100 cells resistant to A and about 10 resistant to B, which either drug alone would select, but expects only 10^10 × 10^-17 = 10^-7 cells resistant to both, so with both drugs there is almost surely nothing to select."
+      }
+    ],
+    "result": "About 100 A-resistant and 10 B-resistant cells are present, which either drug alone would select, but a double-resistant cell has a probability of about 10^-17 each, so the infection almost surely holds none and the combination leaves no survivors to multiply."
+  },
+  "bloom-filter": {
+    "q": "Two Bloom filters have the same size and the same hash functions; one was built from a set A and the other from a set B. How can you get a filter for A ∪ B without the items, and is it exact? What does a bitwise AND of the two give?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Adding an item sets the k bits its hash functions choose to 1, and bits are never cleared."
+      },
+      {
+        "kind": "derived",
+        "text": "So a bit in a filter is 1 exactly when at least one added item chose it."
+      },
+      {
+        "kind": "derived",
+        "text": "The items of A ∪ B choose exactly the bits chosen by A's items or by B's items, so OR-ing the two arrays gives the same bits as building the filter from A ∪ B: exact."
+      },
+      {
+        "kind": "derived",
+        "text": "AND keeps a bit that one item of A and a different item of B both chose, even when no item in both sets chose it; every item in both sets still has all its bits set, so AND gives a filter for A ∩ B with no false negatives but possibly extra 1s."
+      }
+    ],
+    "result": "OR the bit arrays: the result is exactly the filter built from A ∪ B. AND gives a filter for A ∩ B that never misses a common item but can have extra 1s, so more false positives than one built from A ∩ B."
+  },
+  "float-sum": {
+    "q": "Which of these can a double store exactly: 0.375, 0.2, 0.0625, 0.3? And why does adding 0.125 eight times give exactly 1.0, while adding 0.1 ten times does not?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Floating-point numbers are binary fractions: a value is stored exactly only if it is a fraction whose denominator is a power of 2 (within the available digits)."
+      },
+      {
+        "kind": "block",
+        "text": "0.1 has no finite binary expansion, so it is stored as the nearest double, with a small error."
+      },
+      {
+        "kind": "derived",
+        "text": "0.375 = 3/8 and 0.0625 = 1/16 have power-of-2 denominators and are exact; 0.2 = 1/5 and 0.3 = 3/10 have a factor of 5 in the denominator and are not."
+      },
+      {
+        "kind": "derived",
+        "text": "0.125 = 1/8 and every sum of eighths up to 1 is exact, so eight additions give exactly 1.0; the stored 0.1 carries an error, and the additions round again, so ten of them do not land exactly on 1.0."
+      }
+    ],
+    "result": "Exact: 0.375 and 0.0625; not exact: 0.2 and 0.3. Eighths add exactly to 1.0, but ten copies of the inexact 0.1 sum to a nearby double (0.9999999999999999), not 1.0."
+  },
+  "gps-relativity": {
+    "q": "A receiver's own clock is right, but one of the four satellites it uses has a clock 10 nanoseconds fast that nothing corrects. Roughly how wrong is the distance to that satellite, and why can the receiver's fourth unknown not absorb this error the way it absorbs its own clock error?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "The receiver turns each signal's travel time into a distance: distance = speed of light × travel time, where the travel time is the arrival time minus the send time stamped in the signal."
+      },
+      {
+        "kind": "block",
+        "text": "The receiver's own clock error is a fourth unknown, solved for together with the three coordinates from four distances."
+      },
+      {
+        "kind": "derived",
+        "text": "A satellite clock 10 ns fast stamps its signal 10 ns too late, so that travel time comes out 10 ns short and that one distance about 3 m short (3×10^8 m/s × 10^-8 s)."
+      },
+      {
+        "kind": "derived",
+        "text": "An error in the receiver's clock shifts every distance by the same amount; an error in one satellite's distance alone does not have that form, so solving for the clock error cannot remove it, and it moves the computed position."
+      }
+    ],
+    "result": "About 3 m, in that one distance only; the clock unknown can absorb only an error shared by all the distances, so this one shifts the position fix."
+  },
+  "greenhouse": {
+    "q": "Suppose the atmosphere had the same temperature at every height. What would adding CO2 then do to the surface temperature, and why?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "The Earth radiates to space from the height at which infrared can escape, and adding CO2 raises that height."
+      },
+      {
+        "kind": "block",
+        "text": "Higher air is normally colder and radiates less, so raising the emission height makes the Earth give off less than it takes in until the surface and lower air warm."
+      },
+      {
+        "kind": "derived",
+        "text": "If temperature did not fall with height, the new emission height would be as warm as the old one, so the Earth would give off as much as before."
+      },
+      {
+        "kind": "derived",
+        "text": "With no imbalance between what comes in and what goes out, nothing would have to warm: adding CO2 would not warm the surface."
+      }
+    ],
+    "result": "Nothing: with no drop in temperature with height, raising the emission height does not reduce the outgoing radiation, so there is no imbalance and no warming."
+  },
+  "heat-pump": {
+    "q": "The same machine run in reverse is an air conditioner: it takes heat from the cold inside and gives it to the warm outside. What is its ideal limit on heat removed per unit of electricity, and why is it exactly one less than the heating limit for the same two temperatures?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Energy is conserved: the heat given off on the warm side = the heat taken from the cold side + the electrical work."
+      },
+      {
+        "kind": "block",
+        "text": "The ideal heating limit is COP = T_hot ÷ (T_hot − T_cold), in kelvin."
+      },
+      {
+        "kind": "derived",
+        "text": "The heat taken from the cold side is the heat given off minus the work, so the heat removed per unit of work is the heating COP minus 1."
+      },
+      {
+        "kind": "derived",
+        "text": "T_hot ÷ (T_hot − T_cold) − 1 = T_cold ÷ (T_hot − T_cold)."
+      }
+    ],
+    "result": "COP_cooling = T_cold ÷ (T_hot − T_cold), exactly one less than the heating limit, because the work ends up in the heat given off but not in the heat removed."
+  },
+  "key-exchange": {
+    "q": "Three people, Alice, Bob, and Carol, want one shared secret key, using the same public p and g and sending only messages anyone can read. How can they do it, and why does an eavesdropper still not get the key?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Each person keeps a secret exponent and can raise any number they receive to it, mod p."
+      },
+      {
+        "kind": "block",
+        "text": "Exponents multiply and their order does not matter: (g^a)^b = (g^b)^a = g^(ab) mod p."
+      },
+      {
+        "kind": "block",
+        "text": "Recovering an exponent from g^x mod p (the discrete logarithm) is infeasible for large p."
+      },
+      {
+        "kind": "derived",
+        "text": "So the key can be g^(abc): each person needs g raised to the product of the other two secrets, which can be built by passing values around (Alice sends g^a to Bob, who sends g^(ab) to Carol, and likewise from each starting person), and then raises it to their own secret."
+      },
+      {
+        "kind": "derived",
+        "text": "The eavesdropper sees only values like g^a and g^(ab); getting g^(abc) needs one of the secret exponents, which means solving a discrete logarithm."
+      }
+    ],
+    "result": "Each computes g^(abc) mod p by raising a public value g^(product of the other two secrets), built by passing values around, to their own secret; the eavesdropper sees only values like g^a and g^(ab), and undoing them needs a discrete logarithm."
+  },
+  "quorum": {
+    "q": "A five-server store uses a write group of W servers and a read group of R servers, not necessarily majorities. What must W and R satisfy for every read to see the latest committed write, and with W = 4 and R = 2, how many failures can writes and reads each survive?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "A write is committed when a group of servers acknowledges it."
+      },
+      {
+        "kind": "block",
+        "text": "Majorities are used because any two majorities share at least one server, so the next group always sees every committed write."
+      },
+      {
+        "kind": "derived",
+        "text": "What matters is the overlap: a read group of R and a write group of W among N servers must share a server whenever R + W > N."
+      },
+      {
+        "kind": "derived",
+        "text": "With N = 5, W = 4, R = 2: 4 + 2 > 5, so every read sees the latest write; writes need 4 of 5 servers and survive 1 failure, reads need 2 and survive 3."
+      }
+    ],
+    "result": "R + W > N (here R + W > 5); with W = 4 and R = 2, every read overlaps every write, writes survive 1 failure, and reads survive 3."
+  },
+  "two-tides": {
+    "q": "At first and third quarter Moon, the Sun and Moon are at right angles as seen from Earth. How large are the tides then, compared with spring tides?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "Each body stretches the oceans along the line toward it, raising water at both ends of that line and lowering it in between."
+      },
+      {
+        "kind": "block",
+        "text": "The Sun's tidal effect is about half the Moon's; at new and full Moon the two lie in line and their effects add."
+      },
+      {
+        "kind": "derived",
+        "text": "At right angles, the Sun's stretch raises water where the Moon's lowers it, so the two effects work against each other."
+      },
+      {
+        "kind": "derived",
+        "text": "The range is then about 1 − ½ of the Moon's alone, against 1 + ½ at spring tide: about a third of a spring tide's range."
+      }
+    ],
+    "result": "Smallest (neap) tides, with a range of about (1 − ½) ÷ (1 + ½) ≈ one third of a spring tide's, because the Sun's stretch works against the Moon's."
+  },
+  "vaccine-memory": {
+    "q": "In a simple model, the immune cells that match an antigen double every 12 hours until there are enough to clear the infection. Vaccination leaves 1,000 times more matching cells than a first infection starts with. About how much sooner does the response reach full strength, and why does the answer not depend on how many cells count as 'enough'?",
+    "steps": [
+      {
+        "kind": "block",
+        "text": "A first response starts from few matching cells and must select and multiply them, which takes one to two weeks."
+      },
+      {
+        "kind": "block",
+        "text": "After vaccination, memory cells specific to that antigen remain, so the response starts from many more matching cells."
+      },
+      {
+        "kind": "derived",
+        "text": "Starting with 1,000 times more cells saves the doublings needed to grow 1,000-fold: about 10 doublings, since 2^10 ≈ 1,000."
+      },
+      {
+        "kind": "derived",
+        "text": "Ten doublings at 12 hours each is about 5 days; each start needs log2(enough ÷ start) doublings, so the difference between the two starts is log2(1,000) whatever 'enough' is."
+      }
+    ],
+    "result": "About 5 days sooner (about 10 doublings saved); the saving is the same whatever number of cells counts as enough."
+  }
+}

From 457576990d8ad68517e8c9dfad61c22d90ed06f4 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:35:58 -0400
Subject: [PATCH 10/13] Docs: the rederivation eval and what its dev baseline
 found

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 AGENTS.md     |  1 +
 CHANGELOG.md  |  9 +++++++++
 CLAUDE.md     |  1 +
 ROADMAP.md    |  3 +++
 docs/cli.md   |  5 ++++-
 docs/evals.md | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index 63d9db5..d610247 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -19,6 +19,7 @@ uv run explainer coldread <slug> --run        # first-viewing read by a fresh ag
 uv run explainer findings --stats             # how many review findings authors adopt, per tool
 uv run explainer eval chat                    # chat answers under each system prompt, graded blind
 uv run explainer eval artifact --split dev    # held-out subjects built under each condition, read and graded blind
+uv run explainer eval rederive --builds <run> # a fresh reader works out a result each explanation never states, graded blind
 uv run explainer render <slug> --draft        # fast silent layout pass
 uv run pytest -q                              # toolkit tests
 ```
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bad7aa0..c3a973d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Changelog
 
+## Unreleased
+
+Rederivation: can a reader work out what an explanation never states?
+
+- **A rederivation target for every subject** in `evals/artifact/questions.yaml`: a question the explanation was never asked to answer, the expected steps (building blocks a good explanation gives, and derived steps), and the result. A fresh agent checked each one (`explainer eval targets`, `evals/artifact/rederive-checks.json`), and all 30 were frozen before the first run.
+- **The rederivation stage** (`explainer eval rederive --builds <run>`; `eval artifact` runs it too). A fresh reader works the target out from the renderings, naming the part of the explanation each step rests on; a grader marks each expected step supported, unsupported, missing, or stated, blind, in three passes. Stated steps are left out of the score. [docs/evals.md](docs/evals.md#rederivation).
+- [What it found](docs/evals.md#what-the-dev-baseline-found) on the v0.8 dev builds: it is also near its ceiling (90–100% of steps supported). Under the rule fixed before the run, one pair separates, none > published, by about two steps of 38, from one subject where the published explanation lacks a building block the quiz also found missing. Reported with it: one target that overclaims (float-sum), explanations that state the derived steps in 3 of 10 subjects, and a partial building block graded inconsistently.
+- `explainer eval human` and `evals/artifact/human-check.md`: a person works out a target, graded with the same rubric.
+
 ## 0.8.0 — 2026-10-19
 
 Measure the toolkit, not the examples.
diff --git a/CLAUDE.md b/CLAUDE.md
index b20121c..bafaa18 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -19,6 +19,7 @@ uv run explainer coldread <slug> --run        # first-viewing read by a fresh ag
 uv run explainer findings --stats             # how many review findings authors adopt, per tool
 uv run explainer eval chat                    # chat answers under each system prompt, graded blind (needs the claude CLI)
 uv run explainer eval artifact --split dev     # held-out subjects built under each condition, read and graded blind
+uv run explainer eval rederive --builds <run>  # a fresh reader works out a result each explanation never states, graded blind
 uv run explainer render <slug> --draft        # fast silent layout pass
 uv run explainer render <slug> --review       # 1080p60, voice, captions, chapters, review sheet
 uv run pytest -q                              # toolkit tests
diff --git a/ROADMAP.md b/ROADMAP.md
index df5b402..e4a0dc6 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -221,6 +221,7 @@ Rounds 2 and 3 also produced general rules: names match pictures (call it an L o
 - The examples are frozen as reference implementations and regression fixtures: `explainer check` must pass; no more review rounds.
 - `evals/artifact/questions.yaml`: 30 held-out subjects (10 dev, 20 test), none an example or a chat-eval question, each with a fixed quiz of four questions; the last is a prediction about a case the explanation need not mention.
 - `explainer eval artifact`: per subject and condition, a fresh agent builds the explainer (none, the principles, or the explain skill at the quick or published tier), a second reads only the renderings and answers the quiz with a quote for each answer (an answer whose quote is not in the renderings scores 0), and a third grades blind. [docs/evals.md](docs/evals.md#the-artifact-eval).
+- Rederivation (PRD-002): each subject also has a frozen, model-checked target, a result its explanation was never asked to state. A fresh reader works it out from the renderings, naming the part each step rests on; a grader marks each expected step blind, in three passes. `eval artifact` runs it; `eval rederive --builds <run>` runs it on saved builds. [docs/evals.md](docs/evals.md#rederivation).
 
 **Rules.**
 
@@ -233,12 +234,14 @@ Rounds 2 and 3 also produced general rules: names match pictures (call it an L o
 - The quiz is at its ceiling (94–100% in every condition, with a strong reader and with Haiku): a model reader cannot measure the difference. The same holds for the published tier's blind test.
 - The principles alone cut length 40% and rank first on effort in every grading pass, at the lowest cost. The quick tier is shortest but ranks below them and makes the most errors; the published tier costs 13× as much for no measured gain.
 - The first run was invalid: builders inside the repo loaded its CLAUDE.md in every condition. Builds now run outside every project.
+- Rederivation is also near its ceiling (90–100% of steps supported). One pair separates under the rule fixed before the run, none > published, by about two of 38 steps, from one subject (two-tides) where the published explanation lacks a building block the quiz also found missing. Two target defects and three subjects whose explanations state the derived steps are reported with it ([docs/evals.md](docs/evals.md#what-the-dev-baseline-found)).
 
 **Next.**
 
 - A person ranks a sample (principles, quick, published on three subjects); the grader's ranking is used only if it agrees.
 - If it agrees: decide what the skill keeps. Candidates: the model file and the reviews only for the published tier, or the reviews dropped where they do not change the result.
 - A quiz that discriminates: harder subjects, or a reader limited in another way (time, words read), since a weaker model was not enough.
+- Open: whether PRD-003 adopts rederivation as its measure. With a strong model reader it mostly re-detects missing building blocks. Options: a weaker or constrained reader, harder targets with more derived steps (and a checker that tests "not stated" against real explanations), or human readers (`evals/artifact/human-check.md`). Recommendation: get two or three human checks before adopting it.
 - `plugin/skills/explain/references/html.md` says "the seven understanding questions from principles.md §7", but §7 has eight. Fix it with the principles rewrite, because skill text is measured.
 - The blind test (`explainer_kit/review.py`) does not ask "Could anything be cut with no loss?" Decide whether it should when the objective becomes least *wasted* effort.
 
diff --git a/docs/cli.md b/docs/cli.md
index 9ad7f7e..ccb9884 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -22,7 +22,10 @@ With the plugin installed, run `explainer <command>` from any project. In the Ex
 | `explainer say "<text>" [--voice V] [--speed S]` | Synthesize one line and play it. Use it to choose a voice or test a lexicon spelling. |
 | `explainer frames <slug> [--draft] [--every N]` | Rebuild the contact sheet from an existing render. |
 | `explainer eval chat [--conditions name=source ...]` | Answer the questions in `evals/chat/questions.yaml` under several system prompts with fresh `claude -p` calls, grade them blind, and write a report. See [Evals](evals.md). |
-| `explainer eval artifact [--split dev\|test\|all] [--only id ...] [--conditions name=source ...]` | Build an explainer for each held-out subject in `evals/artifact/questions.yaml` under each condition (`none`, `principles`, `git:<rev>`, a file, `quick`, `published`), have a fresh reader answer its quiz from the renderings alone, grade blind, and write a report. A rerun into the same `--out` resumes. See [Evals](evals.md#the-artifact-eval). |
+| `explainer eval artifact [--split dev\|test\|all] [--only id ...] [--conditions name=source ...]` | Build an explainer for each held-out subject in `evals/artifact/questions.yaml` under each condition (`none`, `principles`, `git:<rev>`, a file, `quick`, `published`), have a fresh reader answer its quiz from the renderings alone, grade blind, and write a report; then run the rederivation stage on the same builds. A rerun into the same `--out` resumes. See [Evals](evals.md#the-artifact-eval). |
+| `explainer eval rederive --builds <run> [--only id ...] [--out folder]` | The rederivation stage alone, on the builds of an earlier artifact run (only read, never changed): in three passes, a fresh reader works out each subject's target question from the renderings and names the part each step rests on, and a grader marks each expected step blind. Writes `rederive.md` and `rederive-scores.json`. See [Evals](evals.md#rederivation). |
+| `explainer eval targets [--only id ...]` | Check each rederivation target in `evals/artifact/questions.yaml` with a fresh agent, and record the verdicts in `evals/artifact/rederive-checks.json`. Only targets changed since their last check are checked. |
+| `explainer eval human --builds <run> --chain <file>` | Grade a person's working on a rederivation target with the same rubric as the model readers. See [`evals/artifact/human-check.md`](../evals/artifact/human-check.md). |
 
 ## `check`
 
diff --git a/docs/evals.md b/docs/evals.md
index 1836f83..145d60f 100644
--- a/docs/evals.md
+++ b/docs/evals.md
@@ -46,6 +46,53 @@ Effort rank: the grader's ranking of each subject's four explanations by the rea
 
 Two faults in the first run, both fixed: builders ran inside this repo, so Claude Code loaded its CLAUDE.md (and the principles) in every condition, including `none`; and the grader read Markdown with inline code removed, so formulas looked like blanks. Builds now run in a temp folder outside every project, with a guard.
 
+## Rederivation
+
+The quiz checks what an explanation says. A reader who has grokked a subject can do more: from its building blocks, work out a result nobody told them. An explanation of entropy as "the average length of the best code for a source" never mentions KL divergence, yet a reader who holds that idea can derive it: messages from p sent with a code built for q cost −log q each instead of −log p, so the average extra cost is Σ p log(p/q), never negative, because no code beats the one built for the true source. The rederivation stage tests that, on the same held-out subjects.
+
+**Targets.** Each subject in `evals/artifact/questions.yaml` has a `rederive` target: a question the explanation was never asked to answer, 3–6 expected steps, and the result. Each step is a building block (an idea a good explanation gives) or a derived step (worked out from the steps before it). A fresh agent checked every target (`explainer eval targets`, verdicts in `evals/artifact/rederive-checks.json`) against five tests: every step and the result are true; every building block comes from the subject's question, the quiz's expected answers, or background this reader already has; every derived step follows from earlier steps plus that background and brings in no new fact about the subject; each step is one any valid derivation needs; and a good answer to the subject's question would not state the result. The second and third tests matter most: a target that needs an idea a focused explanation may leave out would reward length, not understanding. All 30 passed (two after a revision) and were frozen in one commit before the first run; a test fails if a results folder's targets differ from the file.
+
+**Reader and grader.** The reader gets the renderings and the target's question, never the steps or the result. It works the question out step by step, and for each step names the part of the explanation it rests on (a heading, paragraph, figure, or a control on a page) and says what that part gives it. Reader and grader get the same rule: background this reader already has may be used without a citation; every fact about the subject must come from a part the reader names. The grader sees each subject's explanations and the readers' working under shuffled labels, and marks each expected step, credited in any order, merged, split, or by an equivalent route:
+
+- **supported:** made, and the cited parts carry the ideas it rests on (or it uses only background on top of earlier steps);
+- **unsupported:** made from the reader's own knowledge, or from a part that does not carry the idea;
+- **missing;**
+- **stated:** a derived step the explanation states outright, so the reader looked it up. A stated step, or a stated result, is left out of the score and counted, so a long explanation is neither rewarded nor penalized for spelling out what the reader was meant to derive.
+
+The headline is the **supported** share of expected steps; **raw** is the share made at all; **result right** the share of results that match. A run makes three **passes**: each is a fresh reader run over every build, graded once under its own label shuffle, so the spread covers both the reader's and the grader's variation. **The separation rule**, fixed before the first run: condition A beats condition B when A's supported score is higher than B's in all three passes.
+
+```bash
+uv run explainer eval rederive --builds evals/artifact/results/2026-10-04-dev   # the stage alone, on saved builds
+uv run explainer eval artifact --split dev                                     # builds, quiz, then this stage
+```
+
+### What the dev baseline found
+
+Dev baseline, 2026-10-20: the 40 v0.8 builds (10 subjects × 4 conditions), read and graded three times by the `claude` CLI's default model; no new builds. [Report](../evals/artifact/results/2026-10-20-dev-rederive/rederive.md).
+
+| condition | supported (3 passes) | result right | stated steps | words | quiz (grounded) |
+|---|---|---|---|---|---|
+| none | 100%, 100%, 100% | 100%, 100%, 100% | 2, 2, 3 | 1,689 | 100% |
+| principles | 95%, 100%, 97% | 89%, 89%, 100% | 4, 4, 5 | 1,006 | 99% |
+| quick (skill) | 92%, 100%, 90% | 100%, 100%, 89% | 2, 2, 2 | 606 | 95% |
+| published (skill) | 95%, 95%, 95% | 89%, 78%, 89% | 3, 3, 3 | 1,016 | 95% |
+
+**Under the separation rule, one pair separates: none > published** (100% against 95% in every pass). No other pair does.
+
+**What that result is made of.** About 38 expected steps count per condition, so 95% is two steps short. The gap comes from one subject: on two-tides, the published explanation never says the Sun's tide is about half the Moon's (a building block), so its readers could not ground the step that leads to the neap-tide ratio. That is the same gap the quiz already found (published scored 6 of 8 on two-tides). The quick explanation has the same gap, but its readers sometimes reached the step anyway, so it does not separate. The only condition at 100% in every pass, none, is also the longest.
+
+**How much a single subject moves between passes.** The same quick two-tides build scored 3/4, 4/4, and 1/4 supported steps in the three passes. A difference of a step or two in one subject is within what one fresh reader and one grading change on their own.
+
+**Known defects, found after the run** (the targets are frozen, so they stay and are reported):
+
+- **The float-sum target overclaims.** Its last derived step argues that adding 0.1 ten times cannot land exactly on 1.0 because each addition rounds. Rounding errors can cancel (`0.1` added five times does give exactly `0.5`), so the honest answer from the building blocks is "not guaranteed", which is what the principles and published readers said. They were marked wrong. Their "result right" shares are lower for this reason; their supported shares lost one step in pass 1. The separation does not depend on it: two-tides alone carries none > published.
+- **Real explanations stated derived steps outright in 3 of 10 subjects,** more often than the target checker predicted: the gps-relativity clock argument (three conditions), the greenhouse no-lapse-rate case (both derived steps, in principles, quick, and published), and the two-tides right-angle step (none and principles). Those steps are left out of the score, so for greenhouse three conditions were scored on building blocks alone.
+- **A partial building block is graded inconsistently.** The quorum block "any two majorities share a server, so the next group sees every committed write" is half present in the principles and quick explanations (they give the overlap, for conflicting writes, not for reads). The grader marked it unsupported in two of three passes.
+
+**What we take from it (interpretation, not the rule).** With a strong model reader, rederivation mostly re-detects missing building blocks, which the quiz already catches; it does not yet show a difference in understanding between conditions. The one separation is small, comes from one subject, and favors the longest explanation. Whether PRD-003 adopts this stage, and what to change first (a weaker or constrained reader, harder targets with more derived steps, or human readers), is open: see ROADMAP §15.
+
+**Human check:** none yet. A brief for testers is in [`evals/artifact/human-check.md`](../evals/artifact/human-check.md); results will be recorded here.
+
 ## The chat eval
 
 `evals/chat/questions.yaml` holds six questions about phenomena (why ice floats, why TCP starts slowly, how a wing makes lift, why a hash table is fast, why we see one side of the Moon, why salt melts ice). For each one it lists:

From 4cbf1925d0349f2b51dba90bf657d4e9a33bb813 Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:51:33 -0400
Subject: [PATCH 11/13] rederive: a build with no explanation scores nothing
 and is shown; a grader reply that does not fit is asked again, and its raw
 marks are kept

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 explainer_kit/rederive.py | 28 +++++++++++++++-----
 tests/test_rederive.py    | 55 +++++++++++++++++++++++++++++++++------
 2 files changed, 69 insertions(+), 14 deletions(-)

diff --git a/explainer_kit/rederive.py b/explainer_kit/rederive.py
index 095089a..1226e16 100644
--- a/explainer_kit/rederive.py
+++ b/explainer_kit/rederive.py
@@ -294,20 +294,34 @@ def grade_subject(subject: dict, key: dict[str, str], reader: str, builds: Path,
     saved = out / "rederive" / f"pass-{k}" / "grades" / f"{subject['id']}.json"
     if saved.exists():
         return json.loads(saved.read_text())
-    entries = {}
+    kinds = [s["kind"] for s in subject["rederive"]["steps"]]
+    entries, missing = {}, set()
     for label, cond in key.items():
         chain = json.loads((out / "rederive" / f"pass-{k}" / "read" / subject["id"] / f"{cond}.json").read_text())
+        if chain.get("missing"):
+            missing.add(label)
         files = ae.renderings(builds / "work" / subject["id"] / cond, subject["id"])
         entries[label] = {"text": "\n\n".join(grader_text(f) for f in files) or "(no explanation)",
                           "chain": "(no chain)" if chain.get("missing") else chain_text(chain)}
-    reply = agent.parse_json(agent.ask(ae.GRADER_SYSTEM, grade_prompt(subject, reader, entries), model=model))
-    kinds = [s["kind"] for s in subject["rederive"]["steps"]]
+
+    def fits(g: object) -> bool:
+        return isinstance(g, dict) and isinstance(g.get("marks"), list) and len(g["marks"]) == len(kinds)
+
+    reply: dict = {}
+    if len(missing) < len(key):  # nothing to grade when no build has an explanation
+        prompt = grade_prompt(subject, reader, entries)
+        for _ in range(2):  # a reply missing a label, or with the wrong number of marks, gets one more try
+            reply = agent.parse_json(agent.ask(ae.GRADER_SYSTEM, prompt, model=model))
+            if all(fits((reply.get("grades") or {}).get(label)) for label in key if label not in missing):
+                break
     grades = {}
     for label, cond in key.items():
         g = (reply.get("grades") or {}).get(label)
-        g = g if isinstance(g, dict) else {}
+        g = g if isinstance(g, dict) and label not in missing else {}
         grades[cond] = {"marks": marks(g.get("marks"), kinds), "result_right": g.get("result_right") is True,
-                        "result_stated": g.get("result_stated") is True}
+                        "result_stated": g.get("result_stated") is True, "raw": g.get("marks")}
+        if label in missing:  # a failed build scores nothing, whatever a grader says about "(no explanation)"
+            grades[cond]["missing"] = True
     result = {"key": key, "grades": grades}
     saved.parent.mkdir(parents=True, exist_ok=True)
     saved.write_text(json.dumps(result, indent=2, ensure_ascii=False))
@@ -429,7 +443,9 @@ def mean_words(n: str) -> str:
         "| subject | " + " | ".join(names) + " |", "|---|" + "---|" * len(names),
     ]
     for i, s in enumerate(subjects):
-        cells = [", ".join(f"{tallies[k][n][i]['supported']}/{tallies[k][n][i]['counted']}" for k in ks) for n in names]
+        cells = [", ".join(f"{tallies[k][n][i]['supported']}/{tallies[k][n][i]['counted']}" for k in ks)
+                 + (" NO EXPLANATION" if any(grades[k, s["id"]]["grades"][n].get("missing") for k in ks) else "")
+                 for n in names]
         lines.append(f"| {s['id']} | " + " | ".join(cells) + " |")
     return "\n".join(lines) + "\n"
 
diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 709e3b4..971c4a5 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -245,22 +245,26 @@ def ask(system, prompt, model=None, **kw):
 
     monkeypatch.setattr(agent, "ask", ask)
     g = rederive.grade_subject(s, {"A": "b", "B": "a"}, "A reader.", builds, out, 1, None)
-    assert g["grades"]["b"] == {"marks": ["supported", "supported", "stated"], "result_right": True, "result_stated": False}
-    assert g["grades"]["a"] == {"marks": ["missing"] * 3, "result_right": False, "result_stated": False}
+    assert {k: g["grades"]["b"][k] for k in ("marks", "result_right", "result_stated")} == \
+        {"marks": ["supported", "supported", "stated"], "result_right": True, "result_stated": False}
+    assert {k: g["grades"]["a"][k] for k in ("marks", "result_right", "result_stated")} == \
+        {"marks": ["missing"] * 3, "result_right": False, "result_stated": False}
     assert "BETA" in calls[0].split("=== Explanation A ===")[1].split("=== Explanation B ===")[0]
     assert (out / "rederive" / "pass-1" / "grades" / "s1.json").exists()
+    assert len(calls) == 2                                         # a reply missing a label is asked once more
     rederive.grade_subject(s, {"A": "b", "B": "a"}, "A reader.", builds, out, 1, None)
-    assert len(calls) == 1
+    assert len(calls) == 2
 
 
 ROOT = Path(__file__).resolve().parent.parent
 
 
-def run_fixture(monkeypatch, tmp_path):
+def run_fixture(monkeypatch, tmp_path, texts=None, lenient=False):
     """One subject, two conditions (a: ALPHA, b: BETA), a stub reader, and a grader that supports every step of the
-    ALPHA explanation and none of the other. Returns builds, out, and the list of calls."""
+    ALPHA explanation and none of the other (lenient: every step of every label). Returns builds, out, and the list
+    of calls."""
     monkeypatch.setattr(ae, "questions_file", lambda: subjects_file(tmp_path, {"s1": target()}))
-    builds = builds_folder(tmp_path)
+    builds = builds_folder(tmp_path, texts=texts)
     (builds / "conditions.json").write_text(json.dumps({"a": "none", "b": "quick"}))
     (builds / "scores.json").write_text(json.dumps({
         "a": {"subjects": [{"id": "s1", "score": [2, 2, 1, 2], "raw": [2, 2, 2, 2]}]},
@@ -272,14 +276,33 @@ def ask(system, prompt, model=None, **kw):
         if system == ae.READER_SYSTEM:
             return json.dumps(CHAIN)
         blocks = dict(re.findall(r"=== Explanation (\w) ===\n(.*?)(?==== Explanation|\Z)", prompt, re.S))
-        return json.dumps({"grades": {lab: {"marks": ["supported" if "ALPHA" in b else "missing"] * 3,
-                                            "result_right": "ALPHA" in b, "result_stated": False}
+        return json.dumps({"grades": {lab: {"marks": ["supported" if lenient or "ALPHA" in b else "missing"] * 3,
+                                            "result_right": lenient or "ALPHA" in b, "result_stated": False}
                                       for lab, b in blocks.items()}})
 
     monkeypatch.setattr(agent, "ask", ask)
     return builds, tmp_path / "out", calls
 
 
+def test_a_grader_reply_that_does_not_fit_is_asked_again_and_kept(monkeypatch, tmp_path):
+    builds, out = builds_folder(tmp_path), tmp_path / "out"
+    s = {"id": "s1", "q": "Question?", "rederive": TARGET}
+    for cond in ("a", "b"):
+        f = out / "rederive" / "pass-1" / "read" / "s1" / f"{cond}.json"
+        f.parent.mkdir(parents=True, exist_ok=True)
+        f.write_text(json.dumps(CHAIN))
+    replies = [{"A": {"marks": ["supported"], "result_right": True}},                          # short, and no B
+               {"A": {"marks": ["supported"] * 3, "result_right": True},
+                "B": {"marks": ["missing", "supported", "Supported"], "result_right": False}}]
+    calls = []
+    monkeypatch.setattr(agent, "ask", lambda *a, **k: calls.append(1) or json.dumps({"grades": replies[len(calls) - 1]}))
+    g = rederive.grade_subject(s, {"A": "a", "B": "b"}, "A reader.", builds, out, 1, None)
+    assert len(calls) == 2
+    assert g["grades"]["a"]["marks"] == ["supported"] * 3
+    assert g["grades"]["b"]["marks"] == ["missing", "supported", "supported"]
+    assert g["grades"]["b"]["raw"] == ["missing", "supported", "Supported"]      # the reply as given, for audit
+
+
 def test_run_end_to_end(monkeypatch, tmp_path):
     builds, out, calls = run_fixture(monkeypatch, tmp_path)
     report = rederive.run(out, builds).read_text()
@@ -294,6 +317,22 @@ def test_run_end_to_end(monkeypatch, tmp_path):
     assert scores["separations"] == [["a", "b"]] and len(scores["passes"]) == 3
 
 
+def test_a_build_with_no_explanation_scores_nothing_and_is_shown(monkeypatch, tmp_path):
+    # A failed build must not take whatever a lenient grader says about "(no explanation)".
+    builds, out, calls = run_fixture(monkeypatch, tmp_path, texts={"a": "ALPHA explains it.", "b": None}, lenient=True)
+    report = rederive.run(out, builds).read_text()
+    assert "| b | 0%, 0%, 0% | 0%, 0%, 0% |" in report
+    assert "| s1 | 3/3, 3/3, 3/3 | 0/3, 0/3, 0/3 NO EXPLANATION |" in report
+    g = json.loads((out / "rederive" / "pass-1" / "grades" / "s1.json").read_text())["grades"]["b"]
+    assert g["marks"] == ["missing"] * 3 and g["result_right"] is False and g["missing"] is True
+
+
+def test_no_grader_call_when_no_build_has_an_explanation(monkeypatch, tmp_path):
+    builds, out, calls = run_fixture(monkeypatch, tmp_path, texts={"a": None, "b": None}, lenient=True)
+    rederive.run(out, builds)
+    assert calls == []
+
+
 def test_rerun_makes_no_calls(monkeypatch, tmp_path):
     builds, out, calls = run_fixture(monkeypatch, tmp_path)
     first = rederive.run(out, builds).read_text()

From 9140d7d31b2b053cf33d817b75ae1e002091af3a Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:52:25 -0400
Subject: [PATCH 12/13] Pin all 30 rederivation targets to the freeze

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 tests/test_rederive.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/test_rederive.py b/tests/test_rederive.py
index 971c4a5..d889375 100644
--- a/tests/test_rederive.py
+++ b/tests/test_rederive.py
@@ -423,3 +423,13 @@ def test_human_check_lists_only_questions():
         if "rederive" in s:
             assert s["rederive"]["q"] in text, s["id"]
             assert all(step["text"] not in text for step in s["rederive"]["steps"]) and s["rederive"]["result"] not in text
+
+
+FROZEN = "07e484f8d7635887"   # all 30 targets as committed in 6b61cdf, before the first rederivation run
+
+
+def test_targets_are_the_frozen_ones():
+    # Every target, test split included, stays as frozen: a changed target fails here even before any run uses it.
+    targets = {s["id"]: s["rederive"] for s in ae.load("all")[1] if "rederive" in s}
+    digest = hashlib.sha256(json.dumps(targets, sort_keys=True, ensure_ascii=False).encode()).hexdigest()[:16]
+    assert digest == FROZEN, "a rederivation target changed after the freeze; add a new versioned target set instead"

From e294795471387bf814c031eb82459c8c55b28f8e Mon Sep 17 00:00:00 2001
From: ifrit98 <ifrit98@gmail.com>
Date: Tue, 20 Oct 2026 05:53:06 -0400
Subject: [PATCH 13/13] Docs: the one separation rests on half a building
 block; float-sum and length stated exactly

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DuVfjP13T9TDZwFJdP5uui
---
 CHANGELOG.md  |  2 +-
 ROADMAP.md    |  2 +-
 docs/evals.md | 10 ++++++----
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3a973d..37d8c92 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ Rederivation: can a reader work out what an explanation never states?
 
 - **A rederivation target for every subject** in `evals/artifact/questions.yaml`: a question the explanation was never asked to answer, the expected steps (building blocks a good explanation gives, and derived steps), and the result. A fresh agent checked each one (`explainer eval targets`, `evals/artifact/rederive-checks.json`), and all 30 were frozen before the first run.
 - **The rederivation stage** (`explainer eval rederive --builds <run>`; `eval artifact` runs it too). A fresh reader works the target out from the renderings, naming the part of the explanation each step rests on; a grader marks each expected step supported, unsupported, missing, or stated, blind, in three passes. Stated steps are left out of the score. [docs/evals.md](docs/evals.md#rederivation).
-- [What it found](docs/evals.md#what-the-dev-baseline-found) on the v0.8 dev builds: it is also near its ceiling (90–100% of steps supported). Under the rule fixed before the run, one pair separates, none > published, by about two steps of 38, from one subject where the published explanation lacks a building block the quiz also found missing. Reported with it: one target that overclaims (float-sum), explanations that state the derived steps in 3 of 10 subjects, and a partial building block graded inconsistently.
+- [What it found](docs/evals.md#what-the-dev-baseline-found) on the v0.8 dev builds: it is also near its ceiling (90–100% of steps supported). Under the rule fixed before the run, one pair separates, none > published, by about two steps of 38, from one subject where the published explanation lacks part of a building block (when the Sun's and Moon's tides add), a gap the quiz also found. Reported with it: one target that overclaims (float-sum), explanations that state the derived steps in 3 of 10 subjects, and a partial building block graded inconsistently.
 - `explainer eval human` and `evals/artifact/human-check.md`: a person works out a target, graded with the same rubric.
 
 ## 0.8.0 — 2026-10-19
diff --git a/ROADMAP.md b/ROADMAP.md
index e4a0dc6..9fe58ca 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -234,7 +234,7 @@ Rounds 2 and 3 also produced general rules: names match pictures (call it an L o
 - The quiz is at its ceiling (94–100% in every condition, with a strong reader and with Haiku): a model reader cannot measure the difference. The same holds for the published tier's blind test.
 - The principles alone cut length 40% and rank first on effort in every grading pass, at the lowest cost. The quick tier is shortest but ranks below them and makes the most errors; the published tier costs 13× as much for no measured gain.
 - The first run was invalid: builders inside the repo loaded its CLAUDE.md in every condition. Builds now run outside every project.
-- Rederivation is also near its ceiling (90–100% of steps supported). One pair separates under the rule fixed before the run, none > published, by about two of 38 steps, from one subject (two-tides) where the published explanation lacks a building block the quiz also found missing. Two target defects and three subjects whose explanations state the derived steps are reported with it ([docs/evals.md](docs/evals.md#what-the-dev-baseline-found)).
+- Rederivation is also near its ceiling (90–100% of steps supported). One pair separates under the rule fixed before the run, none > published, by about two of 38 steps, from one subject (two-tides) where the published explanation lacks part of a building block (when the Sun's and Moon's tides add), a gap the quiz also found. Two target defects and three subjects whose explanations state the derived steps are reported with it ([docs/evals.md](docs/evals.md#what-the-dev-baseline-found)).
 
 **Next.**
 
diff --git a/docs/evals.md b/docs/evals.md
index 145d60f..193fb11 100644
--- a/docs/evals.md
+++ b/docs/evals.md
@@ -79,17 +79,19 @@ Dev baseline, 2026-10-20: the 40 v0.8 builds (10 subjects × 4 conditions), read
 
 **Under the separation rule, one pair separates: none > published** (100% against 95% in every pass). No other pair does.
 
-**What that result is made of.** About 38 expected steps count per condition, so 95% is two steps short. The gap comes from one subject: on two-tides, the published explanation never says the Sun's tide is about half the Moon's (a building block), so its readers could not ground the step that leads to the neap-tide ratio. That is the same gap the quiz already found (published scored 6 of 8 on two-tides). The quick explanation has the same gap, but its readers sometimes reached the step anyway, so it does not separate. The only condition at 100% in every pass, none, is also the longest.
+**What that result is made of.** About 38 expected steps count per condition, so 95% is two steps short. The gap comes from one subject, two-tides, and from half of one building block. Block 2 bundles two ideas: the Sun's tide is about half the Moon's, and at new and full Moon the two line up and add. The published explanation gives the ratio but never says when the tides add (no spring or neap tides), so the grader marked the block unsupported in all three passes. That is the gap the quiz already found (published scored 6 of 8 on two-tides, 0 on the spring-tide question). The quick explanation also gives the ratio, and only mentions in a "not covered" line that the Sun's bulges add to or partly cancel the Moon's; the grader marked its block unsupported, supported, and missing in the three passes, so it does not separate.
 
 **How much a single subject moves between passes.** The same quick two-tides build scored 3/4, 4/4, and 1/4 supported steps in the three passes. A difference of a step or two in one subject is within what one fresh reader and one grading change on their own.
 
 **Known defects, found after the run** (the targets are frozen, so they stay and are reported):
 
-- **The float-sum target overclaims.** Its last derived step argues that adding 0.1 ten times cannot land exactly on 1.0 because each addition rounds. Rounding errors can cancel (`0.1` added five times does give exactly `0.5`), so the honest answer from the building blocks is "not guaranteed", which is what the principles and published readers said. They were marked wrong. Their "result right" shares are lower for this reason; their supported shares lost one step in pass 1. The separation does not depend on it: two-tides alone carries none > published.
+- **The float-sum target overclaims.** Its last derived step argues that adding 0.1 ten times cannot land exactly on 1.0 because each addition rounds. Rounding errors can cancel (`0.1` added five times does give exactly `0.5`), so the honest answer from the building blocks is "not guaranteed", which is what the principles and published readers said. They were marked wrong in passes 1 and 2; in pass 3 the published reader gave the same hedged answer and was marked right, so the grader was not consistent either. This lowers principles' and published's "result right" (published's also falls on two-tides in passes 2 and 3) and cost each one supported step in pass 1. The separation does not depend on it: two-tides alone carries none > published.
 - **Real explanations stated derived steps outright in 3 of 10 subjects,** more often than the target checker predicted: the gps-relativity clock argument (three conditions), the greenhouse no-lapse-rate case (both derived steps, in principles, quick, and published), and the two-tides right-angle step (none and principles). Those steps are left out of the score, so for greenhouse three conditions were scored on building blocks alone.
-- **A partial building block is graded inconsistently.** The quorum block "any two majorities share a server, so the next group sees every committed write" is half present in the principles and quick explanations (they give the overlap, for conflicting writes, not for reads). The grader marked it unsupported in two of three passes.
+- **Compound building blocks are graded inconsistently when half present.** The quorum block "any two majorities share a server, so the next group sees every committed write" is half present in the principles and quick explanations (they give the overlap, for conflicting writes, not for reads); the grader marked it unsupported in two of three passes. The two-tides block above is the same kind, and it carries the only separation.
 
-**What we take from it (interpretation, not the rule).** With a strong model reader, rederivation mostly re-detects missing building blocks, which the quiz already catches; it does not yet show a difference in understanding between conditions. The one separation is small, comes from one subject, and favors the longest explanation. Whether PRD-003 adopts this stage, and what to change first (a weaker or constrained reader, harder targets with more derived steps, or human readers), is open: see ROADMAP §15.
+**Does the order follow length?** Roughly. On the mean supported share the order is none (100%) > principles (97%) > published (95%) > quick (94%); by words it is none (1,689) > published (1,016) ≈ principles (1,006) > quick (606). The one separation goes in length's direction. The word count also leaves out what the grader reads in pages' scripts, and only none made pages (5 of 10).
+
+**What we take from it (interpretation, not the rule).** With a strong model reader, rederivation mostly re-detects missing building blocks, which the quiz already catches; it does not yet show a difference in understanding between conditions. The one separation is small, comes from half of one building block in one subject, and favors the longest explanation. Whether PRD-003 adopts this stage, and what to change first (a weaker or constrained reader, harder targets with more derived steps, or human readers), is open: see ROADMAP §15.
 
 **Human check:** none yet. A brief for testers is in [`evals/artifact/human-check.md`](../evals/artifact/human-check.md); results will be recorded here.