style(brain/memory/search): Task 5 review cleanups

- combined_search(seed_id=..., domain=...) now post-filters spreading
  results by domain. The Hebbian graph is domain-agnostic, so the
  pre-scoring _candidates() filter can't apply; post-filter honours the
  documented "domain filter is a pre-scoring restriction" contract for
  the seed-only path too.
- Docstring on combined_search calls out the /100 emotion normalisation
  as a rough heuristic (not principled — tuning expected in v1.1), and
  clarifies that domain is pre-filter for query/emotions but post-filter
  for seed_id.

Tests added:
- combined_search_seed_id_surfaces_connected_memories (seed-only path)
- combined_search_seed_id_honours_domain_filter (the new post-filter)
- combined_search_blends_query_and_emotions (multi-filter accumulation —
  m hitting both signals outranks one hitting either alone)

191 tests total, ruff clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Hana

brain/memory/search.py

@@ -111,6 +111,14 @@ def combined_search(
         """Blend sub-queries with equal weight (1.0 each). Returns
         (memory, combined_score) ordered desc.
 
+        Emotion scores are divided by 100 as a rough scale heuristic so
+        they don't dwarf cosine similarity (0..1). Not principled —
+        tuning expected in v1.1.
+
+        Domain filter: applied pre-scoring for query/emotions via
+        _candidates(); applied post-scoring for seed_id since the
+        Hebbian graph is domain-agnostic.
+
         Returns [] if no filters are specified.
         """
         if not any((query, emotions, seed_id)):
@@ -134,6 +142,11 @@ def combined_search(
             for mem, act in self.spreading_search(
                 seed_id, depth=2, decay_per_hop=0.5, limit=limit * 2
             ):
+                # spreading_search has no domain parameter — the graph is
+                # domain-agnostic — so post-filter here to honour the
+                # domain contract documented at the module level.
+                if domain is not None and mem.domain != domain:
+                    continue
                 scores[mem.id] = scores.get(mem.id, 0.0) + act
                 ref_memory[mem.id] = mem
 

tests/unit/brain/memory/test_search.py

@@ -149,3 +149,60 @@ def test_combined_search_empty_inputs_returns_empty(search: MemorySearch) -> Non
     search.store.create(_mem("x"))
     results = search.combined_search(limit=5)
     assert results == []
+
+
+def test_combined_search_seed_id_surfaces_connected_memories(
+    search: MemorySearch,
+) -> None:
+    """combined_search with only seed_id returns spreading-activation neighbours."""
+    seed = _mem("seed memory")
+    near = _mem("near neighbour")
+    far = _mem("unrelated")
+    for m in (seed, near, far):
+        search.store.create(m)
+    search.hebbian.strengthen(seed.id, near.id, delta=0.8)
+
+    results = search.combined_search(seed_id=seed.id, limit=5)
+    returned_ids = [m.id for m, _ in results]
+    assert near.id in returned_ids
+    assert seed.id not in returned_ids  # seed always excluded
+    assert far.id not in returned_ids  # no edge to far
+
+
+def test_combined_search_seed_id_honours_domain_filter(search: MemorySearch) -> None:
+    """combined_search post-filters spreading results by domain (graph is
+    domain-agnostic, so the filter runs after activation).
+    """
+    seed = _mem("seed", domain="us")
+    us_neighbour = _mem("us neighbour", domain="us")
+    work_neighbour = _mem("work neighbour", domain="work")
+    for m in (seed, us_neighbour, work_neighbour):
+        search.store.create(m)
+    search.hebbian.strengthen(seed.id, us_neighbour.id, delta=0.7)
+    search.hebbian.strengthen(seed.id, work_neighbour.id, delta=0.7)
+
+    results = search.combined_search(seed_id=seed.id, domain="us", limit=5)
+    returned_ids = [m.id for m, _ in results]
+    assert us_neighbour.id in returned_ids
+    assert work_neighbour.id not in returned_ids
+
+
+def test_combined_search_blends_query_and_emotions(search: MemorySearch) -> None:
+    """When both query and emotions are given, scores from both sub-queries
+    accumulate on matching memories — a memory hitting both filters outranks
+    one hitting only one.
+    """
+    # m1 matches both the query content AND the emotion filter
+    m1 = _mem("strong love memory", emotions={"love": 9.0})
+    # m2 matches only the query content
+    m2 = _mem("strong love memory", emotions={"anger": 8.0})
+    # m3 matches only the emotion filter
+    m3 = _mem("unrelated", emotions={"love": 9.0})
+    for m in (m1, m2, m3):
+        search.store.create(m)
+
+    results = search.combined_search(query="strong love memory", emotions={"love": 9.0}, limit=5)
+    assert len(results) >= 1
+    # m1 accumulates both signals → top rank
+    top_id = results[0][0].id
+    assert top_id == m1.id