@senpi/runtime 3.0.135 → 3.0.139

package/dist/scanners/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/scanners/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,sFAAsF;AACtF,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,6EAA6E;AAC7E,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,yCAAyC;AACzC,MAAM,WAAW,sBAAsB;IACrC,mBAAmB,EAAE,oBAAoB,CAAC;IAC1C,sBAAsB,EAAE,uBAAuB,CAAC;IAChD,kBAAkB,EAAE,mBAAmB,CAAC;IACxC,mBAAmB,EAAE,oBAAoB,CAAC;CAC3C;AAED,qEAAqE;AACrE,MAAM,MAAM,uBAAuB,GAAG,MAAM,sBAAsB,CAAC;AAEnE,sFAAsF;AACtF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,CAAC,SAAS,EAAE,uBAAuB,EAAE,KAAK,EAAE,sBAAsB,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAC1G,MAAM,EAAE,UAAU,GACjB,IAAI,CAmCN"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/scanners/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,sFAAsF;AACtF,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,6EAA6E;AAC7E,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,yCAAyC;AACzC,MAAM,WAAW,sBAAsB;IACrC,mBAAmB,EAAE,oBAAoB,CAAC;IAC1C,sBAAsB,EAAE,uBAAuB,CAAC;IAChD,kBAAkB,EAAE,mBAAmB,CAAC;IACxC,mBAAmB,EAAE,oBAAoB,CAAC;CAC3C;AAED,qEAAqE;AACrE,MAAM,MAAM,uBAAuB,GAAG,MAAM,sBAAsB,CAAC;AAEnE,sFAAsF;AACtF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,CAAC,SAAS,EAAE,uBAAuB,EAAE,KAAK,EAAE,sBAAsB,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAC1G,MAAM,EAAE,UAAU,GACjB,IAAI,CAiCN"}

package/dist/scanners/events.js

@@ -8,7 +8,6 @@ export function emitTerminalScannerRunEvent(emit, result) {
             scannerId: result.scannerId,
             timestamp,
             error: result.reason ?? "Unknown scanner error.",
-            tickId: result.tickId,
         });
         return;
     }
@@ -21,7 +20,6 @@ export function emitTerminalScannerRunEvent(emit, result) {
             timestamp,
             status: result.status,
             reason: result.reason ?? "Scanner run skipped.",
-            tickId: result.tickId,
         });
         return;
     }

package/dist/scanners/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/scanners/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmC,MAAM,YAAY,CAAC;AAuDzE,sFAAsF;AACtF,MAAM,UAAU,2BAA2B,CACzC,IAA0G,EAC1G,MAAkB;IAElB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACnC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,KAAK,EAAE,CAAC;QACvC,IAAI,CAAC,mBAAmB,EAAE;YACxB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,SAAS;YACT,KAAK,EAAE,MAAM,CAAC,MAAM,IAAI,wBAAwB;YAChD,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,IACE,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,OAAO;QACpC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM;QACnC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,QAAQ,EACrC,CAAC;QACD,IAAI,CAAC,kBAAkB,EAAE;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,SAAS;YACT,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,sBAAsB;YAC/C,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,IAAI,CAAC,sBAAsB,EAAE;QAC3B,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,SAAS;QACT,MAAM;KACP,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/scanners/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmC,MAAM,YAAY,CAAC;AAmDzE,sFAAsF;AACtF,MAAM,UAAU,2BAA2B,CACzC,IAA0G,EAC1G,MAAkB;IAElB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACnC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,KAAK,EAAE,CAAC;QACvC,IAAI,CAAC,mBAAmB,EAAE;YACxB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,SAAS;YACT,KAAK,EAAE,MAAM,CAAC,MAAM,IAAI,wBAAwB;SACjD,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,IACE,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,OAAO;QACpC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM;QACnC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,QAAQ,EACrC,CAAC;QACD,IAAI,CAAC,kBAAkB,EAAE;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,SAAS;YACT,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,sBAAsB;SAChD,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,IAAI,CAAC,sBAAsB,EAAE;QAC3B,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,SAAS;QACT,MAAM;KACP,CAAC,CAAC;AACL,CAAC"}

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

@@ -11,23 +11,18 @@ build_delivery_sink(
     clock: Callable[[], float] = time.time,
 ) -> sink
 
-The returned sink is a callable: sink(candidates, tick_id=None, tick=None)
-`tick` is the scaffold's per-tick observability facts; the sink stamps the journal's
-pending count onto them (it owns the journal) and rides them on the POST it already
-makes. On each call it:
+The returned sink is a callable: sink(candidates)
+On each call it:
   1. Replays journal on first call (if file-backed), re-queuing valid undelivered entries
   2. Flushes still-valid undelivered entries from prior ticks (retry)
-  3. Wraps this tick's candidates into wire signals (skips invalid ones), stamping the
-     producing tick's id on each
+  3. Wraps this tick's candidates into wire signals (skips invalid ones)
   4. Drops locally superseded / expired entries
   5. POSTs {scanner_id, signals:[...]} to <intake_url>/signals
   6. Interprets the response: accepted/expired/superseded/rejected = delivered;
      transport failure or non-success envelope leaves entry queued for retry
 
-sink.post_error(error: dict, tick: dict | None = None) -> None
-    POSTs {scanner_id, error} to <intake_url>/errors. Fire-and-forget. A failed tick's
-    facts ride here for the same reason they ride /signals on a clean one: this is the
-    POST that tick already makes.
+sink.post_error(error: dict) -> None
+    POSTs {scanner_id, error} to <intake_url>/errors. Fire-and-forget.
 
 Module constants:
     SIGNALS_PATH = "/signals"
@@ -64,47 +59,14 @@ 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()
-    # Distinct unusable tick-id shapes already warned about, same rate-limit reason: a loop
-    # handing the sink the same bad id every tick warns ONCE, not on every tick forever.
-    warned_unusable_tick_ids: set[str] = set()
-    # Set once per process, the first time the intake refuses a batch for carrying tick_id.
-    # From then on the field is left off the wire and the "this intake predates the field" line
-    # is not written again. Never cleared: an intake that refuses the field once would refuse it
-    # again, so re-arming would buy back the guaranteed-400 round-trip on every later tick.
-    intake_predates_tick_id = [False]
-    # The same latch for the body-level `tick` facts. Separate from the one above because
-    # they are separate fields on separate levels of the body: an intake may know one and
-    # not the other, and stripping both on either refusal would throw away what still works.
-    intake_predates_tick_facts = [False]
 
     # ------------------------------------------------------------------
     # 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)
 
@@ -127,40 +89,13 @@ def build_delivery_sink(
                 to_drop.append(entry)
         for entry in to_drop:
             journal.record_outcome(entry.id, "dropped_expired")
-            # 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)),
-            )
+            log_event("delivery_dropped_expired", entry_id=entry.id, asset=entry.asset)
         return to_send
 
-    def _usable_tick_id(tick_id: Any) -> str | None:
-        """The tick id to stamp, or None to leave the field off the wire entirely.
-
-        The intake requires a non-empty string and rejects the WHOLE post on one bad field, so an
-        unusable id is dropped here rather than taking the tick's signals down with it. No id at
-        all is the old call shape, not a fault, and is not logged.
-        """
-        if tick_id is None or (isinstance(tick_id, str) and tick_id):
-            return tick_id
-        shape = repr(tick_id)[:80]
-        if shape in warned_unusable_tick_ids:
-            return None
-        warned_unusable_tick_ids.add(shape)
-        log_event("delivery_tick_id_unusable", scanner_id=scanner_id, rejected_tick_id=shape)
-        return None
-
     def _on_reject(reason: dict) -> None:
         """Loud rejection: log AND POST to /errors (design §4 — never a silent drop)."""
-        # Merged into one dict before expanding: a reject record that happens to carry
-        # its own `tick_id` would otherwise be a duplicate kwarg — a TypeError raised
-        # here would take down the whole tick's delivery. The scaffold's id goes last,
-        # so the tick that actually ran the candidate is the one named.
-        log_event("delivery_candidate_invalid", **{**reason, **_tick_field(current_tick_id[0])})
-        _post_error({"type": "candidate_rejected", **reason, **_tick_field(current_tick_id[0])})
+        log_event("delivery_candidate_invalid", **reason)
+        _post_error({"type": "candidate_rejected", **reason})
 
     def _on_warn(info: dict) -> None:
         """Loud-but-non-fatal: a valid signal still emitted, but author top-level
@@ -175,10 +110,9 @@ 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]:
+    def _wrap_candidates(candidates, produced_at_ms: int) -> list[tuple]:
         """Wrap candidates into (signal, entry_id) pairs, skipping invalid ones.
 
         Schema-rejected candidates are NOT silently dropped: candidate_to_signal
@@ -201,51 +135,13 @@ def build_delivery_sink(
             )
             if sig is None:
                 continue
-            # Stamped before the journal writes the entry, so a retry — later in this process or
-            # after a restart — re-posts the id of the tick that PRODUCED the signal. Skipped
-            # once the intake has proved it predates the field: a stamped signal is refused and
-            # re-posted without it, and stamping again would buy that same 400 every tick.
-            if tick_id is not None and not intake_predates_tick_id[0]:
-                sig["tick_id"] = tick_id
             entry_id = journal.record_produced(sig, now_ms=produced_at_ms)
             result.append((sig, entry_id))
         return result
 
-    def _is_shape_reject(status: int, parsed: Any) -> bool:
-        """True when the intake refused the whole POST because it did not know the shape."""
-        if status != 400 or not isinstance(parsed, dict):
-            return False
-        err = parsed.get("error")
-        return isinstance(err, dict) and err.get("code") == "INVALID_SHAPE"
-
-    def _without_tick_id(signals: list[dict]) -> list[dict]:
-        """Copies of `signals` with `tick_id` removed.
-
-        Copies, never edits: the journal keeps each entry's producing tick, so once the intake
-        is upgraded a later retry of the same entry names it again.
-        """
-        return [
-            {k: v for k, v in sig.items() if k != "tick_id"} if isinstance(sig, dict) else sig
-            for sig in signals
-        ]
-
-    def _with_pending(tick: dict | None) -> dict | None:
-        """The tick facts plus the journal's BACKLOG, which only this closure knows.
-
-        Counted before this tick's own candidates are journalled, so the number is
-        signals from EARLIER ticks that the intake never acknowledged — a scanner
-        producing work that is not arriving. Counting this tick's own signals too
-        would put a 1 on every healthy signal-bearing tick and say nothing.
-        """
-        if tick is None:
-            return None
-        return {**tick, "journal_pending": len(journal.pending())}
-
-    def _post_signals(signals: list[dict], tick: dict | None = None) -> tuple[int, Any]:
-        """POST the signals list to the intake, with this tick's facts when it has any."""
+    def _post_signals(signals: list[dict]) -> tuple[int, Any]:
+        """POST the signals list to the intake."""
         body = {"scanner_id": scanner_id, "signals": signals}
-        if tick is not None and not intake_predates_tick_facts[0]:
-            body["tick"] = tick
         # Log the exact wire shape so a 400 can be matched to the field that broke.
         if signals:
             log_event(
@@ -258,7 +154,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_signals: list) -> bool:
+    def _interpret_response(status: int, parsed: Any, pending_eids: list[str], pending_entries: list) -> bool:
         """Interpret POST response; journal outcomes. Returns True if successful envelope."""
         if status != 200 or parsed is None:
             if isinstance(parsed, dict):
@@ -298,10 +194,6 @@ 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. Built only if one of
-        # those lines is actually reached: every POST pays for it otherwise, and the unknown-status
-        # branch that reads it is the rare one.
-        produced_by: dict | None = None
         for sig_status in per_signal:
             if not isinstance(sig_status, dict):
                 continue
@@ -319,16 +211,7 @@ def build_delivery_sink(
                 journal.record_outcome(eid, st)
             else:
                 # Unknown status — treat as undelivered (no outcome written)
-                if produced_by is None:
-                    produced_by = {
-                        e: _signal_tick_id(sig) for e, sig in zip(pending_eids, pending_signals)
-                    }
-                log_event(
-                    "delivery_unknown_status",
-                    entry_id=eid,
-                    status=st,
-                    **_tick_field(produced_by.get(eid)),
-                )
+                log_event("delivery_unknown_status", entry_id=eid, status=st)
         # Entries with no matching status returned stay pending (retry next tick).
 
         return True
@@ -337,10 +220,7 @@ def build_delivery_sink(
     # The sink callable
     # ------------------------------------------------------------------
 
-    def _sink(candidates, tick_id=None, tick=None) -> None:
-        tick_id = _usable_tick_id(tick_id)
-        current_tick_id[0] = tick_id
-
+    def _sink(candidates) -> None:
         # Replay journal on very first invocation
         if not replayed[0]:
             replayed[0] = True
@@ -352,12 +232,8 @@ def build_delivery_sink(
         # 1. Flush prior pending (retry candidates from older ticks)
         prior_entries = _flush_prior_pending(now_ms)
 
-        # Read here and not below: the backlog is what EARLIER ticks left behind, and
-        # step 2 is about to journal this tick's own candidates on top of it.
-        tick_body = _with_pending(tick)
-
         # 2. Wrap new candidates into signals
-        new_signal_pairs = _wrap_candidates(candidates, produced_at_ms, tick_id)
+        new_signal_pairs = _wrap_candidates(candidates, produced_at_ms)
 
         # Build the ordered signal list and corresponding entry-id list:
         # prior entries first (retry), then new ones.
@@ -377,75 +253,30 @@ def build_delivery_sink(
                 all_signals.append(sig)
                 all_eids.append(eid)
 
-        # 3. POST (always, even when signals==[]) — which is what makes this the channel
-        # the tick facts ride: a quiet scanner still posts, every tick.
+        # 3. POST (always, even when signals==[])
         try:
-            status, parsed = _post_signals(all_signals, tick_body)
+            status, parsed = _post_signals(all_signals)
         except TransportError as exc:
             log_event("delivery_transport_error", error=str(exc))
             # All signals remain undelivered -> retry on next tick
             # Empty-list no-ops: nothing to retry (no produced lines were written)
             return
 
-        # 3b. Forward-compat guard for an intake rolled back to before tick_id. Such an intake
-        # validates with additionalProperties:false, so it 400s the WHOLE batch on the unknown
-        # field — and because the journal re-posts the stored signal untouched, that batch is
-        # re-sent every tick forever, taking every fresh signal batched with it down too. Re-post
-        # the same batch without the field so one unknown key cannot strand real signals, and
-        # latch the discovery so later ticks leave the field off and stop paying the refused POST.
-        # Entries already journalled with an id still reach here and are still stripped per POST.
-        sent_tick_id = any(isinstance(sig, dict) and "tick_id" in sig for sig in all_signals)
-        sent_tick_facts = tick_body is not None and not intake_predates_tick_facts[0]
-        if _is_shape_reject(status, parsed) and (sent_tick_id or sent_tick_facts):
-            if sent_tick_id and not intake_predates_tick_id[0]:
-                intake_predates_tick_id[0] = True
-                log_event("delivery_intake_predates_tick_id", scanner_id=scanner_id)
-            if sent_tick_facts:
-                intake_predates_tick_facts[0] = True
-                log_event("delivery_intake_predates_tick_facts", scanner_id=scanner_id)
-            try:
-                status, parsed = _post_signals(_without_tick_id(all_signals))
-            except TransportError as exc:
-                log_event("delivery_transport_error", error=str(exc))
-                return
-
         # 4. Interpret response
         # The response per-signal list corresponds only to all_signals that have
-        # produced entries (all_eids). Empty no-ops: no eids. The signals are the ones the
-        # journal holds — with their tick ids — so a log line still names the producing tick
-        # even when the retry above had to send them without it.
-        _interpret_response(status, parsed, all_eids, all_signals)
-
-    def _post_error(error: dict, tick: dict | None = None) -> None:
-        """POST an error dict, with the failed tick's facts when the caller has them.
+        # produced entries (all_eids). Empty no-ops: no eids.
+        _interpret_response(status, parsed, all_eids, [])
 
-        Fire-and-forget, with one exception: an intake that refuses the body because it
-        does not know `tick` is retried once without it and latched, so a failed tick's
-        error record is never lost to a field that only telemetry wanted.
-        """
-        tick_body = _with_pending(tick)
+    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 {}
-
-        def _body(with_tick: bool) -> dict:
-            body = {"scanner_id": scanner_id, "error": error}
-            if with_tick and tick_body is not None and not intake_predates_tick_facts[0]:
-                body["tick"] = tick_body
-            return body
-
         try:
-            sent_tick_facts = tick_body is not None and not intake_predates_tick_facts[0]
-            status, parsed = post_json(url, _body(True), timeout)
-            if sent_tick_facts and _is_shape_reject(status, parsed):
-                intake_predates_tick_facts[0] = True
-                log_event("delivery_intake_predates_tick_facts", scanner_id=scanner_id)
-                post_json(url, _body(False), timeout)
+            post_json(url, body, timeout)
         except TransportError as exc:
-            log_event("delivery_error_post_failed", error=str(exc), **origin)
+            log_event("delivery_error_post_failed", error=str(exc))
         except Exception as exc:  # noqa: BLE001
-            log_event("delivery_error_post_failed", error=str(exc), **origin)
+            log_event("delivery_error_post_failed", error=str(exc))
 
     _sink.post_error = _post_error  # type: ignore[attr-defined]
     return _sink