@senpi/runtime 3.0.93 → 3.0.94

package/dist/scanners/external/scaffold/delivery.py

@@ -60,6 +60,11 @@ def build_delivery_sink(
 
     journal = Journal(journal_path)
     replayed = [False]  # mutable cell; replay runs once on first invocation
+    # Mutable cell; the id of the tick currently inside _sink, so the reject/warn
+    # callbacks — which are built once, here — can name it. _sink sets it on entry,
+    # before anything can read it, and both callbacks run only from inside _sink.
+    # None when the caller passed no id, or one the wire would refuse.
+    current_tick_id: list[str | None] = [None]
     # Distinct dropped-field shapes already warned about (rate-limit: a scanner that
     # sets a stray key every tick warns ONCE per shape, not every tick).
     warned_dropped_shapes: set[frozenset] = set()
@@ -68,6 +73,22 @@ def build_delivery_sink(
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _tick_field(tick_id: Any) -> dict:
+        """`tick_id=...` as log kwargs, or nothing at all when no tick is nameable.
+
+        An absent key is the honest answer; a null or a blank would join to nothing
+        while looking like an id.
+        """
+        return {"tick_id": tick_id} if isinstance(tick_id, str) and tick_id else {}
+
+    def _signal_tick_id(signal: Any) -> Any:
+        """The producing tick's id off a stored signal, or None.
+
+        A journal line is arbitrary text on disk: `signal` may be a null, a string or
+        a list, so this never assumes a mapping.
+        """
+        return signal.get("tick_id") if isinstance(signal, dict) else None
+
     def _now_ms() -> int:
         return int(clock() * 1000)
 
@@ -90,7 +111,14 @@ def build_delivery_sink(
                 to_drop.append(entry)
         for entry in to_drop:
             journal.record_outcome(entry.id, "dropped_expired")
-            log_event("delivery_dropped_expired", entry_id=entry.id, asset=entry.asset)
+            # The producing tick's id, read off the journalled signal — the tick that
+            # noticed the expiry did not cause it.
+            log_event(
+                "delivery_dropped_expired",
+                entry_id=entry.id,
+                asset=entry.asset,
+                **_tick_field(_signal_tick_id(entry.signal)),
+            )
         return to_send
 
     def _usable_tick_id(tick_id: Any) -> str | None:
@@ -102,12 +130,12 @@ def build_delivery_sink(
         """
         if tick_id is None or (isinstance(tick_id, str) and tick_id):
             return tick_id
-        log_event("delivery_tick_id_unusable", scanner_id=scanner_id, tick_id=repr(tick_id)[:80])
+        log_event("delivery_tick_id_unusable", scanner_id=scanner_id, rejected_tick_id=repr(tick_id)[:80])
         return None
 
     def _on_reject(reason: dict) -> None:
         """Loud rejection: log AND POST to /errors (design §4 — never a silent drop)."""
-        log_event("delivery_candidate_invalid", **reason)
+        log_event("delivery_candidate_invalid", **_tick_field(current_tick_id[0]), **reason)
         _post_error({"type": "candidate_rejected", **reason})
 
     def _on_warn(info: dict) -> None:
@@ -123,6 +151,7 @@ def build_delivery_sink(
             scanner_id=scanner_id,
             dropped=info.get("dropped"),
             asset=info.get("asset"),
+            **_tick_field(current_tick_id[0]),
         )
 
     def _wrap_candidates(candidates, produced_at_ms: int, tick_id: str | None) -> list[tuple]:
@@ -171,7 +200,7 @@ def build_delivery_sink(
         url = intake_url.rstrip("/") + SIGNALS_PATH
         return post_json(url, body, timeout)
 
-    def _interpret_response(status: int, parsed: Any, pending_eids: list[str], pending_entries: list) -> bool:
+    def _interpret_response(status: int, parsed: Any, pending_eids: list[str], pending_signals: list) -> bool:
         """Interpret POST response; journal outcomes. Returns True if successful envelope."""
         if status != 200 or parsed is None:
             if isinstance(parsed, dict):
@@ -211,6 +240,10 @@ def build_delivery_sink(
         # signals), and unknown/missing signal_id (ignored safely, never applied by
         # position). An unmatched entry stays pending and is retried.
         pending = set(pending_eids)
+        # eid -> the tick that produced it, for the per-entry lines below.
+        produced_by = {
+            eid: _signal_tick_id(sig) for eid, sig in zip(pending_eids, pending_signals)
+        }
         for sig_status in per_signal:
             if not isinstance(sig_status, dict):
                 continue
@@ -228,7 +261,12 @@ def build_delivery_sink(
                 journal.record_outcome(eid, st)
             else:
                 # Unknown status — treat as undelivered (no outcome written)
-                log_event("delivery_unknown_status", entry_id=eid, status=st)
+                log_event(
+                    "delivery_unknown_status",
+                    entry_id=eid,
+                    status=st,
+                    **_tick_field(produced_by.get(eid)),
+                )
         # Entries with no matching status returned stay pending (retry next tick).
 
         return True
@@ -239,6 +277,7 @@ def build_delivery_sink(
 
     def _sink(candidates, tick_id=None) -> None:
         tick_id = _usable_tick_id(tick_id)
+        current_tick_id[0] = tick_id
 
         # Replay journal on very first invocation
         if not replayed[0]:
@@ -284,18 +323,21 @@ def build_delivery_sink(
         # 4. Interpret response
         # The response per-signal list corresponds only to all_signals that have
         # produced entries (all_eids). Empty no-ops: no eids.
-        _interpret_response(status, parsed, all_eids, [])
+        _interpret_response(status, parsed, all_eids, all_signals)
 
     def _post_error(error: dict) -> None:
         """POST an error dict. Fire-and-forget."""
         body = {"scanner_id": scanner_id, "error": error}
         url = intake_url.rstrip("/") + ERRORS_PATH
+        # The error belongs to exactly one tick and already names it; a body that
+        # names none leaves the key off rather than borrowing the current one.
+        origin = _tick_field(error.get("tick_id")) if isinstance(error, dict) else {}
         try:
             post_json(url, body, timeout)
         except TransportError as exc:
-            log_event("delivery_error_post_failed", error=str(exc))
+            log_event("delivery_error_post_failed", error=str(exc), **origin)
         except Exception as exc:  # noqa: BLE001
-            log_event("delivery_error_post_failed", error=str(exc))
+            log_event("delivery_error_post_failed", error=str(exc), **origin)
 
     _sink.post_error = _post_error  # type: ignore[attr-defined]
     return _sink

package/dist/scanners/external/scaffold/scaffold.py

@@ -261,6 +261,7 @@ def run_scaffold(
                         log_event(
                             "scaffold_tick_malformed",
                             tick=tick_count,
+                            tick_id=tick_id,
                             reason=malformed_reason,
                         )
                     else:
@@ -273,6 +274,7 @@ def run_scaffold(
                     log_event(
                         "scaffold_tick_timeout",
                         tick=tick_count,
+                        tick_id=tick_id,
                         reason=str(exc),
                     )
                 except Exception as exc:  # noqa: BLE001 — author bug must not crash scaffold
@@ -287,6 +289,7 @@ def run_scaffold(
                     log_event(
                         "scaffold_tick_error",
                         tick=tick_count,
+                        tick_id=tick_id,
                         error_type=type(exc).__name__,
                         error=str(exc),
                     )
@@ -312,6 +315,7 @@ def run_scaffold(
                         log_event(
                             "scaffold_state_persist_failed",
                             tick=tick_count,
+                            tick_id=tick_id,
                             error_type=type(commit_exc).__name__,
                             error=str(commit_exc),
                         )
@@ -328,6 +332,7 @@ def run_scaffold(
                                     ),
                                 },
                                 tick_count,
+                                tick_id,
                             )
 
                     if committed and sink is not None:
@@ -340,6 +345,7 @@ def run_scaffold(
                             log_event(
                                 "scaffold_sink_error",
                                 tick=tick_count,
+                                tick_id=tick_id,
                                 error_type=type(sink_exc).__name__,
                                 error=str(sink_exc),
                             )
@@ -353,11 +359,13 @@ def run_scaffold(
                             sink,
                             tick_error or {"type": tick_status, "tick_id": tick_id},
                             tick_count,
+                            tick_id,
                         )
 
                 log_event(
                     "scaffold_tick_finished",
                     tick=tick_count,
+                    tick_id=tick_id,
                     status=tick_status,
                     duration_ms=duration_ms,
                     candidate_count=len(candidates),
@@ -376,6 +384,7 @@ def run_scaffold(
                 log_event(
                     "scaffold_tick_timeout_late",
                     tick=tick_count,
+                    tick_id=tick_id,
                     reason=str(late_exc),
                 )
 
@@ -401,7 +410,7 @@ def run_scaffold(
     return tick_count
 
 
-def _post_error_safe(sink: Any, error: dict, tick_count: int) -> None:
+def _post_error_safe(sink: Any, error: dict, tick_count: int, tick_id: str) -> None:
     """Call sink.post_error(error), swallowing/logging any failure."""
     try:
         sink.post_error(error)
@@ -409,6 +418,7 @@ def _post_error_safe(sink: Any, error: dict, tick_count: int) -> None:
         log_event(
             "scaffold_post_error_failed",
             tick=tick_count,
+            tick_id=tick_id,
             error_type=type(perr).__name__,
             error=str(perr),
         )

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "runtime",
   "name": "Senpi Runtime",
   "description": "Senpi runtime plugin for OpenClaw. Orchestrates scanners, LLM-based trade decisions, and a DSL trailing stop-loss exit engine.",
-  "version": "3.0.93",
+  "version": "3.0.94",
   "commandAliases": [
     {
       "name": "senpi"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senpi/runtime",
-  "version": "3.0.93",
+  "version": "3.0.94",
   "description": "Senpi runtime plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",