@senpi/runtime 3.0.109 → 3.0.112

package/dist/runtime-api/server.d.ts

@@ -19,7 +19,7 @@ import type { RuntimeHandle } from "../runtime/run.js";
 import type { Logger } from "../utils/logger.js";
 import type { ApiConfig } from "./config.js";
 import type { IntakeContext } from "./intake/intake-context.js";
-import type { IntakeSignal } from "./intake/types.js";
+import type { IntakeSignal, IntakeTickFacts } from "./intake/types.js";
 /**
  * Dependencies passed to {@link createApi}.
  */
@@ -53,6 +53,12 @@ export interface CreateApiDeps {
      * a no-op (which is what made the `/errors` boundary silent before B1 Task 2).
      */
     onError?: (scannerId: string, error: Record<string, unknown>) => void;
+    /**
+     * Called once per producer tick, from whichever of the two intake routes that tick took, with
+     * the facts the producer measured about the run itself. Feeds the live per-tick level and
+     * nothing else. Only used when `intakeContext` is present; defaults to a no-op.
+     */
+    onTick?: (scannerId: string, tick: IntakeTickFacts) => void;
 }
 /**
  * Artifacts returned by {@link createApi}.

package/dist/runtime-api/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/runtime-api/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAKxD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,4EAA4E;IAC5E,SAAS,EAAE,SAAS,CAAC;IACrB,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACtF;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACvE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,YAAY,CAsF3D"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/runtime-api/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAKxD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIvE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,4EAA4E;IAC5E,SAAS,EAAE,SAAS,CAAC;IACrB,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACtF;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;CAC7D;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,YAAY,CAuF3D"}

package/dist/runtime-api/server.js

@@ -100,6 +100,7 @@ export function createApi(deps) {
             updateLiveness: (id, now) => deps.intakeContext.liveness.touch(id, now),
             onAccepted: deps.onAccepted ?? (() => { }),
             onError: deps.onError ?? (() => { }),
+            onTick: deps.onTick ?? (() => { }),
             maxItemsPerSignalsRequest: deps.apiConfig.maxItemsPerSignalsRequest,
             logger: deps.logger,
         });

package/dist/runtime-api/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/runtime-api/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/runtime-api/server.ts"],"names":[],"mappings":"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"}

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

@@ -11,8 +11,10 @@ build_delivery_sink(
     clock: Callable[[], float] = time.time,
 ) -> sink
 
-The returned sink is a callable: sink(candidates, tick_id=None)
-On each call it:
+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:
   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
@@ -22,8 +24,10 @@ On each call it:
   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) -> None
-    POSTs {scanner_id, error} to <intake_url>/errors. Fire-and-forget.
+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.
 
 Module constants:
     SIGNALS_PATH = "/signals"
@@ -76,6 +80,10 @@ def build_delivery_sink(
     # 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
@@ -221,9 +229,23 @@ def build_delivery_sink(
             for sig in signals
         ]
 
-    def _post_signals(signals: list[dict]) -> tuple[int, Any]:
-        """POST the signals list to the intake."""
+    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."""
         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(
@@ -315,7 +337,7 @@ def build_delivery_sink(
     # The sink callable
     # ------------------------------------------------------------------
 
-    def _sink(candidates, tick_id=None) -> None:
+    def _sink(candidates, tick_id=None, tick=None) -> None:
         tick_id = _usable_tick_id(tick_id)
         current_tick_id[0] = tick_id
 
@@ -330,6 +352,10 @@ 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)
 
@@ -351,9 +377,10 @@ def build_delivery_sink(
                 all_signals.append(sig)
                 all_eids.append(eid)
 
-        # 3. POST (always, even when signals==[])
+        # 3. POST (always, even when signals==[]) — which is what makes this the channel
+        # the tick facts ride: a quiet scanner still posts, every tick.
         try:
-            status, parsed = _post_signals(all_signals)
+            status, parsed = _post_signals(all_signals, tick_body)
         except TransportError as exc:
             log_event("delivery_transport_error", error=str(exc))
             # All signals remain undelivered -> retry on next tick
@@ -367,12 +394,15 @@ def build_delivery_sink(
         # 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.
-        if _is_shape_reject(status, parsed) and any(
-            isinstance(sig, dict) and "tick_id" in sig for sig in all_signals
-        ):
-            if not intake_predates_tick_id[0]:
+        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:
@@ -386,15 +416,32 @@ def build_delivery_sink(
         # even when the retry above had to send them without it.
         _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}
+    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.
+
+        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)
         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:
-            post_json(url, body, timeout)
+            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)
         except TransportError as exc:
             log_event("delivery_error_post_failed", error=str(exc), **origin)
         except Exception as exc:  # noqa: BLE001

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

@@ -43,6 +43,7 @@ from .loop_primitives import (
     log_event,
 )
 from .state_manager import StateManager
+from .tick_facts import build_tick_facts, count_changed, project_state_row
 from .ulid import new_ulid
 
 
@@ -105,22 +106,22 @@ def _build_senpi_mcp() -> Any:
     )
 
 
-def _sink_accepts_tick_id(sink: Any) -> bool:
-    """Whether `sink` takes the tick id as a keyword.
+def _accepts_kwarg(fn: Any, name: str) -> bool:
+    """Whether `fn` takes `name` as a keyword argument.
 
     Read from the signature, once, rather than calling with the keyword and retrying on
     TypeError: a sink that raises TypeError from its own body would then be called twice and
-    deliver the same candidates twice. A sink whose signature cannot be read keeps the
-    one-argument call it has today.
+    deliver the same candidates twice. A callable whose signature cannot be read keeps the
+    narrower call it has today.
     """
     try:
-        params = list(inspect.signature(sink).parameters.values())
+        params = list(inspect.signature(fn).parameters.values())
     except (TypeError, ValueError):
         return False
     return any(
         p.kind == inspect.Parameter.VAR_KEYWORD
         or (
-            p.name == "tick_id"
+            p.name == name
             and p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
         )
         for p in params
@@ -260,7 +261,24 @@ def run_scaffold(
     # The MCP boundary's per-tick failure tally, when the client exposes one. Duck-typed:
     # an injected stub without it (a validation run) simply never reclassifies a tick.
     mcp_tally = getattr(senpi_mcp, "tick_errors", None)
-    sink_takes_tick_id = sink is not None and _sink_accepts_tick_id(sink)
+    sink_takes_tick_id = sink is not None and _accepts_kwarg(sink, "tick_id")
+    # The per-tick observability facts ride the POST the sink already makes. A sink that
+    # predates them is called exactly as before, so an older sink is not broken by them.
+    sink_takes_tick = sink is not None and _accepts_kwarg(sink, "tick")
+    post_error_takes_tick = (
+        sink is not None
+        and hasattr(sink, "post_error")
+        and _accepts_kwarg(sink.post_error, "tick")
+    )
+
+    # Consecutive ticks that produced no candidate. 47 quiet ticks is information; the word
+    # "quiet" repeated 47 times is not, so the streak is counted here and sent as a number.
+    quiet_ticks = 0
+    # The previous tick's start, for the cadence lag. None on the first tick of a process:
+    # there is no gap to measure yet, and a 0 would claim the scanner was exactly on time.
+    prev_tick_started_at: Optional[float] = None
+    # The last projection reported, so `state_changed` says what MOVED rather than what exists.
+    prev_state_projection: Optional[dict] = None
 
     try:
         while not stop_event.is_set():
@@ -275,6 +293,14 @@ def run_scaffold(
             # error it reports names the same tick.
             tick_id = new_ulid()
             tick_started_at = time.time()
+            # Actual gap between tick starts, minus the cadence the scanner is configured for.
+            # A positive number is a scanner falling behind its own interval.
+            lag_ms = (
+                None
+                if prev_tick_started_at is None
+                else int(round((tick_started_at - prev_tick_started_at - interval) * 1000))
+            )
+            prev_tick_started_at = tick_started_at
             tick_status = "ok"
             tick_error = None
             candidates: list = []
@@ -365,7 +391,12 @@ def run_scaffold(
                         error_count=mcp_error_count,
                     )
 
+                # The quiet streak counts ticks, not words: a tick that produced a
+                # candidate ends the streak whatever its status.
+                quiet_ticks = 0 if candidates else quiet_ticks + 1
+
                 # --- Clean tick: commit ctx.state, deliver candidates ---
+                persist_error = None
                 if tick_status == "ok":
                     # Transactional commit. A failed persist RAISES (StateManager
                     # enforces it) and does NOT advance the committed snapshot — so
@@ -385,28 +416,75 @@ def run_scaffold(
                             error_type=type(commit_exc).__name__,
                             error=str(commit_exc),
                         )
-                        if sink is not None and hasattr(sink, "post_error"):
-                            _post_error_safe(
-                                sink,
-                                {
-                                    "type": "state_persist_failed",
-                                    "tick": tick_count,
-                                    "tick_id": tick_id,
-                                    "message": (
-                                        "scanner state could not be persisted; "
-                                        "tick discarded, state not advanced"
-                                    ),
-                                },
-                                tick_count,
-                                tick_id,
-                            )
+                        persist_error = {
+                            "type": "state_persist_failed",
+                            "tick": tick_count,
+                            "tick_id": tick_id,
+                            "message": (
+                                "scanner state could not be persisted; "
+                                "tick discarded, state not advanced"
+                            ),
+                        }
+                    commit_outcome = "committed" if committed else "persist_failed"
+                else:
+                    # Non-ok tick (error / timeout / malformed): roll back the
+                    # working buffer (discard the tick's mutations — state not
+                    # advanced) and report to /errors via the sink, when supported.
+                    ctx.state.rollback()
+                    committed = False
+                    commit_outcome = "rolled_back"
+
+                # Read AFTER the commit/rollback above, so this is always the last
+                # COMMITTED row — stale by one tick on a failed tick, which is exactly
+                # when the last state the scanner agreed on is worth seeing.
+                state_row = ctx.state.last()
+                state_projection = project_state_row(state_row)
+                state_fields = len(state_row) if isinstance(state_row, dict) else None
+                state_changed = (
+                    None
+                    if state_fields is None
+                    else count_changed(state_projection, prev_state_projection)
+                )
+                prev_state_projection = state_projection if state_fields is not None else None
+
+                tick_facts = build_tick_facts(
+                    tick_id=tick_id,
+                    status=tick_status,
+                    candidate_count=len(candidates),
+                    duration_ms=duration_ms,
+                    commit=commit_outcome,
+                    quiet_ticks=quiet_ticks,
+                    lag_ms=lag_ms,
+                    mcp_snapshot=mcp_tally.snapshot() if mcp_tally is not None else None,
+                    call_snapshot=(
+                        mcp_tally.call_snapshot()
+                        if mcp_tally is not None and hasattr(mcp_tally, "call_snapshot")
+                        else None
+                    ),
+                    state_row=state_row,
+                    state_fields=state_fields,
+                    state_changed=state_changed,
+                )
+
+                # Exactly one POST carries this tick's facts: /signals on a clean tick,
+                # /errors on any tick that failed. Both already happen every tick, so the
+                # facts add no request of their own.
+                sink_can_post_error = sink is not None and hasattr(sink, "post_error")
+                facts_for_error = tick_facts if post_error_takes_tick else None
+                if tick_status == "ok":
+                    if persist_error is not None and sink_can_post_error:
+                        _post_error_safe(
+                            sink, persist_error, tick_count, tick_id, facts_for_error
+                        )
 
                     if committed and sink is not None:
                         try:
+                            kwargs = {}
                             if sink_takes_tick_id:
-                                sink(candidates, tick_id=tick_id)
-                            else:
-                                sink(candidates)
+                                kwargs["tick_id"] = tick_id
+                            if sink_takes_tick:
+                                kwargs["tick"] = tick_facts
+                            sink(candidates, **kwargs)
                         except Exception as sink_exc:  # noqa: BLE001
                             log_event(
                                 "scaffold_sink_error",
@@ -415,18 +493,14 @@ def run_scaffold(
                                 error_type=type(sink_exc).__name__,
                                 error=str(sink_exc),
                             )
-                else:
-                    # Non-ok tick (error / timeout / malformed): roll back the
-                    # working buffer (discard the tick's mutations — state not
-                    # advanced) and report to /errors via the sink, when supported.
-                    ctx.state.rollback()
-                    if sink is not None and hasattr(sink, "post_error"):
-                        _post_error_safe(
-                            sink,
-                            tick_error or {"type": tick_status, "tick_id": tick_id},
-                            tick_count,
-                            tick_id,
-                        )
+                elif sink_can_post_error:
+                    _post_error_safe(
+                        sink,
+                        tick_error or {"type": tick_status, "tick_id": tick_id},
+                        tick_count,
+                        tick_id,
+                        facts_for_error,
+                    )
 
                 log_event(
                     "scaffold_tick_finished",
@@ -506,10 +580,24 @@ def _classify_mcp_errors(mcp_tally: Any, candidates: list) -> tuple[int, Optiona
     }
 
 
-def _post_error_safe(sink: Any, error: dict, tick_count: int, tick_id: str) -> None:
-    """Call sink.post_error(error), swallowing/logging any failure."""
+def _post_error_safe(
+    sink: Any,
+    error: dict,
+    tick_count: int,
+    tick_id: str,
+    tick: Optional[dict] = None,
+) -> None:
+    """Call sink.post_error(error), swallowing/logging any failure.
+
+    `tick` is passed only when the sink's signature accepts it — the caller checks
+    once at launch, so a sink that predates the per-tick facts keeps its one-argument
+    call rather than being handed a keyword it would raise on.
+    """
     try:
-        sink.post_error(error)
+        if tick is None:
+            sink.post_error(error)
+        else:
+            sink.post_error(error, tick=tick)
     except Exception as perr:  # noqa: BLE001
         log_event(
             "scaffold_post_error_failed",

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

@@ -404,28 +404,93 @@ def _cast_market_numerics(name: str, payload: Any, args: Optional[dict] = None)
     return payload
 
 
+# Per-call detail kept for one tick. The counts and the total duration below are
+# whole however many calls a tick makes; only this per-call list is cut, because
+# a scanner that calls a tool in a loop would otherwise grow an unbounded list
+# inside a process that must not grow.
+MAX_TICK_CALL_RECORDS = 64
+
+# Per-argument bounds for a recorded call. Arguments are author-supplied and
+# reach a watching operator's screen, so what is kept is scalars only, capped.
+MAX_TICK_CALL_ARG_KEYS = 16
+MAX_TICK_CALL_ARG_CHARS = 1024
+
+
+def _record_args(args: Optional[dict]) -> dict:
+    """The scalar arguments of one call, bounded — never the caller's own dict.
+
+    A reference would let authored code mutate what the tally already recorded,
+    and a deep copy would pay for a payload the wire is going to drop anyway.
+    """
+    if not isinstance(args, dict):
+        return {}
+    kept: dict = {}
+    for key in list(args.keys())[:MAX_TICK_CALL_ARG_KEYS]:
+        if not isinstance(key, str):
+            continue
+        value = args[key]
+        if isinstance(value, str):
+            kept[key] = value[:MAX_TICK_CALL_ARG_CHARS]
+        elif isinstance(value, bool) or (isinstance(value, (int, float)) and value == value):
+            kept[key] = value
+    return kept
+
+
 class TickErrorTally:
-    """Per-tick count of MCP call failures, by error type.
+    """Per-tick record of what the MCP boundary did: every call, and every failure.
+
+    Two tallies, one object, because both are read at the same moment and reset
+    at the same moment.
+
+    FAILURES. Authored scan() code routinely catches the MCP exception and
+    returns [], so the exception alone never reaches the scaffold — the tick
+    would finish `ok` with zero candidates while the scanner is blind. The client
+    records every failure here as it re-raises; the scaffold resets the tally at
+    tick start and reads it at tick end to decide whether a candidate-less tick
+    was really ok.
+
+    CALLS. Every call is recorded, succeeded or failed, with the time it took.
+    Failures alone say what broke but not what the tick actually did or where its
+    time went — a tick with no failures and one 9-second call is a slow venue, and
+    nothing else on the box can tell an operator that.
 
-    Authored scan() code routinely catches the MCP exception and returns [], so
-    the exception alone never reaches the scaffold — the tick would finish `ok`
-    with zero candidates while the scanner is blind. The client records every
-    failure here as it re-raises; the scaffold resets the tally at tick start and
-    reads it at tick end to decide whether a candidate-less tick was really ok.
     Thread-safe because call_tool may be driven from author threads.
     """
 
     def __init__(self) -> None:
         self._by_type: dict[str, int] = {}
+        self._calls: list[dict] = []
+        self._call_count = 0
+        self._total_ms = 0.0
         self._lock = threading.Lock()
 
     def record(self, error_type: str) -> None:
         with self._lock:
             self._by_type[error_type] = self._by_type.get(error_type, 0) + 1
 
+    def record_call(
+        self,
+        tool: str,
+        elapsed_ms: float,
+        args: Optional[dict] = None,
+        error_type: Optional[str] = None,
+    ) -> None:
+        """Record one completed call. Called on the success path and the failure path alike."""
+        entry = {"tool": tool, "ms": elapsed_ms, "args": _record_args(args)}
+        if error_type is not None:
+            entry["error_type"] = error_type
+        with self._lock:
+            self._call_count += 1
+            self._total_ms += elapsed_ms
+            if len(self._calls) < MAX_TICK_CALL_RECORDS:
+                self._calls.append(entry)
+
     def reset(self) -> None:
         with self._lock:
             self._by_type = {}
+            self._calls = []
+            self._call_count = 0
+            self._total_ms = 0.0
 
     def snapshot(self) -> dict[str, Any]:
         """{count, dominant_error_type, by_type}; count 0 / None when clean.
@@ -440,6 +505,15 @@ class TickErrorTally:
         dominant = max(by_type, key=by_type.__getitem__) if by_type else None
         return {"count": count, "dominant_error_type": dominant, "by_type": by_type}
 
+    def call_snapshot(self) -> dict[str, Any]:
+        """{count, total_ms, calls}. `count` and `total_ms` are whole; `calls` may be cut."""
+        with self._lock:
+            return {
+                "count": self._call_count,
+                "total_ms": round(self._total_ms, 1),
+                "calls": [dict(call) for call in self._calls],
+            }
+
 
 # --------------------------------------------------------------------------
 # Transport-failure classification — which errors mean "the session is dead".
@@ -670,7 +744,11 @@ class SenpiMcpClient:
 
             used = self._ensure_connected(name, deadline)
             result = self._run(used.session.call_tool(name, arguments=args), name, deadline)
-            return _cast_market_numerics(name, self._unwrap(name, result), args)
+            value = _cast_market_numerics(name, self._unwrap(name, result), args)
+            # Recorded after the unwrap, so a call that returned an `isError` result is
+            # counted on the failure path below and never twice.
+            self.tick_errors.record_call(name, round((time.monotonic() - started) * 1000, 1), args)
+            return value
         except Exception as exc:
             # Catch every failure — mutation block, missing creds, the lazy
             # `import mcp`, transport errors, timeouts, tool `isError` — tally
@@ -691,13 +769,15 @@ class SenpiMcpClient:
             # counts under the SAME name, so the dominant type a blind tick
             # reports to /errors matches the senpi_mcp_error lines beside it.
             error_type = "TimeoutError" if timed_out else type(primary).__name__
+            elapsed_ms = round((time.monotonic() - started) * 1000, 1)
             self.tick_errors.record(error_type)
+            self.tick_errors.record_call(name, elapsed_ms, args, error_type)
             log_event(
                 "senpi_mcp_error",
                 tool=name,
                 error_type=error_type,
                 error=str(primary)[:500],
-                elapsed_ms=round((time.monotonic() - started) * 1000, 1),
+                elapsed_ms=elapsed_ms,
                 **({"leaf_count": len(leaves)} if len(leaves) > 1 else {}),
                 **({"timeout_seconds": self._call_timeout} if timed_out else {}),
                 **({"session_rebuilt": True} if rebuilt else {}),