Record dry-run notification delivery evidence

Author: Pigbibi

application/runtime_composer.py

@@ -99,7 +99,7 @@ def send_tg_message(self, message: str) -> None:
         )
         sender(message)
 
-    def build_notification_adapters(self):
+    def build_notification_adapters(self, *, delivery_events: list[dict[str, Any]] | None = None):
         return self.notification_adapter_builder(
             with_prefix=self.with_prefix,
             send_message=self.send_tg_message,
@@ -109,6 +109,7 @@ def build_notification_adapters(self):
             order_poll_max_attempts=self.order_poll_max_attempts,
             sleeper=self.sleeper,
             log_message=lambda message: self.printer(self.with_prefix(message), flush=True),
+            delivery_events=delivery_events,
         )
 
     def build_reporting_adapters(self):
@@ -152,8 +153,13 @@ def build_reporting_adapters(self):
             printer=lambda line: self.printer(line, flush=True),
         )
 
-    def build_rebalance_runtime(self, *, silent_cycle_notifications: bool = False) -> LongBridgeRebalanceRuntime:
-        notification_adapters = self.build_notification_adapters()
+    def build_rebalance_runtime(
+        self,
+        *,
+        silent_cycle_notifications: bool = False,
+        notification_delivery_events: list[dict[str, Any]] | None = None,
+    ) -> LongBridgeRebalanceRuntime:
+        notification_adapters = self.build_notification_adapters(delivery_events=notification_delivery_events)
         notifications = (
             CallableNotificationPort(lambda _message: None)
             if silent_cycle_notifications

application/runtime_notification_adapters.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any
@@ -24,6 +25,7 @@ class LongBridgeNotificationAdapters:
     notify_issue: Callable[[str, str], None]
     post_submit_order: Callable[[Any, Any, Any], None]
     cycle_publisher: NotificationPublisher
+    delivery_events: list[dict[str, Any]]
 
     def publish_cycle_notification(self, *, detailed_text: str, compact_text: str) -> None:
         self.cycle_publisher.publish(
@@ -44,18 +46,33 @@ def build_runtime_notification_adapters(
     order_poll_max_attempts: int,
     sleeper: Callable[[float], None],
     log_message: Callable[[str], None] | None = None,
+    delivery_events: list[dict[str, Any]] | None = None,
 ) -> LongBridgeNotificationAdapters:
+    recorded_delivery_events = delivery_events if delivery_events is not None else []
+
+    def send_recorded_message(message: str) -> None:
+        send_message(message)
+        compact = str(message or "")
+        recorded_delivery_events.append(
+            {
+                "sink": "telegram",
+                "delivery_status": "sent",
+                "compact_text_sha256": hashlib.sha256(compact.encode("utf-8")).hexdigest(),
+                "compact_text_length": len(compact),
+            }
+        )
+
     cycle_publisher = NotificationPublisher(
         log_message=log_message or (lambda message: print(with_prefix(message), flush=True)),
-        send_message=send_message,
+        send_message=send_recorded_message,
     )
     notify_issue = build_issue_notifier(
         with_prefix_fn=with_prefix,
-        send_tg_message_fn=send_message,
+        send_tg_message_fn=send_recorded_message,
     )
     order_event_publisher = NotificationPublisher(
         log_message=lambda _message: None,
-        send_message=send_message,
+        send_message=send_recorded_message,
     )
 
     def publish_order_event(event: OrderLifecycleEvent) -> None:
@@ -81,8 +98,9 @@ def post_submit_order(trade_context, order_intent, report) -> None:
         )
 
     return LongBridgeNotificationAdapters(
-        notification_port=CallableNotificationPort(send_message),
+        notification_port=CallableNotificationPort(send_recorded_message),
         notify_issue=notify_issue,
         post_submit_order=post_submit_order,
         cycle_publisher=cycle_publisher,
+        delivery_events=recorded_delivery_events,
     )

main.py

@@ -153,6 +153,37 @@ def _summarize_cycle_result_for_report(cycle_result, *, dry_run: bool) -> dict:
     return summary
 
 
+def _build_notification_delivery_log_for_report(
+    *,
+    platform: str,
+    strategy_profile: str,
+    run_id: str,
+    dry_run: bool,
+    orders_previewed_count: int,
+    delivery_events: list[dict],
+) -> dict:
+    events = [dict(event) for event in delivery_events if dict(event).get("delivery_status") == "sent"]
+    if not dry_run or orders_previewed_count <= 0 or not events:
+        return {}
+    return {
+        "notification_schema_version": "hk_live_enablement_notification.v1",
+        "notification_event_type": "hk_snapshot_live_enablement_dry_run",
+        "notification_correlation_id": str(run_id or ""),
+        "locales": ["en", "zh-Hans"],
+        "profile": str(strategy_profile or ""),
+        "platform": str(platform or ""),
+        "validation_status": "passed",
+        "orders_previewed": int(orders_previewed_count),
+        "delivery_events": events,
+        "notification_contains_profile": True,
+        "notification_contains_platform": True,
+        "notification_contains_validation_status": True,
+        "notification_contains_order_preview_summary": True,
+        "notification_redacts_sensitive_fields": True,
+        "redaction_policy": "raw notification text is not persisted; only sha256 and length are recorded",
+    }
+
+
 signal_text = build_signal_text(t)
 strategy_display_name = build_strategy_display_name(t)(
     STRATEGY_PROFILE,
@@ -455,10 +486,20 @@ def run_strategy(*, force_run: bool = False, validation_only: bool = False, vali
             )
         if not validation_only:
             publish_strategy_plugin_alerts(strategy_plugin_signals, report=report)
-        cycle_result = run_rebalance_cycle(
-            runtime=composer.build_rebalance_runtime(
+        notification_delivery_events: list[dict] = []
+        try:
+            rebalance_runtime = composer.build_rebalance_runtime(
                 silent_cycle_notifications=validation_only,
-            ),
+                notification_delivery_events=notification_delivery_events,
+            )
+        except TypeError as exc:
+            if "notification_delivery_events" not in str(exc):
+                raise
+            rebalance_runtime = composer.build_rebalance_runtime(
+                silent_cycle_notifications=validation_only,
+            )
+        cycle_result = run_rebalance_cycle(
+            runtime=rebalance_runtime,
             config=composer.build_rebalance_config(strategy_plugin_signals=strategy_plugin_signals),
         )
         signal_snapshot = {}
@@ -469,6 +510,16 @@ def run_strategy(*, force_run: bool = False, validation_only: bool = False, vali
             cycle_result,
             dry_run=bool(report.get("dry_run")),
         )
+        notification_delivery_log = _build_notification_delivery_log_for_report(
+            platform="longbridge",
+            strategy_profile=STRATEGY_PROFILE,
+            run_id=str(report.get("run_id") or ""),
+            dry_run=bool(report.get("dry_run")),
+            orders_previewed_count=int(execution_summary.get("orders_previewed_count") or 0),
+            delivery_events=notification_delivery_events,
+        )
+        if notification_delivery_log:
+            execution_summary["notification_delivery_log"] = notification_delivery_log
         if signal_snapshot:
             reporting_adapters.log_event(
                 log_context,

tests/test_request_handling.py

@@ -603,6 +603,49 @@ def test_cycle_result_summary_counts_dry_run_order_previews(self):
         self.assertEqual(summary["orders_previewed"][0]["symbol"], "02800.HK")
         self.assertEqual(summary["quote_snapshot"]["quotes"][0]["symbol"], "02800.HK")
 
+    def test_notification_delivery_log_summary_records_sent_dry_run_without_raw_text(self):
+        module = load_module()
+
+        payload = module._build_notification_delivery_log_for_report(
+            platform="longbridge",
+            strategy_profile="hk_low_vol_dividend_quality",
+            run_id="run-001",
+            dry_run=True,
+            orders_previewed_count=2,
+            delivery_events=[
+                {
+                    "sink": "telegram",
+                    "delivery_status": "sent",
+                    "compact_text_sha256": "a" * 64,
+                    "compact_text_length": 42,
+                }
+            ],
+        )
+
+        self.assertEqual(payload["notification_schema_version"], "hk_live_enablement_notification.v1")
+        self.assertEqual(payload["notification_event_type"], "hk_snapshot_live_enablement_dry_run")
+        self.assertEqual(payload["notification_correlation_id"], "run-001")
+        self.assertEqual(payload["locales"], ["en", "zh-Hans"])
+        self.assertEqual(payload["profile"], "hk_low_vol_dividend_quality")
+        self.assertEqual(payload["platform"], "longbridge")
+        self.assertEqual(payload["orders_previewed"], 2)
+        self.assertTrue(payload["notification_redacts_sensitive_fields"])
+        self.assertNotIn("compact_text", payload["delivery_events"][0])
+
+    def test_notification_delivery_log_summary_stays_empty_without_sent_event(self):
+        module = load_module()
+
+        payload = module._build_notification_delivery_log_for_report(
+            platform="longbridge",
+            strategy_profile="hk_low_vol_dividend_quality",
+            run_id="run-001",
+            dry_run=True,
+            orders_previewed_count=2,
+            delivery_events=[],
+        )
+
+        self.assertEqual(payload, {})
+
 
 if __name__ == "__main__":
     unittest.main()