fix(C12.a): wrapper-extracted facts now populate the facts table + dedup runs extraction

[kohai-ut]

Summary

• Mnemosyne.remember(extract=True) now writes to the facts table the same way BeamMemory.remember(extract=True) already did. Previously the wrapper reimplemented half of beam's canonical _extract_and_store_facts helper inline, calling triples.add_facts(...) but never _store_facts_in_table(...). Wrapper-extracted facts were visible through recall() (which scores fact triples) but invisible through fact_recall() (which queries the facts table).
• Three bundled fixes:
  1. Wrapper delegates extraction to BeamMemory.remember (drops ~25 lines of duplicated logic).
  2. BeamMemory.remember's dedup early-return now also runs extraction so backfill calls work (mem.remember(same_content, extract=True) on an already-existing row populates the facts table).
  3. fact_recall was crashing on sqlite3.Row.get(...) once rows existed — latent bug, masked while the wrapper kept the table empty. Converted to dict at the top of the per-row loop. Also normalized the None-handling for confidence/subject/predicate.
• 6 regression tests in tests/test_extract_parity.py: 3 RED before the wrapper fix, 1 RED before the fact_recall fix, 1 RED before the dedup-extract fix.

The bug

Mnemosyne stores knowledge graph facts in two places:

Storage	Used by
triples table	recall() — scores fact triples as part of NAI-5's "fact voice"
facts table	fact_recall() — public API for structured fact retrieval

The canonical helper _extract_and_store_facts in mnemosyne/core/beam.py:597 writes to BOTH:

def _extract_and_store_facts(beam, memory_id, content, source=""):
    facts = extract_facts_safe(content)
    if not facts:
        return
    triples = TripleStore(db_path=beam.db_path)
    triples.add_facts(memory_id, facts, source=source, confidence=0.7)
    _store_facts_in_table(beam, memory_id, content, source, facts)

Mnemosyne.remember(extract=True) reimplemented half of this inline at memory.py:299-309:

if extract:
    try:
        from mnemosyne.core.extraction import extract_facts_safe
        from mnemosyne.core.triples import TripleStore
        facts = extract_facts_safe(content)
        if facts:
            triples = TripleStore(db_path=self.db_path)
            triples.add_facts(memory_id, facts, source=source, confidence=0.7)
                                 # ← never called _store_facts_in_table
    except Exception:
        pass

Result: a memory remembered through the wrapper showed up in recall() (because triples are populated and NAI-5 scores them) but fact_recall() returned nothing for the same memory.

Why it slipped through

Same anti-pattern as C26 / C23 / C20: tests called BeamMemory.remember(extract=True) directly with db_path=tmp and never went through Mnemosyne.remember(extract=True). The wrapper's parallel extract path had zero coverage. tests/test_extraction_integration.py exists but it manually injects facts via TripleStore.add_facts(...) rather than exercising extract=True end-to-end through the wrapper.

The fix (commit 1: ab4a81b)

Mnemosyne.remember (memory.py) — pass extract=extract, extract_entities=extract_entities to the first self.beam.remember(...) call. Drop the wrapper's two inline extract blocks (~25 lines). All extraction now routes through BeamMemory's canonical helpers (_extract_and_store_entities, _extract_and_store_facts) plus NAI-5's _ingest_graph_and_veracity. The wrapper becomes a thin shim — its only remaining job is the legacy memories dual-write.

fact_recall row access (beam.py:2160-2174) — sqlite3.Row supports bracket access but NOT .get(). The existing code called row.get("confidence", 0.5) etc. and crashed AttributeError the moment the facts table contained rows. The bug was unreachable while the wrapper bug above kept the table empty. Once C12.a was fixed and rows existed, fact_recall would crash on the first iteration. Convert to dict at the top of the loop so .get(...) works as the author intended.

Pre-landing review (commit 2: 85db0dd)

Cross-model adversarial review (Claude subagent + Codex CLI). Both flagged the same primary regression introduced by commit 1:

BeamMemory.remember has an early-return on duplicate content (beam.py:942-963). The early-return runs UPDATE + _ingest_graph_and_veracity and returns BEFORE the extract blocks at lines 985-988. So mem.remember(same_content, extract=True) after a duplicate silently skipped extraction entirely — breaking backfill on pre-existing databases.

Both also flagged a related issue: the wrapper made TWO beam.remember calls per Mnemosyne.remember, both of which run _ingest_graph_and_veracity. The second call duplicated graph_edges (autoincrement PK) and bumped mention_count for what was a single user-level write.

Fixes applied in commit 2:

1. Dedup branch runs extraction (CRITICAL — addresses Codex's primary finding). mnemosyne/core/beam.py — when _find_duplicate fires, the dedup branch now also calls _extract_and_store_entities and _extract_and_store_facts before returning. extract=True now means "extraction always runs" regardless of insert vs dedup, matching the wrapper's pre-fix inline behavior.

2. Drop redundant second beam.remember call. The wrapper used to call beam.remember twice per remember (once for ID generation, once for "ID-sync dedup"). Now that the first call accepts extract flags and produces the working_memory row with the right ID, the second call only ran the dedup branch redundantly + double-fired _ingest_graph_and_veracity. Removed entirely.

3. Normalize fact_recall row access. Replaced inconsistent or "" collapse with the same is not None pattern used for confidence. Extracted intermediate locals so each row.get is computed once.

New backfill regression test

tests/test_extract_parity.py::test_extract_runs_on_dedup_for_backfill locks in the dedup-extraction contract by exactly the regression scenario the adversarial review found: pre-existing working_memory row (from BeamMemory.remember(extract=False)), then mem.remember(same_content, extract=True) — asserts dedup fires AND facts table populates. Without commit 2's fix this would fail silently; with the fix it's GREEN.

Behavior change worth flagging

Pre-fix: Mnemosyne.remember(extract=True) with already-existing working_memory content → wrapper's inline extract block ran AFTER both beam.remember calls regardless of dedup. Triples populated; facts table never.

Post-fix: Mnemosyne.remember(extract=True) with already-existing content → first beam.remember hits dedup, runs extraction (including facts table). Single user-level call → single set of extraction effects.

This is the intended behavior for backfill scenarios. Anyone who depended on "extract=True is a no-op on duplicate content" (no callers found) would see facts/triples now actually appear.

Deferred (filed separately)

• C12.a.cognee (added to .hermes/ledger/memory-contract.md locally): mnemosyne/core/importers/cognee.py:106-109 has the same latent sqlite3.Row.get() pattern as fact_recall. Currently masked by except Exception: pass. Both adversarial reviewers flagged it independently. Small follow-up PR.
• NaN confidence handling — edge case noted by Claude, not exercised by current writers.
• Per-row dict.get perf nit — bounded by top_k, not a real concern.

Test plan

• uv run pytest tests/test_extract_parity.py -q (6 passed locally)
• uv run pytest -q --ignore=tests/test_local_llm.py --ignore=tests/test_llm_backends.py (470 passed locally)
• Manual: mem.remember("Alice was born in Boston.", extract=True) then mem.beam.fact_recall("alice") returns the fact (was empty pre-fix).
• Manual backfill: write a memory with extract=False, then re-remember the same content with extract=True. Verify the facts table populates after the second call.
• Manual fact_recall under load: with several extract=True memories, fact_recall returns sensibly without AttributeError.

Verification

```
tests/test_extract_parity.py: 6 passed (new file)
broader sweep (extraction + entities + beam): 119 passed
full suite excluding LLM-dependent tests: 470 passed
```