Tim Lingo
77e3c5fa26
Iteration 7 measured this harness's own ceiling at +3 gross / +1 net against a decision floor of 6. An instrument whose ceiling sits below its floor cannot certify or refute anything, so the gold set — not the retriever — was the blocker. This iteration builds no retrieval mechanism; it fixes the instrument and uses it once. extend_gold_set.py appends 37 queries (q39-q75) WITHOUT touching q01-q38, so every committed baseline and per-query id stays comparable. 30 held-out paraphrases: targets sampled mechanically (seed 8080) from addressable 500-2600 char nodes outside the original answer space and outside any duplicate cluster; queries authored from the node body alone, before any retrieval was run, and each one re-proved at build time to share ZERO content words with its target. 7 extra nonsense controls, fully mechanical. Why this was needed: the original 13 paraphrase and 6 associative queries share ONE answer space — the 13 `Self - Values (grounded)` children. 19 of 35 scored queries tested retrieval against a single 13-node neighbourhood. FIRST OUT-OF-SAMPLE RESULT (main vs the accumulated stack, embedded corpus): held-out only : +5 / -0, p=0.0625 — one query short of the floor, NOT-SHOWN original 38 : +15 / -0 full 75 : +20 / -0, p=0.0000, latency 0.46x In-sample paraphrase 61.5% vs out-of-sample 16.7%: generalisation is real, directional and 3.7x weaker than the headline number suggested. Also recorded: 47.4% of this corpus is redundant and ONE record accounts for 46.6% of all 78,768 nodes (36,737 byte-identical copies under distinct ids). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
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 andcompare.pysays 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:
main0 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:
- 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.
- 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.