# Retrieval eval harness

Measures Neuron's memory retrieval so a change can be shown to help before it is
believed to help. Nothing else on the memory roadmap should ship without a run
through this.

```
tools/retrieval-eval/run_comparison.sh --baseline main --candidate <branch>
```

That builds a soul from each ref, boots each in isolation on a fixed corpus,
runs the gold set three times per ref, and prints a table plus a verdict that
refuses to call a difference real if it is inside the noise band.

## What was reused

This is not a new idea, it is the missing third of an existing one.

| Prior work | What it gave | What was missing |
|---|---|---|
| `docs/research/graphrag_eval/` (`collect.py`, `score.py`, 2026-06-08) | The three-retriever comparison that produced the numbers everyone quotes: substring 1.7% P@5, graph 21.7%, BM25 55%. Per-query relevant-id scoring, fixed-denominator precision@5, unique-relevant analysis. | 13 hand-written queries, judged by an LLM after the fact; measured the *live* soul on the *live* engram. |
| `docs/research-archive/p0-prototypes/eval_pinned_40q_20260715.py` | The pinned-query discipline: ground truth committed as regexes so every run judges alike, plus a `--check` winnability gate. 40 queries in 5 bands including a deliberate paraphrase-hard band. | Scored offline replicas of substring/BM25 — it never ran the real retrieval path. |
| `docs/research-archive/p0-prototypes/stage0_eval_20260714.py` | The `hit@5` metric and the substring/BM25 reference implementations. | Same: offline only. |
| `scripts/verify-soul-contract.sh` | The isolation recipe, verbatim: throwaway port, throwaway `HOME`, `SOUL_ENGRAM_PATH`, and the non-obvious `SOUL_ISE_URL` pin that stops an "isolated" soul silently syncing the operator's live brain. | It is a contract gate, not a measurement. |
| `_engine-liveness-91/gen-soul-amalgam.sh` + `.gitea/workflows/ci.yaml` | The build recipe (`elc --target=c` with every `.elh` on the import chain removed) and CI's exact compile flags. | — |

**Reused directly:** the isolation recipe, the build recipe, fixed-denominator
precision@5, the pinned-ground-truth and winnability ideas.
**New here:** ids rather than regexes as ground truth, an associative category
derived from real graph edges, a superseded/contradicted category scored on
ranking, a machine-checked zero-lexical-overlap guarantee on paraphrases,
paired significance testing, and — the point — measurement against the **real
compiled soul** rather than an offline replica of one leg of it.

## Design fit

The thing under measurement is Will's designed retrieval: spreading activation
over the weighted directed graph, four-factor multiplicative scoring (parent
strength x edge weight x target salience x query/target cosine). A Python
re-implementation would measure my reading of the design. So the harness
compiles the actual `soul.el` amalgam and asks it over HTTP on
`/api/neuron/recall`, exactly as the MCP wrapper and the app do.

## Files

| File | Does |
|---|---|
| `build_gold_set.py` | Derives and **validates** the gold set from the corpus. `--check` re-validates and exits non-zero if a query became unwinnable or a paraphrase leaked a word. |
| `gold_set.json` | 38 queries. Every one carries a `derivation` string. |
| `run_eval.py` | Boots one soul in isolation, runs the gold set, writes metrics. Kills and **confirms dead** its child; records the confirmation in the results file. |
| `compare.py` | Paired diff of two result files with McNemar's exact test and a stated noise floor. |
| `build-soul.sh` | Compiles a soul binary from a plain source tree. |
| `run_comparison.sh` | All of the above, end to end, from two git refs. |

## The gold set — 38 queries

Built from the real corpus (`snapshot-pre-repair-20260806.json`, 78,768 nodes /
14,214 edges) so it reflects one person's accumulating memory, not document QA.

| Category | n | Expected answer derived by |
|---|---|---|
| `exact_rare` | 6 | **Mined.** Tokens with document frequency 1 across all 78,768 nodes, whose single containing node is a 300–6000 char Memory/Knowledge/Belief. That node is the only possible answer. Re-verified every build. |
| `phrase` | 7 | **Mined.** Case-insensitive verbatim scan; the matching set *is* the answer key. Phrases matching >25 nodes are rejected as too diffuse. |
| `paraphrase` | 13 | **Hand-selected, machine-checked.** Target locked by id; the build then proves that **zero** content words of the query appear anywhere in the target's label, content, or tags. A leak fails the build — the category cannot quietly decay into lexical matching. |
| `associative` | 6 | **Derived from edges.** Query built from one value node's distinctive vocabulary; expected answers are its siblings on the `Self - Values (grounded)` hub. Siblings sharing any query word are dropped, so the only route from query to answer is seed -> hub -> sibling. |
| `nonsense` | 3 | **Control.** Verified that no token occurs anywhere in the corpus. Correct behaviour is to return nothing. |
| `superseded` | 3 | **Derived.** Correction/stale pairs located by regex scan, kept only when both sides resolve to different surviving nodes. Scored on **ranking**: the correction must be returned *and* rank above the stale node. |

## Metrics

`hit@5`, `recall@5`, `recall@10`, `precision@5` (fixed denominator 5, so an
empty result is punished like a page of junk), `MRR@10`, and wall-clock latency
per query (p50/p95/max). Output is a table plus a machine-readable JSON per run
so runs can be diffed.

## Honesty about noise

- **Minimum detectable swing on this 38-query set: 6 queries.** If every query
  that changes changes the same way, `p = 2 x 0.5^n`, which first drops under
  0.05 at n=6. Any net change smaller than that is inside the noise band and
  `compare.py` says so in those words.
- **Run-to-run drift is measured, not assumed.** Activation is a stateful read
  by design (traversal reinforces what it touches), so identical inputs need not
  give identical outputs. Observed: `main` 0 queries of drift across 3 runs
  (fully deterministic); the activation branch 1 query.
- The noise floor used for the verdict is `max(6, observed_drift + 1)`.
- **This gold set is underpowered for small effects.** A genuine 3-query
  improvement would not clear the bar. Growing the set is the fix; until then, a
  small positive delta means "not shown", not "no effect".

## First result: `main` vs `feat/recall-through-activation`

Corpus and gold set identical, three runs each, fresh corpus copy per run.

| | main | recall-through-activation | delta |
|---|---|---|---|
| hit@5 | 34.3% | 22.9% | **-11.4pp** |
| recall@5 | 26.9% | 19.1% | -7.9pp |
| recall@10 | 33.3% | 24.3% | -9.1pp |
| precision@5 | 12.0% | 7.4% | -4.6pp |
| MRR@10 | 0.294 | 0.242 | -0.053 |
| latency p50 | 1140 ms | 3209 ms | **2.81x** |
| latency p95 | 1584 ms | 4852 ms | 3.06x |
| nonsense clean | 2/3 | 2/3 | — |
| superseded outranks | 1/3 | 0/3 | -1 |

By category (hit@5):

| category | main | activation |
|---|---|---|
| exact_rare | 100% | 100% |
| phrase | 85.7% | **28.6%** |
| paraphrase | 0% | 0% |
| associative | 0% | 0% |
| superseded | 0% | 0% |

**Verdict: directionally worse, one query short of significant.** 5 discordant
pairs, all 5 against the candidate, 0 for it. McNemar exact p = 0.0625 — under
the stated rule that is *inside* the noise band, so the harness reports "no
measurable difference" on accuracy and the honest summary is "5 for 5 the wrong
way, needs a 6th or a larger gold set to call".

Latency is a different story: 2.8x at p50 is deterministic and far outside any
noise band. That regression is real.

The result the branch was written for did not appear. Its stated purpose was to
recover sibling nodes one hub-hop away — the `associative` category — and that
category is **0/6 on both builds**. Probing directly: for the query
`Marines hernia sepsis medical ward`, the activation build returns the lexical
seed node itself at rank 8, and none of its 12 hub siblings anywhere in the top
10. The traversal is running; it is not reaching siblings.

Two corpus facts likely explain it, and both are measurable rather than
speculative:

1. **The graph is nearly edgeless.** Only 4,060 of 78,768 nodes (5.2%) carry any
   edge at all — 14,214 edges total, 0.18 per node. Spreading activation over a
   graph with no edges is an expensive way to do lexical matching, which is
   roughly what the numbers show.
2. **No embeddings.** No node in this snapshot has an embedding field, so the
   fourth factor of the four-factor product — query/target cosine similarity —
   has nothing to compute from, and the semantic seeding pass is inert.

That is the harness earning its keep on its first job: the change would have
felt like progress (it is the designed mechanism, and it does run) and measures
as a regression on phrase queries plus a 2.8x latency cost, with its intended
benefit unrealised because the corpus lacks the structure it needs.
