Summarize scope demotions in memory health (#74)

Author: SonAIengine

docs/REPORT-memory-operating-layer-eval.md

@@ -336,6 +336,31 @@ uv run --extra sqlite python eval/scripts/memory_operating_poc.py \
 - ranking diagnostics는 positive boost와 negative demotion을 분리해서 기록한다.
 - 최종 result order는 조정된 resonance 기준으로 정렬된다.
 
+후속 health demotion summary guard 검증:
+
+```bash
+uv run --extra sqlite python eval/scripts/memory_operating_poc.py \
+  --results ~/synaptic-eval/memory_operating_health_demotion_summary_results.json
+```
+
+결과:
+
+| 항목 | 값 |
+|---|---:|
+| result | PASS |
+| gates | `31/31` |
+| health_summarizes_scope_demotions | `true` |
+| memory_demoted_retrieval_count | `1` |
+| memory_demoted_node_count | `1` |
+| max_memory_scope_demotion | `0.1` |
+| memory_adjusted_retrieval_count | `2` |
+| memory_adjusted_node_count | `2` |
+
+추가로 검증된 동작:
+
+- retrieval ledger에 기록된 scope demotion diagnostics가 `memory_health()` summary로 집계된다.
+- positive boost, negative demotion, 전체 adjustment count를 health report에서 분리해서 볼 수 있다.
+
 ### 4. OpenIE off baseline smoke
 
 ```bash

eval/scripts/memory_operating_poc.py

@@ -511,6 +511,7 @@ async def run_memory_operating_poc(args: argparse.Namespace) -> dict[str, Any]:
             item for item in edge_only_penalty_result.nodes if item.node.id == edge_only_suspect.id
         )
         await graph._record_retrieval_event(edge_boost_result, scope=scope)
+        await graph._record_retrieval_event(negative_scope_result, scope=scope)
         await graph._record_retrieval_event(edge_only_penalty_result, scope=scope)
         for i in range(12):
             await backend.save_memory_score(
@@ -632,12 +633,23 @@ async def run_memory_operating_poc(args: argparse.Namespace) -> dict[str, Any]:
             ),
             "health_summarizes_memory_ranking_diagnostics": (
                 ranking_health.memory_boosted_retrieval_count >= 1
+                and ranking_health.memory_demoted_retrieval_count >= 1
+                and ranking_health.memory_adjusted_retrieval_count >= 2
                 and ranking_health.memory_penalized_retrieval_count >= 1
                 and ranking_health.memory_boosted_node_count >= 1
+                and ranking_health.memory_demoted_node_count >= 1
+                and ranking_health.memory_adjusted_node_count >= 2
                 and ranking_health.memory_penalized_node_count >= 1
                 and ranking_health.max_memory_scope_boost > 0.0
+                and ranking_health.max_memory_scope_demotion > 0.0
+                and ranking_health.max_memory_scope_adjustment > 0.0
                 and ranking_health.max_memory_signal_penalty > 0.0
             ),
+            "health_summarizes_scope_demotions": (
+                ranking_health.memory_demoted_retrieval_count >= 1
+                and ranking_health.memory_demoted_node_count >= 1
+                and ranking_health.max_memory_scope_demotion > 0.0
+            ),
             "health_reports_top_reinforced_edges": (
                 "poc_edge_score_boost_relation" in ranking_health.top_reinforced_edge_ids
             ),

src/synaptic/graph.py

@@ -2853,6 +2853,8 @@ async def _apply_scope_boost(self, result: SearchResult, scope: MemoryScope) ->
         adjusted_nodes = 0
         clamped_nodes = 0
         max_abs_boost = 0.0
+        max_positive_boost = 0.0
+        max_demotion = 0.0
         for idx, item in enumerate(result.nodes):
             raw = (
                 local_by_node.get(item.node.id, 0.0)
@@ -2866,8 +2868,10 @@ async def _apply_scope_boost(self, result: SearchResult, scope: MemoryScope) ->
                 max_abs_boost = max(max_abs_boost, abs(boost))
                 if boost > 0.0:
                     boosted_nodes += 1
+                    max_positive_boost = max(max_positive_boost, boost)
                 else:
                     demoted_nodes += 1
+                    max_demotion = max(max_demotion, abs(boost))
             item.activation = max(0.0, item.activation * (1.0 + boost))
             item.resonance = max(0.0, item.resonance * (1.0 + boost))
             if boost > 0.0 and idx > 0 and item.resonance > base_resonances[idx - 1]:
@@ -2883,6 +2887,8 @@ async def _apply_scope_boost(self, result: SearchResult, scope: MemoryScope) ->
         )
         result.diagnostics["memory_scope_edge_score_hits"] = float(len(edge_by_node))
         result.diagnostics["memory_scope_max_abs_boost"] = max_abs_boost
+        result.diagnostics["memory_scope_max_positive_boost"] = max_positive_boost
+        result.diagnostics["memory_scope_max_demotion"] = max_demotion
         result.diagnostics["memory_scope_order_clamps"] = float(clamped_nodes)
 
     async def _apply_memory_signal_penalties(
@@ -3282,20 +3288,54 @@ async def memory_health(
             if edge.id.startswith("openie_") or _prop_bool(edge.properties, "is_openie")
         )
         boosted_retrieval_count = 0
+        demoted_retrieval_count = 0
+        adjusted_retrieval_count = 0
         penalized_retrieval_count = 0
         boosted_node_count = 0
+        demoted_node_count = 0
+        adjusted_node_count = 0
         penalized_node_count = 0
         max_scope_boost = 0.0
+        max_scope_demotion = 0.0
+        max_scope_adjustment = 0.0
         max_signal_penalty = 0.0
         for event in retrieval_events:
             props = event.properties or {}
             boosted_nodes = _prop_int(props, "memory_scope_boosted_nodes", 0)
+            demoted_nodes = _prop_int(props, "memory_scope_demoted_nodes", 0)
+            adjusted_nodes = _prop_int(
+                props,
+                "memory_scope_adjusted_nodes",
+                boosted_nodes + demoted_nodes,
+            )
             penalized_nodes = _prop_int(props, "memory_signal_penalized_nodes", 0)
             if boosted_nodes > 0:
                 boosted_retrieval_count += 1
                 boosted_node_count += boosted_nodes
                 max_scope_boost = max(
                     max_scope_boost,
+                    _prop_float(
+                        props,
+                        "memory_scope_max_positive_boost",
+                        _prop_float(props, "memory_scope_max_abs_boost", 0.0),
+                    ),
+                )
+            if demoted_nodes > 0:
+                demoted_retrieval_count += 1
+                demoted_node_count += demoted_nodes
+                max_scope_demotion = max(
+                    max_scope_demotion,
+                    _prop_float(
+                        props,
+                        "memory_scope_max_demotion",
+                        _prop_float(props, "memory_scope_max_abs_boost", 0.0),
+                    ),
+                )
+            if adjusted_nodes > 0:
+                adjusted_retrieval_count += 1
+                adjusted_node_count += adjusted_nodes
+                max_scope_adjustment = max(
+                    max_scope_adjustment,
                     _prop_float(props, "memory_scope_max_abs_boost", 0.0),
                 )
             if penalized_nodes > 0:
@@ -3327,10 +3367,16 @@ async def memory_health(
             openie_artifact_count=openie_nodes + openie_edges,
             openie_failure_rate=(failures / selected) if selected else 0.0,
             memory_boosted_retrieval_count=boosted_retrieval_count,
+            memory_demoted_retrieval_count=demoted_retrieval_count,
+            memory_adjusted_retrieval_count=adjusted_retrieval_count,
             memory_penalized_retrieval_count=penalized_retrieval_count,
             memory_boosted_node_count=boosted_node_count,
+            memory_demoted_node_count=demoted_node_count,
+            memory_adjusted_node_count=adjusted_node_count,
             memory_penalized_node_count=penalized_node_count,
             max_memory_scope_boost=max_scope_boost,
+            max_memory_scope_demotion=max_scope_demotion,
+            max_memory_scope_adjustment=max_scope_adjustment,
             max_memory_signal_penalty=max_signal_penalty,
             top_reinforced_node_ids=[score.node_id for score in top_node_scores if score.node_id],
             top_reinforced_edge_ids=[score.edge_id for score in top_edge_scores if score.edge_id],

src/synaptic/models.py

@@ -261,10 +261,16 @@ class MemoryHealthReport:
     openie_artifact_count: int = 0
     openie_failure_rate: float = 0.0
     memory_boosted_retrieval_count: int = 0
+    memory_demoted_retrieval_count: int = 0
+    memory_adjusted_retrieval_count: int = 0
     memory_penalized_retrieval_count: int = 0
     memory_boosted_node_count: int = 0
+    memory_demoted_node_count: int = 0
+    memory_adjusted_node_count: int = 0
     memory_penalized_node_count: int = 0
     max_memory_scope_boost: float = 0.0
+    max_memory_scope_demotion: float = 0.0
+    max_memory_scope_adjustment: float = 0.0
     max_memory_signal_penalty: float = 0.0
     top_reinforced_node_ids: list[str] = field(default_factory=_str_list)
     top_reinforced_edge_ids: list[str] = field(default_factory=_str_list)

tests/test_memory_operating_layer.py

@@ -1265,7 +1265,22 @@ async def test_memory_health_summarizes_retrieval_ranking_diagnostics():
             scope=scope,
             properties={
                 "memory_scope_boosted_nodes": "2.000000",
+                "memory_scope_adjusted_nodes": "2.000000",
                 "memory_scope_max_abs_boost": "0.100000",
+                "memory_scope_max_positive_boost": "0.100000",
+            },
+        )
+    )
+    await backend.save_retrieval_event(
+        RetrievalEvent(
+            id="ret_demotion",
+            query="demotion",
+            scope=scope,
+            properties={
+                "memory_scope_demoted_nodes": "2.000000",
+                "memory_scope_adjusted_nodes": "2.000000",
+                "memory_scope_max_abs_boost": "0.080000",
+                "memory_scope_max_demotion": "0.080000",
             },
         )
     )
@@ -1299,12 +1314,18 @@ async def test_memory_health_summarizes_retrieval_ranking_diagnostics():
 
     health = await graph.memory_health(scope=scope, persist_signals=False)
 
-    assert health.retrieval_events == 2
+    assert health.retrieval_events == 3
     assert health.memory_boosted_retrieval_count == 1
+    assert health.memory_demoted_retrieval_count == 1
+    assert health.memory_adjusted_retrieval_count == 2
     assert health.memory_penalized_retrieval_count == 1
     assert health.memory_boosted_node_count == 2
+    assert health.memory_demoted_node_count == 2
+    assert health.memory_adjusted_node_count == 4
     assert health.memory_penalized_node_count == 1
     assert health.max_memory_scope_boost == pytest.approx(0.10)
+    assert health.max_memory_scope_demotion == pytest.approx(0.08)
+    assert health.max_memory_scope_adjustment == pytest.approx(0.10)
     assert health.max_memory_signal_penalty == pytest.approx(0.05)
     assert len(health.top_reinforced_node_ids) == 10
     assert health.top_reinforced_edge_ids == ["edge_top"]