feat(brain): add DarkRadar fifth signal to BrainHub

[rudi193-cmd]

Summary

Adds DarkRadar as a fifth signal to BrainHub in synrix_runtime/monitoring/brain.py.

DarkRadar detects memories that exist in the agent's store but are functionally invisible to semantic search — a silent failure mode where writes succeed but retrievals always miss.

Three detection levels:

1. None embedding — write was accepted but embedding was never computed
2. Zero-vector — norm < 1e-6, mathematically invisible to cosine similarity
3. Search verification — backend.semantic_search() returns no results for this key (index desync)

Returns a BrainEvent(event_type="dark", severity="warning", action_type="reindex") when triggered. Tracks per-tenant/agent dark counts.

Also adds tests/test_brain.py — 13 unit tests, first coverage for brain.py. All passing.

Why

The existing four signals (LoopBreaker, DriftRadar, ContradictionShield, MemoryHealth) all operate on memories the agent can see. DarkRadar covers the case where the memory is invisible — the agent wrote it, confirmed success, but can never retrieve it. Without this, dark records accumulate silently and degrade agent reasoning quality over time.

Test Plan

• python3 -m pytest tests/test_brain.py -v — all 13 tests pass
• process_write() with embedding=None returns a dark event
• process_write() with zero-vector returns a dark event
• process_write() with valid embedding and no backend returns None (no false positive)
• get_brain_status() includes dark_warnings key
• DarkRadar.reset() clears the count for a tenant/agent pair

Generated with Claude Code

[RyjoxTechnologies]

Let me know how you get on

[rudi193-cmd]

Working well on our end. The DarkRadar signal caught a real production failure that motivated the PR — a Postgres knowledge store where 27/28 atoms (96%) were invisible to semantic search due to FTS tokenization gaps. The embeddings existed, the writes confirmed success, but retrievals always missed. Classic silent dark.

The three-tier check (None → zero-vector → live search verification) is the right layering. The search-verification level was the critical one for our use case — embedding-level checks pass, but the records don't surface in actual queries. All 13 tests pass locally.

One thing to note for reviewers: the backend parameter on DarkRadar.check() is optional and defaults to None, so it degrades gracefully in environments without a live backend. That was an intentional design choice to avoid blocking writes.

---

In case the question was how to wire it in:

from synrix_runtime.monitoring.brain import DarkRadar

# After your memory write returns an embedding:
event = DarkRadar.check(
    tenant_id="your-tenant",
    agent_id="your-agent",
    key=memory_key,
    value=memory_value,
    embedding=embedding_from_write,  # None if write didn't return one
    backend=your_store_backend,       # optional — enables live search verify
)

if event:
    # event.event_type == "dark", event.action_type == "reindex"
    # log it, alert, queue a reindex — your call
    handle_dark_memory(event)

backend is optional — if you pass it, DarkRadar does a live search verification after checking the embedding. If you omit it, you still catch None and zero-vector cases. get_brain_status() on BrainHub now includes a dark_warnings count per tenant/agent.

[rudi193-cmd]

Still working well — the DarkRadar signal has been catching real production failures in our setup (Postgres knowledge store where atoms were invisible to semantic search despite confirmed writes). All 13 tests passing. Let us know if there's anything you'd like adjusted before merge.