# Evolution 80 — Evidence Lineage and Reproduction

Three benchmark runs were executed on 2026-11-15. Only the third is accepted. The first two are
preserved, labelled, and **must not be cited as evidence**.

| Run | Started (UTC) | Directory | Status | Reason |
|---|---|---|---|---|
| 1 | 16:51 | `artifacts/e80_superseded_run1_nondeterministic/` | **SUPERSEDED** | Task generation was non-deterministic across processes; the replication process overwrote `tasks/*.json` with different task instances, so the stored test set did not match the scored test rows. |
| 2 | 18:41 | `artifacts/e80_superseded_run2_evidence_gaps/` | **SUPERSEDED** | Deterministic tasks, but the gate audit did not record grant units or scopes, model-call rows did not carry a grant id, and the audit chain restarted when a second process appended. Authorization was enforced at runtime, but the offline record could not bind each call to a grant. |
| 3 | 20:31:59 | `artifacts/e80/` | **ACCEPTED** (interrupted at 21:31:48, resumed 22:01; see below) | Deterministic tasks; every model call carries `grant_id`, `grant_units` and `grant_scope_sha256`; every ALLOW decision logs `units` and `scope_sha256`; the audit hash chain continues across processes. |

## Defects found and fixed

### 1. Non-deterministic task generation (run 1)

`cain/cain2027/e79/tasks79.py` built a character for the `string_op` software task with
`r.choice(list(set(w)))`. Python randomises string hashes per process, so the list order differed
between the main and replication processes. `make_splits` therefore produced different instances in
each process. The replication process wrote the task files last, so the accepted test set on disk
was not the one used by the main run.

Fix: `r.choice(sorted(set(w)))`. Verified by generating the same split in three separate processes
and comparing SHA-256.

Guard: `run_bench.py` now refuses to overwrite an existing split that differs
(`TASK_SET_DRIFT`), instead of silently replacing evidence.

### 2. Unverifiable model-call signatures (runs 1–2)

The main benchmark process wrote `specialists.json` but not `identity_registries.jsonl`, so the
public keys for 1,083 model-call signatures were never persisted. The signatures existed; the
verification material did not.

Fix: every process that opens a gate now calls `write_registry`, including the main process.

### 3. Authorization not bound to call rows (run 2)

The gate enforced single-use, scope-bound, budget-bound grants at runtime, but the audit row for a
DECIDE recorded only the grant id. An offline verifier could count ALLOW decisions and call rows
but could not show that the units authorised equalled the calls made.

Fix:

- `Gate.decide` logs `units` and `scope_sha256` on both ALLOW and DENY.
- `ModelPool.infer` obtains the grant explicitly and stamps every call row with `grant_id`,
  `grant_units` and `grant_scope_sha256`.
- `Gate` resumes an existing audit file by reading its last hash and sequence number, so a second
  process continues one chain rather than starting a new one.

Smoke check before the accepted run: 182 model calls, 182 with a grant id, 111 ALLOW decisions
summing to exactly 182 units, chain sequences 0…251 with no break.

### 4. Run 3 was interrupted and resumed

The process that started run 3 ended without writing `run_state.json`; its last model call was at
21:31:48 UTC, after the `worker1` coordination stage and before the `evidence` stage made any call.
The session that owned it had ended, and the cause was not recorded.

A takeover session resumed the same run at 22:01 UTC with the unchanged command. The runner reuses
completed stage files, re-checks the frozen policy hash and refuses a changed task split. Only the
three unfinished coordination stages (`evidence`, `evidence_answer`, `synthesis`) were executed; each
had zero model calls before the resume, so no test task was sampled twice. `run_state.json` describes
the resumed process only. The record is `artifacts/e80/run_lineage.json`, which is inside the signed
manifest.

## What "reproduced" means

The accepted run's **numbers** can be recomputed from its raw rows by two independent verifiers:

1. `scripts/evolution80/verify_e80_offline.py` — shipped inside the signed bundle; 166 checks (159 benchmark and systems checks plus 7 for the endurance campaign).
2. `verification/e80_independent/verify_independent.py` — authored by a separate session and executed against run 3 by the takeover session, imports
   no CAIN code, recomputes accuracy, paired tests, routing, accounting, signatures, memory, skill,
   drill, Agentic 75 and release-gate counts.

Neither verifier re-runs the model. Re-running CPU inference would produce different latency and
different samples at non-zero temperature; the raw rows of the accepted run are the evidence.

## Honest limits of the lineage

- Runs 1 and 2 consumed real CPU time and produced real measurements. They are preserved, not
  deleted, because deleting an inconvenient run is indistinguishable from fabrication.
- Run 2's scientific results were nearly identical to run 3's, which is expected: the fixes changed
  logging and determinism, not the models or the task templates. That similarity is **not** used as
  evidence; only run 3's rows are.
- The accepted run still has the limitations in `LIMITATIONS_AND_UNVERIFIED_CLAIMS.md`: small
  samples, one model family, constructed tasks, same-host execution, a self-generated key, no
  transparency log, no independent witness, no third-party audit.
- The build host is the production host. No production file, service, DNS record, credential or
  payment was changed by any of the three runs.
