diff --git a/core/bridge.py b/core/bridge.py index 25ad22f..732f4d6 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -1093,9 +1093,39 @@ class MemoryCompanionBridge: return await self._plugin.store.update_memory_visibility(memory_id, visibility) def get_emotional_events(self, *, session_id: str = "", limit: int = 5) -> list[dict[str, Any]]: - """Retrieve pending emotional drift events for the companion plugin.""" + """Legacy read-and-remove compatibility path; new consumers use list/ack.""" return self._plugin.bridge_get_emotional_events(session_id=session_id, limit=limit) + async def list_emotion_events( + self, + *, + consumer_id: str, + cursor: str = "", + session_id: str = "", + exclude_session_id: str = "", + limit: int = 10, + ) -> dict[str, Any]: + """List redacted pending afterglow events without consuming them.""" + return await self._plugin.store.list_emotion_event_deliveries( + consumer_id=consumer_id, + cursor=cursor, + session_id=session_id, + exclude_session_id=exclude_session_id, + limit=limit, + ) + + async def ack_emotion_events( + self, + event_refs: list[dict[str, Any]], + *, + consumer_id: str, + ) -> dict[str, Any]: + """Acknowledge only events durably applied by the named consumer.""" + return await self._plugin.store.ack_emotion_event_deliveries( + consumer_id=consumer_id, + event_refs=event_refs, + ) + async def record_emotion_event(self, event: dict[str, Any]) -> dict[str, Any]: """Persist one redacted event revision outside normal memory retrieval.""" return await self._plugin.store.upsert_emotion_event(event) @@ -1197,7 +1227,13 @@ class MemoryCompanionBridge: projection["touch_count"] = touch_count return projection - def get_recent_emotional_state(self) -> dict[str, Any]: + def get_recent_emotional_state( + self, + *, + exclude_session_id: str = "", + window_seconds: float = 1800.0, + limit: int = 5, + ) -> dict[str, Any]: """Return a summary of recent emotional events across ALL sessions. This provides cross-window emotional continuity for the companion plugin: @@ -1207,7 +1243,11 @@ class MemoryCompanionBridge: getter = getattr(self._plugin, "_get_cross_window_emotional_state", None) if not callable(getter): return {"total": 0, "scar_count": 0, "warm_count": 0, "vulnerable_count": 0} - return getter() + return getter( + exclude_session_id=exclude_session_id, + window_seconds=window_seconds, + limit=limit, + ) def _entity(self, payload: dict[str, Any]) -> EntityRef: return EntityRef( diff --git a/core/service.py b/core/service.py index cd6edf4..4ca9c84 100644 --- a/core/service.py +++ b/core/service.py @@ -1824,7 +1824,13 @@ class MemoryCompanionService: return "" return " ".join(hints) - def _get_cross_window_emotional_state(self) -> dict[str, Any]: + def _get_cross_window_emotional_state( + self, + *, + exclude_session_id: str = "", + window_seconds: float = 1800.0, + limit: int = 5, + ) -> dict[str, Any]: """Return a summary of recent emotional events across all sessions for the companion plugin.""" if not self.config.bool("private_companion_bridge.cross_window_emotional_continuity_enabled", False): return { @@ -1835,13 +1841,23 @@ class MemoryCompanionService: "vulnerable_count": 0, } now = time.time() - recent_window = 1800.0 + recent_window = max(60.0, min(86400.0, float(window_seconds or 1800.0))) + excluded = clean_text(exclude_session_id, 220) all_events: list[dict[str, Any]] = [] for session_id, queue in self._emotional_event_queue.items(): + if excluded and session_id == excluded: + continue for event in queue: age = now - event.get("ts", 0) if age < recent_window: - all_events.append({**event, "age_seconds": round(age, 0)}) + all_events.append({ + "event_id": clean_text(event.get("event_id") or event.get("id"), 96), + "session_id": clean_text(event.get("session_id"), 220), + "event_type": clean_text(event.get("event_type"), 48), + "energy_delta": max(-8.0, min(5.0, float(event.get("energy_delta") or 0.0))), + "age_seconds": round(max(0.0, age), 0), + "ts": float(event.get("ts") or 0.0), + }) if not all_events: return {"total": 0, "scar_count": 0, "warm_count": 0, "vulnerable_count": 0} all_events.sort(key=lambda e: e.get("ts", 0), reverse=True) @@ -1850,7 +1866,7 @@ class MemoryCompanionService: "scar_count": sum(1 for e in all_events if e.get("event_type") == "scar_touched"), "warm_count": sum(1 for e in all_events if e.get("event_type") == "warm_memory"), "vulnerable_count": sum(1 for e in all_events if e.get("event_type") == "vulnerable_resonance"), - "recent": all_events[:5], + "recent": all_events[: max(1, min(20, int(limit or 5)))], } async def _retrieval_cache_key( diff --git a/core/store.py b/core/store.py index d12cced..d87c9a6 100644 --- a/core/store.py +++ b/core/store.py @@ -521,6 +521,20 @@ class MemoryStore: created_at TEXT NOT NULL DEFAULT '', PRIMARY KEY(event_id, revision) ); + + CREATE TABLE IF NOT EXISTS emotion_event_deliveries ( + event_id TEXT NOT NULL, + revision INTEGER NOT NULL DEFAULT 1, + consumer_id TEXT NOT NULL, + attempts INTEGER NOT NULL DEFAULT 0, + first_delivered_at TEXT NOT NULL DEFAULT '', + last_delivered_at TEXT NOT NULL DEFAULT '', + acked_at TEXT NOT NULL DEFAULT '', + PRIMARY KEY(event_id, revision, consumer_id), + FOREIGN KEY(event_id, revision) + REFERENCES emotion_events(event_id, revision) + ON DELETE CASCADE + ); """ ) self._ensure_memory_columns_sync() @@ -582,6 +596,10 @@ class MemoryStore: self._conn.execute( "CREATE INDEX IF NOT EXISTS idx_emotion_events_dedupe ON emotion_events(dedupe_key, event_type)" ) + self._conn.execute( + "CREATE INDEX IF NOT EXISTS idx_emotion_event_deliveries_pending " + "ON emotion_event_deliveries(consumer_id, acked_at, last_delivered_at)" + ) self._conn.commit() def _ensure_retrieval_revision_sync(self) -> None: @@ -5649,6 +5667,172 @@ class MemoryStore: ).fetchall() return [self._emotion_event_row(row) for row in rows] + async def list_emotion_event_deliveries( + self, + *, + consumer_id: str, + session_id: str = "", + exclude_session_id: str = "", + cursor: str = "", + limit: int = 10, + ) -> dict[str, Any]: + return await self._run_recoverable_database_operation( + self._list_emotion_event_deliveries_sync, + consumer_id, + session_id, + exclude_session_id, + cursor, + limit, + ) + + def _list_emotion_event_deliveries_sync( + self, + consumer_id: str, + session_id: str, + exclude_session_id: str, + cursor: str, + limit: int, + ) -> dict[str, Any]: + consumer = clean_text(consumer_id, 80) + if not consumer: + return {"schema_version": "emotion_afterglow_delivery.v1", "events": [], "next_cursor": "", "has_more": False} + session = clean_text(session_id, 220) + excluded = clean_text(exclude_session_id, 220) + bounded_limit = max(1, min(20, int(limit or 10))) + clauses = [ + "e.origin_kind='memory_recall'", + "e.status NOT IN ('ignored','expired')", + "COALESCE(d.acked_at, '')=''", + ] + params: list[Any] = [consumer] + if session: + clauses.append("e.session_id=?") + params.append(session) + if excluded: + clauses.append("e.session_id!=?") + params.append(excluded) + with self._lock: + rows = self._conn.execute( + f""" + SELECT e.* + FROM emotion_events e + JOIN ( + SELECT event_id, MAX(revision) AS revision + FROM emotion_events + GROUP BY event_id + ) latest ON latest.event_id=e.event_id AND latest.revision=e.revision + LEFT JOIN emotion_event_deliveries d + ON d.event_id=e.event_id AND d.revision=e.revision AND d.consumer_id=? + WHERE {' AND '.join(clauses)} + ORDER BY e.occurred_at DESC, e.event_id DESC, e.revision DESC + LIMIT 201 + """, + params, + ).fetchall() + events = [self._emotion_event_row(row) for row in rows] + cursor_value = clean_text(cursor, 400) + if cursor_value: + positions = [self._emotion_delivery_cursor(item) for item in events] + try: + events = events[positions.index(cursor_value) + 1 :] + except ValueError: + events = [] + page = events[:bounded_limit] + has_more = len(events) > bounded_limit + delivered_at = utc_now() + for event in page: + self._conn.execute( + """ + INSERT INTO emotion_event_deliveries( + event_id, revision, consumer_id, attempts, + first_delivered_at, last_delivered_at, acked_at + ) VALUES(?,?,?,1,?,?,'') + ON CONFLICT(event_id, revision, consumer_id) DO UPDATE SET + attempts=emotion_event_deliveries.attempts+1, + last_delivered_at=excluded.last_delivered_at + """, + (event["event_id"], event["revision"], consumer, delivered_at, delivered_at), + ) + self._conn.commit() + projection = [self._emotion_delivery_projection(event) for event in page] + return { + "schema_version": "emotion_afterglow_delivery.v1", + "events": projection, + "next_cursor": self._emotion_delivery_cursor(page[-1]) if page and has_more else "", + "has_more": has_more, + } + + async def ack_emotion_event_deliveries( + self, + *, + consumer_id: str, + event_refs: list[dict[str, Any]], + ) -> dict[str, Any]: + return await self._run_recoverable_database_operation( + self._ack_emotion_event_deliveries_sync, consumer_id, event_refs + ) + + def _ack_emotion_event_deliveries_sync( + self, + consumer_id: str, + event_refs: list[dict[str, Any]], + ) -> dict[str, Any]: + consumer = clean_text(consumer_id, 80) + if not consumer or not isinstance(event_refs, list): + return {"acked": 0, "consumer_id": consumer} + unique_refs: set[tuple[str, int]] = set() + for item in event_refs[:100]: + if not isinstance(item, dict): + continue + event_id = clean_text(item.get("event_id"), 96) + try: + revision = max(1, min(1000000, int(item.get("revision") or 1))) + except (TypeError, ValueError): + continue + if event_id: + unique_refs.add((event_id, revision)) + acked_at = utc_now() + acked = 0 + with self._lock: + for event_id, revision in unique_refs: + cursor = self._conn.execute( + """ + UPDATE emotion_event_deliveries + SET acked_at=? + WHERE event_id=? AND revision=? AND consumer_id=? AND acked_at='' + """, + (acked_at, event_id, revision, consumer), + ) + acked += max(0, int(cursor.rowcount or 0)) + self._conn.commit() + return {"acked": acked, "consumer_id": consumer, "acked_at": acked_at} + + @staticmethod + def _emotion_delivery_cursor(event: dict[str, Any]) -> str: + return "|".join(( + clean_text(event.get("occurred_at"), 48), + clean_text(event.get("event_id"), 96), + str(max(1, int(event.get("revision") or 1))), + )) + + @staticmethod + def _emotion_delivery_projection(event: dict[str, Any]) -> dict[str, Any]: + return { + "event_id": clean_text(event.get("event_id"), 96), + "revision": max(1, int(event.get("revision") or 1)), + "trace_id": clean_text(event.get("trace_id"), 96), + "session_id": clean_text(event.get("session_id"), 220), + "event_type": clean_text(event.get("event_type"), 48), + "intensity": float(event.get("intensity") or 0.0), + "confidence": float(event.get("confidence") or 0.0), + "energy_delta": float(event.get("applied_energy_delta") or 0.0), + "valence": float(event.get("valence_hint") or 0.0), + "arousal": float(event.get("arousal_hint") or 0.0), + "vulnerability": float(event.get("vulnerability_hint") or 0.0), + "occurred_at": clean_text(event.get("occurred_at"), 48), + "expires_at": clean_text(event.get("expires_at"), 48), + } + @staticmethod def _emotion_event_row(row: sqlite3.Row) -> dict[str, Any]: result = dict(row) diff --git a/tests/test_emotion_e4_afterglow_delivery.py b/tests/test_emotion_e4_afterglow_delivery.py new file mode 100644 index 0000000..f7c828b --- /dev/null +++ b/tests/test_emotion_e4_afterglow_delivery.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import tempfile +from pathlib import Path +import sys +import unittest + + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) + +from core.emotion_event_contract import normalize_emotion_event # noqa: E402 +from core.store import MemoryStore # noqa: E402 + + +class EmotionE4AfterglowDeliveryTests(unittest.IsolatedAsyncioTestCase): + def make_store(self) -> MemoryStore: + temp_dir = tempfile.TemporaryDirectory() + self.addCleanup(temp_dir.cleanup) + store = MemoryStore(Path(temp_dir.name) / "memory.db") + store.initialize() + self.addCleanup(store.close) + return store + + async def add_event(self, store: MemoryStore, *, session_id: str, suffix: str) -> dict: + event = normalize_emotion_event({ + "event_id": f"emo-{suffix}", + "trace_id": f"trace-{suffix}", + "origin_kind": "memory_recall", + "session_id": session_id, + "event_type": "warm_memory", + "applied_energy_delta": 3.5, + "valence_hint": 0.4, + "dedupe_key": suffix, + }, producer_plugin="memory_companion") + return await store.upsert_emotion_event(event) + + async def test_list_retries_until_ack_and_returns_redacted_projection(self) -> None: + store = self.make_store() + event = await self.add_event(store, session_id="session-a", suffix="a") + first = await store.list_emotion_event_deliveries( + consumer_id="companion", session_id="session-a", limit=5 + ) + retry = await store.list_emotion_event_deliveries( + consumer_id="companion", session_id="session-a", limit=5 + ) + self.assertEqual([event["event_id"]], [item["event_id"] for item in first["events"]]) + self.assertEqual(first["events"], retry["events"]) + self.assertNotIn("memory_id", repr(first)) + self.assertNotIn("actor_ref", repr(first)) + ack = await store.ack_emotion_event_deliveries( + consumer_id="companion", + event_refs=[{"event_id": event["event_id"], "revision": 1}], + ) + self.assertEqual(1, ack["acked"]) + empty = await store.list_emotion_event_deliveries( + consumer_id="companion", session_id="session-a", limit=5 + ) + self.assertEqual([], empty["events"]) + + async def test_session_and_exclusion_filters_prevent_double_delivery(self) -> None: + store = self.make_store() + await self.add_event(store, session_id="session-a", suffix="a") + event_b = await self.add_event(store, session_id="session-b", suffix="b") + page = await store.list_emotion_event_deliveries( + consumer_id="companion", exclude_session_id="session-a", limit=5 + ) + self.assertEqual([event_b["event_id"]], [item["event_id"] for item in page["events"]]) + + +if __name__ == "__main__": + unittest.main()