feat(emotion-e4): add reliable afterglow delivery

这个提交存在于:
agent 2026-08-05 00:21:04 +08:00
父节点 e9872cc4dd
当前提交 d43e704b70
共有 4 个文件被更改,包括 319 次插入 和 7 次删除

查看文件

@ -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(

查看文件

@ -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(

查看文件

@ -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)

查看文件

@ -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()