Deploy msgboard

src/msgboard/analytics.py

@@ -0,0 +1,99 @@
+"""Units, range validation and aggregation helpers for board analytics. SQL stays in store."""
+
+from __future__ import annotations
+
+import math
+import re
+
+from .errors import bad_request
+
+DAY = 86400
+MAX_TIMESTAMP = 253402300800  # exclusive end of UTC year 9999
+WORD = re.compile(r"\b\w+(?:['’]\w+)*\b", re.UNICODE)
+RESPONSE_BOUNDS = (0, 60, 300, 900, 3600, 14400, 86400)
+
+
+def bounds(now: float, days: int = 7, start: float | None = None,
+           end: float | None = None) -> tuple[float, float]:
+    end = now if end is None else end
+    if not math.isfinite(end) or not 0 < end <= MAX_TIMESTAMP:
+        raise bad_request("to must be a finite positive Unix timestamp through UTC year 9999")
+    if start is None:
+        start = max(0, (math.ceil(end / DAY) - days) * DAY)
+    if not math.isfinite(start) or start < 0 or start >= end:
+        raise bad_request("from must be a finite nonnegative Unix timestamp before to")
+    if end - start > 365 * DAY:
+        raise bad_request("choose at most 365 days")
+    return start, end
+
+
+def percentile(values: list[float], fraction: float) -> float | None:
+    if not values:
+        return None
+    ordered = sorted(values)
+    index = (len(ordered) - 1) * fraction
+    low = math.floor(index)
+    high = math.ceil(index)
+    return ordered[low] + (ordered[high] - ordered[low]) * (index - low)
+
+
+def response_summary(requests: int, latencies: list[float]) -> dict:
+    return {"requests": requests, "answered": len(latencies), "unanswered": requests - len(latencies),
+            "median_seconds": percentile(latencies, .5), "p90_seconds": percentile(latencies, .9)}
+
+
+def response_histogram(latencies: list[float]) -> list[dict]:
+    bins = [{"from_seconds": low, "to_seconds": high, "count": 0}
+            for low, high in zip(RESPONSE_BOUNDS, (*RESPONSE_BOUNDS[1:], None))]
+    for value in latencies:
+        for bucket in bins:
+            if bucket["to_seconds"] is None or value < bucket["to_seconds"]:
+                bucket["count"] += 1
+                break
+    return bins
+
+
+def chord_graph(edges: list[dict], identities: dict[int, dict], top_k: int) -> dict:
+    weights: dict[int, int] = {}
+    for edge in edges:
+        for pid in (edge["source"], edge["target"]):
+            weights[pid] = weights.get(pid, 0) + edge["total"]
+    ranked = sorted(weights, key=lambda pid: (-weights[pid], pid))
+    selected = set(ranked[:top_k])
+    nodes = [dict(identities[pid], total=weights[pid], members=1) for pid in ranked[:top_k]]
+    hidden = set(ranked) - selected
+    if hidden:
+        nodes.append({"id": "other", "display_name": "Other", "external_id": "other", "identity_type": "other",
+                      "total": sum(weights[pid] for pid in hidden), "members": len(hidden)})
+    links = {}
+    for edge in edges:
+        source = edge["source"] if edge["source"] in selected else "other"
+        target = edge["target"] if edge["target"] in selected else "other"
+        key = tuple(sorted((source, target), key=lambda pid: (pid == "other", str(pid))))
+        link = links.setdefault(key, {"source": key[0], "target": key[1], "total": 0,
+                                      "mentions": 0, "replies": 0, "dms": 0})
+        for field in ("total", "mentions", "replies", "dms"):
+            link[field] += edge[field]
+    result = sorted(links.values(), key=lambda link: (-link["total"], str(link["source"]), str(link["target"])))
+    return {"top_k": top_k, "total": sum(edge["total"] for edge in edges), "nodes": nodes, "links": result,
+            "other_internal": next((dict(link) for link in result if link["source"] == link["target"] == "other"),
+                                   {"source": "other", "target": "other", "total": 0, "mentions": 0, "replies": 0, "dms": 0})}
+
+
+def listening_series(start: float, end: float, records: dict[int, tuple[float, int]],
+                     started_at: float | None) -> dict:
+    width = max(60, math.ceil((end - start) / 1500 / 60) * 60)
+    first = math.floor(start / width) * width
+    buckets = {at: [] for at in range(first, math.ceil(end / width) * width, width)}
+    for minute, (observed_at, count) in records.items():
+        at = (minute // width) * width
+        if start <= observed_at < end and at in buckets:
+            buckets[at].append(count)
+    series = []
+    for at, counts in buckets.items():
+        lo, hi = max(at, start), min(at + width, end)
+        expected = math.ceil(hi / 60) - math.floor(lo / 60)
+        series.append({"at": at, "count": sum(counts) / len(counts) if counts else None,
+                       "min": min(counts) if counts else None, "max": max(counts) if counts else None,
+                       "samples": len(counts), "expected_samples": expected})
+    return {"sample_seconds": 60, "bucket_seconds": width, "started_at": started_at, "series": series}

src/msgboard/client.py

@@ -328,9 +328,15 @@ class Client:
         """How to use this board, as markdown, ending with the workspace guidelines its admins wrote."""
         return self._request("GET", "/guide").text
 
-    def analytics(self, days: int = 30) -> dict:
-        """Board activity (admins and readers): totals, daily counts, channels, who posts."""
-        return self._request("GET", "/analytics", params={"days": days}).json()
+    def analytics(self, days: int = 7, *, start: float | None = None, end: float | None = None,
+                  top_k: int = 10) -> dict:
+        """Analytics for admins/readers. Optional Unix-second bounds select [start, end)."""
+        params = {"days": days, "top_k": top_k}
+        if start is not None:
+            params["from"] = start
+        if end is not None:
+            params["to"] = end
+        return self._request("GET", "/analytics", params=params).json()
 
     def open_dm(self, principal_id: int) -> dict:
         """The direct-message channel with someone (created on first use); post to its `id`."""

src/msgboard/dashboard.html

@@ -612,6 +612,31 @@ button.fchip:hover { border-color: var(--ink); }
 .sbody p.lead a { color: var(--ink); }
 #guide-rendered { border: 1px solid var(--rule); padding: 4px 14px; min-height: 120px; }
 .an-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
+#ch-info:not(.hidden) + #analytics-open, #ch-doc:not(.hidden) ~ #analytics-open { margin-left: 4px; }
+.an-page { max-width: 1400px; }
+.an-page .an-head { justify-content: flex-start; margin-bottom: 4px; }
+.an-custom { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; padding: 2px 6px; border: 1px solid transparent; }
+.an-custom.on { border-color: var(--ink); }
+.an-custom input[type=date] { font: 12px var(--mono); border: 1px solid var(--rule-2); background: var(--bg); color: var(--ink); padding: 2px 4px; }
+.an-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(420px, 100%), 1fr)); gap: 18px; margin-bottom: 18px; }
+.an-grid .card { margin: 0; min-width: 0; }
+.an-rule { margin: 2px 0 6px; color: var(--ink-3); }
+.an-k { display: inline-flex; align-items: center; gap: 6px; } .an-k input { width: 140px; accent-color: var(--ink); }
+.an-chart .line { fill: none; stroke: var(--ink); stroke-width: 2; stroke-linejoin: round; }
+.an-chart .dotm { fill: var(--ink); stroke: var(--bg); stroke-width: 2; }
+.an-chart .mark { stroke: var(--ink); stroke-width: 1; stroke-dasharray: 3 3; }
+.an-chart .tick.strong { fill: var(--ink); font-weight: 600; }
+.an-chord svg { max-width: 560px; margin: 0 auto; }
+.an-chord .ribbon { fill: var(--ink); fill-opacity: .16; stroke: var(--bg); stroke-width: 1; transition: fill-opacity .1s; }
+.an-chord .ribbon.dim { fill-opacity: .05; } .an-chord .ribbon:not(.dim):hover { fill-opacity: .6; }
+.an-chord .arc { stroke: var(--ink); stroke-width: 1; cursor: default; }
+.an-chord .arc.agents { fill: var(--ink); } .an-chord .arc.people { fill: var(--ink-3); } .an-chord .arc.other { fill: var(--bg); stroke-dasharray: 2 2; }
+.an-chord .node { fill: var(--ink); font: 11.5px var(--sans); }
+.sw.other { background: var(--bg); border: 1px dashed var(--ink); }
+.an-files .hbar { width: calc(100% - 76px); } .an-files .bar-col b { white-space: nowrap; }
+.an-health { display: grid; grid-template-columns: repeat(auto-fill, minmax(170px, 1fr)); border: 1px solid var(--rule-2); }
+.an-health div { padding: 10px 12px; border-right: 1px solid var(--rule); border-bottom: 1px solid var(--rule); margin: 0 -1px -1px 0; }
+.an-health b { display: block; font-size: 17px; font-variant-numeric: tabular-nums; } .an-health span { font-size: 12px; color: var(--ink-3); }
 .seg { display: inline-flex; border: 1px solid var(--rule-2); }
 .seg button { background: none; border: 0; padding: 4px 11px; font: 11.5px var(--mono); color: var(--ink-2); }
 .seg button + button { border-left: 1px solid var(--rule-2); }
@@ -755,6 +780,8 @@ dialog input[type=text] { width: 100%; margin: 4px 0 12px; }
       <button class="info-btn hidden" id="ch-doc" aria-label="Channel doc" title="Channel doc"></button>
       <button class="info-btn hidden" id="ch-info" aria-label="Channel info" aria-haspopup="dialog" aria-expanded="false" title="Channel info">
         <svg viewBox="0 0 18 18" aria-hidden="true"><circle cx="9" cy="9" r="7.2"/><path d="M9 8v5"/><path d="M9 5.2h.01" stroke-width="2.2" stroke-linecap="round"/></svg></button>
+      <button class="info-btn hidden" id="analytics-open" aria-label="Analytics" title="Analytics">
+        <svg viewBox="0 0 18 18" aria-hidden="true"><path d="M2.5 15.5h13M5 13V9M9 13V4.5M13 13V7"/></svg></button>
     </div>
     <div id="chat-view" style="display:contents">
       <div class="scroll" id="scroll"><div id="messages"></div></div>
@@ -764,6 +791,7 @@ dialog input[type=text] { width: 100%; margin: 4px 0 12px; }
     <div id="settings" class="hidden"></div>
     <div id="activity" class="scroll hidden" style="padding:0"></div>
     <div id="search" class="scroll hidden"></div>
+    <div id="analytics" class="scroll hidden"></div>
   </main>
   <section id="panel" class="hidden">
     <div class="resizer" id="panel-resize" role="separator" aria-orientation="vertical" aria-label="Resize side panel" tabindex="0" title="Drag to resize · double-click to reset"></div>
@@ -987,7 +1015,7 @@ function decorate(html, mentions) {
     if (h) {   // a link to a message, file or channel on this board: open it here, with a readable label
       a.dataset.internal = h; a.removeAttribute("target");
       if (a.textContent.trim() === a.getAttribute("href") || a.textContent.trim() === a.href) {
-        a.textContent = h.startsWith("msg/") ? "↪ message" : h.startsWith("file/") ? "📎 file" : /^(settings|activity|search)$/.test(h) ? h : "#" + h;
+        a.textContent = h.startsWith("msg/") ? "↪ message" : h.startsWith("file/") ? "📎 file" : /^(settings|activity|search|analytics)$/.test(h) ? h : "#" + h;
       }
     } else { a.target = "_blank"; a.rel = "noopener noreferrer"; }
   });
@@ -1465,11 +1493,13 @@ async function boot() {
   $("new-dm").classList.toggle("hidden", !can("post"));
   $("settings-open").classList.toggle("hidden", !(can("invite_agents") || can("manage")));
   $("add-agents").classList.toggle("hidden", !can("invite_agents"));
+  $("analytics-open").classList.toggle("hidden", !canAnalytics());
   $("show-private-row").classList.toggle("hidden", !can("manage"));
   $("show-private").checked = !!(state.me.prefs && state.me.prefs.show_private);
   await Promise.all([refreshChannels(), renderLibs]);
   if (location.hash === "#settings") return openSettings();
   if (location.hash === "#activity") return openActivity();
+  if (location.hash === "#analytics" && canAnalytics()) return openAnalytics();
   if (/^#(msg|file)\//.test(location.hash)) {   // a shared link: open a channel first, then the message or file
     const first = state.channels.find((c) => c.name === store.get("channel")) || state.channels.find((c) => c.kind !== "dm") || state.channels[0];
     const target = location.hash;
@@ -1614,7 +1644,7 @@ function updateMeta(live) {
 }
 function showChat() {
   state.view = "chat";
-  $("settings").classList.add("hidden"); $("activity").classList.add("hidden"); $("search").classList.add("hidden"); $("chat-view").style.display = "contents";
+  $("settings").classList.add("hidden"); $("activity").classList.add("hidden"); $("search").classList.add("hidden"); leaveAnalytics(); $("chat-view").style.display = "contents";
 }
 async function openChannel(id) {
   const c = state.channels.find((x) => x.id === id);
@@ -2632,7 +2662,7 @@ function internalHash(href) {
   let u; try { u = new URL(href, location.href); } catch { return null; }
   if (u.origin !== location.origin || u.pathname !== location.pathname || !u.hash) return null;
   const h = decodeURIComponent(u.hash.slice(1));
-  return /^(msg|file)\/[\w-]+$/.test(h) || /^(settings|activity|search)$/.test(h) || state.chanIndex.has(h.toLowerCase()) ? h : null;
+  return /^(msg|file)\/[\w-]+$/.test(h) || /^(settings|activity|search|analytics)$/.test(h) || state.chanIndex.has(h.toLowerCase()) ? h : null;
 }
 async function routeHash(h) {
   h = decodeURIComponent((h || "").replace(/^#/, ""));
@@ -2645,6 +2675,7 @@ async function routeHash(h) {
   if ((m = /^file\/([\w-]+)$/.exec(h))) { openViewer([m[1]], 0); return true; }
   if (h === "settings") { openSettings(); return true; }
   if (h === "activity") { openActivity(); return true; }
+  if (h === "analytics") { openAnalytics(); return true; }
   if (h === "search") { openSearch(""); return true; }
   const c = state.chanIndex.get(h.toLowerCase()) || state.channels.find((x) => x.name === h);
   if (c) { closePanel(); openChannel(c.id); return true; }
@@ -3184,7 +3215,7 @@ async function openActivity() {
   if (state.poll) state.poll.abort();
   state.current = null; closePanel(); renderChannels();
   history.replaceState(null, "", location.pathname + "#activity");
-  $("chat-view").style.display = "none"; $("settings").classList.add("hidden"); $("search").classList.add("hidden"); $("activity").classList.remove("hidden");
+  $("chat-view").style.display = "none"; $("settings").classList.add("hidden"); $("search").classList.add("hidden"); leaveAnalytics(); $("activity").classList.remove("hidden");
   $("ch-title").innerHTML = "Activity"; $("ch-desc").textContent = "";
   $("ch-meta").textContent = ""; $("members-open").classList.add("hidden"); $("ch-info").classList.add("hidden"); $("ch-doc").classList.add("hidden"); $("ch-join").classList.add("hidden"); closeInfo();
   // show the last list right away and swap in the fresh one when it arrives
@@ -3370,7 +3401,7 @@ async function openSearch(q, opts = {}) {
   if (state.poll) state.poll.abort();
   state.current = null; closePanel(); renderChannels();
   history.replaceState(null, "", location.pathname + "#search");
-  $("chat-view").style.display = "none"; $("settings").classList.add("hidden"); $("activity").classList.add("hidden"); $("search").classList.remove("hidden");
+  $("chat-view").style.display = "none"; $("settings").classList.add("hidden"); $("activity").classList.add("hidden"); leaveAnalytics(); $("search").classList.remove("hidden");
   $("ch-title").innerHTML = "Search"; $("ch-desc").textContent = "";
   $("ch-meta").textContent = ""; $("members-open").classList.add("hidden"); $("ch-info").classList.add("hidden"); $("ch-doc").classList.add("hidden"); $("ch-join").classList.add("hidden"); closeInfo();
   const f = state.searchFilters = Object.assign({ channel: "", sender: "", when: "", has: "", by: "", sort: "newest" }, opts.keep ? state.searchFilters : {}, opts.filters || {});
@@ -3464,19 +3495,19 @@ function openSettings(tab) {
   if (state.poll) state.poll.abort();
   state.current = null; renderChannels(); closePanel();
   history.replaceState(null, "", location.pathname + "#settings");
-  $("chat-view").style.display = "none"; $("activity").classList.add("hidden"); $("search").classList.add("hidden"); $("settings").classList.remove("hidden");
+  $("chat-view").style.display = "none"; $("activity").classList.add("hidden"); $("search").classList.add("hidden"); leaveAnalytics(); $("settings").classList.remove("hidden");
   $("ch-title").innerHTML = "Settings"; $("ch-desc").textContent = ""; $("ch-meta").textContent = "";
   $("members-open").classList.add("hidden"); $("ch-info").classList.add("hidden"); $("ch-doc").classList.add("hidden"); $("ch-join").classList.add("hidden"); closeInfo();
   const tabs = [["invites", "Invites"]];
   if (can("manage")) tabs.push(["people", "People"]);
   tabs.push(["agents", can("manage") ? "Agents" : "My agents"], ["listening", "Who's listening"]);
-  if (can("manage")) tabs.push(["suspended", "Suspended"], ["board", "Board"], ["analytics", "Analytics"]);
+  if (can("manage")) tabs.push(["suspended", "Suspended"], ["board", "Board"]);
   tab = tab || state.settingsTab || "invites";
   if (!tabs.some(([k]) => k === tab)) tab = "invites";
   state.settingsTab = tab;
   $("settings").innerHTML = `<div class="tabs">${tabs.map(([k, l]) => `<button data-tab="${k}" class="${k === tab ? "on" : ""}">${l}</button>`).join("")}</div><div class="sbody" id="sbody"><div class="empty">Loading…</div></div>`;
   $("settings").querySelectorAll("[data-tab]").forEach((b) => b.onclick = () => openSettings(b.dataset.tab));
-  ({ invites: settingsInvites, people: settingsPeople, agents: settingsAgents, listening: settingsListening, suspended: settingsSuspended, board: settingsBoard, analytics: settingsAnalytics })[tab]()
+  ({ invites: settingsInvites, people: settingsPeople, agents: settingsAgents, listening: settingsListening, suspended: settingsSuspended, board: settingsBoard })[tab]()
     .catch((e) => { $("sbody").innerHTML = `<div class="empty">${esc(e.message)}</div>`; });
 }
 // A2 look on trial: a per-browser switch, applied before first paint by the snippet in <head>
@@ -3778,48 +3809,274 @@ async function settingsListening() {
   hydrate($("sbody"));
   $("sbody").querySelectorAll("[data-lf]").forEach((b) => b.onclick = () => { state.listenFilter = b.dataset.lf; settingsListening(); });
 }
-async function settingsAnalytics() {
-  const days = state.analyticsDays || 30;
-  const a = await api("GET", `/analytics?days=${days}`);
-  if (state.settingsTab !== "analytics") return;
-  const t = a.totals, filter = state.analyticsWho || "all";
-  const tile = (label, value, sub) => `<div class="tile"><div class="label">${label}</div><div class="num">${fmtN(value)}</div><div class="small">${sub}</div></div>`;
-  const posters = a.posters.filter((x) => filter === "all" || (filter === "agents") === (x.identity_type !== "user"));
-  const maxP = Math.max(1, ...a.posters.map((x) => x.messages)), maxC = Math.max(1, ...a.channels.map((c) => c.messages));
-  $("sbody").innerHTML = `
-    <div class="an-head"><h3>Analytics</h3><div class="seg" role="group" aria-label="Time range">${[7, 30, 90].map((d) =>
-      `<button data-days="${d}" class="${d === days ? "on" : ""}">${d} days</button>`).join("")}</div></div>
-    <p class="lead">Messages posted on this board, by day (UTC). Everything is counted, including private channels and DMs; DMs are only counted together.</p>
+// ------------------------------------------------------------------ analytics (its own page; admins and readers)
+// GET /v1/analytics?from=&to=&top_k= : message stats, response times, who talks to whom, files, listening, health.
+const DAY_S = 86400;
+const canAnalytics = () => !!(state.me && (state.me.role === "admin" || state.me.role === "reader"));
+function analyticsRange() {
+  const r = state.anRange || { days: 7 };
+  if (r.custom) return r;
+  const to = (Math.floor(Date.now() / 1000 / DAY_S) + 1) * DAY_S;   // the end of today (UTC), exclusive
+  return { days: r.days, from: to - r.days * DAY_S, to };
+}
+function leaveAnalytics() { $("analytics").classList.add("hidden"); $("analytics-open").classList.remove("on"); }
+async function openAnalytics() {
+  if (!canAnalytics()) return;
+  state.view = "analytics";
+  if (state.poll) state.poll.abort();
+  state.current = null; closePanel(); renderChannels();
+  history.replaceState(null, "", location.pathname + "#analytics");
+  $("chat-view").style.display = "none"; $("settings").classList.add("hidden"); $("activity").classList.add("hidden"); $("search").classList.add("hidden");
+  $("analytics").classList.remove("hidden"); $("analytics-open").classList.add("on");
+  $("ch-title").innerHTML = "Analytics"; $("ch-desc").textContent = ""; $("ch-meta").textContent = "";
+  $("members-open").classList.add("hidden"); $("ch-info").classList.add("hidden"); $("ch-doc").classList.add("hidden"); $("ch-join").classList.add("hidden"); closeInfo();
+  $("analytics").innerHTML = `<div class="empty">Loading…</div>`;
+  await renderAnalytics();
+}
+const fmtDur = (s) => s == null ? "—" : s < 1 ? "under 1 s" : s < 60 ? `${Math.round(s)} s` : s < 3600 ? `${(s / 60).toFixed(s < 600 ? 1 : 0)} min` : s < 86400 ? `${(s / 3600).toFixed(s < 36000 ? 1 : 0)} h` : `${(s / 86400).toFixed(1)} days`;
+const fmtBytes = (n) => n == null ? "—" : n < 1024 ** 3 ? fmtSize(n) : (n / 1024 ** 3).toFixed(1) + " GB";
+const anDate = (t) => new Date(t * 1000).toISOString().slice(0, 10);
+async function renderAnalytics() {
+  const r = analyticsRange(), k = state.anTopK || 8, days = Math.round((r.to - r.from) / DAY_S);
+  let a;
+  try { a = await api("GET", `/analytics?from=${r.from}&to=${r.to}&top_k=${k}`); }
+  catch (e) { if (state.view === "analytics") $("analytics").innerHTML = `<div class="empty">${esc(e.message)}</div>`; return; }
+  if (state.view !== "analytics") return;
+  const ms = a.message_stats || {}, rt = a.response_times || {}, fi = a.files || {}, li = a.listening || {}, t = a.totals || {};
+  const filter = state.analyticsWho || "all";
+  const tile = (label, value, sub) => `<div class="tile"><div class="label">${label}</div><div class="num">${value}</div><div class="small">${sub}</div></div>`;
+  const posters = (a.posters || []).filter((x) => filter === "all" || (filter === "agents") === (x.identity_type !== "user"));
+  const maxP = Math.max(1, ...(a.posters || []).map((x) => x.messages)), maxC = Math.max(1, ...(a.channels || []).map((c) => c.messages));
+  const fmax = Math.max(1, ...(fi.by_principal || []).map((x) => x.bytes));
+  const span = r.custom ? `${anDate(r.from)} → ${anDate(r.to - DAY_S)}` : `last ${days} days`;
+  $("analytics").innerHTML = `<div class="sbody an-page">
+    <div class="an-head"><div class="seg" role="group" aria-label="Time range">${[7, 30, 90].map((d) =>
+      `<button data-days="${d}" class="${!r.custom && d === r.days ? "on" : ""}">${d} days</button>`).join("")}</div>
+      <form class="an-custom${r.custom ? " on" : ""}" id="an-custom"><span class="label">Custom</span>
+        <input type="date" id="an-from" value="${anDate(r.from)}" max="${anDate(Date.now() / 1000)}" aria-label="From">
+        <span>→</span><input type="date" id="an-to" value="${anDate(r.to - DAY_S)}" max="${anDate(Date.now() / 1000)}" aria-label="To">
+        <button class="btn ghost small">Apply</button></form></div>
+    <p class="lead">Everything on the board in the chosen days (UTC), private channels and DMs included; DMs are only counted together.</p>
     <div class="tiles">
-      ${tile("Messages", t.messages_window, `${fmtN(t.messages)} all time`)}
-      ${tile("Active agents", t.active_agents_7d, `of ${t.agents} · last 7 days`)}
-      ${tile("Active people", t.active_people_7d, `of ${t.people} · last 7 days`)}
-      ${tile("Threads", t.threads_window, `with replies, last ${days} days`)}
-      ${tile("Files", t.attachments_window, `shared, last ${days} days`)}
-      ${tile("Channels", t.channels, "open")}
+      ${tile("Messages", fmtN(ms.messages ?? t.messages_window ?? 0), span)}
+      ${tile("Words", fmtN(ms.words ?? 0), days ? `about ${fmtN(Math.round((ms.words || 0) / days))} a day` : "")}
+      ${tile("Avg length", ms.average_length == null ? "—" : `${Math.round(ms.average_length)}`, "characters per message")}
+      ${tile("Median response", fmtDur(rt.median_seconds), rt.p90_seconds == null ? "no answered requests" : `90% within ${fmtDur(rt.p90_seconds)}`)}
+      ${tile("Files", fmtN(fi.count ?? 0), `${fmtBytes(fi.bytes || 0)} attached`)}
+      ${tile("Listening now", li.now ?? "—", `<a class="linkish" href="#settings" id="an-listen-link">who's listening</a>`)}
+    </div>
+    <div class="an-grid">
+      <div class="card"><div class="chart-top"><h4>Messages per day</h4>
+        <div class="legend"><span><i class="sw agents"></i>agents</span><span><i class="sw people"></i>people</span></div></div>
+        <div id="an-chart" class="an-chart"></div></div>
+      <div class="card"><div class="chart-top"><h4>Words per day</h4></div><div id="an-words" class="an-chart"></div>
+        <div class="chart-top"><h4>Average length, characters</h4></div><div id="an-len" class="an-chart"></div></div>
+      <div class="card"><div class="chart-top"><h4>Time to response</h4><span class="small">${fmtN(rt.requests || 0)} requests · ${fmtN(rt.unanswered || 0)} unanswered</span></div>
+        <p class="small an-rule">${esc(rt.rule || "An agent is mentioned or DMed; its first later message in that thread or DM answers it.")}</p>
+        <div id="an-hist" class="an-chart"></div>
+        ${(rt.agents || []).length ? `<table class="an-table"><thead><tr><th>Agent</th><th>Asked</th><th class="hide-sm">Unanswered</th><th>Median</th><th>90% within</th></tr></thead><tbody>
+        ${rt.agents.map((x) => `<tr><td><span class="who" data-profile="${x.id}">${avatar(x, "xs", false)}<span>${esc(nameOf(x))}</span></span></td><td>${x.requests}</td><td class="hide-sm">${x.unanswered}</td><td>${fmtDur(x.median_seconds)}</td><td>${fmtDur(x.p90_seconds)}</td></tr>`).join("")}</tbody></table>` : ""}</div>
+      <div class="card"><div class="chart-top"><h4>Who talks to whom</h4>
+        <label class="small an-k">Top <input type="range" id="an-k" min="3" max="30" value="${k}"> <b id="an-k-n">${k}</b></label></div>
+        <p class="small an-rule">People and agents; a ribbon is the messages between the two: DMs, replies and mentions, both directions.</p>
+        <div id="an-chord" class="an-chart an-chord"></div>
+        <div class="legend"><span><i class="sw agents"></i>agent</span><span><i class="sw people"></i>person</span><span><i class="sw other"></i>other</span></div></div>
+      <div class="card"><div class="chart-top"><h4>Agents listening</h4><span class="small">${li.started_at ? `collected since ${esc(fmtDate(li.started_at))}` : "not collected yet"}</span></div>
+        <div id="an-listen" class="an-chart"></div><p class="small">Gaps are times with no data, not zero.</p></div>
+      <div class="card"><div class="chart-top"><h4>Files</h4><span class="small">${fmtN(fi.count || 0)} files · ${fmtBytes(fi.bytes || 0)}</span></div>
+        ${(fi.by_principal || []).length ? `<table class="an-table an-files"><thead><tr><th>Who</th><th>Files</th><th class="bar-col">Size</th></tr></thead><tbody>
+        ${fi.by_principal.map((x) => `<tr><td><span class="who" data-profile="${x.id}">${avatar(x, "xs", false)}<span>${esc(nameOf(x))}</span></span></td><td>${x.count}</td>
+          <td class="bar-col"><span class="hbar"><span style="width:${(100 * x.bytes / fmax).toFixed(1)}%"></span></span><b>${fmtBytes(x.bytes)}</b></td></tr>`).join("")}</tbody></table>`
+          : `<div class="empty">No files in these days.</div>`}</div>
     </div>
-    <div class="card chart-card"><div class="chart-top"><h4>Messages per day</h4>
-      <div class="legend"><span><i class="sw agents"></i>agents</span><span><i class="sw people"></i>people</span></div></div>
-      <div id="an-chart" class="an-chart"></div>
-      <details class="small"><summary>Show as table</summary><table class="an-table"><thead><tr><th>Day</th><th>Agents</th><th>People</th><th>Total</th></tr></thead><tbody>
-        ${a.daily.slice().reverse().map((d) => `<tr><td>${esc(dayLabel(d.day, true))}</td><td>${d.agents}</td><td>${d.people}</td><td>${d.agents + d.people}</td></tr>`).join("")}</tbody></table></details></div>
+    ${a.health ? `<div class="card"><h4>Board health</h4><p class="small">Right now, whatever days are selected.</p><div class="an-health">${healthCells(a.health)}</div></div>` : ""}
     <div class="card"><h4>Channels</h4>
-      <table class="an-table wide"><thead><tr><th>Channel</th><th class="bar-col">Messages, last ${days} days</th><th>Posters</th><th class="hide-sm">All time</th><th class="hide-sm">Last message</th></tr></thead><tbody>
-      ${a.channels.map((c) => `<tr class="${c.archived ? "muted" : ""}"><td>${c.id ? `<span class="chan-link" data-channel="${c.id}" role="link" tabindex="0">${c.kind === "private" ? LOCK : "#"}${esc(c.name)}</span>` : `<i>${esc(c.name)}</i>`}${c.archived ? ' <span class="label">archived</span>' : ""}</td>
+      <table class="an-table wide"><thead><tr><th>Channel</th><th class="bar-col">Messages</th><th>Posters</th><th class="hide-sm">All time</th><th class="hide-sm">Last message</th></tr></thead><tbody>
+      ${(a.channels || []).map((c) => `<tr class="${c.archived ? "muted" : ""}"><td>${c.id ? `<span class="chan-link" data-channel="${c.id}" role="link" tabindex="0">${c.kind === "private" ? LOCK : "#"}${esc(c.name)}</span>` : `<i>${esc(c.name)}</i>`}${c.archived ? ' <span class="label">archived</span>' : ""}</td>
         <td class="bar-col"><span class="hbar"><span style="width:${(100 * c.messages / maxC).toFixed(1)}%"></span></span><b>${c.messages}</b></td>
         <td>${c.posters}</td><td class="hide-sm">${c.total}</td><td class="small hide-sm">${c.last_at ? esc(ago(c.last_at)) : "never"}</td></tr>`).join("")}</tbody></table></div>
-    <div class="card"><div class="chart-top"><h4>Who posts</h4><div class="seg small-seg" role="group" aria-label="Show">${[["all", "Everyone"], ["agents", "Agents"], ["people", "People"]].map(([k, l]) =>
-      `<button data-who="${k}" class="${k === filter ? "on" : ""}">${l}</button>`).join("")}</div></div>
+    <div class="card"><div class="chart-top"><h4>Who posts</h4><div class="seg small-seg" role="group" aria-label="Show">${[["all", "Everyone"], ["agents", "Agents"], ["people", "People"]].map(([key, l]) =>
+      `<button data-who="${key}" class="${key === filter ? "on" : ""}">${l}</button>`).join("")}</div></div>
       ${posters.length ? `<table class="an-table wide"><thead><tr><th>Name</th><th class="hide-sm">Owner</th><th class="bar-col">Messages</th><th class="hide-sm">Daily</th><th class="hide-sm">Channels</th><th>Last post</th></tr></thead><tbody>
       ${posters.map((x) => `<tr><td><span class="who" data-profile="${x.id}">${avatar(x, "xs", false)}<span>${esc(nameOf(x))}</span><span class="label">${esc(kindLabel(x))}</span></span></td>
         <td class="small hide-sm">${x.owner ? esc(nameOf(x.owner)) : ""}</td>
         <td class="bar-col"><span class="hbar"><span style="width:${(100 * x.messages / maxP).toFixed(1)}%"></span></span><b>${x.messages}</b></td>
         <td class="hide-sm">${spark(x.daily, a.daily)}</td><td class="hide-sm">${x.channels}</td><td class="small">${esc(ago(x.last_at))}</td></tr>`).join("")}</tbody></table>`
-      : `<div class="empty">Nobody in this group posted in the last ${days} days.</div>`}</div>`;
-  hydrate($("sbody"));
-  $("sbody").querySelectorAll("[data-days]").forEach((b) => b.onclick = () => { state.analyticsDays = Number(b.dataset.days); settingsAnalytics(); });
-  $("sbody").querySelectorAll("[data-who]").forEach((b) => b.onclick = () => { state.analyticsWho = b.dataset.who; settingsAnalytics(); });
-  drawDaily($("an-chart"), a.daily);
+      : `<div class="empty">Nobody in this group posted in these days.</div>`}</div>
+  </div>`;
+  hydrate($("analytics"));
+  const daily = ms.daily && ms.daily.length ? ms.daily : (a.daily || []);
+  drawDaily($("an-chart"), daily);
+  drawSeries($("an-words"), daily.map((d) => ({ t: d.day, v: d.words ?? null })), { label: "words", fmt: fmtN });
+  drawSeries($("an-len"), daily.map((d) => ({ t: d.day, v: d.average_length ?? null })), { label: "characters", fmt: (v) => String(Math.round(v)) });
+  drawHist($("an-hist"), rt);
+  drawChord($("an-chord"), a.interactions);
+  drawSeries($("an-listen"), ((li.series) || []).map((p) => ({ t: p.at, v: p.count, note: p.samples != null && p.expected_samples ? `${p.samples} of ${p.expected_samples} samples` : "" })),
+    { label: "agents", fmt: (v) => (Math.round(v * 10) / 10).toString(), time: (li.bucket_seconds || DAY_S) < DAY_S });
+  const root = $("analytics");
+  root.querySelectorAll("[data-days]").forEach((b) => b.onclick = () => { state.anRange = { days: Number(b.dataset.days) }; renderAnalytics(); });
+  root.querySelectorAll("[data-who]").forEach((b) => b.onclick = () => { state.analyticsWho = b.dataset.who; renderAnalytics(); });
+  $("an-custom").onsubmit = (e) => {
+    e.preventDefault();
+    const f = Date.parse($("an-from").value + "T00:00:00Z") / 1000, to = Date.parse($("an-to").value + "T00:00:00Z") / 1000 + DAY_S;
+    if (!(f < to)) return;
+    state.anRange = { custom: true, from: f, to, days: Math.round((to - f) / DAY_S) }; renderAnalytics();
+  };
+  $("an-listen-link").onclick = (e) => { e.preventDefault(); openSettings("listening"); };
+  // the slider refetches only the chord, and waits until dragging pauses
+  let timer = 0;
+  $("an-k").oninput = (e) => {
+    $("an-k-n").textContent = e.target.value; clearTimeout(timer);
+    timer = setTimeout(async () => {
+      state.anTopK = Number(e.target.value);
+      try { const b = await api("GET", `/analytics?from=${r.from}&to=${r.to}&top_k=${state.anTopK}`); if (state.view === "analytics" && $("an-chord")) drawChord($("an-chord"), b.interactions); } catch {}
+    }, 300);
+  };
+}
+// health: whatever the server reports, formatted by the unit in its name
+const HEALTH_KEYS = ["db_bytes", "wal_bytes", "disk_free_bytes", "free_disk_bytes", "uptime_seconds", "open_polls", "pending_writes", "write_queue", "queued_reads", "errors_5xx", "replication"];
+function healthCells(hl) {
+  hl = Object.fromEntries(HEALTH_KEYS.filter((k) => k in hl).map((k) => [k, hl[k]]));
+  const label = (k) => k.replace(/_(bytes|seconds|at)$/, "").replace(/_/g, " ").replace(/\bwal\b/, "WAL").replace(/\bdb\b/, "database").replace(/^./, (c) => c.toUpperCase());
+  const val = (k, v) => v == null ? "—" : typeof v === "boolean" ? (v ? "yes" : "no")
+    : /bytes$/.test(k) ? fmtBytes(v) : /_at$/.test(k) ? ago(v) : /seconds$/.test(k) ? fmtDur(v) : typeof v === "number" ? fmtN(v) : String(v);
+  const cells = [];
+  for (const [k, v] of Object.entries(hl)) {
+    if (v && typeof v === "object") for (const [k2, v2] of Object.entries(v)) { if (typeof v2 !== "object") cells.push([`${k}_${k2}`, val(k2, v2)]); }
+    else cells.push([k, val(k, v)]);
+  }
+  return cells.map(([k, v]) => `<div><b>${esc(v)}</b><span>${esc(label(k))}</span></div>`).join("");
+}
+// a hover box beside the mark, kept inside the chart
+function anTip(host, mark, html) {
+  let tip = host.querySelector(".an-tip"); if (!tip) { tip = document.createElement("div"); tip.className = "an-tip"; host.append(tip); }
+  tip.innerHTML = html; tip.classList.remove("hidden");
+  const box = host.getBoundingClientRect(), rb = mark.getBoundingClientRect();
+  const right = rb.right - box.left + 6, left = rb.left - box.left - tip.offsetWidth - 6;
+  tip.style.left = (right + tip.offsetWidth <= box.width ? right : Math.max(0, left)) + "px";
+  tip.style.top = Math.max(0, Math.min(rb.top - box.top, box.height - tip.offsetHeight)) + "px";
+}
+const niceTop = (max) => {
+  max = Math.max(1, max);
+  const p = Math.pow(10, Math.floor(Math.log10(max / 4))), step = Math.max(1, p * ([1, 2, 5, 10].find((m) => p * m >= max / 4) || 10));
+  return [Math.ceil(max / step) * step, step];
+};
+// one line over time; null values break the line (no data, not zero)
+function drawSeries(host, pts, { label, fmt, time } = {}) {
+  if (!pts.length || pts.every((p) => p.v == null)) { host.innerHTML = `<div class="empty small">No data in these days.</div>`; return; }
+  const W = Math.max(280, host.clientWidth || 500), H = 120, L = 40, R = 10, T = 10, B = 22;
+  const [top, step] = niceTop(Math.max(...pts.map((p) => p.v || 0)));
+  const x = (i) => L + (pts.length === 1 ? (W - L - R) / 2 : i * (W - L - R) / (pts.length - 1)), y = (v) => T + (H - T - B) * (1 - v / top);
+  let d = "", pen = false;
+  pts.forEach((p, i) => { if (p.v == null) { pen = false; return; } d += `${pen ? "L" : "M"}${x(i).toFixed(1)},${y(p.v).toFixed(1)}`; pen = true; });
+  const every = Math.ceil(pts.length / Math.max(2, Math.floor((W - L - R) / 70)));
+  let svg = `<svg viewBox="0 0 ${W} ${H}" width="100%" height="${H}" role="img" aria-label="${esc(label || "")} over time">`;
+  for (let i = 0; i * step <= top; i++) { const v = i * step; svg += `<line class="grid" x1="${L}" x2="${W - R}" y1="${y(v)}" y2="${y(v)}"/><text class="tick" x="${L - 6}" y="${y(v) + 3.5}" text-anchor="end">${fmtN(v)}</text>`; }
+  if (time) {
+    const starts = pts.map((p, i) => [p, i]).filter(([p], i) => i === 0 || Math.floor(p.t / DAY_S) !== Math.floor(pts[i - 1].t / DAY_S)), gap = Math.ceil(starts.length / Math.max(2, Math.floor((W - L - R) / 70)));
+    starts.forEach(([p, i], j) => { if (j % gap === 0) svg += `<text class="tick" x="${x(i)}" y="${H - 6}" text-anchor="middle">${esc(dayLabel(p.t))}</text>`; });
+  } else pts.forEach((p, i) => { if (i % every === 0 || i === pts.length - 1) svg += `<text class="tick" x="${x(i)}" y="${H - 6}" text-anchor="middle">${esc(dayLabel(p.t))}</text>`; });
+  svg += `<path class="line" d="${d}"/>`;
+  const last = [...pts].reverse().find((p) => p.v != null), li = pts.lastIndexOf(last);
+  svg += `<circle class="dotm" cx="${x(li)}" cy="${y(last.v)}" r="3.5"/>`;
+  const slot = (W - L - R) / Math.max(1, pts.length - 1);
+  pts.forEach((p, i) => { svg += `<rect class="hit" data-i="${i}" x="${x(i) - slot / 2}" y="${T}" width="${slot}" height="${H - T - B}"/>`; });
+  host.innerHTML = svg + `</svg><div class="an-tip hidden"></div>`;
+  host.querySelectorAll(".hit").forEach((r) => r.addEventListener("mouseenter", () => {
+    const p = pts[Number(r.dataset.i)];
+    host.querySelectorAll(".hit.on").forEach((h) => h.classList.remove("on")); r.classList.add("on");
+    anTip(host, r, `<b>${esc(time ? new Date(p.t * 1000).toLocaleString() : dayLabel(p.t, true))}</b><span>${p.v == null ? "no data" : `${esc(fmt ? fmt(p.v) : String(p.v))} ${esc(label || "")}`}</span>${p.note ? `<span>${esc(p.note)}</span>` : ""}`);
+  }));
+  host.querySelector("svg").addEventListener("mouseleave", () => { host.querySelector(".an-tip").classList.add("hidden"); host.querySelectorAll(".hit.on").forEach((h) => h.classList.remove("on")); });
+}
+// response-time histogram with median and 90% markers
+function drawHist(host, rt) {
+  const rows = (rt && rt.histogram) || [];
+  if (!rows.length || !rows.some((b) => b.count)) { host.innerHTML = `<div class="empty small">No requests to agents in these days.</div>`; return; }
+  const W = Math.max(280, host.clientWidth || 500), H = 170, L = 40, R = 8, T = 18, B = 26;
+  const [top, step] = niceTop(Math.max(...rows.map((b) => b.count)));
+  const slot = (W - L - R) / rows.length, bw = Math.max(4, slot - 4), y = (v) => T + (H - T - B) * (1 - v / top);
+  const unit = (s) => s < 60 ? "s" : s < 3600 ? "m" : "h", num = (s) => s < 60 ? s : s < 3600 ? s / 60 : s / 3600;
+  const short = (s) => `${num(s)}${unit(s)}`;
+  // compact axis labels ("2–5m"); the hover says it in full
+  const name = (b, i) => i === 0 ? `<${short(b.to_seconds)}` : b.to_seconds == null ? `>${short(b.from_seconds)}`
+    : unit(b.from_seconds) === unit(b.to_seconds) ? `${num(b.from_seconds)}–${short(b.to_seconds)}` : `${short(b.from_seconds)}–${short(b.to_seconds)}`;
+  const full = (b, i) => i === 0 ? `under ${fmtDur(b.to_seconds)}` : b.to_seconds == null ? `over ${fmtDur(b.from_seconds)}` : `${fmtDur(b.from_seconds)} to ${fmtDur(b.to_seconds)}`;
+  let svg = `<svg viewBox="0 0 ${W} ${H}" width="100%" height="${H}" role="img" aria-label="Time to response, distribution">`;
+  for (let i = 0; i * step <= top; i++) { const v = i * step; svg += `<line class="grid" x1="${L}" x2="${W - R}" y1="${y(v)}" y2="${y(v)}"/><text class="tick" x="${L - 6}" y="${y(v) + 3.5}" text-anchor="end">${fmtN(v)}</text>`; }
+  rows.forEach((b, i) => {
+    const x = L + i * slot + (slot - bw) / 2;
+    if (b.count) svg += `<path class="bar agents" d="${barPath(x, y(b.count), bw, y(0) - y(b.count), true)}"/>`;
+    svg += `<text class="tick" x="${x + bw / 2}" y="${H - 8}" text-anchor="middle">${esc(name(b, i))}</text>`;
+    svg += `<rect class="hit" data-i="${i}" x="${L + i * slot}" y="${T}" width="${slot}" height="${H - T - B}"/>`;
+  });
+  // markers sit inside their bucket, placed linearly between its edges
+  const at = (s) => { const i = rows.findIndex((b) => s >= b.from_seconds && (b.to_seconds == null || s < b.to_seconds)); if (i < 0) return null;
+    const b = rows[i], f = b.to_seconds == null ? 0.5 : (s - b.from_seconds) / (b.to_seconds - b.from_seconds); return L + (i + f) * slot; };
+  const m1 = rt.median_seconds == null ? null : at(rt.median_seconds), m2 = rt.p90_seconds == null ? null : at(rt.p90_seconds);
+  if (m1 != null) svg += `<line class="mark" x1="${m1}" x2="${m1}" y1="${T - 6}" y2="${y(0)}"/>`;
+  if (m2 != null && (m1 == null || Math.abs(m2 - m1) > 1)) svg += `<line class="mark" x1="${m2}" x2="${m2}" y1="${T - 6}" y2="${y(0)}"/>`;
+  if (m1 != null && m2 != null && m2 - m1 < 110) svg += `<text class="tick strong" x="${m1 + 4}" y="${T - 2}">median ${esc(fmtDur(rt.median_seconds))} · 90% ${esc(fmtDur(rt.p90_seconds))}</text>`;
+  else {
+    if (m1 != null) svg += `<text class="tick strong" x="${m1 + 4}" y="${T - 2}">median ${esc(fmtDur(rt.median_seconds))}</text>`;
+    if (m2 != null) svg += `<text class="tick strong" x="${m2 + 4}" y="${T - 2}">90% ${esc(fmtDur(rt.p90_seconds))}</text>`;
+  }
+  host.innerHTML = svg + `<line class="axis" x1="${L}" x2="${W - R}" y1="${y(0)}" y2="${y(0)}"/></svg><div class="an-tip hidden"></div>`;
+  host.querySelectorAll(".hit").forEach((r) => r.addEventListener("mouseenter", () => {
+    const i = Number(r.dataset.i), b = rows[i];
+    host.querySelectorAll(".hit.on").forEach((h) => h.classList.remove("on")); r.classList.add("on");
+    anTip(host, r, `<b>${esc(full(b, i))}</b><span>${b.count} answered</span>`);
+  }));
+  host.querySelector("svg").addEventListener("mouseleave", () => { host.querySelector(".an-tip").classList.add("hidden"); host.querySelectorAll(".hit.on").forEach((h) => h.classList.remove("on")); });
+}
+// who talks to whom: a chord diagram drawn by hand (arcs per person or agent, ribbons per pair)
+function drawChord(host, inter) {
+  const nodes = (inter && inter.nodes) || [], links = ((inter && inter.links) || []).filter((l) => l.source !== l.target && l.total > 0);
+  if (!links.length) { host.innerHTML = `<div class="empty small">No messages between people and agents in these days.</div>`; return; }
+  const W = Math.max(300, Math.min(host.clientWidth || 480, 560)), H = W, R = W / 2 - 92, r0 = R - 12, PAD = 0.03;
+  const byId = new Map(nodes.map((n) => [String(n.id), n]));
+  const vol = new Map(nodes.map((n) => [String(n.id), 0]));
+  links.forEach((l) => { vol.set(String(l.source), (vol.get(String(l.source)) || 0) + l.total); vol.set(String(l.target), (vol.get(String(l.target)) || 0) + l.total); });
+  // people first, then agents, then other; each group by volume
+  const kind = (n) => n.id === "other" ? 2 : n.identity_type === "user" ? 0 : 1;
+  const order = nodes.filter((n) => vol.get(String(n.id))).sort((p, q) => kind(p) - kind(q) || vol.get(String(q.id)) - vol.get(String(p.id)));
+  const total = order.reduce((s, n) => s + vol.get(String(n.id)), 0), k = (2 * Math.PI - PAD * order.length) / total;
+  const arcs = new Map(); let a0 = 0;
+  order.forEach((n) => { const v = vol.get(String(n.id)); arcs.set(String(n.id), { n, a0, a1: a0 + v * k, cur: a0 }); a0 += v * k + PAD; });
+  const P = (a, r) => [(r * Math.sin(a)).toFixed(2), (-r * Math.cos(a)).toFixed(2)];
+  const arcPath = (s, e, ri, ro) => `M${P(s, ro)}A${ro},${ro} 0 ${e - s > Math.PI ? 1 : 0} 1 ${P(e, ro)}L${P(e, ri)}A${ri},${ri} 0 ${e - s > Math.PI ? 1 : 0} 0 ${P(s, ri)}Z`;
+  // each arc is cut into one slice per link, biggest first
+  const slices = links.slice().sort((p, q) => q.total - p.total).map((l) => {
+    const s = arcs.get(String(l.source)), t = arcs.get(String(l.target)); if (!s || !t) return null;
+    const ss = [s.cur, s.cur += l.total * k], ts = [t.cur, t.cur += l.total * k]; return { l, ss, ts };
+  }).filter(Boolean);
+  const big = (p) => p[1] - p[0] > Math.PI ? 1 : 0;
+  const ribbon = ({ ss, ts }) => `M${P(ss[0], r0)}A${r0},${r0} 0 ${big(ss)} 1 ${P(ss[1], r0)}Q0,0 ${P(ts[0], r0)}A${r0},${r0} 0 ${big(ts)} 1 ${P(ts[1], r0)}Q0,0 ${P(ss[0], r0)}Z`;
+  const cls = (n) => n.id === "other" ? "other" : n.identity_type === "user" ? "people" : "agents";
+  const nm = (n) => n.id === "other" ? `other (${n.members})` : nameOf(n);
+  let svg = `<svg viewBox="${-W / 2} ${-H / 2} ${W} ${H}" width="100%" height="${H}" role="img" aria-label="Who talks to whom">`;
+  svg += slices.map((s, i) => `<path class="ribbon" data-i="${i}" data-a="${s.l.source}" data-b="${s.l.target}" d="${ribbon(s)}"/>`).join("");
+  for (const { n, a0: s, a1: e } of arcs.values()) {
+    const mid = (s + e) / 2, deg = mid * 180 / Math.PI - 90, flip = mid > Math.PI;
+    svg += `<path class="arc ${cls(n)}" data-n="${n.id}" d="${arcPath(s, e, r0, R)}"/>`;
+    svg += `<g transform="rotate(${deg.toFixed(1)}) translate(${R + 8},0)${flip ? " rotate(180)" : ""}"><text class="node" text-anchor="${flip ? "end" : "start"}" dy="-0.1em">${esc(nm(n))}</text>` +
+      `<text class="tick" text-anchor="${flip ? "end" : "start"}" dy="1.1em">${fmtN(vol.get(String(n.id)))}</text></g>`;
+  }
+  host.innerHTML = svg + `</svg><div class="an-tip hidden"></div>`;
+  const svgEl = host.querySelector("svg");
+  const focus = (fn) => host.querySelectorAll(".ribbon").forEach((p) => p.classList.toggle("dim", !fn(p)));
+  host.querySelectorAll(".ribbon").forEach((p) => p.addEventListener("mouseenter", () => {
+    const l = slices[Number(p.dataset.i)].l, a = byId.get(String(l.source)), b = byId.get(String(l.target));
+    focus((q) => q === p);
+    anTip(host, p, `<b>${esc(nm(a))} ↔ ${esc(nm(b))}</b><span>${l.total} messages</span><span>${l.dms} DMs · ${l.replies} replies · ${l.mentions} mentions</span>`);
+  }));
+  host.querySelectorAll(".arc").forEach((p) => p.addEventListener("mouseenter", () => {
+    const id = p.dataset.n, n = byId.get(id);
+    focus((q) => q.dataset.a === id || q.dataset.b === id);
+    const inner = n.id === "other" && inter.other_internal && inter.other_internal.total ? `<span>${inter.other_internal.total} among themselves</span>` : "";
+    anTip(host, p, `<b>${esc(nm(n))}</b><span>${fmtN(vol.get(id))} messages with ${n.identity_type === "user" ? "agents" : "people"}</span>${inner}`);
+  }));
+  svgEl.addEventListener("mouseleave", () => { focus(() => true); host.querySelector(".an-tip").classList.add("hidden"); });
 }
 function spark(values, daily) {
   const w = 84, h = 18, max = Math.max(1, ...values), bw = w / values.length;
@@ -3869,10 +4126,12 @@ function barPath(x, y0, w, h, roundTop) {
   const r = roundTop ? Math.min(4, w / 2, h) : 0;   // rounded only on the data end
   return `M${x},${y0 + h}V${y0 + r}${r ? `Q${x},${y0} ${x + r},${y0}` : ""}H${x + w - r}${r ? `Q${x + w},${y0} ${x + w},${y0 + r}` : ""}V${y0 + h}Z`;
 }
-window.addEventListener("resize", () => { if (state.view === "settings" && state.settingsTab === "analytics" && $("an-chart")) settingsAnalytics(); });
+let anResize = 0;
+window.addEventListener("resize", () => { clearTimeout(anResize); anResize = setTimeout(() => { if (state.view === "analytics") renderAnalytics(); }, 250); });
 
 // ------------------------------------------------------------------ misc
 $("me-who").onclick = () => state.me && openProfile(state.me.id);
+$("analytics-open").onclick = () => openAnalytics();
 $("menu").onclick = () => $("app").classList.toggle("nav");
 $("app").addEventListener("click", (e) => {
   if (!$("app").classList.contains("nav") || e.target.closest("aside, #menu")) return;
@@ -3935,6 +4194,7 @@ $("channel-form").addEventListener("submit", async (e) => {
 window.addEventListener("hashchange", () => {
   if (location.hash === "#settings") { if (state.view !== "settings") openSettings(); return; }
   if (location.hash === "#activity") { if (state.view !== "activity") openActivity(); return; }
+  if (location.hash === "#analytics") { if (state.view !== "analytics") openAnalytics(); return; }
   const c = state.channels.find((x) => x.name === decodeURIComponent(location.hash.slice(1)));
   if (c && (!state.current || c.id !== state.current.id)) openChannel(c.id);
 });

src/msgboard/db.py

@@ -445,10 +445,23 @@ CREATE TABLE principal_presence (
 );
 """
 
+# v25: sampled listening counts and bounded analytics lookups.
+SCHEMA_V25 = """
+CREATE TABLE presence_history (
+    minute     INTEGER PRIMARY KEY,
+    sampled_at REAL NOT NULL,
+    agents     INTEGER NOT NULL CHECK (agents >= 0)
+);
+CREATE INDEX messages_created_at ON messages(created_at);
+CREATE INDEX messages_response_thread ON messages(sender_id, thread_id, created_at, id);
+CREATE INDEX messages_response_dm ON messages(channel_id, sender_id, created_at, id);
+CREATE INDEX attachments_published_at ON attachments(published, created_at);
+"""
+
 # Index i holds the SQL that moves the schema from version i to i + 1.
 MIGRATIONS = [SCHEMA_V1, SCHEMA_V2, SCHEMA_V3, SCHEMA_V4, SCHEMA_V5, SCHEMA_V6, SCHEMA_V7, SCHEMA_V8, SCHEMA_V9,
               SCHEMA_V10, SCHEMA_V11, SCHEMA_V12, SCHEMA_V13, SCHEMA_V14, SCHEMA_V15, SCHEMA_V16, SCHEMA_V17, SCHEMA_V18, SCHEMA_V19, SCHEMA_V20, SCHEMA_V21, SCHEMA_V22,
-              SCHEMA_V23, SCHEMA_V24]
+              SCHEMA_V23, SCHEMA_V24, SCHEMA_V25]
 SCHEMA_VERSION = len(MIGRATIONS)
 
 

src/msgboard/presence.py

@@ -20,6 +20,8 @@ class Presence:
         self._version = 0
         self._poll_sequence = 0
         self._latest_poll: dict[int, int] = {}
+        self._history: dict[int, tuple[float, int]] = {}
+        self._last_sample_minute: int | None = None
         self._lock = threading.Lock()
 
     def _put(self, pid: int, record: dict) -> None:
@@ -95,3 +97,28 @@ class Presence:
             for pid, version in versions.items():
                 if self._dirty.get(pid) == version:
                     del self._dirty[pid]
+
+    def listening_now(self, now: float) -> int:
+        with self._lock:
+            return self._listening_now(now)
+
+    def _listening_now(self, now: float) -> int:
+        return sum(record["last_poll_at"] is not None and 0 <= now - record["last_poll_at"] <= ACTIVE_SECONDS
+                   for record in self._records.values())
+
+    def sample(self, now: float) -> None:
+        minute = int(now // 60) * 60
+        with self._lock:
+            if self._last_sample_minute is None or minute > self._last_sample_minute:
+                self._last_sample_minute = minute
+                self._history[minute] = (now, self._listening_now(now))
+
+    def pending_history(self) -> dict[int, tuple[float, int]]:
+        with self._lock:
+            return dict(self._history)
+
+    def history_saved(self, history: dict[int, tuple[float, int]]) -> None:
+        with self._lock:
+            for minute, sample in history.items():
+                if self._history.get(minute) == sample:
+                    del self._history[minute]

src/msgboard/server.py

@@ -262,15 +262,18 @@ class Board:
 
     async def flush_presence(self) -> None:
         versions, records = self.presence.pending()
-        if records:
-            await self.db.write(store.save_presence, records)
+        history = self.presence.pending_history()
+        if records or history:
+            await self.db.write(store.save_presence, records, history)
             self.presence.saved(versions)
+            self.presence.history_saved(history)
 
     async def presence_loop(self) -> None:
         while True:
             await asyncio.sleep(PRESENCE_FLUSH_SECONDS)
             if self.shutting_down:
                 return
+            self.presence.sample(time.time())
             try:
                 await self.flush_presence()
             except Exception:
@@ -286,11 +289,13 @@ class Board:
         # writes, before the replicator takes its final snapshot. This also works
         # when begin_shutdown has closed the normal HTTP writer entry point.
         versions, records = self.presence.pending()
-        if records:
+        history = self.presence.pending_history()
+        if records or history:
             try:
-                self.db._writer.submit(self.db._run_write, store.save_presence, (records,)).result()
+                self.db._writer.submit(self.db._run_write, store.save_presence, (records, history)).result()
                 self.db.generation += 1
                 self.presence.saved(versions)
+                self.presence.history_saved(history)
             except Exception:
                 # Ephemeral presence must never prevent the final snapshot of
                 # acknowledged messages or leave the database/lease open.
@@ -333,6 +338,7 @@ def create_app(board: Board, dashboard: bool = True) -> FastAPI:
     async def lifespan(app):
         board.notifier.loop = asyncio.get_running_loop()
         board.commit_lock = asyncio.Lock()
+        board.presence.sample(time.time())
         task = asyncio.create_task(board.presence_loop())
         try:
             yield
@@ -391,6 +397,9 @@ def create_app(board: Board, dashboard: bool = True) -> FastAPI:
         p = await authn(request)
         if not p.is_admin:
             raise forbidden("admin only")
+        return health_summary()
+
+    def health_summary():
         db_path = board.data_dir / DB_NAME
         wal = Path(str(db_path) + "-wal")
         return {
@@ -686,9 +695,16 @@ def create_app(board: Board, dashboard: bool = True) -> FastAPI:
                                                        now=time.time()))
 
     @app.get("/v1/analytics")
-    async def get_analytics(request: Request, days: int = Query(30, ge=1, le=365)):
+    async def get_analytics(request: Request, days: int = Query(7, ge=1, le=365),
+                            start: float | None = Query(None, alias="from"),
+                            end: float | None = Query(None, alias="to"),
+                            top_k: int = Query(10, ge=1, le=100)):
         p = await authn(request)
-        return await db.read(store.analytics, p, time.time(), days)
+        result = await db.read(store.analytics, p, time.time(), days, start, end, top_k,
+                               board.presence.pending_history())
+        result["listening"]["now"] = board.presence.listening_now(time.time())
+        result["health"] = health_summary()
+        return result
 
     def _origin(request: Request) -> str:
         proto = request.headers.get("x-forwarded-proto") or request.url.scheme

src/msgboard/store.py

@@ -25,6 +25,7 @@ import sqlite3
 from typing import Any
 
 from . import auth
+from . import analytics as analyticsmod
 from .auth import Principal
 from .config import LIMITS
 from .presence import FIELDS as PRESENCE_FIELDS, unknown as unknown_presence
@@ -409,7 +410,7 @@ def load_presence(conn) -> dict[int, dict]:
     return records
 
 
-def save_presence(conn, records: dict[int, dict]) -> None:
+def save_presence(conn, records: dict[int, dict], history: dict | None = None) -> None:
     conn.executemany(
         """INSERT INTO principal_presence
            (principal_id, last_seen_at, last_poll_at, listens, cursor, cursor_since, waiting, waiting_since)
@@ -421,6 +422,11 @@ def save_presence(conn, records: dict[int, dict]) -> None:
           json.dumps(record["listens"]) if record["listens"] is not None else None,
           record["cursor"], record["cursor_since"], record["waiting"], record["waiting_since"])
          for pid, record in records.items()])
+    if history:
+        conn.executemany("""INSERT INTO presence_history (minute, sampled_at, agents) VALUES (?, ?, ?)
+                            ON CONFLICT(minute) DO UPDATE SET sampled_at=excluded.sampled_at, agents=excluded.agents
+                            WHERE excluded.sampled_at >= presence_history.sampled_at""",
+                         [(minute, sample[0], sample[1]) for minute, sample in history.items()])
 
 
 def attach_presence(conn, viewer: Principal, items: list[dict], records: dict[int, dict]) -> list[dict]:
@@ -2001,28 +2007,26 @@ def _reactions_to_me(conn, p: Principal, scope: str, limit: int) -> list[dict]:
 # ------------------------------------------------------------------ analytics
 
 
-def analytics(conn, p: Principal, now: float, days: int = 30) -> dict:
+def analytics(conn, p: Principal, now: float, days: int = 7, start: float | None = None,
+              end: float | None = None, top_k: int = 10, history: dict | None = None) -> dict:
     """Board activity for admins (and readers): totals, a daily series, channels and who posts."""
     if not p.sees_everything:
-        raise forbidden("only admins can see analytics")
+        raise forbidden("only admins and readers can see analytics")
     days = max(1, min(int(days), 365))
-    day0 = (int(now // 86400) - days + 1) * 86400            # start of the first UTC day in the window
-    kind = "CASE WHEN p.identity_type = 'user' THEN 'people' ELSE 'agents' END"
-    daily = {(day0 + i * 86400): {"people": 0, "agents": 0} for i in range(days)}
-    for d, k, n in conn.execute(f"""SELECT CAST(m.created_at / 86400 AS INTEGER) * 86400, {kind}, COUNT(*)
-                                    FROM messages m JOIN principals p ON p.id = m.sender_id
-                                    WHERE m.created_at >= ? GROUP BY 1, 2""", (day0,)):
-        if d in daily:
-            daily[d][k] = n
-    series = [{"day": d, **v} for d, v in sorted(daily.items())]
+    start, end = analyticsmod.bounds(now, days, start, end)
+    if not 1 <= top_k <= 100:
+        raise bad_request("top_k must be between 1 and 100")
+    stats = _analytics_messages(conn, start, end)
+    series = [{key: row[key] for key in ("day", "people", "agents")} for row in stats["daily"]]
+    daily = {row["day"]: row for row in series}
 
     chans: dict = {}
     for r in conn.execute("""SELECT c.id, c.name, c.kind, c.archived,
                                     (SELECT COUNT(*) FROM messages m WHERE m.channel_id = c.id) AS total,
-                                    (SELECT COUNT(*) FROM messages m WHERE m.channel_id = c.id AND m.created_at >= :d0) AS recent,
-                                    (SELECT COUNT(DISTINCT m.sender_id) FROM messages m WHERE m.channel_id = c.id AND m.created_at >= :d0) AS posters,
+                                    (SELECT COUNT(*) FROM messages m WHERE m.channel_id = c.id AND m.created_at >= :d0 AND m.created_at < :end) AS recent,
+                                    (SELECT COUNT(DISTINCT m.sender_id) FROM messages m WHERE m.channel_id = c.id AND m.created_at >= :d0 AND m.created_at < :end) AS posters,
                                     (SELECT MAX(m.created_at) FROM messages m WHERE m.channel_id = c.id) AS last_at
-                             FROM channels c""", {"d0": day0}):
+                             FROM channels c""", {"d0": start, "end": end}):
         key = "dm" if r["kind"] == "dm" else r["id"]          # DMs are counted together, never by pair
         c = chans.setdefault(key, {"id": None if key == "dm" else r["id"], "name": "direct messages" if key == "dm" else r["name"],
                                    "kind": r["kind"], "archived": bool(r["archived"]) if key != "dm" else False,
@@ -2033,15 +2037,15 @@ def analytics(conn, p: Principal, now: float, days: int = 30) -> dict:
 
     per_day = {}
     for pid, d, n in conn.execute("""SELECT sender_id, CAST(created_at / 86400 AS INTEGER) * 86400, COUNT(*) FROM messages
-                                     WHERE created_at >= ? GROUP BY 1, 2""", (day0,)):
+                                     WHERE created_at >= ? AND created_at < ? GROUP BY 1, 2""", (start, end)):
         per_day.setdefault(pid, {})[d] = n
     posters = []
     for r in conn.execute("""SELECT p.id, p.display_name, p.external_id, p.identity_type, p.role, p.owner_id, p.pattern_seed,
                                     substr(av.sha256, 1, 12) AS avatar, COUNT(m.id) AS n, MAX(m.created_at) AS last_at,
                                     COUNT(DISTINCT m.channel_id) AS nchannels
-                             FROM principals p JOIN messages m ON m.sender_id = p.id AND m.created_at >= ?
+                             FROM principals p JOIN messages m ON m.sender_id = p.id AND m.created_at >= ? AND m.created_at < ?
                              LEFT JOIN avatars av ON av.principal_id = p.id
-                             GROUP BY p.id ORDER BY n DESC""", (day0,)):
+                             GROUP BY p.id ORDER BY n DESC, p.id""", (start, end)):
         posters.append({"id": r["id"], "display_name": r["display_name"], "external_id": r["external_id"],
                         "identity_type": r["identity_type"], "role": r["role"], "avatar": r["avatar"], "pattern": r["pattern_seed"],
                         "owner": _brief(conn, r["owner_id"]), "messages": r["n"], "last_at": r["last_at"], "channels": r["nchannels"],
@@ -2049,6 +2053,7 @@ def analytics(conn, p: Principal, now: float, days: int = 30) -> dict:
 
     count = lambda sql, *a: conn.execute(sql, a).fetchone()[0]
     week = now - 7 * 86400
+    files = _analytics_files(conn, start, end)
     totals = {
         "messages": count("SELECT COUNT(*) FROM messages"),
         "messages_window": sum(d["people"] + d["agents"] for d in series),
@@ -2056,14 +2061,136 @@ def analytics(conn, p: Principal, now: float, days: int = 30) -> dict:
         "agents": count("SELECT COUNT(*) FROM principals WHERE identity_type != 'user' AND disabled = 0"),
         "channels": count("SELECT COUNT(*) FROM channels WHERE kind != 'dm' AND archived = 0"),
         "active_people_7d": count("""SELECT COUNT(DISTINCT m.sender_id) FROM messages m JOIN principals p ON p.id = m.sender_id
-                                     WHERE m.created_at >= ? AND p.identity_type = 'user'""", week),
+                                     WHERE m.created_at >= ? AND m.created_at < ? AND p.identity_type = 'user'""", week, now),
         "active_agents_7d": count("""SELECT COUNT(DISTINCT m.sender_id) FROM messages m JOIN principals p ON p.id = m.sender_id
-                                     WHERE m.created_at >= ? AND p.identity_type != 'user'""", week),
-        "threads_window": count("SELECT COUNT(DISTINCT thread_id) FROM messages WHERE thread_id IS NOT NULL AND created_at >= ?", day0),
-        "attachments_window": count("SELECT COUNT(*) FROM attachments WHERE published = 1 AND created_at >= ?", day0),
+                                     WHERE m.created_at >= ? AND m.created_at < ? AND p.identity_type != 'user'""", week, now),
+        "threads_window": count("SELECT COUNT(DISTINCT thread_id) FROM messages WHERE thread_id IS NOT NULL AND created_at >= ? AND created_at < ?", start, end),
+        "attachments_window": files["count"],
     }
-    return {"days": days, "since": day0, "generated_at": now, "totals": totals, "daily": series,
-            "channels": channels, "posters": posters}
+    return {"days": len(series), "since": start, "generated_at": now, "totals": totals, "daily": series,
+            "channels": channels, "posters": posters, "range": {"from": start, "to": end, "bucket_seconds": 86400},
+            "message_stats": stats, "response_times": _analytics_responses(conn, start, min(now, end)),
+            "interactions": _analytics_interactions(conn, start, end, top_k), "files": files,
+            "listening": _analytics_listening(conn, start, end, history or {})}
+
+
+def _analytics_messages(conn, start: float, end: float) -> dict:
+    import math
+
+    daily = {day: {"day": day, "messages": 0, "people": 0, "agents": 0, "words": 0, "characters": 0}
+             for day in range(int(start // 86400) * 86400, math.ceil(end / 86400) * 86400, 86400)}
+    for row in conn.execute("""SELECT m.created_at, m.body, p.identity_type FROM messages m
+                               JOIN principals p ON p.id = m.sender_id
+                               WHERE m.created_at >= ? AND m.created_at < ?""", (start, end)):
+        data = daily[int(row["created_at"] // 86400) * 86400]
+        data["messages"] += 1
+        data["people" if row["identity_type"] == "user" else "agents"] += 1
+        data["characters"] += len(row["body"])
+        data["words"] += len(analyticsmod.WORD.findall(row["body"]))
+    for data in daily.values():
+        data["average_length"] = data["characters"] / data["messages"] if data["messages"] else None
+    total = {key: sum(data[key] for data in daily.values()) for key in ("messages", "words", "characters")}
+    return {**total, "average_length": total["characters"] / total["messages"] if total["messages"] else None,
+            "daily": list(daily.values())}
+
+
+def _analytics_files(conn, start: float, end: float) -> dict:
+    rows = conn.execute("""SELECT uploader_id, COUNT(*) AS count, COALESCE(SUM(size), 0) AS bytes
+                           FROM attachments WHERE published = 1 AND created_at >= ? AND created_at < ?
+                           GROUP BY uploader_id ORDER BY bytes DESC, uploader_id""", (start, end))
+    people = [dict(_brief(conn, row["uploader_id"]), count=row["count"], bytes=row["bytes"]) for row in rows]
+    return {"count": sum(item["count"] for item in people), "bytes": sum(item["bytes"] for item in people),
+            "by_principal": people}
+
+
+def _analytics_responses(conn, start: float, end: float) -> dict:
+    # Each request/agent appears once even when a DM also mentions its recipient.
+    # Indexed first-response lookups avoid joining every request to every later message.
+    rows = conn.execute("""WITH requests AS (
+        SELECT m.id, mm.principal_id AS target, m.channel_id, COALESCE(m.thread_id, m.id) AS thread,
+               m.created_at, c.kind
+        FROM messages m JOIN message_mentions mm ON mm.message_id = m.id
+        JOIN principals p ON p.id = mm.principal_id JOIN channels c ON c.id = m.channel_id
+        WHERE m.created_at >= :start AND m.created_at < :end AND p.identity_type != 'user'
+              AND mm.principal_id != m.sender_id
+        UNION
+        SELECT m.id, cm.principal_id, m.channel_id, COALESCE(m.thread_id, m.id), m.created_at, c.kind
+        FROM messages m JOIN channels c ON c.id = m.channel_id
+        JOIN channel_members cm ON cm.channel_id = c.id JOIN principals p ON p.id = cm.principal_id
+        WHERE c.kind = 'dm' AND m.created_at >= :start AND m.created_at < :end
+              AND p.identity_type != 'user' AND cm.principal_id != m.sender_id
+    ) SELECT q.target, q.created_at,
+        CASE WHEN q.kind = 'dm' THEN (
+            SELECT r.created_at FROM messages r WHERE r.channel_id = q.channel_id AND r.sender_id = q.target
+                AND r.created_at >= q.created_at AND r.created_at < :end AND r.id > q.id
+            ORDER BY r.created_at, r.id LIMIT 1)
+        ELSE (
+            SELECT r.created_at FROM messages r WHERE r.sender_id = q.target AND r.thread_id = q.thread
+                AND r.created_at >= q.created_at AND r.created_at < :end AND r.id > q.id
+            ORDER BY r.created_at, r.id LIMIT 1)
+        END AS answered_at FROM requests q""", {"start": start, "end": end})
+    agents = {}
+    latencies = []
+    requests = 0
+    for row in rows:
+        requests += 1
+        agent = agents.setdefault(row["target"], {"requests": 0, "latencies": []})
+        agent["requests"] += 1
+        if row["answered_at"] is not None:
+            latency = row["answered_at"] - row["created_at"]
+            latencies.append(latency)
+            agent["latencies"].append(latency)
+    per_agent = [dict(_brief(conn, pid), **analyticsmod.response_summary(data["requests"], data["latencies"]))
+                 for pid, data in agents.items()]
+    return {"rule": "Mention or DM to an agent -> its first later message in that thread or DM, before the range ends. Reactions do not count.",
+            **analyticsmod.response_summary(requests, latencies), "histogram": analyticsmod.response_histogram(latencies),
+            "agents": sorted(per_agent, key=lambda item: (-item["requests"], item["id"]))}
+
+
+def _analytics_interactions(conn, start: float, end: float, top_k: int) -> dict:
+    rows = conn.execute("""WITH events AS (
+        SELECT m.id, m.sender_id AS source, cm.principal_id AS target, 0 AS priority
+        FROM messages m JOIN channels c ON c.id = m.channel_id
+        JOIN channel_members cm ON cm.channel_id = m.channel_id
+        WHERE c.kind = 'dm' AND m.created_at >= :start AND m.created_at < :end AND cm.principal_id != m.sender_id
+        UNION ALL
+        SELECT m.id, m.sender_id, parent.sender_id, 1
+        FROM messages m JOIN messages parent ON parent.id = m.reply_to JOIN channels c ON c.id = m.channel_id
+        WHERE c.kind != 'dm' AND m.created_at >= :start AND m.created_at < :end
+        UNION ALL
+        SELECT m.id, m.sender_id, mm.principal_id, 2
+        FROM messages m JOIN message_mentions mm ON mm.message_id = m.id JOIN channels c ON c.id = m.channel_id
+        WHERE c.kind != 'dm' AND m.created_at >= :start AND m.created_at < :end
+    ), pairs AS (
+        SELECT e.id, min(source, target) AS a, max(source, target) AS b, min(priority) AS priority
+        FROM events e JOIN principals s ON s.id = e.source JOIN principals t ON t.id = e.target
+        WHERE (s.identity_type = 'user') != (t.identity_type = 'user') GROUP BY e.id, a, b
+    ) SELECT a, b, priority, COUNT(*) AS count FROM pairs GROUP BY a, b, priority""", {"start": start, "end": end})
+    edges = {}
+    weights = {}
+    for row in rows:
+        a, b, count = row["a"], row["b"], row["count"]
+        edge = edges.setdefault((a, b), {"source": a, "target": b, "total": 0, "mentions": 0, "replies": 0, "dms": 0})
+        edge[("dms", "replies", "mentions")[row["priority"]]] += count
+        edge["total"] += count
+        for pid in (a, b):
+            weights[pid] = weights.get(pid, 0) + count
+    selected = sorted(weights, key=lambda pid: (-weights[pid], pid))[:top_k]
+    identities = {pid: _brief(conn, pid) for pid in selected}
+    return analyticsmod.chord_graph(list(edges.values()), identities, top_k)
+
+
+def _analytics_listening(conn, start: float, end: float, pending: dict) -> dict:
+    first = conn.execute("SELECT sampled_at FROM presence_history ORDER BY minute LIMIT 1").fetchone()
+    started_at = first[0] if first else None
+    if pending:
+        candidate = min(sample[0] for sample in pending.values())
+        started_at = min(started_at, candidate) if started_at is not None else candidate
+    rows = conn.execute("SELECT minute, sampled_at, agents FROM presence_history WHERE minute >= ? AND minute < ?",
+                        (int(start // 60) * 60, end))
+    samples = {row[0]: (row[1], row[2]) for row in rows}
+    samples.update(pending)
+    return analyticsmod.listening_series(start, end, samples, started_at)
 
 
 # ------------------------------------------------------------------ search