Tim Lingo
6f3a048f36
engram_assoc_leg previously took its seeds only from the top-3 LEXICAL hits. For a paraphrase query the lexical hits are noise by construction, so the walk never reached the neighbourhood that holds the answer. This adds the seeding pass Will documents at el_runtime.c l.6082 — "Semantic seeding (HippoRAG pattern, use similarity twice): the query is embedded, the top-K nodes by cosine join the seed set" — using his own ENGRAM_EMBED_SEED_K (8). Similarity is now used twice, coherently: cosine picks where to STAND in the graph, the structural-relation walk decides what is REACHABLE, and cosine orders what was reached (iteration 2's finding, unchanged). The seed list is deliberately NOT floored at ENGRAM_EMBED_SEED_MIN. Measured over all 38 gold queries: true paraphrase targets score cosine 0.46-0.66 and the three nonsense controls' own nearest neighbours score 0.55/0.60/0.62 — the distributions OVERLAP, so no absolute cosine floor separates signal from gibberish. The gate that works is reachability: gibberish's nearest neighbours carry no structural edge, so its graph leg is empty and the controls hold. The raw top-K is selected inside the existing scoring pass, so the cosine is computed exactly once per node: no extra corpus pass, no extra embed round-trip, latency flat (p50 1220 -> 1227 ms, 1.01x). Measured vs the certified baseline feat/hybrid-semantic-recall, embedded corpus, 2 runs each, zero run-to-run drift on both sides: hit@5 51.4% -> 68.6% MRR@10 0.387 -> 0.461 paraphrase 38.5% -> 61.5% associative 0% -> 66.7% exact_rare 100% held, nonsense 2/3 held, superseded 2/3 held phrase 85.7% -> 71.4% (q11, the known rank-5 rotation tax) net +6 queries (7 fixed / 1 broken), McNemar p=0.0703
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.