@senpi/runtime 3.0.148 → 3.0.149

package/dist/quant/engine/quantdesk/senpi_history.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Closed round trips from Senpi discovery (`discovery_get_trader_history`) — the PRIMARY source when a
+Senpi token is present. Senpi ingests the whole fill stream, TWAP slices included, so its closed positions
+are complete where the public endpoints are not. Rows are mapped onto the same episode schema the
+fill-based tracker produces, so every downstream module is source-agnostic.
+
+Row fields (guide `senpi://guides/trader-closed-positions`): closedOrderId, coin, coinDisplayName, entryPx,
+exitPx, leverage{type,value}, maxLeverage, openTime, closeTime (ms), szi (absolute size), realizedPnl
+(gross of fees), marginUsed, type, totalFills, totalFees (signed). Numbers arrive as strings.
+
+`type` is the exchange's own label and is the ONLY place a liquidation is named: "Close Long",
+"Close Short", "Liquidated Cross Long", "Liquidated Isolated Short", "Auto-Deleveraging". A row whose
+opening side discovery could not rebuild arrives with szi, entryPx and openTime all ZERO — common on
+cross-liquidations and HIP-3 `xyz:` assets. Those rows still carry real realized P&L, so they are kept
+and marked `complete=False`/`truncated=True` rather than dropped."""
+# Copyright 2026 Senpi (https://senpi.ai) — Apache-2.0
+PAGE = 200
+MAX_PAGES = 25
+
+
+def _num(v, d=0.0):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return d
+
+
+def _ms(t):
+    t = _num(t)
+    return t * 1000.0 if t and t < 1e12 else t
+
+
+def _rows(data):
+    if isinstance(data, dict):
+        if data.get("success") is False:
+            return []
+        data = data.get("data", data)
+    if isinstance(data, dict):
+        for k in ("closedPositions", "closed_positions", "positions", "data"):
+            v = data.get(k)
+            if isinstance(v, list):
+                return v
+        return []
+    return data if isinstance(data, list) else []
+
+
+def fetch(client, addr, window_start_ms, meta):
+    """Page newest-first until a page ends before the window; returns episode dicts closed in the window.
+
+    Sets `meta["senpi_history_failed"]` when a page could not be READ — an exception or a
+    `success: false` envelope. An empty list means one of two very different things, and the caller
+    has to tell them apart: senpi has no closed positions for this wallet in the window (a quiet
+    wallet, or one that is not indexed yet), or senpi could not answer. Reporting the second as the
+    first tells an indexed reader they are not indexed — and, since the desk offers to flag them to
+    the team, promises something about a wallet that is already there.
+    """
+    out, offset = [], 0
+    for _page in range(MAX_PAGES):
+        try:
+            resp = client.mcp_call("discovery_get_trader_history", trader_address=addr, latest=True, limit=PAGE, offset=offset,
+                                   sort_by="CLOSED_TIME", sort_direction="DESC", timeout=20)
+        except Exception as e:  # noqa: BLE001
+            meta.setdefault("warnings", []).append(f"senpi history page {offset // PAGE} failed: {e}")
+            meta["senpi_history_failed"] = True
+            # Pages already read are a PREFIX of the history, not the history. Breaking with `out`
+            # non-empty shipped a truncated record as a complete one — same source line, same
+            # `indexed: True`, totals quietly short. (@0xsarvesh, #718.)
+            if out:
+                meta["senpi_history_partial"] = True
+            break
+        if isinstance(resp, dict) and resp.get("success") is False:
+            # `_rows` flattens this to [] like any empty page, and it is the shape a degraded
+            # discovery service returns most often — so it has to be caught before that.
+            meta.setdefault("warnings", []).append(
+                f"senpi history page {offset // PAGE} refused: {str((resp.get('error') or {}).get('code') or 'success=false')[:80]}")
+            meta["senpi_history_failed"] = True
+            break
+        rows = _rows(resp)
+        if not rows:
+            break
+        for r in rows:
+            e = episode(r)
+            if e and e["close_time"] >= window_start_ms:
+                out.append(e)
+        if _ms(rows[-1].get("closeTime")) < window_start_ms or len(rows) < PAGE:
+            break
+        offset += PAGE
+    else:
+        # Fell out of the loop without ever hitting a short page: there is more history than
+        # MAX_PAGES covers and what we hold is a PREFIX. This exits NORMALLY, so #733's flag — set
+        # only in the except branch — never fired, and a truncated record shipped as complete with
+        # indexed=True. (@danielmbirochi, #718.)
+        if out:
+            meta.setdefault("warnings", []).append(
+                f"senpi history hit the {MAX_PAGES}-page ceiling; older closed positions are not included")
+            meta["senpi_history_partial"] = True
+    return sorted(out, key=lambda e: e["close_time"])
+
+
+def _direction(r, szi, ent, ext, realized):
+    """`szi` on a closed row is the absolute size on the live API (a closed short arrives as "0.2099", not
+    "-0.2099"), so the sign is the last resort: the price move against the P&L decides when both are
+    non-zero, then the row's `type` ("Close Short" / "Close Long"), then an explicit side field, then szi."""
+    if ent and ext and ext != ent and realized:
+        return "LONG" if ((ext > ent) == (realized > 0)) else "SHORT"
+    typ = str(r.get("type") or "").upper()
+    if "SHORT" in typ:
+        return "SHORT"
+    if "LONG" in typ:
+        return "LONG"
+    side = str(r.get("direction") or r.get("side") or r.get("positionSide") or "").upper()
+    if side in ("LONG", "SHORT"):
+        return side
+    if side in ("BUY", "B"):
+        return "LONG"
+    if side in ("SELL", "A", "S"):
+        return "SHORT"
+    return "LONG" if szi > 0 else "SHORT"
+
+
+def _liquidated(r):
+    """`type` carries the exchange's own words — "Liquidated Cross Long", "Liquidated Isolated Short".
+    Matching on "LIQUIDAT" covers all four. `Auto-Deleveraging` is deliberately NOT counted: ADL is the
+    venue unwinding a profitable book, not a stop the trader failed to place."""
+    return "LIQUIDAT" in str(r.get("type") or "").upper()
+
+
+def episode(r):
+    coin = r.get("coin") or r.get("coinDisplayName")
+    close_t = _ms(r.get("closeTime"))
+    if not coin or not close_t:
+        return None          # with no coin and no close there is nothing to place in the window
+    szi = _num(r.get("szi"))
+    ent, ext = _num(r.get("entryPx")), _num(r.get("exitPx"))
+    lev = r.get("leverage") or {}
+    open_t = _ms(r.get("openTime"))
+    # Discovery cannot always rebuild the OPENING side of a position: a cross-liquidation arrives with
+    # szi, entryPx and openTime all zero. Requiring them dropped the whole row — and those rows carry
+    # real realized P&L. On one wallet that was $1,137,374 of a $1,496,623 loss, including a $773,802
+    # cross-liquidation; venue-wide it is 14% of realized P&L by magnitude. Keep the row so every TOTAL
+    # is right, and mark it incomplete so the statistics that genuinely need an open — hold time, entry
+    # timing, sizing, the lever grid — skip it exactly as they skip a truncated fill-built episode.
+    reconstructed = bool(szi) and bool(open_t)
+    if not open_t:
+        # never leave this 0: `score._funding_after` reads `open_time + 24h` as a real instant, and an
+        # epoch open would match every funding payment before the close.
+        open_t = close_t
+    size = abs(szi); notional = size * ent
+    realized = _num(r.get("realizedPnl")); fees = _num(r.get("totalFees"))
+    direction = _direction(r, szi, ent, ext, realized)
+    signed = size if direction == "LONG" else -size
+    return dict(coin=coin, signed=signed, direction=direction, open_time=open_t, close_time=close_t, last_time=close_t,
+                realized=realized, fees=fees, net=realized - fees, volume=size * (ent + ext), taker_volume=0.0, twap_volume=0.0,
+                adds=None, partial_closes=0, entry_qty=size, entry_val=notional, exit_qty=size,
+                exit_val=size * ext, peak_size=size, peak_notional=notional, liquidated=_liquidated(r),
+                truncated=not reconstructed, n_fills=int(_num(r.get("totalFills"), 0)),
+                unobserved_qty=0.0, unobserved_notional=0.0, close_observed=True, entry_vwap=ent or None, exit_vwap=ext or None,
+                hold_h=(close_t - open_t) / 3.6e6,
+                taker_share=None, complete=reconstructed, win=realized > 0, leverage=_num(lev.get("value")) if isinstance(lev, dict) else _num(lev),
+                margin_used=_num(r.get("marginUsed")), closed_order_id=r.get("closedOrderId"), source="senpi")

package/dist/quant/engine/quantdesk/smart_money.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""You vs the whale cohort. Two sources for the cohort, same math (ported from senpi-smart-money):
+
+* senpi discovery — the ALL_TIME realized-PnL ranking (`discovery_get_top_traders`), members with ≥ $1M
+  realized, their live books from `discovery_get_trader_state` with position ages (entry times →
+  "WITH — BUT LATE"). Needs a Senpi token.
+* public fallback — the largest profitable accounts on Hyperliquid's public leaderboard, their live books
+  from `clearinghouseState` (no entry times → WITH / AGAINST only).
+
+Per coin the cohort's bias is net/gross signed notional in [-1, +1]. The you-vs-whale-median table reads
+`references/benchmark.json`, computed by `benchmark.py` over the public cohort with this skill's own engine."""
+# Copyright 2026 Senpi (https://senpi.ai) — Apache-2.0
+import statistics
+
+SMART_MIN_REALIZED = 1_000_000
+PAGE_SIZE = 1000
+MAX_PAGES = 6
+SAMPLE_CAP = 150
+STATE_BATCH = 50
+MIN_MEMBERS = 3
+LEAN = 0.2            # |bias| below this = the cohort is split
+
+LATE_H = 4.0          # entering this much after the cohort's median entry = "late"
+RECENT_H = 14 * 24.0  # a cohort entry older than this is a hold, not a move: no lag is read against it
+def _side(bias):
+    """LONG / SHORT / None. `bias > 0 else "SHORT"` made a bias of exactly 0.0 — a perfectly split
+    cohort, or one with nothing to read at all (`bias` is set to 0.0 when gross is 0) — render as a
+    SHORT cohort. Zero is the absence of a lean, not a lean the other way.
+    (@danielmbirochi, #718, round 2.)"""
+    return None if not bias else ("LONG" if bias > 0 else "SHORT")
+
+
+def _ok(resp):
+    if isinstance(resp, dict):
+        if resp.get("success") is False:
+            return None
+        return resp.get("data", resp)
+    return resp
+
+
+def _num(v):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _f(d, *keys, default=0.0):
+    if isinstance(d, dict):
+        for k in keys:
+            if k in d and d[k] is not None:
+                n = _num(d[k])
+                if n is not None:
+                    return n
+    return default
+
+
+def _field(d, *names, default=None):
+    if isinstance(d, dict):
+        for n in names:
+            if n in d and d[n] is not None:
+                return d[n]
+    return default
+
+
+def _traders_of(data):
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        for k in ("traders", "data", "results"):
+            v = data.get(k)
+            if isinstance(v, list):
+                return v
+    return []
+
+
+def _realized(t):
+    return _f(t, "realizedProfitAndLoss", "realized_profit_and_loss", "profit_and_loss_realized", "realizedPnl", "realized_pnl", default=0.0)
+
+
+def _signed_notional(p):
+    szi = _f(p, "szi", "size")
+    val = _f(p, "positionValue", "notional", "position_value")
+    if val <= 0:
+        val = abs(szi) * _f(p, "entryPx", "markPx", "entry_price")
+    return (1.0 if szi > 0 else (-1.0 if szi < 0 else 0.0)) * abs(val)
+
+
+def _empty():
+    return {"net": 0.0, "gross": 0.0, "n_long": 0, "n_short": 0, "entries_long": [], "entries_short": []}
+
+
+def _add(per, coin, sn, entry_ms=None):
+    d = per.setdefault(coin, _empty())
+    d["net"] += sn; d["gross"] += abs(sn); d["n_long" if sn > 0 else "n_short"] += 1
+    if entry_ms:
+        d["entries_long" if sn > 0 else "entries_short"].append(entry_ms)
+
+
+def _finish(per):
+    for d in per.values():
+        d["bias"] = round(d["net"] / d["gross"], 3) if d["gross"] > 0 else 0.0
+        d["members"] = d["n_long"] + d["n_short"]
+    return per
+
+
+# ---------------------------------------------------------------- senpi source
+def senpi_cohort(client, meta):
+    smart, seen = [], set()
+    for page in range(MAX_PAGES):
+        try:
+            resp = client.mcp_call("discovery_get_top_traders", time_frame="ALL_TIME", sort_by="PROFIT_AND_LOSS_REALIZED",
+                                   open_position_filter=False, limit=PAGE_SIZE, offset=page * PAGE_SIZE, timeout=20)
+        except Exception as e:  # noqa: BLE001
+            meta.setdefault("warnings", []).append(f"top_traders page {page} failed: {e}")
+            break
+        rows = _traders_of(_ok(resp))
+        if not rows:
+            break
+        page_top = None
+        for t in rows:
+            if not isinstance(t, dict):
+                continue
+            addr = str(_field(t, "address", "trader_address", "wallet", default="")).lower()
+            if not addr or addr in seen:
+                continue
+            rp = _realized(t)
+            page_top = rp if page_top is None else max(page_top, rp)
+            if rp >= SMART_MIN_REALIZED and len(smart) < SAMPLE_CAP:
+                smart.append(addr); seen.add(addr)
+        if len(smart) >= SAMPLE_CAP or (page_top is not None and page_top < SMART_MIN_REALIZED):
+            break
+    return smart
+
+
+def senpi_positions(client, addrs, meta):
+    per = {}
+    for i in range(0, len(addrs), STATE_BATCH):
+        batch = addrs[i:i + STATE_BATCH]
+        try:
+            resp = client.mcp_call("discovery_get_trader_state", trader_addresses=batch, include_position_age=True, timeout=25)
+        except Exception as e:  # noqa: BLE001
+            meta.setdefault("warnings", []).append(f"trader_state batch failed: {e}")
+            continue
+        for t in _traders_of(_ok(resp)):
+            for p in (t.get("openPositions") or t.get("open_positions") or []):
+                if not isinstance(p, dict):
+                    continue
+                coin = p.get("coin") or p.get("asset")
+                sn = _signed_notional(p) if coin else 0.0
+                if not coin or sn == 0:
+                    continue
+                st = _f(p, "startTime", "start_time", default=0.0)
+                entry_ms = (st * 1000.0 if st < 1e12 else st) if st else None   # documented as Unix seconds
+                _add(per, coin, sn, entry_ms)
+    return _finish(per)
+
+
+# ---------------------------------------------------------------- public source
+def public_positions(states):
+    per = {}
+    for cs in (states or {}).values():
+        for ap in (cs or {}).get("assetPositions") or []:
+            p = ap.get("position") or {}
+            sn = _signed_notional(p)
+            if p.get("coin") and sn:
+                _add(per, p["coin"], sn)
+    return _finish(per)
+
+
+# ---------------------------------------------------------------- the reads
+def compare(per, book, opened_episodes, ages=None, now_ms=None):
+    """One row per open position: your side vs the cohort's bias on that coin, and the read. Your entry
+    time comes from Senpi's position age when present; from fills only when the open was actually observed."""
+    opens = {e["coin"]: e["open_time"] for e in opened_episodes or [] if not e.get("truncated") and not e.get("unobserved_qty")}
+    opens.update({c: t for c, t in (ages or {}).items() if t})
+    rows, lags, lag_coins = [], [], []
+    for p in book["positions"]:
+        d = per.get(p["coin"])
+        bias = d["bias"] if d else None
+        members = d["members"] if d else 0
+        lag = None
+        if not d or members < MIN_MEMBERS:
+            read = "NO COHORT VIEW"
+        elif abs(bias) < LEAN:
+            read = "COHORT SPLIT"
+        elif _side(bias) == p["side"]:
+            read = "WITH"
+            ent = d["entries_long" if p["side"] == "LONG" else "entries_short"]
+            if ent and p["coin"] in opens:
+                med_entry = statistics.median(ent); age_h = (now_ms - med_entry) / 3.6e6 if now_ms else None
+                if age_h is not None and age_h > RECENT_H:
+                    read = f"WITH — they've held it {age_h / 24:.0f}d"
+                else:
+                    lag = (opens[p["coin"]] - med_entry) / 3.6e6
+                    lags.append(lag); lag_coins.append(p["coin"])
+                    read = f"WITH — BUT LATE (+{lag:.0f}h)" if lag > LATE_H else ("WITH — AHEAD" if lag < -LATE_H else "WITH")
+        else:
+            read = "AGAINST SMART MONEY"
+        if not d:
+            cohort = "no whale holds it"
+        elif members < MIN_MEMBERS:
+            cohort = (f"{_side(bias)} · {members} wallet{'s' if members != 1 else ''} (thin)"
+                      if _side(bias) else f"SPLIT · {members} wallet{'s' if members != 1 else ''} (thin)")
+        elif abs(bias) < LEAN:
+            cohort = f"SPLIT · {members} wallets"
+        else:
+            cohort = f"{_side(bias)} · {members} wallets ({bias:+.2f})"
+        rows.append(dict(coin=p["coin"], you=f"{p['side']} {p['leverage']}x" if p.get("leverage") else p["side"], cohort=cohort,
+                         bias=bias, members=members, read=read, lag_h=lag))
+    return dict(rows=rows, against=[r["coin"] for r in rows if r["read"].startswith("AGAINST")],
+                entry_lag_h=statistics.median(lags) if lags else None, lag_coins=lag_coins)
+
+
+BENCH_ROWS = (("Median hold — winners", "hold_winners_h", "h"), ("Median hold — losers", "hold_losers_h", "h"), ("Losers held ÷ winners held", "hold_ratio", "x"),
+              ("Costs ÷ gross income", "cost_ratio", "%"), ("Taker share of volume", "taker_share", "%"), ("Win rate", "win_rate", "%"),
+              ("Profit factor", "profit_factor", "x"), ("Avg winner ÷ avg loser", "payoff_ratio", "x"))
+
+
+def benchmark_table(tr, bench):
+    rows = []
+    for label, key, unit in BENCH_ROWS:
+        you, whale = tr.get(key), (bench or {}).get(key)
+        rows.append(dict(metric=label, you=you, whale=whale, unit=unit,
+                         better="lower" if key in ("hold_losers_h", "hold_ratio", "cost_ratio", "taker_share") else "higher"))
+    return rows
+
+
+# ================================================================ v2: two cohorts, entry ages, the whole book
+import collections  # noqa: E402
+
+import taxonomy  # noqa: E402
+
+HOT_N = 100
+PROVEN_N = 100
+
+
+def hot_cohort(client, meta, n=HOT_N):
+    """The most profitable traders of the last 30 days that hold positions now — a hot streak, not a record."""
+    try:
+        resp = client.mcp_call("discovery_get_top_traders", time_frame="MONTHLY", sort_by="PROFIT_AND_LOSS", open_position_filter=True, limit=n, offset=0, timeout=20)
+    except Exception as e:  # noqa: BLE001
+        meta.setdefault("warnings", []).append(f"hot cohort failed: {e}")
+        return []
+    out = []
+    for t in _traders_of(_ok(resp)):
+        a = str(_field(t, "address", "trader_address", "wallet", default="")).lower()
+        if a:
+            out.append(a)
+    return out
+
+
+def proven_cohort(client, meta, n=PROVEN_N):
+    """Top traders by ALL-TIME realized PnL with ≥ $1M realized — a demonstrated record."""
+    global SAMPLE_CAP
+    keep = SAMPLE_CAP
+    SAMPLE_CAP = n
+    try:
+        return senpi_cohort(client, meta)
+    finally:
+        SAMPLE_CAP = keep
+
+
+def books(client, addrs, meta, progress=None, label=""):
+    """Per-wallet live books (coin, signed notional, entry ms) for a cohort, batched."""
+    out = []
+    for i in range(0, len(addrs), STATE_BATCH):
+        batch = addrs[i:i + STATE_BATCH]
+        try:
+            resp = client.mcp_call("discovery_get_trader_state", trader_addresses=batch, include_position_age=True, timeout=25)
+        except Exception as e:  # noqa: BLE001
+            meta.setdefault("warnings", []).append(f"trader_state batch failed: {e}")
+            continue
+        if progress:
+            progress(f"[quant-desk]   · senpi-smart-money: {label}{min(i + STATE_BATCH, len(addrs))} of {len(addrs)} wallets read …")
+        for t in _traders_of(_ok(resp)):
+            rows = []
+            for p in (t.get("openPositions") or t.get("open_positions") or []):
+                if not isinstance(p, dict):
+                    continue
+                coin = p.get("coin") or p.get("asset"); sn = _signed_notional(p) if coin else 0.0
+                if not coin or not sn:
+                    continue
+                st = _f(p, "startTime", "start_time", default=0.0)
+                rows.append((coin, sn, (st * 1000.0 if st < 1e12 else st) if st else None))
+            out.append(dict(address=str(_field(t, "address", "trader_address", "wallet", default="")).lower(), positions=rows))
+    return out
+
+
+def public_books(states):
+    out = []
+    for a, cs in (states or {}).items():
+        rows = []
+        for ap in (cs or {}).get("assetPositions") or []:
+            p = ap.get("position") or {}; sn = _signed_notional(p)
+            if p.get("coin") and sn:
+                rows.append((p["coin"], sn, None))
+        if rows:
+            out.append(dict(address=a, positions=rows))
+    return out
+
+
+def per_from_books(bks):
+    per = {}
+    for b in bks:
+        for coin, sn, entry_ms in b["positions"]:
+            _add(per, coin, sn, entry_ms)
+    return _finish(per)
+
+
+def class_tilt(bks, majors, large):
+    """Net ÷ gross signed notional per asset class across the cohort's books, plus headcount per class-side."""
+    net = collections.defaultdict(float); gross = collections.defaultdict(float); heads = collections.Counter()
+    for b in bks:
+        for coin, sn, _ in b["positions"]:
+            cls = taxonomy.classify(coin, majors, large)
+            net[cls] += sn; gross[cls] += abs(sn); heads[(cls, "LONG" if sn > 0 else "SHORT")] += 1
+    tot = sum(gross.values()) or 1.0
+    return {cls: dict(label=taxonomy.label(cls), bias=(net[cls] / gross[cls]) if gross[cls] else 0.0, weight=gross[cls] / tot,
+                      long=heads[(cls, "LONG")], short=heads[(cls, "SHORT")]) for cls in gross}
+
+
+def user_tilt(book, majors, large):
+    net = collections.defaultdict(float); gross = collections.defaultdict(float)
+    for p in book["positions"]:
+        cls = taxonomy.classify(p["coin"], majors, large); sn = p["notional"] * (1 if p["side"] == "LONG" else -1)
+        net[cls] += sn; gross[cls] += abs(sn)
+    tot = sum(gross.values()) or 1.0
+    return {cls: dict(label=taxonomy.label(cls), bias=(net[cls] / gross[cls]) if gross[cls] else 0.0, weight=gross[cls] / tot) for cls in gross}
+
+
+def cohort_view(name, bks, book, opened, majors, large, ages=None, now_ms=None):
+    """Everything the desk says about one cohort: per-position reads (with ages), class tilt vs yours,
+    coins they hold that you don't (by headcount), coins you hold that none of them touch."""
+    per = per_from_books(bks)
+    cmp_ = compare(per, book, opened, ages, now_ms)
+    tilt = class_tilt(bks, majors, large); yours = user_tilt(book, majors, large)
+    mine = {p["coin"] for p in book["positions"]}
+    theirs = sorted(((d["members"], coin, d) for coin, d in per.items() if coin not in mine and d["members"] >= MIN_MEMBERS and abs(d["bias"]) >= LEAN), reverse=True)
+    orphans = [c for c in mine if c not in per]
+    # book-level agreement: weight-averaged sign agreement over the classes you hold
+    agree = 0.0; wsum = 0.0
+    for cls, y in yours.items():
+        t = tilt.get(cls)
+        # A class with no lean on either side contributed a full-weight AGREEMENT, because
+        # `False == False` is True — two books with no opinion were scored as being of one mind.
+        if t and t["weight"] > 0 and _side(y["bias"]) and _side(t["bias"]):
+            agree += y["weight"] * (1 if _side(y["bias"]) == _side(t["bias"]) else -1) * min(1.0, abs(t["bias"]) / LEAN)
+            wsum += y["weight"]
+    return dict(name=name, wallets=len(bks), coins=len(per), rows=cmp_["rows"], against=cmp_["against"], entry_lag_h=cmp_["entry_lag_h"], lag_coins=cmp_.get("lag_coins") or [],
+                tilt=sorted(tilt.values(), key=lambda t: -t["weight"])[:6], yours=sorted(yours.values(), key=lambda t: -t["weight"]),
+                agreement=(agree / wsum) if wsum else None,
+                they_hold=[dict(coin=c, members=m, bias=d["bias"], side=_side(d["bias"]), n_long=d["n_long"], n_short=d["n_short"]) for m, c, d in theirs[:8]],
+                you_alone=orphans)