Signal strongly negative scope scores (#76)

Author: SonAIengine

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

@@ -383,6 +383,31 @@ uv run --extra sqlite python eval/scripts/memory_operating_poc.py \
 - scope score가 음수로 누적된 node/edge를 `memory_health()`에서 직접 확인할 수 있다.
 - reinforced summary는 양수 score만, demoted summary는 음수 score만 분리해서 보여준다.
 
+후속 strong negative scope score signal guard 검증:
+
+```bash
+uv run --extra sqlite python eval/scripts/memory_operating_poc.py \
+  --results ~/synaptic-eval/memory_operating_strong_negative_signal_results.json
+```
+
+결과:
+
+| 항목 | 값 |
+|---|---:|
+| result | PASS |
+| gates | `33/33` |
+| strong_negative_scope_score_signal_created | `true` |
+| signal_kind | `repeated_failure` |
+| score_signal_type | `strong_negative_scope_score` |
+| signal tags | `_memory_signal`, `_memory_suspect` |
+| score | `-1.000000` |
+
+추가로 검증된 동작:
+
+- `failure_count >= 3`이 아니어도 scope score가 강하게 음수이면 suspect signal 후보가 된다.
+- top demoted memory가 health summary에만 머물지 않고 pollution monitor signal로 연결된다.
+- signal provenance에는 `score_scope_key`, feedback count, score가 metadata로 남는다.
+
 ### 4. OpenIE off baseline smoke
 
 ```bash

eval/scripts/memory_operating_poc.py

@@ -537,6 +537,16 @@ async def run_memory_operating_poc(args: argparse.Namespace) -> dict[str, Any]:
                 )
             )
         ranking_health = await graph.memory_health(scope=scope)
+        ranking_signal_nodes = await backend.list_nodes(kind=NodeKind.OBSERVATION, limit=1000)
+        strong_negative_signal = next(
+            (
+                node
+                for node in ranking_signal_nodes
+                if node.properties.get("score_signal_type") == "strong_negative_scope_score"
+                and scope_demoted.id in node.properties.get("node_ids", "")
+            ),
+            None,
+        )
 
         selected_before_success = (
             selected_before_feedback.success_count if selected_before_feedback else -1
@@ -611,6 +621,10 @@ async def run_memory_operating_poc(args: argparse.Namespace) -> dict[str, Any]:
                 and consolidation_candidate.id in consolidation_result.nodes_updated
             ),
             "scope_score_repeated_failure_signal_created": (scope_score_failure_signal is not None),
+            "strong_negative_scope_score_signal_created": (
+                strong_negative_signal is not None
+                and "_memory_suspect" in (strong_negative_signal.tags or [])
+            ),
             "entity_property_conflict_signal_created": (property_conflict_signal is not None),
             "superseded_target_stale_signal_created": (superseded_stale_signal is not None),
             "signal_events_recorded_idempotently": (
@@ -749,6 +763,15 @@ async def run_memory_operating_poc(args: argparse.Namespace) -> dict[str, Any]:
                 "scope_score_failure_signal": (
                     asdict(scope_score_failure_signal) if scope_score_failure_signal else {}
                 ),
+                "strong_negative_scope_score_signal": (
+                    {
+                        "id": strong_negative_signal.id,
+                        "tags": list(strong_negative_signal.tags or []),
+                        "properties": dict(strong_negative_signal.properties or {}),
+                    }
+                    if strong_negative_signal
+                    else {}
+                ),
                 "property_conflict_signal": (
                     asdict(property_conflict_signal) if property_conflict_signal else {}
                 ),

src/synaptic/graph.py

@@ -239,6 +239,7 @@ def _infer_openie_model_profile(model: str) -> str:
 
 _MEMORY_SIGNAL_MIN_PENALTY_CONFIDENCE = 0.7
 _MEMORY_SIGNAL_MAX_RANKING_PENALTY = 0.05
+_MEMORY_STRONG_NEGATIVE_SCORE_SIGNAL_THRESHOLD = -0.5
 _MEMORY_DRIFT_MIN_FAILURES = 3
 _MEMORY_DRIFT_MIN_FAILURE_RATE = 0.25
 _MEMORY_PROPERTY_CONFLICT_IGNORED_KEYS = frozenset(
@@ -3194,22 +3195,41 @@ async def scan_memory_signals(
                 target = score.node_id or score.edge_id
                 if not target or target in repeated_failure_targets:
                     continue
-                if score.failure_count < 3 or score.failure_count <= score.success_count:
+                repeated_failure = (
+                    score.failure_count >= 3 and score.failure_count > score.success_count
+                )
+                strong_negative = score.score <= _MEMORY_STRONG_NEGATIVE_SCORE_SIGNAL_THRESHOLD
+                if not repeated_failure and not strong_negative:
                     continue
                 node_ids = [score.node_id] if score.node_id else []
                 edge_ids = [score.edge_id] if score.edge_id else []
+                signal_type = (
+                    "repeated_negative_feedback"
+                    if repeated_failure
+                    else "strong_negative_scope_score"
+                )
+                confidence = (
+                    0.75 if repeated_failure else min(0.9, max(0.7, 0.55 + abs(score.score) * 0.35))
+                )
+                reason = (
+                    "scope score has repeated negative retrieval feedback"
+                    if repeated_failure
+                    else "scope score is strongly negative from retrieval feedback"
+                )
                 signals.append(
                     self._make_signal(
                         MemorySignalKind.REPEATED_FAILURE,
                         signal_scope,
                         node_ids=node_ids,
                         edge_ids=edge_ids,
-                        confidence=0.75,
-                        reason="scope score has repeated negative retrieval feedback",
+                        confidence=confidence,
+                        reason=reason,
                         properties={
+                            "score_signal_type": signal_type,
                             "score_scope_key": score.scope_key,
                             "score_failure_count": str(score.failure_count),
                             "score_success_count": str(score.success_count),
+                            "score_access_count": str(score.access_count),
                             "score": f"{score.score:.6f}",
                         },
                     )

tests/test_memory_operating_layer.py

@@ -1507,6 +1507,49 @@ async def test_memory_monitor_flags_scope_score_repeated_failures_without_node_p
     assert health.repeated_failure_count >= 1
 
 
+@pytest.mark.asyncio
+async def test_memory_monitor_flags_strong_negative_scope_score_as_suspect():
+    backend = MemoryBackend()
+    graph = SynapticGraph(backend)
+    scope = MemoryScope(user_id="u1")
+    node = Node(id="strong_negative", title="Strong negative memory")
+    await backend.save_node(node)
+    await backend.save_memory_score(
+        MemoryScore(
+            scope_key=scope.key,
+            node_id=node.id,
+            access_count=1,
+            success_count=0,
+            failure_count=0,
+            score=-0.75,
+        )
+    )
+
+    signals = await graph.scan_memory_signals(scope=scope)
+    repeated = [
+        signal
+        for signal in signals
+        if MemorySignalKind(str(signal.kind)) == MemorySignalKind.REPEATED_FAILURE
+        and node.id in signal.node_ids
+    ]
+
+    assert repeated
+    assert repeated[0].properties["score_signal_type"] == "strong_negative_scope_score"
+    assert repeated[0].properties["score_scope_key"] == scope.key
+    assert repeated[0].properties["score"] == "-0.750000"
+    signal_nodes = await backend.list_nodes(kind=NodeKind.OBSERVATION, limit=100)
+    signal_node = next(
+        signal_node
+        for signal_node in signal_nodes
+        if signal_node.properties.get("score_signal_type") == "strong_negative_scope_score"
+    )
+    assert "_memory_suspect" in signal_node.tags
+
+    health = await graph.memory_health(scope=scope)
+    assert node.id in health.top_demoted_node_ids
+    assert health.repeated_failure_count >= 1
+
+
 @pytest.mark.asyncio
 async def test_memory_monitor_flags_entity_property_conflicts_by_source():
     backend = MemoryBackend()