From f9fd81cd800557dd733de700fcfc3cc3f8507a0d Mon Sep 17 00:00:00 2001
From: Brain
 <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 11:05:53 +0200
Subject: [PATCH 1/6] Add bounded snapshot presence using existing session and
 socket owners

Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 AGENTS.md                                 |  21 ++
 dev/relay-broker-api.test.mjs             |  46 +++
 dev/relay-broker.mjs                      | 173 ++++++----
 docs/presence.md                          |  52 +++
 src/bundled/profiles/ProfilePanel.tsx     |   2 +
 src/features/communities/service.ts       |   9 +-
 src/features/messages/MessageRow.tsx      |   7 +
 src/features/presence/activity.test.ts    |  76 +++++
 src/features/presence/activity.ts         |  80 +++++
 src/features/presence/presence.test.ts    | 326 ++++++++++++++++++
 src/features/presence/presence.ts         | 290 ++++++++++++++++
 src/features/presence/react.tsx           |  42 +++
 src/features/relay/broker-live.ts         |  18 +
 src/features/relay/host-admission.test.ts |  31 +-
 src/features/relay/host-admission.ts      |   8 +-
 src/features/relay/http-admission.ts      |  57 +++-
 src/features/relay/live.test.ts           |  87 +++++
 src/features/relay/live.ts                | 114 +++++++
 src/features/relay/service.ts             |   3 +
 src/features/relay/session.ts             |  15 +
 src/features/relay/transport.test.ts      |  75 ++++
 src/features/relay/transport.ts           |  88 +++++
 tests/browser/channel-opening.spec.mjs    |  83 +++++
 tests/browser/fixture.mjs                 |  52 +++
 tests/browser/policy-relay.mjs            |  62 ++++
 tests/browser/presence.spec.mjs           | 396 ++++++++++++++++++++++
 26 files changed, 2147 insertions(+), 66 deletions(-)
 create mode 100644 docs/presence.md
 create mode 100644 src/features/presence/activity.test.ts
 create mode 100644 src/features/presence/activity.ts
 create mode 100644 src/features/presence/presence.test.ts
 create mode 100644 src/features/presence/presence.ts
 create mode 100644 src/features/presence/react.tsx
 create mode 100644 tests/browser/presence.spec.mjs

diff --git a/AGENTS.md b/AGENTS.md
index a760a3f5..af22d8c3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -28,6 +28,27 @@ complete alternative. Require a current caller or explicit approval for adapter
 parity. Review necessity separately from correctness; passing tests do not justify
 scope growth. Split at real ownership boundaries, not by deleting safety coverage.
 
+For non-trivial work, make that standard operational:
+
+- Before coding, publish a short scope checkpoint: required behavior, non-goals,
+  existing owners/platform support to reuse, expected files, and a rough production
+  diff budget (separate from tests/docs). A small fix needs only a sentence, not a
+  design ceremony.
+- Use one implementation owner per end-to-end change. Reviewers challenge necessity
+  as well as correctness; delegate bounded evidence/review, not competing rewrites.
+  Review the first working slice before expanding the design, without blocking
+  ordinary human UI feedback on a full validation cycle.
+- Justify each new abstraction, lifecycle owner, timer, retry policy, or shared
+  contract expansion against a current requirement. If the implementation materially
+  exceeds the checkpoint, stop adding machinery and show the smallest alternative
+  and any behavior tradeoff before continuing. Do not silently weaken agreed behavior.
+- Assess the combined feature diff, including stacked PRs. Passing tests, splitting
+  PRs, or already-invested work do not establish proportionality. Preserve required
+  regression coverage; do not game the budget by deleting tests or compressing code.
+  Keep speculative hardening and unrelated failures outside the task.
+- Close with one verified end-to-end result and explicit remaining gaps, not a chain
+  of green intermediate repairs presented as completion.
+
 Keep files cohesive and group modules and tests by owner. Treat size as a review
 signal, not a quota. Extract stable boundaries only when they simplify the
 requested change.
diff --git a/dev/relay-broker-api.test.mjs b/dev/relay-broker-api.test.mjs
index c6818119..61d13f06 100644
--- a/dev/relay-broker-api.test.mjs
+++ b/dev/relay-broker-api.test.mjs
@@ -494,3 +494,49 @@ test("both real sign and publish routes admit direct replies but reject arbitrar
     await h.close();
   }
 });
+
+test("held optional snapshot body leaves ordinary broker capacity free and start credit untouched", async () => {
+  let release;
+  const h = await harness((call) => {
+    if (call.body?.[0]?.kinds?.includes(20001))
+      return new Response(
+        new ReadableStream({
+          start(controller) {
+            release = () => {
+              controller.enqueue(new TextEncoder().encode("[]"));
+              controller.close();
+            };
+          },
+        }),
+      );
+    return Response.json([]);
+  });
+  const presence = [{ kinds: [20001], authors: [h.event.pubkey], limit: 1 }];
+  try {
+    const snapshot = h.post("presence-snapshot", presence);
+    await vi.waitFor(() => expect(release).toBeTypeOf("function"));
+    const duplicate = await h.post("presence-snapshot", presence);
+    expect(duplicate.status).toBe(204);
+    expect((await h.post("query", filters)).status).toBe(200);
+    expect(h.calls).toHaveLength(2);
+    expect(h.calls[1].at - h.calls[0].at).toBeLessThan(400);
+    release();
+    release = undefined;
+    expect(await (await snapshot).json()).toEqual([]);
+    expect(
+      (await h.post("presence-snapshot", [{ ...presence[0], authors: [] }]))
+        .status,
+    ).toBe(400);
+    expect(
+      (
+        await h.post("presence-snapshot", [
+          { ...presence[0], authors: Array(257).fill(h.event.pubkey) },
+        ])
+      ).status,
+    ).toBe(400);
+    expect(h.calls).toHaveLength(2);
+  } finally {
+    release?.();
+    await h.close();
+  }
+});
diff --git a/dev/relay-broker.mjs b/dev/relay-broker.mjs
index 4df3a188..11971022 100644
--- a/dev/relay-broker.mjs
+++ b/dev/relay-broker.mjs
@@ -39,6 +39,8 @@ import {
   ApiPaused,
   ApiCapacity,
   apiFailure,
+  presenceFilter,
+  presenceText,
 } from "../src/features/relay/http-admission.ts";
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
@@ -331,6 +333,7 @@ export function relayBrokerPlugin({
       };
       const stats = { queries: 0, errors: 0, media: 0, connects: 0 };
       let inflight = 0;
+      let presenceFlight = false;
       let sidebarUploads = 0;
       let libraryRead;
       const streams = new Map();
@@ -528,6 +531,7 @@ export function relayBrokerPlugin({
               readState: true,
               agentLibrary: true,
               live: true,
+              presence: true,
               agentActivity: true,
             });
           if (
@@ -535,9 +539,11 @@ export function relayBrokerPlugin({
               "/api/relay/stream-retry",
               "/api/relay/stream-priority",
               "/api/relay/stream-observer",
+              "/api/relay/stream-presence",
             ].includes(route) &&
             req.method === "POST"
           ) {
+            const publishingPresence = route === "/api/relay/stream-presence";
             const prioritizing = route === "/api/relay/stream-priority";
             const observing = route === "/api/relay/stream-observer";
             let raw = "";
@@ -546,10 +552,15 @@ export function relayBrokerPlugin({
               if (Buffer.byteLength(raw) > (prioritizing ? 9000 : 256))
                 return json(res, 413, { error: "Live control too large" });
             }
-            let streamId, priority, observer;
+            let streamId, priority, observer, status;
             try {
               const body = JSON.parse(raw);
               streamId = body.streamId;
+              if (publishingPresence) {
+                status = body.status;
+                if (status !== "online" && status !== "away")
+                  throw new Error("Invalid presence");
+              }
               if (observing) observer = observerGeneration(body.observer);
               if (prioritizing) {
                 liveChannels(body.channels);
@@ -566,10 +577,27 @@ export function relayBrokerPlugin({
             )
               return json(res, 400, { error: "Invalid live control" });
             const stream = streams.get(streamId);
+            if (publishingPresence && (!stream || stream.relay !== relay))
+              return json(res, 200, { accepted: false });
             if (!stream || stream.relay !== relay)
               return json(res, 404, {
                 error: "Live stream no longer available",
               });
+            if (publishingPresence) {
+              const cancel = new AbortController();
+              const abort = () => cancel.abort();
+              res.once("close", abort);
+              try {
+                const accepted = await stream.traffic.publishPresence(
+                  status,
+                  cancel.signal,
+                );
+                if (!res.destroyed) return json(res, 200, { accepted });
+              } finally {
+                res.off("close", abort);
+              }
+              return;
+            }
             if (prioritizing) stream.traffic.prioritize(priority);
             else if (observing) stream.traffic.observe(observer);
             else stream.traffic.retry();
@@ -726,6 +754,7 @@ export function relayBrokerPlugin({
           if (
             ![
               "/api/relay/query",
+              "/api/relay/presence-snapshot",
               "/api/relay/sign",
               "/api/relay/publish",
               "/api/relay/read-state-sign",
@@ -738,10 +767,11 @@ export function relayBrokerPlugin({
             req.method !== "POST"
           )
             return json(res, 404, { error: "Unknown broker route" });
+          const presence = route === "/api/relay/presence-snapshot";
           let raw = "";
           for await (const part of req) {
             raw += part;
-            if (raw.length > 65536)
+            if (Buffer.byteLength(raw) > (presence ? 20 * 1024 : 65536))
               return json(res, 413, { error: "Filter body too large" });
           }
           let filters;
@@ -750,6 +780,8 @@ export function relayBrokerPlugin({
           } catch {
             return json(res, 400, { error: "Filter body is not JSON" });
           }
+          if (presence && !presenceFilter(filters))
+            return json(res, 400, { error: "Invalid presence filter" });
           const profile = route === "/api/relay/profile";
           const claim = route === "/api/relay/claim";
           const policy = route === "/api/relay/accept-policy";
@@ -891,14 +923,24 @@ export function relayBrokerPlugin({
                 : policy
                   ? "/api/invites/accept-policy"
                   : "/query";
-          if (inflight >= MAX_INFLIGHT)
+          const lane = admissions(relay, viewer).api;
+          let releasePresence;
+          if (presence) {
+            releasePresence =
+              !presenceFlight && !inflight ? lane.tryPresence() : undefined;
+            if (!releasePresence) {
+              res.writeHead(204);
+              return res.end();
+            }
+            presenceFlight = true;
+          }
+          if (!presence && inflight >= MAX_INFLIGHT)
             return json(res, 429, {
               error: "Query concurrency limit",
               sent: false,
             });
-          inflight++;
+          if (!presence) inflight++;
           try {
-            const lane = admissions(relay, viewer).api;
             const body = JSON.stringify(filters);
             // A browser that gave up (the client's ten-second deadline) must also release
             // this upstream request, or hung requests exhaust the inflight budget.
@@ -911,65 +953,69 @@ export function relayBrokerPlugin({
             try {
               const requestSignal = AbortSignal.any([
                 cancel.signal,
-                AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
+                AbortSignal.timeout(presence ? 10000 : UPSTREAM_TIMEOUT_MS),
               ]);
-              response = await admittedApiRequest(
-                lane,
-                () => {
-                  // Auth freshness and network timings begin at dispatch, not queue entry.
-                  requestSignal.throwIfAborted();
-                  timings.push(
-                    `admission;dur=${(performance.now() - admissionStart).toFixed(2)}`,
-                  );
-                  const authStart = performance.now();
-                  const auth = finalizeEvent(
-                    {
-                      kind: 27235,
-                      created_at: Math.floor(Date.now() / 1000),
-                      content: "",
-                      tags: [
-                        ["u", `${relay}${upstreamPath}`],
-                        ["method", "POST"],
-                        [
-                          "payload",
-                          createHash("sha256").update(body).digest("hex"),
-                        ],
-                        ["nonce", randomBytes(16).toString("hex")],
+              const request = () => {
+                // Auth freshness and network timings begin at dispatch, not queue entry.
+                requestSignal.throwIfAborted();
+                timings.push(
+                  `admission;dur=${(performance.now() - admissionStart).toFixed(2)}`,
+                );
+                const authStart = performance.now();
+                const auth = finalizeEvent(
+                  {
+                    kind: 27235,
+                    created_at: Math.floor(Date.now() / 1000),
+                    content: "",
+                    tags: [
+                      ["u", `${relay}${upstreamPath}`],
+                      ["method", "POST"],
+                      [
+                        "payload",
+                        createHash("sha256").update(body).digest("hex"),
                       ],
-                    },
-                    key,
-                  );
+                      ["nonce", randomBytes(16).toString("hex")],
+                    ],
+                  },
+                  key,
+                );
+                timings.push(
+                  `auth;dur=${(performance.now() - authStart).toFixed(2)}`,
+                );
+                connectsBefore = upstream.connects();
+                upstreamStart = performance.now();
+                return fetchUpstream(`${relay}${upstreamPath}`, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    Authorization:
+                      "Nostr " +
+                      Buffer.from(JSON.stringify(auth)).toString("base64"),
+                  },
+                  body,
+                  redirect: "error",
+                  signal: requestSignal,
+                }).then((response) => {
                   timings.push(
-                    `auth;dur=${(performance.now() - authStart).toFixed(2)}`,
+                    `ttfb;dur=${(performance.now() - upstreamStart).toFixed(2)}`,
                   );
-                  connectsBefore = upstream.connects();
-                  upstreamStart = performance.now();
-                  return fetchUpstream(`${relay}${upstreamPath}`, {
-                    method: "POST",
-                    headers: {
-                      "Content-Type": "application/json",
-                      Authorization:
-                        "Nostr " +
-                        Buffer.from(JSON.stringify(auth)).toString("base64"),
-                    },
-                    body,
-                    redirect: "error",
-                    signal: requestSignal,
-                  }).then((response) => {
-                    timings.push(
-                      `ttfb;dur=${(performance.now() - upstreamStart).toFixed(2)}`,
-                    );
-                    return response;
-                  });
-                },
-                requestSignal,
-                route === "/api/relay/query" &&
-                  req.headers["x-buzz-read-priority"] === "background"
-                  ? "background"
-                  : "foreground",
-              );
-              const text =
-                snapshot && response.ok
+                  return response;
+                });
+              };
+              response = presence
+                ? await request()
+                : await admittedApiRequest(
+                    lane,
+                    request,
+                    requestSignal,
+                    route === "/api/relay/query" &&
+                      req.headers["x-buzz-read-priority"] === "background"
+                      ? "background"
+                      : "foreground",
+                  );
+              const text = presence
+                ? await presenceText(response)
+                : snapshot && response.ok
                   ? await readSnapshotText(response)
                   : await response.text();
               // The relay's own service time separates server work from network time.
@@ -994,6 +1040,8 @@ export function relayBrokerPlugin({
                 } catch {
                   failure = apiFailure(response.status, undefined);
                 }
+                if (presence && failure.quota === "api")
+                  lane.pause(failure.retryAfterMs);
                 return json(res, response.status, failure);
               }
               if (profile) {
@@ -1015,7 +1063,10 @@ export function relayBrokerPlugin({
               res.off("close", release);
             }
           } finally {
-            inflight--;
+            if (presence) {
+              presenceFlight = false;
+              releasePresence();
+            } else inflight--;
           }
         } catch (error) {
           if (res.destroyed) return; // The browser gave up first; nothing to answer.
diff --git a/docs/presence.md b/docs/presence.md
new file mode 100644
index 00000000..6279f9b8
--- /dev/null
+++ b/docs/presence.md
@@ -0,0 +1,52 @@
+# Periodically refreshed community presence
+
+Message and thread bylines and profiles show Online, Away, Offline or Unknown
+with text and distinct symbols, not color alone. This is snapshot presence, not
+an immediate live-status stream.
+
+## Ownership and bounds
+
+- One app input source derives Away after ten minutes without Buzz input. Focus
+  loss and changing communities alone do not mean Away. Same-origin windows share
+  recent input through BroadcastChannel; no machine-idle or cross-device claim.
+- Each retained connected session owns one volatile presence directory. Mounted
+  rows (including timeline overscan and offscreen thread replies) demand authors.
+  At most 256 unique authors are selected; profiles take priority, then existing
+  selections and stable acquisition order. Overflow stays Unknown with a tooltip.
+- Initial/new demand coalesces for 100ms behind a five-second start gate. Successful
+  views refresh after 60–65 seconds. Evidence expires 75 seconds after request start.
+  Empty demand makes no request; removed authors lose their evidence. Hidden views,
+  disconnect, access/cache invalidation and disposal invalidate observations.
+- One bounded complete snapshot is validated before any status changes. The
+  configured relay must sign each unique requested subject; only a successful
+  complete response can make omitted subjects Offline. This is read-time evidence,
+  not the relay's remaining lease. Invalid or failed responses mean Unknown.
+- The development broker permits one optional HTTP flight, a principal-wide
+  five-second start gate, 256 subjects, a 20 KiB request and 1 MiB response, and
+  a ten-second request lifetime. Optional work never uses ordinary read slots or
+  dispatch credit. Local busy skips retry after 5–6 seconds; network failures wait
+  60–65 seconds, honoring longer server cooldowns.
+- Renewal uses the existing authenticated socket, with a Web Lock per scope/viewer
+  serializing same-origin windows. Publication is lossy and bounded; it never
+  enters the durable outbox, replays missed ticks, or publishes Offline on close.
+  Hidden observation does not stop connected-community renewal. Ordinary setup and
+  actual shared relay cooldowns still take priority.
+
+Sustained ordinary traffic may starve optional reads and renewal. Unknown can last
+indefinitely when busy/unavailable. These limits bound client work; they do not
+promise zero CPU/network/backend cost, instant transitions, or a delivery SLA.
+There are no presence REQs, added sockets, relay changes, or direct-adapter parity.
+
+## Validation
+
+Owner tests live with `features/presence`, relay transport/admission and the broker.
+`tests/browser/presence.spec.mjs` exercises the built app and production broker with
+modeled upstream and ephemeral keys: held snapshots versus chat, shared row demand,
+300 distinct thread authors, Unknown during held replacement reads, and real
+same-origin Web Lock handoff. `channel-opening.spec.mjs` includes matched-thread
+measurement support. See [browser measurement limits](browser-testing.md).
+
+These fixtures do not certify deployed relay capacity, native-window behavior,
+attended account use, or cross-device availability. Full browser activity/idle
+transition integration and the complete changed-call-site mutation audit remain
+separate validation work; activity derivation has controlled owner tests.
diff --git a/src/bundled/profiles/ProfilePanel.tsx b/src/bundled/profiles/ProfilePanel.tsx
index 4259775a..496234ef 100644
--- a/src/bundled/profiles/ProfilePanel.tsx
+++ b/src/bundled/profiles/ProfilePanel.tsx
@@ -1,3 +1,4 @@
+import { PresenceIndicator } from "../../features/presence/react";
 import {
   useEffect,
   useMemo,
@@ -102,6 +103,7 @@ function ProfileDetails({
         />
         <h2 className="text-heading">{name}</h2>
       </div>
+      <PresenceIndicator presence={session.presence} pubkey={pubkey} profile />
       {profile?.about && <p className={styles.about}>{profile.about}</p>}
       {context?.canOpen(activity) && (
         <div>
diff --git a/src/features/communities/service.ts b/src/features/communities/service.ts
index ee7951ca..8a9dfac5 100644
--- a/src/features/communities/service.ts
+++ b/src/features/communities/service.ts
@@ -1,4 +1,5 @@
 // FOUNDATION: Client identity and membership selection outlive community query sessions.
+import { createPresenceActivity } from "../presence/activity";
 import { Context } from "@deepseek-ai/cordis";
 import { provideRelay, type RelayData } from "../relay/service";
 import { connectBrokerTransport } from "../relay/transport";
@@ -31,6 +32,7 @@ export function createCommunities(ctx: Context, live: boolean) {
   let unresolvedSelection: string | null = null;
   let disposed = false;
   const controller = new AbortController();
+  const presenceActivity = createPresenceActivity();
   const listeners = new Set<() => void>();
   const relayListeners = new Set<() => void>();
   const sessions = new Map<string, RelayData>();
@@ -72,8 +74,10 @@ export function createCommunities(ctx: Context, live: boolean) {
   const acquire = (id: string) => {
     let session = sessions.get(id);
     if (!session) {
-      session = provideRelay(newScope(), (signal) =>
-        connectBrokerTransport("", signal, id),
+      session = provideRelay(
+        newScope(),
+        (signal) => connectBrokerTransport("", signal, id),
+        presenceActivity,
       );
       sessions.set(id, session);
       session.subscribe(() => {
@@ -185,6 +189,7 @@ export function createCommunities(ctx: Context, live: boolean) {
   ctx.effect(() => () => {
     disposed = true;
     controller.abort();
+    presenceActivity.dispose();
     listeners.clear();
     relayListeners.clear();
     return Promise.all(scopes.map((scope) => scope.fiber.dispose()));
diff --git a/src/features/messages/MessageRow.tsx b/src/features/messages/MessageRow.tsx
index 323a9580..4df88f5f 100644
--- a/src/features/messages/MessageRow.tsx
+++ b/src/features/messages/MessageRow.tsx
@@ -1,4 +1,5 @@
 import { memo, useCallback, useSyncExternalStore } from "react";
+import { PresenceIndicator } from "../presence/react";
 import type { UnreadCapability } from "../relay/unread";
 import { profileTarget } from "../profiles/target";
 import { InlineText } from "../conversation/InlineText";
@@ -119,6 +120,12 @@ export const MessageRow = memo(function MessageRow({
         <div className={styles.messageBody}>
           <div className={styles.byline}>
             <strong>{name}</strong>
+            {session && (
+              <PresenceIndicator
+                presence={session.presence}
+                pubkey={row.authorId}
+              />
+            )}
             <time dateTime={new Date(row.createdAt * 1000).toISOString()}>
               {new Date(row.createdAt * 1000).toLocaleTimeString(undefined, {
                 hour: "numeric",
diff --git a/src/features/presence/activity.test.ts b/src/features/presence/activity.test.ts
new file mode 100644
index 00000000..08a570d0
--- /dev/null
+++ b/src/features/presence/activity.test.ts
@@ -0,0 +1,76 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { createPresenceActivity } from "./activity";
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+it("input is local, derived transitions are sparse, visibility is independent and disposal removes listeners", async () => {
+  vi.useFakeTimers();
+  const document = Object.assign(new EventTarget(), {
+    visibilityState: "visible",
+  });
+  vi.stubGlobal("document", document);
+  const activity = createPresenceActivity();
+  const changed = vi.fn();
+  activity.subscribe(changed);
+  expect(activity.status()).toBe("online");
+  await vi.advanceTimersByTimeAsync(599999);
+  expect(activity.status()).toBe("online");
+  await vi.advanceTimersByTimeAsync(1);
+  expect(activity.status()).toBe("away");
+  document.dispatchEvent(new Event("keydown"));
+  expect(activity.status()).toBe("online");
+  for (let i = 0; i < 1000; i++)
+    document.dispatchEvent(new Event("pointermove"));
+  expect(changed).toHaveBeenCalledTimes(2);
+  document.visibilityState = "hidden";
+  document.dispatchEvent(new Event("visibilitychange"));
+  expect(activity.visible()).toBe(false);
+  expect(activity.status()).toBe("online");
+  activity.dispose();
+  document.dispatchEvent(new Event("keydown"));
+  await vi.advanceTimersByTimeAsync(600000);
+  expect(changed).toHaveBeenCalledTimes(3);
+  expect(vi.getTimerCount()).toBe(0);
+});
+it("same-origin input wakes an idle peer without rebroadcast or per-input notifications", async () => {
+  vi.useFakeTimers();
+  const channels: {
+    onmessage?: (event: { data: number }) => void;
+    postMessage: ReturnType<typeof vi.fn>;
+    close: ReturnType<typeof vi.fn>;
+  }[] = [];
+  vi.stubGlobal("window", {});
+  vi.stubGlobal(
+    "document",
+    Object.assign(new EventTarget(), { visibilityState: "visible" }),
+  );
+  vi.stubGlobal(
+    "BroadcastChannel",
+    class {
+      onmessage?: (event: { data: number }) => void;
+      close = vi.fn();
+      postMessage = vi.fn((data: number) => {
+        for (const peer of channels)
+          if (peer !== this) peer.onmessage?.({ data });
+      });
+      constructor() {
+        channels.push(this);
+      }
+    },
+  );
+  const activity = createPresenceActivity(),
+    changed = vi.fn();
+  activity.subscribe(changed);
+  await vi.advanceTimersByTimeAsync(600000);
+  expect(activity.status()).toBe("away");
+  channels[0]?.onmessage?.({ data: Date.now() + 100000 });
+  expect(activity.status()).toBe("away");
+  channels[0]?.onmessage?.({ data: Date.now() });
+  expect(activity.status()).toBe("online");
+  expect(channels[0]?.postMessage).not.toHaveBeenCalled();
+  expect(changed).toHaveBeenCalledTimes(2);
+  activity.dispose();
+  expect(channels[0]?.close).toHaveBeenCalledOnce();
+});
diff --git a/src/features/presence/activity.ts b/src/features/presence/activity.ts
new file mode 100644
index 00000000..05ae99d3
--- /dev/null
+++ b/src/features/presence/activity.ts
@@ -0,0 +1,80 @@
+/** One app input source; focus and selected community are not availability. */
+export function createPresenceActivity() {
+  const listeners = new Set<() => void>();
+  let last = Date.now(),
+    sharedAt = 0;
+  let away = false;
+  const visible = () =>
+    typeof document !== "undefined" && document.visibilityState === "visible";
+  let shown = visible();
+  const channel =
+    typeof window !== "undefined" && typeof BroadcastChannel !== "undefined"
+      ? new BroadcastChannel("buzz-presence-input")
+      : undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  function update() {
+    clearTimeout(timer);
+    const nextAway = Date.now() - last >= 600000;
+    const nextShown = visible();
+    if (nextAway !== away || nextShown !== shown) {
+      away = nextAway;
+      shown = nextShown;
+      for (const listener of listeners) listener();
+    }
+    if (!away)
+      timer = setTimeout(update, Math.max(1, last + 600000 - Date.now()));
+  }
+  const input = () => {
+    last = Date.now();
+    if (last - sharedAt >= 1000) {
+      sharedAt = last;
+      channel?.postMessage(last);
+    }
+    update();
+  };
+  if (channel)
+    channel.onmessage = ({ data }) => {
+      if (
+        typeof data === "number" &&
+        Number.isFinite(data) &&
+        data > last &&
+        data <= Date.now()
+      ) {
+        last = data;
+        update();
+      }
+    };
+  const events = [
+    "pointerdown",
+    "pointermove",
+    "keydown",
+    "wheel",
+    "touchstart",
+  ];
+  if (typeof document !== "undefined") {
+    for (const event of events)
+      document.addEventListener(event, input, { passive: true });
+    document.addEventListener("visibilitychange", update);
+    update();
+  }
+  return {
+    status: (): "online" | "away" => (away ? "away" : "online"),
+    visible: () => shown,
+    subscribe(listener: () => void) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      clearTimeout(timer);
+      channel?.close();
+      listeners.clear();
+      if (typeof document !== "undefined") {
+        for (const event of events) document.removeEventListener(event, input);
+        document.removeEventListener("visibilitychange", update);
+      }
+    },
+  };
+}
+export type PresenceActivity = ReturnType<typeof createPresenceActivity>;
diff --git a/src/features/presence/presence.test.ts b/src/features/presence/presence.test.ts
new file mode 100644
index 00000000..7faa787f
--- /dev/null
+++ b/src/features/presence/presence.test.ts
@@ -0,0 +1,326 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { createPresence } from "./presence";
+import type { PresenceActivity } from "./activity";
+import type { ReadTransport } from "../relay/transport";
+import { createRelaySession } from "../relay/session";
+import type { LiveCallbacks } from "../relay/live";
+const key = (n: number) => n.toString(16).padStart(64, "0");
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+function setup() {
+  vi.useFakeTimers();
+  vi.spyOn(Math, "random").mockReturnValue(0);
+  const listeners = new Set<() => void>();
+  let visible = true;
+  const activity: PresenceActivity = {
+    visible: () => visible,
+    status: () => "online",
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    dispose() {},
+  };
+  const read = vi.fn<NonNullable<ReadTransport["presenceSnapshot"]>>(
+    async (authors) => new Map(authors.map((key) => [key, "online"])),
+  );
+  const transport = {
+    viewer: key(1),
+    relayAuthor: key(2),
+    query: async () => [],
+    media: () => undefined,
+    presenceSnapshot: read,
+  };
+  const owner = createPresence(
+    transport,
+    activity,
+    async () => true,
+    (fn) => fn(),
+  );
+  owner.connected(true);
+  return {
+    owner,
+    read,
+    activity,
+    transport,
+    hide() {
+      visible = false;
+      for (const fn of listeners) fn();
+    },
+    show() {
+      visible = true;
+      for (const fn of listeners) fn();
+    },
+  };
+}
+it("deduplicates, bounds mounted demand and prioritizes an explicit profile", async () => {
+  const h = setup();
+  const releases = Array.from({ length: 260 }, (_, i) =>
+    h.owner.subscribe(key(i), () => {}),
+  );
+  const duplicate = h.owner.subscribe(key(0), () => {});
+  const profile = h.owner.subscribe(key(259), () => {}, true);
+  await vi.advanceTimersByTimeAsync(100);
+  expect(h.read).toHaveBeenCalledOnce();
+  const authors = h.read.mock.calls[0]?.[0];
+  expect(authors).toHaveLength(256);
+  expect(new Set(authors).size).toBe(256);
+  expect(authors).toContain(key(259));
+  expect(h.owner.status(key(259))).toBe("online");
+  expect(h.owner.status(key(258))).toBe("unknown");
+  for (const release of releases) release();
+  duplicate();
+  profile();
+  await vi.advanceTimersByTimeAsync(180000);
+  expect(h.read).toHaveBeenCalledOnce();
+  h.owner.dispose();
+});
+it("fences remove/re-add, hide and cache invalidation while a snapshot is held", async () => {
+  const h = setup();
+  let release!: (value: ReadonlyMap<string, "online">) => void;
+  h.read.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        release = resolve;
+      }),
+  );
+  const remove = h.owner.subscribe(key(3), () => {});
+  await vi.advanceTimersByTimeAsync(100);
+  remove();
+  h.owner.subscribe(key(3), () => {});
+  release(new Map([[key(3), "online"]]));
+  await vi.advanceTimersByTimeAsync(0);
+  expect(h.owner.status(key(3))).toBe("unknown");
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(h.owner.status(key(3))).toBe("online");
+  h.hide();
+  expect(h.owner.status(key(3))).toBe("unknown");
+  const calls = h.read.mock.calls.length;
+  await vi.advanceTimersByTimeAsync(120000);
+  expect(h.read).toHaveBeenCalledTimes(calls);
+  h.show();
+  await vi.advanceTimersByTimeAsync(100);
+  expect(h.owner.status(key(3))).toBe("online");
+  h.owner.clear();
+  expect(h.owner.status(key(3))).toBe("unknown");
+  h.owner.dispose();
+});
+it("local skips expire evidence; network failures enforce a minute delay even for new demand", async () => {
+  const h = setup();
+  h.owner.subscribe(key(3), () => {});
+  await vi.advanceTimersByTimeAsync(100);
+  h.read.mockResolvedValue(null);
+  await vi.advanceTimersByTimeAsync(74999);
+  expect(h.owner.status(key(3))).toBe("online");
+  await vi.advanceTimersByTimeAsync(1);
+  expect(h.owner.status(key(3))).toBe("unknown");
+  h.read.mockRejectedValue(new Error("network"));
+  await vi.advanceTimersByTimeAsync(5000);
+  const calls = h.read.mock.calls.length;
+  h.owner.subscribe(key(4), () => {});
+  await vi.advanceTimersByTimeAsync(59999);
+  expect(h.read).toHaveBeenCalledTimes(calls);
+  await vi.advanceTimersByTimeAsync(1);
+  expect(h.read).toHaveBeenCalledTimes(calls + 1);
+  h.owner.dispose();
+});
+it("real session wiring owns publication, snapshot lifetime and ordinary retention separately", async () => {
+  const h = setup();
+  h.owner.dispose();
+  const publish = vi.fn(async () => true);
+  vi.stubGlobal("navigator", {
+    locks: {
+      request: async (
+        _name: string,
+        _options: unknown,
+        work: () => Promise<void>,
+      ) => work(),
+    },
+  });
+  let callbacks!: LiveCallbacks;
+  const store = createRelaySession(
+    {
+      ...h.transport,
+      subscribe(value) {
+        callbacks = value;
+        return {
+          update() {},
+          retry() {},
+          dispose() {},
+          publishPresence: publish,
+        };
+      },
+    },
+    { presenceActivity: h.activity },
+  );
+  store.session.presence.subscribe(key(3), () => {}, true);
+  callbacks.state({ status: "connected", routes: [] });
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(publish).toHaveBeenCalledWith("online", expect.any(AbortSignal));
+  expect(store.session.presence.status(key(3))).toBe("online");
+  expect(h.read).toHaveBeenCalledOnce();
+  await store.clearCache();
+  expect(store.session.presence.status(key(3))).toBe("unknown");
+  callbacks.state({ status: "retrying", routes: [] });
+  const calls = publish.mock.calls.length;
+  await vi.advanceTimersByTimeAsync(120000);
+  expect(publish).toHaveBeenCalledTimes(calls);
+  store.dispose();
+});
+
+it("standard lock ownership serializes windows; hidden observation does not stop renewal and disposal transfers ownership", async () => {
+  const h = setup();
+  h.owner.dispose();
+  // A faithful exclusive-lock queue, not an app-owned election/retry mechanism.
+  let occupied = false;
+  const queue: (() => void)[] = [];
+  const locks = {
+    request: vi.fn(
+      (
+        _name: string,
+        options: { signal: AbortSignal },
+        work: () => Promise<void>,
+      ) =>
+        new Promise<void>((resolve, reject) => {
+          const start = () => {
+            if (options.signal.aborted) {
+              reject(options.signal.reason);
+              return;
+            }
+            occupied = true;
+            void work()
+              .then(resolve, reject)
+              .finally(() => {
+                occupied = false;
+                queue.shift()?.();
+              });
+          };
+          if (occupied) queue.push(start);
+          else start();
+        }),
+    ),
+  };
+  vi.stubGlobal("navigator", { locks });
+  const firstPublish = vi.fn(async () => true),
+    nextPublish = vi.fn(async () => true);
+  const first = createPresence(h.transport, h.activity, firstPublish, (fn) =>
+    fn(),
+  );
+  const next = createPresence(h.transport, h.activity, nextPublish, (fn) =>
+    fn(),
+  );
+  first.connected(true);
+  next.connected(true);
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(firstPublish).toHaveBeenCalledOnce();
+  expect(nextPublish).not.toHaveBeenCalled();
+  h.hide();
+  await vi.advanceTimersByTimeAsync(60000);
+  expect(firstPublish).toHaveBeenCalledTimes(2);
+  expect(nextPublish).not.toHaveBeenCalled();
+  first.dispose();
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(nextPublish).toHaveBeenCalledOnce();
+  next.dispose();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(occupied).toBe(false);
+});
+
+it("bounds continuous mounted-author churn without deferring the first batch or replaying released demand", async () => {
+  const h = setup();
+  const started: number[] = [];
+  h.read.mockImplementation(async (authors) => {
+    started.push(Date.now());
+    return new Map(authors.map((author) => [author, "online"]));
+  });
+  const mounted = Array.from({ length: 256 }, (_, i) =>
+    h.owner.subscribe(key(i), () => {}),
+  );
+  const start = Date.now();
+  let next = 256;
+  // 2,000 author replacements in ten seconds, not an unchanged-demand timer test.
+  for (let step = 0; step < 100; step++) {
+    for (let count = 0; count < 20; count++) {
+      mounted.shift()?.();
+      mounted.push(h.owner.subscribe(key(next++), () => {}));
+    }
+    await vi.advanceTimersByTimeAsync(100);
+  }
+  expect(started.map((at) => at - start)).toEqual([100, 5100]);
+  for (const [authors] of h.read.mock.calls) {
+    expect(authors).toHaveLength(256);
+    expect(new Set(authors).size).toBe(256);
+  }
+  for (const release of mounted) release();
+  await vi.advanceTimersByTimeAsync(120000);
+  expect(h.read).toHaveBeenCalledTimes(2);
+  h.owner.dispose();
+});
+
+it("duplicate demand and unchanged refreshes do not notify existing status subscribers", async () => {
+  const h = setup();
+  const changed = vi.fn();
+  h.owner.subscribe(key(3), changed);
+  await vi.advanceTimersByTimeAsync(100);
+  expect(h.owner.status(key(3))).toBe("online");
+  changed.mockClear();
+  const duplicates = Array.from({ length: 1000 }, () =>
+    h.owner.subscribe(key(3), () => {}),
+  );
+  await vi.advanceTimersByTimeAsync(60000);
+  expect(h.read).toHaveBeenCalledTimes(2);
+  expect(changed).not.toHaveBeenCalled();
+  for (const release of duplicates) release();
+  expect(changed).not.toHaveBeenCalled();
+  h.owner.dispose();
+});
+
+it("starts a fresh 100ms coalescing window when first demand arrives after connection has been idle", async () => {
+  const h = setup();
+  await vi.advanceTimersByTimeAsync(10000);
+  const first = h.owner.subscribe(key(3), () => {}, true);
+  await vi.advanceTimersByTimeAsync(50);
+  const second = h.owner.subscribe(key(4), () => {});
+  await vi.advanceTimersByTimeAsync(49);
+  expect(h.read).not.toHaveBeenCalled();
+  await vi.advanceTimersByTimeAsync(1);
+  expect(h.read).toHaveBeenCalledOnce();
+  expect(h.read.mock.calls[0]?.[0]).toEqual([key(3), key(4)]);
+  first();
+  second();
+  await vi.advanceTimersByTimeAsync(10000);
+  h.owner.subscribe(key(5), () => {});
+  await vi.advanceTimersByTimeAsync(99);
+  expect(h.read).toHaveBeenCalledTimes(1);
+  await vi.advanceTimersByTimeAsync(1);
+  expect(h.read).toHaveBeenCalledTimes(2);
+  h.owner.dispose();
+});
+
+it("retains profile priority across duplicate cleanup and refills released slots before the next task", async () => {
+  const h = setup();
+  const releases = Array.from({ length: 260 }, (_, i) =>
+    h.owner.subscribe(key(i), () => {}),
+  );
+  const row = h.owner.subscribe(key(259), () => {});
+  const first = h.owner.subscribe(key(259), () => {}, true);
+  const second = h.owner.subscribe(key(259), () => {}, true);
+  expect(h.owner.limited(key(259))).toBe(false);
+  first();
+  releases[0]?.();
+  row();
+  await vi.advanceTimersByTimeAsync(100);
+  expect(h.owner.status(key(259))).toBe("online");
+  expect(h.owner.status(key(255))).toBe("online");
+  expect(h.read.mock.calls[0]?.[0]).toHaveLength(256);
+  second();
+  for (const release of releases) release();
+  await vi.advanceTimersByTimeAsync(120000);
+  expect(h.read).toHaveBeenCalledOnce();
+  h.owner.dispose();
+});
diff --git a/src/features/presence/presence.ts b/src/features/presence/presence.ts
new file mode 100644
index 00000000..4ed50fad
--- /dev/null
+++ b/src/features/presence/presence.ts
@@ -0,0 +1,290 @@
+import type { ReadTransport } from "../relay/transport";
+import type { LiveSubscription } from "../relay/live";
+import type { PresenceActivity } from "./activity";
+
+export type PresenceStatus = "online" | "away" | "offline" | "unknown";
+type Subject = {
+  listeners: Map<() => void, boolean>;
+  profiles: number;
+  status: PresenceStatus;
+  expires: number;
+};
+const minute = () => 60000 + Math.random() * 5000;
+/** Volatile session-owned evidence. No event retention, outbox or live observation. */
+export function createPresence(
+  transport: ReadTransport | null,
+  activity: PresenceActivity | undefined,
+  publish: NonNullable<LiveSubscription["publishPresence"]>,
+  notify: (listener: () => void) => void,
+) {
+  const subjects = new Map<string, Subject>();
+  const profiles = new Map<string, Subject>();
+  let selected = new Map<string, Subject>();
+  let connected = false,
+    closed = false,
+    reading = false;
+  let nextRead = Infinity,
+    readGate = 0;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let controller: AbortController | undefined;
+  let publisher: AbortController | undefined;
+  let renewal: ReturnType<typeof setTimeout> | undefined;
+  let stopPublisher: (() => void) | undefined;
+  let lastStatus = activity?.status();
+  const change = (subject: Subject, status: PresenceStatus) => {
+    if (subject.status === status) return;
+    subject.status = status;
+    for (const listener of subject.listeners.keys()) notify(listener);
+  };
+  const eligible = () =>
+    !closed &&
+    connected &&
+    !!transport?.presenceSnapshot &&
+    !!activity?.visible();
+  function schedule() {
+    clearTimeout(timer);
+    if (!eligible() || !selected.size) return;
+    let wake = reading ? Infinity : nextRead;
+    for (const subject of selected.values())
+      if (subject.status !== "unknown") wake = Math.min(wake, subject.expires);
+    if (Number.isFinite(wake))
+      timer = setTimeout(tick, Math.max(0, wake - Date.now()));
+  }
+  function demand() {
+    const previous = selected;
+    selected = new Map();
+    // Stop each source at the cap. Overflow and duplicate rows must not turn
+    // mounting a thread into a full-directory scan per subscription.
+    for (const source of [profiles, previous, subjects]) {
+      for (const [key, subject] of source) {
+        if (selected.size === 256) break;
+        if (subjects.get(key) === subject) selected.set(key, subject);
+      }
+    }
+    for (const [key, subject] of previous)
+      if (!selected.has(key)) {
+        change(subject, "unknown");
+        for (const listener of subject.listeners.keys()) notify(listener);
+      }
+    for (const [key, subject] of selected)
+      if (previous.get(key) !== subject)
+        for (const listener of subject.listeners.keys()) notify(listener);
+    if ([...selected].some(([key, subject]) => previous.get(key) !== subject)) {
+      const initial = Math.max(Date.now() + 100, readGate);
+      nextRead = previous.size ? Math.min(nextRead, initial) : initial;
+    }
+    if (!selected.size) {
+      nextRead = Infinity;
+      controller?.abort();
+    }
+    schedule();
+  }
+  let selectionQueued = false;
+  function queueDemand() {
+    if (selectionQueued || closed) return;
+    selectionQueued = true;
+    queueMicrotask(() => {
+      selectionQueued = false;
+      if (!closed) demand();
+    });
+  }
+  async function tick() {
+    const now = Date.now();
+    for (const subject of selected.values())
+      if (subject.expires <= now) change(subject, "unknown");
+    if (
+      !eligible() ||
+      !transport?.presenceSnapshot ||
+      reading ||
+      now < nextRead ||
+      !selected.size
+    ) {
+      schedule();
+      return;
+    }
+    const captured = new Map(selected);
+    const owned = new AbortController();
+    controller = owned;
+    reading = true;
+    readGate = now + 5000;
+    nextRead = Infinity;
+    schedule();
+    try {
+      const values = await transport.presenceSnapshot(
+        [...captured.keys()],
+        owned.signal,
+      );
+      if (closed || owned.signal.aborted || controller !== owned) return;
+      if (values === null)
+        readGate = nextRead = Math.max(
+          readGate,
+          Date.now() + 5000 + Math.random() * 1000,
+        );
+      else {
+        for (const [key, subject] of captured)
+          if (subjects.get(key) === subject && selected.get(key) === subject) {
+            subject.expires = now + 75000;
+            change(
+              subject,
+              Date.now() < subject.expires
+                ? (values.get(key) ?? "unknown")
+                : "unknown",
+            );
+          }
+        nextRead = Math.min(nextRead, Date.now() + minute());
+      }
+    } catch (error) {
+      if (closed || owned.signal.aborted || controller !== owned) return;
+      for (const subject of captured.values()) change(subject, "unknown");
+      const retry =
+        error &&
+        typeof error === "object" &&
+        "retryAfterMs" in error &&
+        typeof error.retryAfterMs === "number"
+          ? error.retryAfterMs
+          : 0;
+      readGate = nextRead = Date.now() + Math.max(minute(), retry);
+    } finally {
+      reading = false;
+      if (controller === owned) controller = undefined;
+      schedule();
+    }
+  }
+  function clear(publication = true) {
+    controller?.abort();
+    controller = undefined;
+    nextRead = Math.max(Date.now() + 100, readGate);
+    if (publication) {
+      stopPublishing();
+      startPublishing();
+    }
+    for (const subject of subjects.values()) change(subject, "unknown");
+    schedule();
+  }
+  function stopPublishing() {
+    publisher?.abort();
+    publisher = undefined;
+    clearTimeout(renewal);
+    stopPublisher?.();
+    stopPublisher = undefined;
+  }
+  function startPublishing() {
+    if (
+      publisher ||
+      !connected ||
+      !transport?.presenceSnapshot ||
+      !activity ||
+      closed ||
+      typeof navigator === "undefined" ||
+      !navigator.locks
+    )
+      return;
+    const owned = new AbortController();
+    publisher = owned;
+    const valid = () =>
+      !closed && connected && publisher === owned && !owned.signal.aborted;
+    void navigator.locks
+      .request(
+        `buzz-presence:${transport.scope ?? transport.relayAuthor}:${transport.viewer}`,
+        { signal: owned.signal },
+        async () => {
+          if (!valid()) return;
+          await new Promise<void>((resolve) => {
+            stopPublisher = resolve;
+            const renew = async () => {
+              if (!valid()) return;
+              try {
+                await publish(activity.status(), owned.signal);
+              } catch {
+                /* Lossy; next renewal owns current state. */
+              }
+              if (valid()) renewal = setTimeout(() => void renew(), minute());
+            };
+            renewal = setTimeout(() => void renew(), 250 + Math.random() * 750);
+          });
+        },
+      )
+      .catch(() => {})
+      .finally(() => {
+        if (publisher === owned) publisher = undefined;
+      });
+  }
+  const stopActivity = activity?.subscribe(() => {
+    if (!activity.visible()) clear(false);
+    else {
+      nextRead = Math.min(nextRead, Math.max(Date.now() + 100, readGate));
+      schedule();
+    }
+    if (lastStatus !== activity.status()) {
+      lastStatus = activity.status();
+      // Replace desired state, not an event backlog. Restarting the lock cancels late signing.
+      stopPublishing();
+      startPublishing();
+    }
+  });
+  return {
+    status(key: string): PresenceStatus {
+      return subjects.get(key)?.status ?? "unknown";
+    },
+    limited: (key: string) => subjects.has(key) && !selected.has(key),
+    subscribe(key: string, listener: () => void, profile = false) {
+      if (closed || !/^[0-9a-f]{64}$/.test(key)) return () => {};
+      let subject = subjects.get(key);
+      if (!subject) {
+        subject = {
+          listeners: new Map(),
+          profiles: 0,
+          status: "unknown",
+          expires: 0,
+        };
+        subjects.set(key, subject);
+      }
+      const priority = subject.profiles > 0;
+      if (subject.listeners.get(listener)) subject.profiles--;
+      if (profile) subject.profiles++;
+      subject.listeners.set(listener, profile);
+      if (subject.profiles) profiles.set(key, subject);
+      else profiles.delete(key);
+      if (
+        (!selected.has(key) && selected.size < 256) ||
+        priority !== subject.profiles > 0
+      )
+        demand();
+      return () => {
+        if (subjects.get(key) !== subject || !subject.listeners.has(listener))
+          return;
+        const priority = subject.profiles > 0;
+        if (subject.listeners.get(listener)) subject.profiles--;
+        subject.listeners.delete(listener);
+        if (!subject.profiles) profiles.delete(key);
+        if (!subject.listeners.size) {
+          subjects.delete(key);
+          selected.delete(key);
+        }
+        if (!subjects.size) {
+          nextRead = Infinity;
+          controller?.abort();
+          clearTimeout(timer);
+        } else if (selected.size < 256 || priority !== subject.profiles > 0)
+          queueDemand();
+      };
+    },
+    connected(value: boolean) {
+      if (connected === value || closed) return;
+      connected = value;
+      clear();
+    },
+    clear,
+    dispose() {
+      closed = true;
+      stopActivity?.();
+      stopPublishing();
+      clearTimeout(timer);
+      controller?.abort();
+      subjects.clear();
+      profiles.clear();
+      selected.clear();
+    },
+  };
+}
+export type Presence = ReturnType<typeof createPresence>;
diff --git a/src/features/presence/react.tsx b/src/features/presence/react.tsx
new file mode 100644
index 00000000..65aace0d
--- /dev/null
+++ b/src/features/presence/react.tsx
@@ -0,0 +1,42 @@
+import { useCallback, useSyncExternalStore } from "react";
+import type { Presence } from "./presence";
+/** Text and distinct symbols keep presence readable without color perception. */
+export function PresenceIndicator({
+  presence,
+  pubkey,
+  profile = false,
+}: {
+  presence: Presence;
+  pubkey: string;
+  profile?: boolean;
+}) {
+  const subscribe = useCallback(
+    (listener: () => void) => presence.subscribe(pubkey, listener, profile),
+    [presence, pubkey, profile],
+  );
+  const state = useSyncExternalStore(
+    subscribe,
+    () => `${presence.status(pubkey)}:${presence.limited(pubkey)}`,
+  );
+  const status = state.split(":")[0] as ReturnType<Presence["status"]>;
+  const labels = {
+    online: "● Online",
+    away: "◐ Away",
+    offline: "○ Offline",
+    unknown: "? Unknown",
+  };
+  return (
+    <span
+      role="img"
+      className="text-body-sm text-secondary"
+      aria-label={`Presence: ${status}`}
+      title={
+        presence.limited(pubkey)
+          ? "Presence demand limit reached"
+          : "Periodically refreshed community presence"
+      }
+    >
+      {labels[status]}
+    </span>
+  );
+}
diff --git a/src/features/relay/broker-live.ts b/src/features/relay/broker-live.ts
index 6cb4ca69..8bc261f4 100644
--- a/src/features/relay/broker-live.ts
+++ b/src/features/relay/broker-live.ts
@@ -250,6 +250,24 @@ export function subscribeBrokerTraffic(
   }
   start();
   return {
+    async publishPresence(status, signal) {
+      if (closed || !streamId || !controller || latest.status !== "connected")
+        return false;
+      const current = generation;
+      const response = await fetch(`${endpoint}/stream-presence`, {
+        method: "POST",
+        credentials: "same-origin",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ streamId, status }),
+        signal: AbortSignal.any([
+          signal,
+          controller.signal,
+          AbortSignal.timeout(10000),
+        ]),
+      });
+      if (closed || current !== generation || !response.ok) return false;
+      return (await response.json()).accepted === true;
+    },
     observe(value) {
       const next = observerGeneration(value);
       if (closed || observer === next) return;
diff --git a/src/features/relay/host-admission.test.ts b/src/features/relay/host-admission.test.ts
index ebc31a8b..6b1ddecf 100644
--- a/src/features/relay/host-admission.test.ts
+++ b/src/features/relay/host-admission.test.ts
@@ -1,4 +1,4 @@
-import { afterEach, expect, it, vi } from "vitest";
+import { assert, afterEach, expect, it, vi } from "vitest";
 import { createHostAdmission } from "./host-admission";
 afterEach(() => vi.useRealTimers());
 it("owner retention is bounded without evicting active streams or cooldown, with independent quota families", async () => {
@@ -38,3 +38,32 @@ it("asynchronous preparation pins its principal until dispatch ownership is rele
   await preparing;
   expect(owner.api.idle()).toBe(true);
 });
+
+it("optional flights and start gates survive eviction without consuming ordinary admission", async () => {
+  vi.useFakeTimers();
+  const get = createHostAdmission(),
+    owner = get("relay", "viewer");
+  const http = owner.api.tryPresence(),
+    ws = owner.live.tryPresence();
+  expect(http).toBeTypeOf("function");
+  expect(ws).toBeTypeOf("function");
+  owner.live.presenceSent();
+  expect(owner.api.tryPresence()).toBeUndefined();
+  expect(owner.live.tryPresence()).toBeUndefined();
+  const ordinary = vi.fn(async () => {});
+  await owner.api.run(ordinary);
+  expect(ordinary).toHaveBeenCalledOnce();
+  expect(owner.live.delay()).toBe(0);
+  for (let i = 0; i < 80; i++) get(`other-${i}`, "viewer");
+  expect(get("relay", "viewer")).toBe(owner);
+  assert.exists(http);
+  assert.exists(ws);
+  http();
+  ws();
+  await vi.advanceTimersByTimeAsync(4999);
+  get("another", "viewer");
+  expect(get("relay", "viewer")).toBe(owner);
+  await vi.advanceTimersByTimeAsync(1);
+  get("evict", "viewer");
+  expect(get("relay", "viewer")).not.toBe(owner);
+});
diff --git a/src/features/relay/host-admission.ts b/src/features/relay/host-admission.ts
index 04d7bf6e..9e44bee8 100644
--- a/src/features/relay/host-admission.ts
+++ b/src/features/relay/host-admission.ts
@@ -17,7 +17,13 @@ export function createHostAdmission() {
     let principal = principals.get(key);
     if (!principal) {
       for (const [id, entry] of principals)
-        if (!entry.streams && entry.api.idle() && entry.live.delay() === 0)
+        if (
+          !entry.streams &&
+          entry.api.idle() &&
+          entry.api.presenceIdle() &&
+          entry.live.delay() === 0 &&
+          entry.live.presenceIdle()
+        )
           principals.delete(id);
       if (principals.size >= 64)
         throw new Error("Relay admission owner capacity reached");
diff --git a/src/features/relay/http-admission.ts b/src/features/relay/http-admission.ts
index aa5cff5a..1dc4cdd4 100644
--- a/src/features/relay/http-admission.ts
+++ b/src/features/relay/http-admission.ts
@@ -1,3 +1,4 @@
+import type { ReadFilter } from "./events.ts";
 import { ReadError } from "./errors.ts";
 
 /** Admission owns starts, not retries or delivery semantics. An admitted write is
@@ -117,7 +118,9 @@ export function createApiAdmission() {
   let next = 0,
     pausedUntil = 0,
     active = 0,
-    preparing = 0;
+    preparing = 0,
+    presenceBusy = false,
+    presenceNext = 0;
   let timer: ReturnType<typeof setTimeout> | undefined;
   const queue: Ticket[] = [];
   const pauseError = () =>
@@ -151,6 +154,17 @@ export function createApiAdmission() {
     pump();
   }
   return {
+    /** Lossy snapshot lease; never consumes ordinary slots or start credit. */
+    tryPresence() {
+      if (!this.idle() || presenceBusy || performance.now() < presenceNext)
+        return;
+      presenceBusy = true;
+      presenceNext = performance.now() + 5000;
+      return () => {
+        presenceBusy = false;
+      };
+    },
+    presenceIdle: () => !presenceBusy && performance.now() >= presenceNext,
     /** Retain bounded ownership across asynchronous auth and its final dispatch.
      * A cancelled unabortable signer keeps its slot until it settles: repeatedly
      * cancelling must not admit an unbounded number of outstanding sign prompts. */
@@ -244,3 +258,44 @@ export async function admittedApiRequest(
     priority,
   );
 }
+
+/** The optional lane accepts only this bounded presence shape, never a priority hint. */
+export function presenceFilter(raw: unknown): raw is ReadFilter[] {
+  if (!Array.isArray(raw) || raw.length !== 1) return false;
+  const filter = raw[0];
+  return (
+    !!filter &&
+    Object.keys(filter).sort().join(",") === "authors,kinds,limit" &&
+    Array.isArray(filter.kinds) &&
+    filter.kinds.length === 1 &&
+    filter.kinds[0] === 20001 &&
+    Array.isArray(filter.authors) &&
+    filter.authors.length > 0 &&
+    filter.authors.length <= 256 &&
+    filter.limit === filter.authors.length &&
+    new Set(filter.authors).size === filter.authors.length &&
+    filter.authors.every(
+      (key: unknown) => typeof key === "string" && /^[0-9a-f]{64}$/.test(key),
+    )
+  );
+}
+export async function presenceText(response: Response): Promise<string> {
+  if (!response.body) throw new Error("Presence body missing");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let bytes = 0,
+    text = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) return text + decoder.decode();
+      bytes += value.byteLength;
+      if (bytes > 1024 * 1024)
+        throw new Error("Presence response exceeds capacity");
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
diff --git a/src/features/relay/live.test.ts b/src/features/relay/live.test.ts
index 72d484ac..e1b34d46 100644
--- a/src/features/relay/live.test.ts
+++ b/src/features/relay/live.test.ts
@@ -696,3 +696,90 @@ it("observer route is optional, live-only at dispatch/retry, separately fenced a
   h.owner.dispose();
   expect(vi.getTimerCount()).toBe(0);
 });
+
+it("presence holds its receipt without delaying ordinary setup and shares correlated cooldown", async () => {
+  vi.useFakeTimers();
+  const h = setup([]);
+  await h.first.auth();
+  expect(
+    await h.owner.publishPresence?.("online", new AbortController().signal),
+  ).toBe(false);
+  await vi.advanceTimersByTimeAsync(500);
+  for (const [, id] of h.first.requests()) await h.first.receive(["EOSE", id]);
+  const abort = new AbortController();
+  const result = h.owner.publishPresence?.("online", abort.signal);
+  await vi.advanceTimersByTimeAsync(0);
+  const event = h.first.sent.find(([kind]) => kind === "EVENT")?.[1] as {
+    id: string;
+    content: string;
+  };
+  expect(event.content).toBe("online");
+  h.owner.update(["foreground"]);
+  expect(h.first.requests().at(-1)?.[2]["#h"]).toEqual(["foreground"]);
+  abort.abort(); // Keep the receipt correlation after cancellation, to honor late quota.
+  await h.first.receive(["OK", "unrelated", true]);
+  await h.first.receive([
+    "OK",
+    event.id,
+    false,
+    "rate-limited: quota exceeded; retry in 3s",
+  ]);
+  expect(await result).toBe(false);
+  const count = h.first.requests().length;
+  h.owner.update(["foreground", "next"]);
+  expect(h.first.requests()).toHaveLength(count);
+  await vi.advanceTimersByTimeAsync(4000);
+  expect(h.first.requests()).toHaveLength(count + 1);
+  h.owner.dispose();
+});
+
+it("an outstanding presence signer pins its principal flight across socket replacement", async () => {
+  vi.useFakeTimers();
+  const key = keypair(),
+    sockets: Socket[] = [];
+  const admission = createLiveAdmission();
+  let release!: () => void;
+  const gate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const callbacks = { receive() {}, state() {}, established() {}, denied() {} };
+  const owner = subscribeRelayTraffic(
+    "wss://relay.test",
+    async (event) => {
+      if (event.kind === 20001) await gate;
+      return signed(key, event);
+    },
+    key.pubkey,
+    callbacks,
+    () => {
+      const s = new Socket();
+      sockets.push(s);
+      return s as unknown as WebSocket;
+    },
+    admission,
+  );
+  const first = sockets[0];
+  assert.exists(first);
+  await first.auth();
+  await vi.advanceTimersByTimeAsync(500);
+  for (const [, id] of first.requests()) await first.receive(["EOSE", id]);
+  const result = owner.publishPresence?.("away", new AbortController().signal);
+  expect(admission.presenceIdle()).toBe(false);
+  first.close();
+  await vi.advanceTimersByTimeAsync(500);
+  const next = sockets[1];
+  assert.exists(next);
+  await next.auth();
+  await vi.advanceTimersByTimeAsync(500);
+  for (const [, id] of next.requests()) await next.receive(["EOSE", id]);
+  expect(
+    await owner.publishPresence?.("online", new AbortController().signal),
+  ).toBe(false);
+  release();
+  expect(await result).toBe(false);
+  expect(
+    sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"),
+  ).toEqual([]);
+  expect(admission.presenceIdle()).toBe(true);
+  owner.dispose();
+});
diff --git a/src/features/relay/live.ts b/src/features/relay/live.ts
index 8febfae2..b0432f26 100644
--- a/src/features/relay/live.ts
+++ b/src/features/relay/live.ts
@@ -17,9 +17,31 @@ const MAX_QUOTA_RETRIES = 3;
 export function createLiveAdmission() {
   let next = 0;
   let cooldown = 0;
+  let presenceBusy = false,
+    presenceNext = 0;
+  const pending = new Set<object>();
   return {
     delay: () =>
       Math.max(0, next - performance.now(), cooldown - performance.now()),
+    setup(owner: object, busy: boolean) {
+      if (busy) pending.add(owner);
+      else pending.delete(owner);
+    },
+    presenceReady: () =>
+      !pending.size &&
+      performance.now() >= Math.max(next, cooldown, presenceNext),
+    tryPresence() {
+      if (presenceBusy || !this.presenceReady()) return;
+      presenceBusy = true;
+      return () => {
+        presenceBusy = false;
+      };
+    },
+    presenceSent() {
+      presenceNext = performance.now() + 5000;
+    },
+    presenceIdle: () =>
+      !presenceBusy && performance.now() >= presenceNext && !pending.size,
     take() {
       next = performance.now() + REQUEST_INTERVAL_MS;
     },
@@ -83,6 +105,11 @@ export type LiveSubscription = {
   /** Host demand only: reorder existing pending routes, never grant new interests. */
   prioritize?(channels: readonly string[]): void;
   observe?(generation: number | null): void;
+  /** One ephemeral status on this authenticated connection; false means not sent. */
+  publishPresence?(
+    status: "online" | "away",
+    signal: AbortSignal,
+  ): Promise<boolean>;
   retry(): void;
   dispose(): void;
 };
@@ -138,9 +165,18 @@ export function subscribeRelayTraffic(
   let interests: string[] = [];
   let priority: string[] = [];
   let observer: number | null = null;
+  let presenceReceipt:
+    | { id: string; finish(accepted: boolean): void }
+    | undefined;
   const routes = new Map<string, Route>();
   const wires = new Map<string, Route>();
   const notify = () => {
+    admission.setup(
+      routes,
+      !closed &&
+        connection !== "error" &&
+        [...routes.values()].some((route) => route.status === "pending"),
+    );
     if (closed) return;
     callbacks.state(
       Object.freeze({
@@ -340,6 +376,8 @@ export function subscribeRelayTraffic(
   function clearSocket() {
     generation++;
     authenticated = false;
+    presenceReceipt?.finish(false);
+    admission.setup(routes, false);
     clearTimeout(dispatchTimer);
     clearTimeout(deadline);
     for (const route of routes.values()) clearTimeout(route.deadline);
@@ -447,6 +485,23 @@ export function subscribeRelayTraffic(
         notify();
         return;
       }
+      if (data[0] === "OK" && presenceReceipt?.id === data[1]) {
+        if (
+          data[2] === false &&
+          typeof data[3] === "string" &&
+          data[3].startsWith("rate-limited:")
+        ) {
+          const hint = /^rate-limited: quota exceeded; retry in (\d+)s$/.exec(
+            data[3],
+          );
+          const seconds = hint ? Number(hint[1]) : 86400;
+          admission.pause(
+            Number.isSafeInteger(seconds) && seconds <= 86400 ? seconds : 86400,
+          );
+        }
+        presenceReceipt?.finish(data[2] === true);
+        return;
+      }
       const route =
         typeof data[1] === "string" ? wires.get(data[1]) : undefined;
       if (!authenticated || !route) return;
@@ -497,6 +552,65 @@ export function subscribeRelayTraffic(
   }
   connect();
   return {
+    async publishPresence(status, signal) {
+      if (
+        (status !== "online" && status !== "away") ||
+        signal.aborted ||
+        closed ||
+        !authenticated
+      )
+        return false;
+      const release = admission.tryPresence();
+      if (!release) return false;
+      const current = generation;
+      const bounded = AbortSignal.any([signal, AbortSignal.timeout(10000)]);
+      try {
+        const event = eventDto(
+          await sign({
+            kind: 20001,
+            content: status,
+            tags: [],
+            created_at: Math.floor(Date.now() / 1000),
+          }),
+        );
+        if (
+          bounded.aborted ||
+          closed ||
+          current !== generation ||
+          !authenticated ||
+          socket?.readyState !== 1 ||
+          !admission.presenceReady()
+        )
+          return false;
+        if (
+          event.pubkey !== viewer ||
+          event.kind !== 20001 ||
+          event.content !== status ||
+          event.tags.length
+        )
+          throw new Error("Presence signer changed intent");
+        return await new Promise<boolean>((resolve, reject) => {
+          const finish = (accepted: boolean) => {
+            clearTimeout(receiptTimeout);
+            presenceReceipt = undefined;
+            resolve(accepted);
+          };
+          // Once sent, retain the correlated receipt even if the caller leaves:
+          // a late quota refusal still belongs to the shared host cooldown.
+          const receiptTimeout = setTimeout(() => finish(false), 10000);
+          presenceReceipt = { id: event.id, finish };
+          try {
+            admission.presenceSent();
+            send(["EVENT", event]);
+          } catch (error) {
+            finish(false);
+            reject(error);
+          }
+        });
+      } finally {
+        release();
+      }
+    },
     observe(value) {
       const next = observerGeneration(value);
       if (closed || observer === next) return;
diff --git a/src/features/relay/service.ts b/src/features/relay/service.ts
index 02bde1dd..5251c2f8 100644
--- a/src/features/relay/service.ts
+++ b/src/features/relay/service.ts
@@ -1,3 +1,4 @@
+import type { PresenceActivity } from "../presence/activity";
 import type { Context } from "@deepseek-ai/cordis";
 import { createRelaySession, type RelaySession } from "./session";
 import { createHeadPersistence } from "./persistence";
@@ -29,6 +30,7 @@ declare module "@deepseek-ai/cordis" {
 export function provideRelay(
   ctx: Context,
   connect?: (signal: AbortSignal) => Promise<ReadTransport>,
+  presenceActivity?: PresenceActivity,
 ) {
   let disposed = false;
   let generation = 0;
@@ -85,6 +87,7 @@ export function provideRelay(
             if (disposed || signal.aborted || current !== generation) return;
             store.dispose();
             store = createRelaySession(transport, {
+              ...(presenceActivity ? { presenceActivity } : {}),
               prepared: true,
               persistence: createHeadPersistence(
                 transport.viewer,
diff --git a/src/features/relay/session.ts b/src/features/relay/session.ts
index 1f3218dc..bb5d92fe 100644
--- a/src/features/relay/session.ts
+++ b/src/features/relay/session.ts
@@ -1,4 +1,6 @@
 // FOUNDATION: One relay session owns reads, local intent, delivery and shared views.
+import { createPresence } from "../presence/presence";
+import type { PresenceActivity } from "../presence/activity";
 import {
   createRelayReader,
   type ReadOptions,
@@ -61,6 +63,7 @@ export type EventViewSnapshot = Readonly<{
 export function createRelaySession(
   transport: ReadTransport | null,
   options: ChannelStoreOptions & {
+    presenceActivity?: PresenceActivity;
     outboxStorage?: OutboxStorage;
     readStateStorage?: ReadStateStorage;
     readPublisherLock?: ReadPublisherLock;
@@ -181,6 +184,7 @@ export function createRelaySession(
       emoji.clear();
       agentLibrary.clear();
       activity.clear();
+      presence.clear();
       archives.clear();
       for (const purge of views.values()) purge();
       commit();
@@ -297,6 +301,13 @@ export function createRelaySession(
         timers.add(timer);
       });
   }
+  const presence = createPresence(
+    transport,
+    options.presenceActivity,
+    (status, signal) =>
+      traffic?.publishPresence?.(status, signal) ?? Promise.resolve(false),
+    notify,
+  );
   const profiles = createProfileDirectory(verified, localViews, notify);
   const emoji = createEmojiDirectory(verified, notify);
   const agentLibrary = createAgentLibrary(transport?.readAgentLibrary, notify);
@@ -587,6 +598,7 @@ export function createRelaySession(
     notify,
   );
   const session = Object.freeze({
+    presence,
     /** Verified new live-route messages, after reconciliation. Never history or local intent. */
     subscribeIncoming(listener: IncomingListener) {
       if (closed) return () => {};
@@ -1003,6 +1015,7 @@ export function createRelaySession(
     state(snapshot) {
       if (closed) return;
       activity.state(snapshot);
+      presence.connected(snapshot.status === "connected");
       if (
         snapshot.status !== "connected" &&
         liveSnapshot.status === "connected"
@@ -1066,6 +1079,7 @@ export function createRelaySession(
       accessEpoch++;
       cacheClearEpoch++;
       activity.clear();
+      presence.clear();
       sidebarPreferences.clear();
       // New windows must not yield to or receive errors from retired owners.
       catchups.clear();
@@ -1085,6 +1099,7 @@ export function createRelaySession(
       closed = true;
       lifetime.abort();
       activity.dispose();
+      presence.dispose();
       sidebarPreferences.dispose();
       stopInterests();
       traffic?.dispose();
diff --git a/src/features/relay/transport.test.ts b/src/features/relay/transport.test.ts
index d4e54f3e..448db7a0 100644
--- a/src/features/relay/transport.test.ts
+++ b/src/features/relay/transport.test.ts
@@ -184,3 +184,78 @@ it("uses each signed transport's own origin for protected media, never a deploym
   );
   expect(a.media("http://images.example/insecure.png")).toBeUndefined();
 });
+
+it("presence validates whole snapshots before omission means Offline; busy is not empty", async () => {
+  const relay = keypair(),
+    author = keypair().pubkey,
+    absent = keypair().pubkey;
+  const event = signed(relay, {
+    kind: 20001,
+    content: "online",
+    tags: [["p", author]],
+  });
+  let response = () => Response.json([event]);
+  const fetcher = vi.fn(async (url: string) =>
+    url.endsWith("/session")
+      ? Response.json({
+          viewer: key.pubkey,
+          relayAuthor: relay.pubkey,
+          live: true,
+          presence: true,
+        })
+      : response(),
+  );
+  vi.stubGlobal("fetch", fetcher);
+  const transport = await connectBrokerTransport();
+  assert.exists(transport.presenceSnapshot);
+  const snapshot = transport.presenceSnapshot;
+  const read = () => snapshot([author, absent], new AbortController().signal);
+  expect(await read()).toEqual(
+    new Map([
+      [author, "online"],
+      [absent, "offline"],
+    ]),
+  );
+  response = () => new Response(null, { status: 204 });
+  expect(await read()).toBeNull();
+  for (const events of [
+    [event, event],
+    [{ ...event, sig: "0".repeat(128) }],
+    [signed(key, { kind: 20001, content: "online", tags: [["p", author]] })],
+    [
+      signed(relay, {
+        kind: 20001,
+        content: "online",
+        tags: [["p", key.pubkey]],
+      }),
+    ],
+    [signed(relay, { kind: 20001, content: "maybe", tags: [["p", author]] })],
+    [
+      signed(relay, {
+        kind: 20001,
+        content: "away",
+        tags: [
+          ["p", author],
+          ["p", absent],
+        ],
+      }),
+    ],
+  ]) {
+    response = () => Response.json(events);
+    await expect(read()).rejects.toThrow();
+  }
+  response = () =>
+    Response.json([
+      signed(relay, {
+        kind: 20001,
+        content: '{"status":"away"}',
+        tags: [["p", author]],
+      }),
+    ]);
+  expect((await read())?.get(author)).toBe("away");
+  response = () => new Response(" ".repeat(1024 * 1024 + 1));
+  await expect(read()).rejects.toThrow("capacity");
+  await expect(snapshot([], new AbortController().signal)).rejects.toThrow(
+    "demand",
+  );
+});
diff --git a/src/features/relay/transport.ts b/src/features/relay/transport.ts
index fb80d9f1..8e2c3785 100644
--- a/src/features/relay/transport.ts
+++ b/src/features/relay/transport.ts
@@ -13,6 +13,8 @@ import {
   ApiPaused,
   ApiNotSent,
   readApiFailure,
+  presenceFilter,
+  presenceText,
 } from "./http-admission";
 import { yieldToHost } from "./yield";
 import { createRelayProfiler, type RelayProfiler } from "./profiling";
@@ -47,6 +49,11 @@ export interface ReadTransport {
     requestId: string,
     priority: "foreground" | "background",
   ): Promise<RelayEvent[]>;
+  /** Broker-only, complete bounded presence read. null is a local admission skip. */
+  presenceSnapshot?(
+    authors: readonly string[],
+    signal: AbortSignal,
+  ): Promise<ReadonlyMap<string, "online" | "away" | "offline"> | null>;
   readonly profiling?: RelayProfiler;
   /** Verified incoming traffic. The session owns this subscription and fences late delivery. */
   subscribe?(callbacks: LiveCallbacks): LiveSubscription;
@@ -103,6 +110,45 @@ async function parseEvents(
   return events;
 }
 
+async function parsePresence(
+  raw: unknown,
+  authors: readonly string[],
+  relay: string,
+  signal: AbortSignal,
+) {
+  if (!Array.isArray(raw) || raw.length > authors.length)
+    throw new Error("Invalid presence snapshot");
+  const values = new Map<string, "online" | "away" | "offline">();
+  for (const event of await parseEvents(raw, signal)) {
+    const subjects = event.tags.filter(([tag]) => tag === "p");
+    const subject = subjects[0]?.[1];
+    let status: unknown = event.content;
+    if (event.content.startsWith("{")) {
+      try {
+        status = JSON.parse(event.content).status;
+      } catch {
+        status = undefined;
+      }
+    }
+    if (
+      event.kind !== 20001 ||
+      event.pubkey !== relay ||
+      subjects.length !== 1 ||
+      subjects[0]?.length !== 2 ||
+      !subject ||
+      !authors.includes(subject) ||
+      values.has(subject) ||
+      (status !== "online" && status !== "away" && status !== "offline")
+    )
+      throw new Error("Untrusted presence snapshot");
+    values.set(subject, status);
+  }
+  signal.throwIfAborted();
+  for (const author of authors)
+    if (!values.has(author)) values.set(author, "offline");
+  return values;
+}
+
 /** Register trusted-app-origin intent before contacting a new destination. No remote join. */
 export async function registerBrokerCommunity(
   community: string,
@@ -145,6 +191,7 @@ export async function connectBrokerTransport(
     writeKinds?: number[];
     relayUrl?: string;
     live?: boolean;
+    presence?: boolean;
     sidebarPreferences?: boolean;
     agentLibrary?: boolean;
     agentActivity?: boolean;
@@ -165,6 +212,47 @@ export async function connectBrokerTransport(
     );
   return {
     profiling,
+    ...(session.presence && session.live
+      ? {
+          async presenceSnapshot(
+            authors: readonly string[],
+            signal: AbortSignal,
+          ) {
+            const filters = [
+              { kinds: [20001], authors, limit: authors.length },
+            ];
+            if (!presenceFilter(filters))
+              throw new Error("Invalid presence demand");
+            const bounded = AbortSignal.any([
+              signal,
+              AbortSignal.timeout(10000),
+            ]);
+            const result = await fetch(`${endpoint}/presence-snapshot`, {
+              method: "POST",
+              credentials: "same-origin",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(filters),
+              signal: bounded,
+            });
+            if (result.status === 204) return null;
+            if (!result.ok) {
+              const failure = await readApiFailure(result);
+              throw new ReadError(
+                "unavailable",
+                failure.error,
+                result.status,
+                failure.retryAfterMs,
+              );
+            }
+            return parsePresence(
+              JSON.parse(await presenceText(result)),
+              authors,
+              session.relayAuthor as string,
+              bounded,
+            );
+          },
+        }
+      : {}),
     agentActivity: session.agentActivity === true && session.live === true,
     ...(session.live
       ? {
diff --git a/tests/browser/channel-opening.spec.mjs b/tests/browser/channel-opening.spec.mjs
index add4ed87..8a7632fd 100644
--- a/tests/browser/channel-opening.spec.mjs
+++ b/tests/browser/channel-opening.spec.mjs
@@ -163,3 +163,86 @@ test("cold opening bypasses held DM labels; warm switching paints within 100ms w
     app.relay.releaseProfiles();
   }
 });
+
+test.describe("large thread opening", () => {
+  test.use({
+    readState: true,
+    largeSidebar: false,
+    threadUnread: true,
+    presenceThreadAuthors: 300,
+  });
+  test("300-author thread opening retains bounded traversal and measures cold/reopened rendering", async ({
+    page,
+    app,
+  }) => {
+    await open(page, app);
+    const { root } = app.presenceThread;
+    const trigger = page
+      .locator(`[data-channel-timeline] [data-message-id="${root.id}"]`)
+      .getByRole("button", { name: /^View thread:/ });
+    const history = page.getByRole("region", {
+      name: "Thread messages",
+      exact: true,
+    });
+    for (const phase of ["cold", "reopened"]) {
+      const timing = await trigger.evaluate(async (button) => {
+        const start = performance.now();
+        button.click();
+        let firstPaint;
+        await new Promise((resolve, reject) => {
+          const deadline = setTimeout(
+            () => reject(new Error("thread did not finish traversal")),
+            10000,
+          );
+          const check = () => {
+            const panel = document.querySelector(
+              '[aria-label="Thread messages"]',
+            );
+            const rows = panel?.querySelectorAll("[data-message-id]");
+            const rect = panel?.getBoundingClientRect();
+            const visible =
+              rect &&
+              [...rows].some((row) => {
+                const bounds = row.getBoundingClientRect();
+                return (
+                  bounds.height > 0 &&
+                  bounds.bottom > rect.top &&
+                  bounds.top < rect.bottom
+                );
+              });
+            if (visible && firstPaint === undefined)
+              firstPaint = performance.now() - start;
+            if (
+              !visible ||
+              rows.length !== 301 ||
+              panel.textContent.includes("Loading thread…")
+            )
+              return requestAnimationFrame(check);
+            requestAnimationFrame(() => {
+              clearTimeout(deadline);
+              resolve();
+            });
+          };
+          requestAnimationFrame(check);
+        });
+        return {
+          firstVisibleMs: firstPaint,
+          fullTraversalPaintMs: performance.now() - start,
+        };
+      });
+      app.report.measurements.push({
+        scenario: "300-author-thread",
+        phase,
+        ...timing,
+      });
+      await expect(history.locator("[data-message-id]")).toHaveCount(301);
+      await expect(
+        history.getByText("Distinct author reply 299", { exact: true }),
+      ).toBeInViewport();
+      await page
+        .getByRole("button", { name: "Close thread", exact: true })
+        .click();
+      await expect(history).toHaveCount(0);
+    }
+  });
+});
diff --git a/tests/browser/fixture.mjs b/tests/browser/fixture.mjs
index b4ecb916..882b224b 100644
--- a/tests/browser/fixture.mjs
+++ b/tests/browser/fixture.mjs
@@ -27,6 +27,7 @@ export const test = base.extend({
   productionBroker: [false, { option: true }],
   readState: [false, { option: true }],
   threadUnread: [false, { option: true }],
+  presenceThreadAuthors: [0, { option: true }],
   exactMessages: [false, { option: true }],
   sidebarUnread: [false, { option: true }],
   savedSidebar: [false, { option: true }],
@@ -47,6 +48,7 @@ export const test = base.extend({
       productionBroker,
       readState,
       threadUnread,
+      presenceThreadAuthors,
       exactMessages,
       sidebarUnread,
       savedSidebar,
@@ -320,6 +322,42 @@ export const test = base.extend({
         ),
       );
     }
+    // Signed upstream-only stress data; production traversal and mounting stay real.
+    let presenceThread;
+    if (presenceThreadAuthors) {
+      const threadRoot = histories
+        .get("primary/alpha")
+        .find((event) => event.content === "Thread root 0");
+      if (!threadRoot) throw new Error("Presence thread requires threadUnread");
+      const replies = Array.from({ length: presenceThreadAuthors }, (_, i) =>
+        sign(
+          9,
+          [
+            ["h", "alpha"],
+            ["e", threadRoot.id, "", "reply"],
+          ],
+          `Distinct author reply ${i}`,
+          generateSecretKey(),
+          threadRoot.created_at + i + 20,
+        ),
+      );
+      threadReplies.set(threadRoot.id, replies);
+      // The ordinary unread fixture also broadcasts one reply into the timeline.
+      // This stress case owns exactly the distinct replies above, not that extra row.
+      histories.set(
+        "primary/alpha",
+        histories
+          .get("primary/alpha")
+          .filter(
+            (event) =>
+              !event.tags.some(
+                ([key, value]) =>
+                  key === "e" && value.toLowerCase() === threadRoot.id,
+              ),
+          ),
+      );
+      presenceThread = { root: threadRoot, replies };
+    }
     const report = {
       state: {
         head: execFileSync("git", ["rev-parse", "HEAD"], {
@@ -369,6 +407,10 @@ export const test = base.extend({
       response.end(JSON.stringify(body));
     };
     const answer = (community, filter) => {
+      if (filter.kinds?.includes(20001))
+        return filter.authors.map((author) =>
+          sign(20001, [["p", author]], "online"),
+        );
       if (filter.kinds?.includes(39002))
         return rosterIds.map((id) =>
           sign(39002, [
@@ -599,6 +641,15 @@ export const test = base.extend({
                 acceptPublication: (community, event) => {
                   expect(verifyEvent(event)).toBe(true);
                   expect(event.pubkey).toBe(viewer);
+                  if (event.kind === 9) {
+                    report.publications.push({ community, event });
+                    const channel = event.tags.find(
+                      ([name]) => name === "h",
+                    )?.[1];
+                    histories.get(`${community}/${channel}`).push(event);
+                    relay.publish(community, event);
+                    return;
+                  }
                   expect(event.kind).toBe(30078);
                   expect(event.tags).toContainEqual(["t", "read-state"]);
                   const blob = JSON.parse(
@@ -818,6 +869,7 @@ export const test = base.extend({
         report,
         pending,
         histories,
+        presenceThread,
         exact,
         membership(
           type,
diff --git a/tests/browser/policy-relay.mjs b/tests/browser/policy-relay.mjs
index 537f25b6..3285a435 100644
--- a/tests/browser/policy-relay.mjs
+++ b/tests/browser/policy-relay.mjs
@@ -14,6 +14,10 @@ export function policyRelay({
   acceptPublication,
 }) {
   const sockets = [];
+  let presenceHeld = false;
+  const presenceWaiters = [];
+  report.presenceSnapshots = [];
+  report.presencePublications = [];
   const requests = [];
   const rejected = [];
   report.liveRequests = requests;
@@ -54,6 +58,13 @@ export function policyRelay({
       socket.onmessage?.({ data: JSON.stringify(frame) });
   }
   return {
+    holdPresence() {
+      presenceHeld = true;
+    },
+    releasePresence() {
+      presenceHeld = false;
+      for (const release of presenceWaiters.splice(0)) release();
+    },
     holdContent() {
       heldContent = true;
     },
@@ -163,6 +174,43 @@ export function policyRelay({
         const filter = filters[0],
           community = communityOf(url);
         report.queries.push({ community, filter, at: performance.now() });
+        if (filter.kinds?.includes(20001)) {
+          expect(Object.keys(filter).sort()).toEqual([
+            "authors",
+            "kinds",
+            "limit",
+          ]);
+          expect(filter.authors.length).toBeGreaterThan(0);
+          expect(filter.authors.length).toBeLessThanOrEqual(256);
+          expect(filter.limit).toBe(filter.authors.length);
+          const snapshot = {
+            community,
+            filter,
+            pending: presenceHeld,
+            aborted: false,
+          };
+          report.presenceSnapshots.push(snapshot);
+          // Return the pending fetch, like the profile/content holds below.
+          // Awaiting it inside the fixture assertion catch misclassifies normal
+          // consumer cancellation as an unexpected protocol assertion failure.
+          if (presenceHeld)
+            return new Promise((resolve, reject) => {
+              const abort = () => {
+                snapshot.pending = false;
+                snapshot.aborted = true;
+                reject(init.signal.reason);
+              };
+              if (init.signal.aborted) return abort();
+              presenceWaiters.push(() => {
+                init.signal.removeEventListener("abort", abort);
+                snapshot.pending = false;
+                if (!snapshot.aborted)
+                  resolve(Response.json(answer(community, filter)));
+              });
+              init.signal.addEventListener("abort", abort, { once: true });
+            });
+          return Response.json(answer(community, filter));
+        }
         if (heldContent && filter.kinds?.includes(9))
           return new Promise((_resolve, reject) => {
             if (init.signal.aborted) reject(init.signal.reason);
@@ -285,6 +333,20 @@ export function policyRelay({
               this.routes.delete(id);
               return;
             }
+            if (kind === "EVENT") {
+              expect(this.authenticated).toBe(true);
+              expect(verifyEvent(id)).toBe(true);
+              expect(id.pubkey).toBe(viewer);
+              expect(id.kind).toBe(20001);
+              expect(["online", "away"]).toContain(id.content);
+              expect(id.tags).toEqual([]);
+              report.presencePublications.push({
+                community: this.community,
+                event: id,
+              });
+              queueMicrotask(() => emit(this, ["OK", id.id, true]));
+              return;
+            }
             expect(kind).toBe("REQ");
             expect(this.authenticated).toBe(true);
             requests.push({
diff --git a/tests/browser/presence.spec.mjs b/tests/browser/presence.spec.mjs
new file mode 100644
index 00000000..1410633d
--- /dev/null
+++ b/tests/browser/presence.spec.mjs
@@ -0,0 +1,396 @@
+import { test, expect } from "./fixture.mjs";
+import { open, settle } from "./timeline.mjs";
+test.use({ productionBroker: true, readState: true });
+
+test("profile snapshot and same-socket renewal coexist with real chat while optional response is held", async ({
+  page,
+  app,
+}) => {
+  app.relay.holdPresence();
+  await open(page, app);
+  await expect.poll(() => app.relay.hasRoute("primary", "alpha")).toBe(true);
+  await expect.poll(() => app.relay.hasRoute("primary", "beta")).toBe(true);
+  await expect(
+    page.getByRole("button", { name: "Retry live updates", exact: true }),
+  ).toHaveCount(0);
+  await settle(page);
+  try {
+    await page
+      .getByRole("button", { name: "View Alice Fixture profile", exact: true })
+      .first()
+      .click();
+    const profile = page.getByRole("region", { name: "Profile details" });
+    await expect(profile).toBeVisible();
+    await expect(
+      profile.getByRole("img", { name: "Presence: unknown" }),
+    ).toBeVisible();
+    // Narrowing the timeline for the profile can demand an older page. This
+    // fixture deliberately holds those pages; retire that foreground work first.
+    await expect
+      .poll(() => {
+        for (const pending of app.pending.splice(0)) pending.release();
+        return app.report.presenceSnapshots.some(
+          (snapshot) => snapshot.pending,
+        );
+      })
+      .toBe(true);
+    const composer = page.getByRole("textbox", {
+      name: "Message #Alpha",
+      exact: true,
+    });
+    await composer.fill("Presence cannot hold this conversation");
+    const start = performance.now();
+    await composer.press("Enter");
+    await expect
+      .poll(() =>
+        app.report.publications.some(
+          ({ event }) =>
+            event?.content === "Presence cannot hold this conversation",
+        ),
+      )
+      .toBe(true);
+    app.report.measurements.push({
+      sendWhilePresenceHeldMs: performance.now() - start,
+    });
+    expect(
+      app.report.presenceSnapshots.some((snapshot) => snapshot.pending),
+    ).toBe(true);
+    const live = app.append(
+      "primary",
+      "alpha",
+      "Incoming while presence is held",
+    );
+    await expect(page.locator(`[data-message-id="${live.id}"]`)).toBeVisible();
+    expect(
+      app.report.presenceSnapshots.some((snapshot) => snapshot.pending),
+    ).toBe(true);
+    app.relay.releasePresence();
+    await expect(
+      profile.getByRole("img", { name: "Presence: online" }),
+    ).toBeVisible();
+    // Startup may skip busy setup. Keep real time: advancing only browser time
+    // would expire its SSE heartbeat without advancing the broker's keepalive.
+    await expect
+      .poll(() => app.report.presencePublications.length, { timeout: 75000 })
+      .toBeGreaterThan(0);
+    expect(
+      app.relay.requests.some(({ filter }) => filter.kinds.includes(20001)),
+    ).toBe(false);
+    await profile.screenshot({
+      path: test.info().outputPath("presence-profile.png"),
+    });
+  } finally {
+    app.relay.releasePresence();
+  }
+});
+
+test("foreground send and cold channel entry remain available during a profile snapshot", async ({
+  page,
+  app,
+}) => {
+  app.relay.holdPresence();
+  await open(page, app);
+  await expect.poll(() => app.relay.hasRoute("primary", "alpha")).toBe(true);
+  await expect.poll(() => app.relay.hasRoute("primary", "beta")).toBe(true);
+  await settle(page);
+  try {
+    await page
+      .getByRole("button", { name: "View Alice Fixture profile", exact: true })
+      .first()
+      .click();
+    const profile = page.getByRole("region", { name: "Profile details" });
+    await expect(profile).toBeVisible();
+    await expect
+      .poll(() => {
+        for (const pending of app.pending.splice(0)) pending.release();
+        return app.report.presenceSnapshots.some(({ pending }) => pending);
+      })
+      .toBe(true);
+    await settle(page);
+    const composer = page.getByRole("textbox", {
+      name: "Message #Alpha",
+      exact: true,
+    });
+    await composer.fill("Measured foreground publication");
+    const start = performance.now();
+    await composer.press("Enter");
+    await expect
+      .poll(
+        () =>
+          app.report.publications.some(
+            ({ event }) => event.content === "Measured foreground publication",
+          ),
+        { intervals: [10] },
+      )
+      .toBe(true);
+    const sendMs = performance.now() - start;
+    expect(app.report.presenceSnapshots.some(({ pending }) => pending)).toBe(
+      true,
+    );
+    const betaHeads = () =>
+      app.report.queries.filter(
+        ({ filter }) =>
+          filter.kinds?.includes(9) &&
+          filter.top_level === true &&
+          filter["#h"]?.includes("beta") &&
+          filter.until === undefined,
+      );
+    expect(betaHeads()).toHaveLength(0);
+    const visibleMs = await page
+      .getByRole("button", { name: "Beta", exact: true })
+      .evaluate(
+        async (button, ids) => {
+          const start = performance.now();
+          button.click();
+          await new Promise((resolve, reject) => {
+            const deadline = setTimeout(
+              () => reject(new Error("cold channel did not paint")),
+              5000,
+            );
+            const check = () => {
+              const history = document.querySelector(
+                '[aria-label="Channel message history"]',
+              );
+              const bounds = history?.getBoundingClientRect();
+              const visible =
+                bounds &&
+                [...history.querySelectorAll("[data-message-id]")].some(
+                  (row) => {
+                    const rect = row.getBoundingClientRect();
+                    return (
+                      ids.includes(row.dataset.messageId) &&
+                      rect.height > 0 &&
+                      rect.bottom > bounds.top &&
+                      rect.top < bounds.bottom
+                    );
+                  },
+                );
+              if (
+                !visible ||
+                !document.querySelector('textarea[placeholder="Message #Beta"]')
+              )
+                return requestAnimationFrame(check);
+              requestAnimationFrame(() => {
+                clearTimeout(deadline);
+                resolve();
+              });
+            };
+            requestAnimationFrame(check);
+          });
+          return performance.now() - start;
+        },
+        app.histories.get("primary/beta").map(({ id }) => id),
+      );
+    expect(betaHeads().length).toBeGreaterThan(0);
+    // Closing the contextual profile may abort optional work; do not require
+    // an unnecessary snapshot to survive navigation just to satisfy this test.
+    app.report.measurements.push({
+      sendMs,
+      coldVisibleMs: visibleMs,
+      note: "send includes automation/polling; cold uses browser click-to-paint clock",
+    });
+  } finally {
+    app.relay.releasePresence();
+  }
+});
+
+test.describe("mounted conversation demand", () => {
+  test.use({ threadUnread: true });
+  test("timeline and thread author indicators share one bounded snapshot", async ({
+    page,
+    app,
+  }) => {
+    app.relay.holdPresence();
+    await open(page, app);
+    const timeline = page.locator("[data-channel-timeline]");
+    await expect(
+      timeline.getByRole("img", { name: "Presence: unknown" }).first(),
+    ).toBeVisible();
+    await expect.poll(() => app.report.presenceSnapshots.length).toBe(1);
+    app.relay.releasePresence();
+    await expect(
+      timeline.getByRole("img", { name: "Presence: online" }).first(),
+    ).toBeVisible();
+    const root = app.histories
+      .get("primary/alpha")
+      .find((row) => row.content === "Thread root 0");
+    await timeline
+      .locator(`[data-message-id="${root.id}"]`)
+      .getByRole("button", { name: /^View thread:/ })
+      .click();
+    const thread = page.getByRole("region", {
+      name: "Thread messages",
+      exact: true,
+    });
+    await expect(
+      thread.getByText("Unread reply 0", { exact: true }),
+    ).toBeVisible();
+    await expect(
+      thread.getByRole("img", { name: "Presence: online" }).last(),
+    ).toBeVisible();
+    expect(app.report.presenceSnapshots).toHaveLength(1);
+    expect(app.report.presenceSnapshots[0].filter.authors).toHaveLength(1);
+    expect(
+      app.relay.requests.some(({ filter }) => filter.kinds.includes(20001)),
+    ).toBe(false);
+  });
+});
+
+test.describe("large mounted thread", () => {
+  test.use({ threadUnread: true, presenceThreadAuthors: 300 });
+  test("distinct thread authors stay bounded through loading, scrolling and unmount", async ({
+    page,
+    app,
+  }) => {
+    await open(page, app);
+    const { root, replies } = app.presenceThread;
+    const trigger = page
+      .locator(`[data-channel-timeline] [data-message-id="${root.id}"]`)
+      .getByRole("button", { name: /^View thread:/ });
+    const thread = page.getByRole("region", {
+      name: "Thread messages",
+      exact: true,
+    });
+    const start = performance.now();
+    await trigger.click();
+    await expect(
+      thread.getByText("300 replies shown", { exact: true }),
+    ).toBeVisible();
+    await expect(
+      thread.getByText("Loading thread…", { exact: true }),
+    ).toHaveCount(0);
+    await expect(thread.locator("[data-message-id]")).toHaveCount(301);
+    app.report.measurements.push({
+      threadLoadUpperBoundMs: performance.now() - start,
+      distinctAuthors: 300,
+    });
+    // Query starts, rather than UI row counts, prove the actual transport cap.
+    await expect
+      .poll(() =>
+        app.report.presenceSnapshots.some(
+          ({ filter }) => filter.authors.length === 256,
+        ),
+      )
+      .toBe(true);
+    await expect(
+      thread.locator('[title="Presence demand limit reached"]'),
+    ).toHaveCount(45);
+    await expect(
+      thread.getByRole("img", { name: "Presence: online", exact: true }),
+    ).toHaveCount(256);
+    const first = thread.locator(`[data-message-id="${replies[0].id}"]`);
+    const last = thread.locator(`[data-message-id="${replies.at(-1).id}"]`);
+    await expect(last).toBeInViewport();
+    await thread.focus();
+    await page.keyboard.press("Control+Home");
+    // Use actual input; native key handling differs by engine/platform.
+    await first.scrollIntoViewIfNeeded();
+    await expect(first).toBeInViewport();
+    await thread.hover();
+    const before = await thread.evaluate((el) => el.scrollTop);
+    await page.mouse.wheel(0, 500);
+    await expect
+      .poll(() => thread.evaluate((el) => el.scrollTop))
+      .toBeGreaterThan(before);
+    const count = app.report.presenceSnapshots.length;
+    await page
+      .getByRole("button", { name: "Close thread", exact: true })
+      .click();
+    await expect(thread).toHaveCount(0);
+    // Hold the replacement read: eventual Online alone cannot prove old evidence
+    // was absent between remounting and response completion.
+    app.relay.holdPresence();
+    try {
+      const reopen = performance.now();
+      await trigger.click();
+      await expect(
+        thread.getByText("300 replies shown", { exact: true }),
+      ).toBeVisible();
+      await expect(
+        thread.getByText("Loading thread…", { exact: true }),
+      ).toHaveCount(0);
+      app.report.measurements.push({
+        threadReopenUpperBoundMs: performance.now() - reopen,
+      });
+      await expect
+        .poll(() => app.report.presenceSnapshots.length)
+        .toBeGreaterThan(count);
+      expect(app.report.presenceSnapshots.at(-1).pending).toBe(true);
+      // The root remains mounted in the timeline; all 300 distinct reply authors
+      // were released, so only the root may retain its existing Online value.
+      await expect(
+        thread
+          .locator("ol")
+          .getByRole("img", { name: "Presence: unknown", exact: true }),
+      ).toHaveCount(300);
+    } finally {
+      app.relay.releasePresence();
+    }
+    await expect(
+      thread.getByRole("img", { name: "Presence: online", exact: true }),
+    ).toHaveCount(256);
+    for (const { filter } of app.report.presenceSnapshots) {
+      expect(filter.authors.length).toBeLessThanOrEqual(256);
+      expect(new Set(filter.authors).size).toBe(filter.authors.length);
+    }
+    const starts = app.report.queries.filter(({ filter }) =>
+      filter.kinds?.includes(20001),
+    );
+    for (let i = 1; i < starts.length; i++)
+      expect(starts[i].at - starts[i - 1].at).toBeGreaterThanOrEqual(4990);
+    expect(
+      app.relay.requests.some(({ filter }) => filter.kinds.includes(20001)),
+    ).toBe(false);
+  });
+});
+
+test("real same-origin windows queue one publisher and transfer its Web Lock on close", async ({
+  page,
+  context,
+  app,
+}) => {
+  await open(page, app);
+  const presenceLocks = (target) =>
+    target.evaluate(async () => {
+      const locks = await navigator.locks.query();
+      const select = (entries) =>
+        entries.filter(({ name }) => name.startsWith("buzz-presence:"));
+      return { held: select(locks.held), pending: select(locks.pending) };
+    });
+  await expect
+    .poll(async () => (await presenceLocks(page)).held.length)
+    .toBe(1);
+  const owner = (await presenceLocks(page)).held[0];
+  const second = await context.newPage();
+  const errors = [];
+  second.on("pageerror", (error) => errors.push(error.message));
+  second.on("console", (message) => {
+    if (message.type() === "error") errors.push(message.text());
+  });
+  try {
+    await open(second, app);
+    await expect
+      .poll(async () => (await presenceLocks(second)).pending.length)
+      .toBe(1);
+    const both = await presenceLocks(second);
+    expect(both.held).toHaveLength(1);
+    expect(both.held[0].clientId).toBe(owner.clientId);
+    expect(both.pending[0].name).toBe(owner.name);
+    const successor = both.pending[0].clientId;
+    await page.close();
+    await expect
+      .poll(async () => (await presenceLocks(second)).held[0]?.clientId)
+      .toBe(successor);
+    expect((await presenceLocks(second)).pending).toHaveLength(0);
+    const before = app.report.presencePublications.length;
+    await expect
+      .poll(() => app.report.presencePublications.length, { timeout: 75000 })
+      .toBeGreaterThan(before);
+    expect(errors).toEqual([]);
+    app.report.measurements.push({
+      publisherLockHandoff: { owner: owner.clientId, successor },
+    });
+  } finally {
+    await second.close();
+  }
+});

From c75b768639c3ee8a6e0213878bf43ae3e57ea076 Mon Sep 17 00:00:00 2001
From: Brain
 <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 11:07:17 +0200
Subject: [PATCH 2/6] Preserve ordinary broker body limits and assert presence
 listener cleanup

Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 dev/relay-broker.mjs     |  4 +++-
 src/app/services.test.ts | 12 ++++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/dev/relay-broker.mjs b/dev/relay-broker.mjs
index 11971022..2bb13f6c 100644
--- a/dev/relay-broker.mjs
+++ b/dev/relay-broker.mjs
@@ -771,7 +771,9 @@ export function relayBrokerPlugin({
           let raw = "";
           for await (const part of req) {
             raw += part;
-            if (Buffer.byteLength(raw) > (presence ? 20 * 1024 : 65536))
+            if (
+              presence ? Buffer.byteLength(raw) > 20 * 1024 : raw.length > 65536
+            )
               return json(res, 413, { error: "Filter body too large" });
           }
           let filters;
diff --git a/src/app/services.test.ts b/src/app/services.test.ts
index ff070391..83f4917c 100644
--- a/src/app/services.test.ts
+++ b/src/app/services.test.ts
@@ -121,8 +121,16 @@ async function openCommunities() {
 function expectHostStopped() {
   expect(signals.every((signal) => signal.aborted)).toBe(true);
   for (const stream of streams) expect(stream.close).toHaveBeenCalledTimes(1);
-  expect(document.addEventListener).toHaveBeenCalledTimes(3);
-  expect(document.removeEventListener).toHaveBeenCalledTimes(3);
+  const added = vi.mocked(document.addEventListener).mock.calls;
+  const removed = vi.mocked(document.removeEventListener).mock.calls;
+  expect(added).toHaveLength(9); // Existing host listeners + one app presence source.
+  expect(removed).toHaveLength(added.length);
+  for (const [type, listener] of added)
+    expect(
+      removed.filter(
+        ([event, callback]) => event === type && callback === listener,
+      ),
+    ).toHaveLength(1);
   expect(services.pages.snapshot()).toHaveLength(0);
 }
 

From d2404c59d4367d78dc2a75be50f543fb65171a6b Mon Sep 17 00:00:00 2001
From: Pinky
 <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 12:06:02 +0200
Subject: [PATCH 3/6] Restore bottom positioning for ordinary routed threads

Signed-off-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 src/features/messages/ThreadPanel.test.tsx    | 149 ++++++++++++++++--
 src/features/messages/ThreadPanel.tsx         |  25 ++-
 tests/browser/fixture.mjs                     |   4 +-
 .../navigation-thread-history.spec.mjs        | 114 +++++++++++++-
 4 files changed, 272 insertions(+), 20 deletions(-)

diff --git a/src/features/messages/ThreadPanel.test.tsx b/src/features/messages/ThreadPanel.test.tsx
index f1a84d19..334ba1ac 100644
--- a/src/features/messages/ThreadPanel.test.tsx
+++ b/src/features/messages/ThreadPanel.test.tsx
@@ -12,6 +12,9 @@ import { MessageRow } from "./MessageRow";
 import { MessageMarkdown } from "./MessageMarkdown";
 import { MessageComposer } from "./MessageComposer";
 import type { RelaySession } from "../relay/session";
+import type { PageNavigation } from "../navigation/service";
+import { createNavigationController } from "../navigation/controller";
+import { createMemoryHistory } from "../navigation/history";
 import type { ThreadSnapshot, ThreadView } from "../relay/threads";
 import type { ChannelMessage } from "../relay/contracts";
 
@@ -119,7 +122,27 @@ const row: ChannelMessage = {
   reactions: [],
   replyCount: 2,
 };
-function setup() {
+function ordinaryNavigation() {
+  return {
+    entryId: "thread-visit",
+    target: {
+      version: 1,
+      kind: "conversation",
+      channelId: "channel",
+      messageId: row.id,
+      threadRootId: row.id,
+      scope: {
+        viewer: row.authorId,
+        communityOrigin: "https://fixture.invalid",
+      },
+    },
+    signal: new AbortController().signal,
+    complete: vi.fn<PageNavigation["complete"]>(() => true),
+    resolve: vi.fn(() => true),
+    forSession: vi.fn<PageNavigation["forSession"]>(),
+  } satisfies PageNavigation;
+}
+function setup(navigation?: PageNavigation) {
   const snapshot: ThreadSnapshot = {
     status: "ready",
     root: row,
@@ -154,6 +177,7 @@ function setup() {
       channelName: "General",
       channelId: "channel",
       messageId: row.id,
+      navigation,
       close,
       onOpenLink: () => false,
     });
@@ -393,8 +417,8 @@ it("the actual message reply button opens its selected message and canonical thr
   expect(open).toHaveBeenLastCalledWith("b".repeat(64), row.id);
 });
 
-function messagesHarness() {
-  const h = setup();
+function messagesHarness(navigation?: PageNavigation) {
+  const h = setup(navigation);
   h.render();
   h.effects();
   const child = elements(h.render()).find((e) => typeof e.type === "function");
@@ -603,15 +627,25 @@ it("finishes automatic pages before initial positioning and preserves a reader
   h.effects();
   expect(h.element.scrollTop).toBe(4900);
 });
-it.each([false, true])(
-  "positions after automatic loading stops (limited=%s), without restarting pagination",
-  (limited) => {
-    const h = messagesHarness();
+it.each([
+  { limited: false, routed: false },
+  { limited: true, routed: false },
+  { limited: false, routed: true },
+  { limited: true, routed: true },
+])(
+  "positions after automatic loading stops (limited=$limited, routed=$routed), without restarting pagination",
+  ({ limited, routed }) => {
+    const navigation = routed ? ordinaryNavigation() : undefined;
+    const h = messagesHarness(navigation);
     h.snapshot.canLoadMore = true;
     h.render();
     h.effects();
     expect(h.element.scrollTop).toBe(0);
     expect(h.view.loadMore).toHaveBeenCalledTimes(1);
+    if (navigation)
+      expect(navigation.complete).toHaveBeenCalledExactlyOnceWith({
+        status: "opened",
+      });
     h.snapshot.status = "loading";
     h.render();
     h.effects();
@@ -625,12 +659,28 @@ it.each([false, true])(
     h.effects();
     expect(h.element.scrollTop).toBe(4200);
     expect(h.view.loadMore).toHaveBeenCalledTimes(1);
+    // A live update follows without completing the same visit twice.
+    h.snapshot.replies = [...h.snapshot.replies, { ...row, id: "live" }];
+    h.render();
+    h.effects();
+    if (navigation)
+      expect(navigation.complete).toHaveBeenCalledExactlyOnceWith({
+        status: "opened",
+      });
   },
 );
-it.each(["onWheel", "onTouchMove", "onPointerDown", "onKeyDown"])(
-  "a user %s gesture before the page completes wins over initial positioning",
-  (handler) => {
-    const h = messagesHarness();
+it.each(
+  [false, true].flatMap((routed) =>
+    ["onWheel", "onTouchMove", "onPointerDown", "onKeyDown"].map((handler) => ({
+      routed,
+      handler,
+    })),
+  ),
+)(
+  "a user $handler gesture before the page completes wins over initial positioning (routed=$routed)",
+  ({ routed, handler }) => {
+    const navigation = routed ? ordinaryNavigation() : undefined;
+    const h = messagesHarness(navigation);
     h.snapshot.status = "loading";
     const section = h.render();
     h.effects();
@@ -639,8 +689,85 @@ it.each(["onWheel", "onTouchMove", "onPointerDown", "onKeyDown"])(
     h.render();
     h.effects();
     expect(h.element.scrollTop).toBe(0);
+    if (navigation)
+      expect(navigation.complete).toHaveBeenCalledExactlyOnceWith({
+        status: "opened",
+      });
   },
 );
+it("ordinary routed loading failure completes as unavailable, never as an opened visit", () => {
+  const navigation = ordinaryNavigation();
+  const h = messagesHarness(navigation);
+  h.snapshot.status = "error";
+  h.render();
+  h.effects();
+  expect(h.element.scrollTop).toBe(0);
+  expect(navigation.complete).toHaveBeenCalledExactlyOnceWith({
+    status: "failed",
+    reason: "unavailable",
+  });
+});
+it("a presented ordinary thread survives the real navigation deadline while history is pending", async () => {
+  vi.useFakeTimers();
+  const controller = createNavigationController(createMemoryHistory());
+  let release = () => {};
+  try {
+    const navigation = ordinaryNavigation();
+    const result = controller.navigation.open(navigation.target);
+    const { attempt } = controller.navigation.snapshot();
+    navigation.signal = attempt.signal;
+    navigation.complete.mockImplementation((result) =>
+      controller.complete(attempt, result),
+    );
+    const h = messagesHarness(navigation);
+    const held = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    h.view.loadMore.mockImplementation(() => held);
+    h.snapshot.canLoadMore = true;
+    h.render();
+    h.effects();
+    expect(h.view.loadMore).toHaveBeenCalledTimes(1);
+    h.snapshot.status = "loading";
+    h.render();
+    h.effects();
+    await vi.advanceTimersByTimeAsync(16_000);
+    expect(controller.navigation.snapshot().status).toBe("opened");
+    expect(await result).toEqual({ status: "opened" });
+    expect(attempt.signal.aborted).toBe(false);
+    expect(h.view.dispose).not.toHaveBeenCalled();
+    expect(h.element.scrollTop).toBe(0);
+    release();
+    await held;
+    h.snapshot.status = "ready";
+    h.snapshot.canLoadMore = false;
+    h.render();
+    h.effects();
+    expect(h.element.scrollTop).toBe(3400);
+    expect(navigation.complete).toHaveBeenCalledTimes(1);
+    h.unmount();
+  } finally {
+    release();
+    controller.dispose();
+    vi.useRealTimers();
+  }
+});
+it("revoked ordinary presentation cannot position or complete after loading", () => {
+  const controller = new AbortController();
+  const navigation = { ...ordinaryNavigation(), signal: controller.signal };
+  const h = messagesHarness(navigation);
+  h.snapshot.status = "loading";
+  h.snapshot.root = undefined;
+  h.render();
+  h.effects();
+  controller.abort();
+  expect(h.view.dispose).toHaveBeenCalledTimes(1);
+  h.snapshot.status = "ready";
+  h.render();
+  h.effects();
+  expect(h.element.scrollTop).toBe(0);
+  expect(navigation.complete).not.toHaveBeenCalled();
+});
 it("shows bounded participant avatars on the real reply control, through the media boundary with fallback initials", () => {
   const participants = ["p1", "p2", "p3", "p4", "p5"];
   const media = vi.fn((url: string) =>
diff --git a/src/features/messages/ThreadPanel.tsx b/src/features/messages/ThreadPanel.tsx
index e22d0380..749371c6 100644
--- a/src/features/messages/ThreadPanel.tsx
+++ b/src/features/messages/ThreadPanel.tsx
@@ -221,10 +221,9 @@ function ThreadMessages({
     scroller,
     settled: positioned,
     messageId,
-    signal: navigation?.signal,
-    ready: rootTarget
-      ? snapshot.root?.id === messageId
-      : snapshot.targetStatus === "ready" && snapshot.target?.id === messageId,
+    signal: rootTarget ? undefined : navigation?.signal,
+    ready:
+      snapshot.targetStatus === "ready" && snapshot.target?.id === messageId,
     complete: completeTarget,
     prepare: prepareTarget,
   });
@@ -248,9 +247,20 @@ function ThreadMessages({
   // biome-ignore lint/correctness/useExhaustiveDependencies: Rendered rows/profiles change scroll height; sending is explicit navigation intent.
   useLayoutEffect(() => {
     const element = scroller.current;
+    if (!element || navigation?.signal.aborted) return;
+    // A mounted ordinary thread acknowledges the visit before slow history can
+    // exhaust navigation's deadline. Positioning still waits for bounded loading.
     if (
-      !element ||
-      (navigation && revealed.current !== navigation.signal) ||
+      rootTarget &&
+      snapshot.status !== "error" &&
+      snapshot.root?.id === messageId &&
+      revealed.current !== navigation.signal
+    ) {
+      revealed.current = navigation.signal;
+      navigation.complete({ status: "opened" });
+    }
+    if (
+      (navigation && !rootTarget && revealed.current !== navigation.signal) ||
       (!positioned.current &&
         (snapshot.status !== "ready" || snapshot.canLoadMore))
     )
@@ -272,10 +282,13 @@ function ThreadMessages({
   }, [
     snapshot.status,
     snapshot.canLoadMore,
+    snapshot.root,
+    messageId,
     rows,
     profiles,
     sent,
     navigation,
+    rootTarget,
     revealed,
     selectedRow,
   ]);
diff --git a/tests/browser/fixture.mjs b/tests/browser/fixture.mjs
index c4643cdc..d587392d 100644
--- a/tests/browser/fixture.mjs
+++ b/tests/browser/fixture.mjs
@@ -988,7 +988,7 @@ export const test = base.extend({
           targetEvents.push(event);
           relay.publish("primary", event);
         },
-        reply(rootId, own = false) {
+        reply(rootId, own = false, deliver = true) {
           const replies = threadReplies.get(rootId);
           if (!replies) throw new Error("Unknown fixture thread");
           const event = sign(
@@ -1002,7 +1002,7 @@ export const test = base.extend({
             replies.at(-1).created_at + 1,
           );
           replies.push(event);
-          relay.publish("primary", event);
+          if (deliver) relay.publish("primary", event);
           return event;
         },
         append(community, channel, content, deliver = true, own = true) {
diff --git a/tests/browser/navigation-thread-history.spec.mjs b/tests/browser/navigation-thread-history.spec.mjs
index eb45cf5a..314c25b8 100644
--- a/tests/browser/navigation-thread-history.spec.mjs
+++ b/tests/browser/navigation-thread-history.spec.mjs
@@ -1,7 +1,12 @@
 import { test, expect } from "./fixture.mjs";
 import { open } from "./timeline.mjs";
 
-test.use({ productionBroker: true, readState: true, threadUnread: true });
+test.use({
+  productionBroker: true,
+  readState: true,
+  threadUnread: true,
+  pluginFixtures: true,
+});
 
 test("Back restores each thread visit before the previous channel", async ({
   page,
@@ -52,3 +57,110 @@ test("Back restores each thread visit before the previous channel", async ({
     ),
   ).toBe(true);
 });
+
+for (const reading of [false, true]) {
+  test(`ordinary reply-count opening ${reading ? "preserves intervening reading" : "finishes at the bottom"} after held pagination`, async ({
+    page,
+    app,
+  }) => {
+    const root = app.histories
+      .get("primary/alpha")
+      .find((row) => row.content === "Thread root 0");
+    let last;
+    for (let i = 0; i < 120; i++) last = app.reply(root.id, false, false);
+    await open(page, app);
+    const region = page.getByRole("region", {
+      name: "Thread messages",
+      exact: true,
+    });
+    let release;
+    const held = new Promise((resolve) => {
+      release = resolve;
+    });
+    let requested = false;
+    const routePattern = "**/api/relay/**/query";
+    await page.route(routePattern, async (route) => {
+      if (
+        !requested &&
+        route
+          .request()
+          .postDataJSON()
+          .some(
+            (filter) =>
+              filter.depth_limit && filter.thread_cursor !== undefined,
+          )
+      ) {
+        requested = true;
+        await held;
+      }
+      await route.continue();
+    });
+    try {
+      await page
+        .locator(`[data-channel-timeline] [data-message-id="${root.id}"]`)
+        .getByRole("button", { name: /^View thread:/ })
+        .click();
+      await expect.poll(() => requested).toBe(true);
+      await expect(region.locator("[data-message-id]")).toHaveCount(51);
+      await expect(
+        region.getByText("Loading thread…", { exact: true }),
+      ).toBeVisible();
+      // The panel is presented even while bounded history is still pending.
+      await expect
+        .poll(() =>
+          page.evaluate(() => window.fixtureNavigation.snapshot().status),
+        )
+        .toBe("opened");
+      let position = 0;
+      if (reading) {
+        await region.hover();
+        await page.mouse.wheel(0, 500);
+        await expect
+          .poll(() => region.evaluate((node) => node.scrollTop))
+          .toBe(500);
+        position = await region.evaluate((node) => node.scrollTop);
+      }
+      release();
+      await expect(region.locator("[data-message-id]")).toHaveCount(124);
+      await expect(
+        region.getByText("Loading thread…", { exact: true }),
+      ).toHaveCount(0);
+      await expect
+        .poll(() =>
+          page.evaluate(() => window.fixtureNavigation.snapshot().status),
+        )
+        .toBe("opened");
+      if (reading) {
+        expect(await region.evaluate((node) => node.scrollTop)).toBe(position);
+      } else {
+        await expect
+          .poll(() =>
+            region.evaluate(
+              (node) => node.scrollHeight - node.clientHeight - node.scrollTop,
+            ),
+          )
+          .toBeLessThan(4);
+        await expect(
+          region.locator(`[data-message-id="${last.id}"]`),
+        ).toBeInViewport();
+        await expect(
+          page.getByRole("button", { name: "Close thread", exact: true }),
+        ).toBeFocused();
+      }
+      const live = app.reply(root.id);
+      await expect(
+        region.locator(`[data-message-id="${live.id}"]`),
+      ).toBeVisible();
+      if (reading) {
+        expect(await region.evaluate((node) => node.scrollTop)).toBe(position);
+      } else {
+        await expect(
+          region.locator(`[data-message-id="${live.id}"]`),
+        ).toBeInViewport();
+      }
+    } finally {
+      release();
+      await page.unroute(routePattern);
+    }
+  });
+}

From ef3ca395e5061ec18aefeba070fe607bbd78c1dc Mon Sep 17 00:00:00 2001
From: Pinky
 <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 12:46:11 +0200
Subject: [PATCH 4/6] Fix composer fixture and unread-aware navigation CI tests

Signed-off-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 tests/browser/navigation-thread-history.spec.mjs | 4 +++-
 tests/fixtures/link-messages.tsx                 | 5 +++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/browser/navigation-thread-history.spec.mjs b/tests/browser/navigation-thread-history.spec.mjs
index 314c25b8..2ba60753 100644
--- a/tests/browser/navigation-thread-history.spec.mjs
+++ b/tests/browser/navigation-thread-history.spec.mjs
@@ -41,7 +41,9 @@ test("Back restores each thread visit before the previous channel", async ({
   );
   await expect(panel.getByText("Thread root 1", { exact: true })).toBeVisible();
   expect(await openThread.evaluate((node) => node.isConnected)).toBe(true);
-  await page.getByRole("button", { name: "Beta", exact: true }).click();
+  const beta = page.locator('[data-channel-id="beta"]');
+  await expect(beta.locator("[data-channel-unread]")).toBeVisible();
+  await beta.click();
   await expect(
     page.getByRole("textbox", { name: "Message #Beta", exact: true }),
   ).toBeVisible();
diff --git a/tests/fixtures/link-messages.tsx b/tests/fixtures/link-messages.tsx
index dc909c5b..56d27833 100644
--- a/tests/fixtures/link-messages.tsx
+++ b/tests/fixtures/link-messages.tsx
@@ -120,9 +120,14 @@ const library = {
   identities: [{ pubkey: "b".repeat(64), name: "Build Bot" }],
 };
 const emoji = { status: "ready", entries: [] };
+const typing = Object.freeze([]);
 const sent: Array<{ text: string; mentions: readonly string[] }> = [];
 Object.assign(window, { linkComposerFixture: { sent } });
 const previewSession = {
+  typing: {
+    snapshot: () => typing,
+    subscribe: () => () => {},
+  },
   outbox: { supports: () => true },
   emoji: {
     snapshot: () => emoji,

From ab5083f4d88e4482ac2026a15e0d2e87e3627654 Mon Sep 17 00:00:00 2001
From: Brain
 <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 13:05:45 +0200
Subject: [PATCH 5/6] Allow bounded presence during ordinary work and retry
 locally unsent status

Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 dev/relay-broker-api.test.mjs             |  37 +++++
 dev/relay-broker.mjs                      |   5 +-
 docs/presence.md                          |  12 +-
 src/features/presence/presence.test.ts    |  35 +++++
 src/features/presence/presence.ts         |   6 +-
 src/features/relay/broker-live.test.ts    |  32 ++++-
 src/features/relay/broker-live.ts         |   5 +-
 src/features/relay/http-admission.test.ts |  30 ++++
 src/features/relay/http-admission.ts      |   5 +-
 src/features/relay/live.test.ts           |  13 +-
 src/features/relay/live.ts                |  14 +-
 tests/browser/presence.spec.mjs           | 161 ++++++++++++++++------
 tests/fixtures/link-messages.tsx          |   8 ++
 13 files changed, 294 insertions(+), 69 deletions(-)

diff --git a/dev/relay-broker-api.test.mjs b/dev/relay-broker-api.test.mjs
index 61d13f06..f5e8a2c1 100644
--- a/dev/relay-broker-api.test.mjs
+++ b/dev/relay-broker-api.test.mjs
@@ -540,3 +540,40 @@ test("held optional snapshot body leaves ordinary broker capacity free and start
     await h.close();
   }
 });
+
+test("presence snapshot progresses while an ordinary response body is held", async () => {
+  let release;
+  const h = await harness((call) => {
+    if (call.body?.[0]?.kinds?.includes(20001)) return Response.json([]);
+    return new Response(
+      new ReadableStream({
+        start(controller) {
+          release = () => {
+            controller.enqueue(new TextEncoder().encode("[]"));
+            controller.close();
+          };
+        },
+      }),
+    );
+  });
+  let ordinary;
+  try {
+    ordinary = h.post("query", filters, undefined, "background");
+    await vi.waitFor(() => expect(release).toBeTypeOf("function"));
+    const snapshot = await h.post("presence-snapshot", [
+      { kinds: [20001], authors: [h.event.pubkey], limit: 1 },
+    ]);
+    expect(snapshot.status).toBe(200);
+    expect(await snapshot.json()).toEqual([]);
+    expect(h.calls).toHaveLength(2);
+    const missing = await h.post("stream-presence", {
+      streamId: "0".repeat(32),
+      status: "online",
+    });
+    expect(await missing.json()).toEqual({ accepted: null });
+  } finally {
+    release?.();
+    await ordinary;
+    await h.close();
+  }
+});
diff --git a/dev/relay-broker.mjs b/dev/relay-broker.mjs
index ddb89d9f..4685be26 100644
--- a/dev/relay-broker.mjs
+++ b/dev/relay-broker.mjs
@@ -606,7 +606,7 @@ export function relayBrokerPlugin({
               return json(res, 400, { error: "Invalid live control" });
             const stream = streams.get(streamId);
             if (publishingPresence && (!stream || stream.relay !== relay))
-              return json(res, 200, { accepted: false });
+              return json(res, 200, { accepted: null });
             if (!stream || stream.relay !== relay)
               return json(res, 404, {
                 error: "Live stream no longer available",
@@ -994,8 +994,7 @@ export function relayBrokerPlugin({
           const lane = admissions(relay, viewer).api;
           let releasePresence;
           if (presence) {
-            releasePresence =
-              !presenceFlight && !inflight ? lane.tryPresence() : undefined;
+            releasePresence = !presenceFlight ? lane.tryPresence() : undefined;
             if (!releasePresence) {
               res.writeHead(204);
               return res.end();
diff --git a/docs/presence.md b/docs/presence.md
index 6279f9b8..5669fb93 100644
--- a/docs/presence.md
+++ b/docs/presence.md
@@ -29,11 +29,15 @@ an immediate live-status stream.
 - Renewal uses the existing authenticated socket, with a Web Lock per scope/viewer
   serializing same-origin windows. Publication is lossy and bounded; it never
   enters the durable outbox, replays missed ticks, or publishes Offline on close.
-  Hidden observation does not stop connected-community renewal. Ordinary setup and
-  actual shared relay cooldowns still take priority.
+  Hidden observation does not stop connected-community renewal. Actual shared
+  relay cooldowns still take priority. A locally unsent publication
+  retries current status after 5–6 seconds through the same renewal timer; refused
+  or unconfirmed publications retain the 60–65 second interval.
 
-Sustained ordinary traffic may starve optional reads and renewal. Unknown can last
-indefinitely when busy/unavailable. These limits bound client work; they do not
+Bounded presence reads and publications can run during ordinary HTTP work and
+channel subscription setup; neither waits for the entire host to become idle.
+Unknown can persist during relay cooldowns or unavailability. These limits bound
+client work; they do not
 promise zero CPU/network/backend cost, instant transitions, or a delivery SLA.
 There are no presence REQs, added sockets, relay changes, or direct-adapter parity.
 
diff --git a/src/features/presence/presence.test.ts b/src/features/presence/presence.test.ts
index 7faa787f..5fbcfb6f 100644
--- a/src/features/presence/presence.test.ts
+++ b/src/features/presence/presence.test.ts
@@ -324,3 +324,38 @@ it("retains profile priority across duplicate cleanup and refills released slots
   expect(h.read).toHaveBeenCalledOnce();
   h.owner.dispose();
 });
+
+it.each([null, false, true, "error"] as const)(
+  "renewal retries only locally unsent status promptly: %s",
+  async (result) => {
+    const h = setup();
+    h.owner.dispose();
+    vi.stubGlobal("navigator", {
+      locks: {
+        request: async (
+          _name: string,
+          _options: unknown,
+          work: () => Promise<void>,
+        ) => work(),
+      },
+    });
+    const publish = vi.fn(async (): Promise<boolean | null> => {
+      if (result === "error") throw new Error("unconfirmed");
+      return result;
+    });
+    const owner = createPresence(h.transport, h.activity, publish, (fn) =>
+      fn(),
+    );
+    owner.connected(true);
+    await vi.advanceTimersByTimeAsync(250);
+    expect(publish).toHaveBeenCalledOnce();
+    const delay = result === null ? 5000 : 60000;
+    await vi.advanceTimersByTimeAsync(delay - 1);
+    expect(publish).toHaveBeenCalledOnce();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(publish).toHaveBeenCalledTimes(2);
+    owner.dispose();
+    await vi.advanceTimersByTimeAsync(60000);
+    expect(publish).toHaveBeenCalledTimes(2);
+  },
+);
diff --git a/src/features/presence/presence.ts b/src/features/presence/presence.ts
index 4ed50fad..d0f132b1 100644
--- a/src/features/presence/presence.ts
+++ b/src/features/presence/presence.ts
@@ -193,12 +193,14 @@ export function createPresence(
             stopPublisher = resolve;
             const renew = async () => {
               if (!valid()) return;
+              let delay = minute();
               try {
-                await publish(activity.status(), owned.signal);
+                if ((await publish(activity.status(), owned.signal)) === null)
+                  delay = 5000 + Math.random() * 1000;
               } catch {
                 /* Lossy; next renewal owns current state. */
               }
-              if (valid()) renewal = setTimeout(() => void renew(), minute());
+              if (valid()) renewal = setTimeout(() => void renew(), delay);
             };
             renewal = setTimeout(() => void renew(), 250 + Math.random() * 750);
           });
diff --git a/src/features/relay/broker-live.test.ts b/src/features/relay/broker-live.test.ts
index 3522651b..cb489cf1 100644
--- a/src/features/relay/broker-live.test.ts
+++ b/src/features/relay/broker-live.test.ts
@@ -39,7 +39,11 @@ function fixture() {
             live: true,
           }),
         );
-      if (url.endsWith("/stream-retry") || url.endsWith("/stream-observer")) {
+      if (
+        url.endsWith("/stream-retry") ||
+        url.endsWith("/stream-observer") ||
+        url.endsWith("/stream-presence")
+      ) {
         const d = deferred<Response>();
         controls.push(d);
         signals.push(init.signal as AbortSignal);
@@ -283,3 +287,29 @@ it.each([undefined, { phase: "fresh" }, { phase: "live", channelId: ["a"] }])(
     }
   },
 );
+
+it("preserves locally-unsent presence separately from refusal and unknown responses", async () => {
+  vi.useFakeTimers();
+  const f = fixture();
+  const t = await connectBrokerTransport();
+  const owner = required(t.subscribe)(f.callbacks);
+  try {
+    expect(
+      await owner.publishPresence?.("online", new AbortController().signal),
+    ).toBeNull();
+    f.accept(0);
+    await tick();
+    f.publish(0);
+    await tick();
+    for (const accepted of [null, false, true, undefined, "null"]) {
+      const result = owner.publishPresence?.(
+        "online",
+        new AbortController().signal,
+      );
+      required(f.controls.at(-1)).resolve(Response.json({ accepted }));
+      expect(await result).toBe(accepted === null ? null : accepted === true);
+    }
+  } finally {
+    owner.dispose();
+  }
+});
diff --git a/src/features/relay/broker-live.ts b/src/features/relay/broker-live.ts
index 8bc261f4..bc4ec157 100644
--- a/src/features/relay/broker-live.ts
+++ b/src/features/relay/broker-live.ts
@@ -252,7 +252,7 @@ export function subscribeBrokerTraffic(
   return {
     async publishPresence(status, signal) {
       if (closed || !streamId || !controller || latest.status !== "connected")
-        return false;
+        return null;
       const current = generation;
       const response = await fetch(`${endpoint}/stream-presence`, {
         method: "POST",
@@ -266,7 +266,8 @@ export function subscribeBrokerTraffic(
         ]),
       });
       if (closed || current !== generation || !response.ok) return false;
-      return (await response.json()).accepted === true;
+      const { accepted } = await response.json();
+      return accepted === null ? null : accepted === true;
     },
     observe(value) {
       const next = observerGeneration(value);
diff --git a/src/features/relay/http-admission.test.ts b/src/features/relay/http-admission.test.ts
index a3ccc27a..ef57f8b0 100644
--- a/src/features/relay/http-admission.test.ts
+++ b/src/features/relay/http-admission.test.ts
@@ -177,3 +177,33 @@ it("a partial quota body retains its host owner until normalization installs coo
   await vi.advanceTimersByTimeAsync(3000);
   expect(lane.idle()).toBe(true);
 });
+
+it("presence starts alongside held ordinary work but retains its own flight, pacing and shared cooldown", async () => {
+  vi.useFakeTimers();
+  const lane = createApiAdmission();
+  let finish!: () => void;
+  const ordinary = lane.run(
+    () =>
+      new Promise<void>((resolve) => {
+        finish = resolve;
+      }),
+    undefined,
+    "background",
+  );
+  const release = lane.tryPresence();
+  expect(release).toBeTypeOf("function");
+  expect(lane.tryPresence()).toBeUndefined();
+  release?.();
+  expect(lane.tryPresence()).toBeUndefined();
+  await vi.advanceTimersByTimeAsync(5000);
+  lane.pause(6000);
+  expect(lane.tryPresence()).toBeUndefined();
+  await vi.advanceTimersByTimeAsync(5999);
+  expect(lane.tryPresence()).toBeUndefined();
+  await vi.advanceTimersByTimeAsync(1);
+  const resumed = lane.tryPresence();
+  expect(resumed).toBeTypeOf("function");
+  resumed?.();
+  finish();
+  await ordinary;
+});
diff --git a/src/features/relay/http-admission.ts b/src/features/relay/http-admission.ts
index 1dc4cdd4..6bd93a38 100644
--- a/src/features/relay/http-admission.ts
+++ b/src/features/relay/http-admission.ts
@@ -156,7 +156,10 @@ export function createApiAdmission() {
   return {
     /** Lossy snapshot lease; never consumes ordinary slots or start credit. */
     tryPresence() {
-      if (!this.idle() || presenceBusy || performance.now() < presenceNext)
+      if (
+        presenceBusy ||
+        performance.now() < Math.max(pausedUntil, presenceNext)
+      )
         return;
       presenceBusy = true;
       presenceNext = performance.now() + 5000;
diff --git a/src/features/relay/live.test.ts b/src/features/relay/live.test.ts
index 8cde95e9..fcb67171 100644
--- a/src/features/relay/live.test.ts
+++ b/src/features/relay/live.test.ts
@@ -701,12 +701,11 @@ it("observer route is optional, live-only at dispatch/retry, separately fenced a
 it("presence holds its receipt without delaying ordinary setup and shares correlated cooldown", async () => {
   vi.useFakeTimers();
   const h = setup([]);
-  await h.first.auth();
   expect(
     await h.owner.publishPresence?.("online", new AbortController().signal),
-  ).toBe(false);
-  await vi.advanceTimersByTimeAsync(500);
-  for (const [, id] of h.first.requests()) await h.first.receive(["EOSE", id]);
+  ).toBeNull();
+  await h.first.auth();
+  // No EOSE: ordinary setup and its 250ms start clock are still pending.
   const abort = new AbortController();
   const result = h.owner.publishPresence?.("online", abort.signal);
   await vi.advanceTimersByTimeAsync(0);
@@ -714,8 +713,10 @@ it("presence holds its receipt without delaying ordinary setup and shares correl
     id: string;
     content: string;
   };
+  assert.exists(event);
   expect(event.content).toBe("online");
   h.owner.update(["foreground"]);
+  await vi.advanceTimersByTimeAsync(500);
   expect(h.first.requests().at(-1)?.[2]["#h"]).toEqual(["foreground"]);
   abort.abort(); // Keep the receipt correlation after cancellation, to honor late quota.
   await h.first.receive(["OK", "unrelated", true]);
@@ -775,9 +776,9 @@ it("an outstanding presence signer pins its principal flight across socket repla
   for (const [, id] of next.requests()) await next.receive(["EOSE", id]);
   expect(
     await owner.publishPresence?.("online", new AbortController().signal),
-  ).toBe(false);
+  ).toBeNull();
   release();
-  expect(await result).toBe(false);
+  expect(await result).toBeNull();
   expect(
     sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"),
   ).toEqual([]);
diff --git a/src/features/relay/live.ts b/src/features/relay/live.ts
index 9dd0ded8..eb1e7c6a 100644
--- a/src/features/relay/live.ts
+++ b/src/features/relay/live.ts
@@ -27,9 +27,7 @@ export function createLiveAdmission() {
       if (busy) pending.add(owner);
       else pending.delete(owner);
     },
-    presenceReady: () =>
-      !pending.size &&
-      performance.now() >= Math.max(next, cooldown, presenceNext),
+    presenceReady: () => performance.now() >= Math.max(cooldown, presenceNext),
     tryPresence() {
       if (presenceBusy || !this.presenceReady()) return;
       presenceBusy = true;
@@ -105,11 +103,11 @@ export type LiveSubscription = {
   /** Host demand only: reorder existing pending routes, never grant new interests. */
   prioritize?(channels: readonly string[]): void;
   observe?(generation: number | null): void;
-  /** One ephemeral status on this authenticated connection; false means not sent. */
+  /** One ephemeral status: true = accepted, null = locally unsent, false = unconfirmed/refused. */
   publishPresence?(
     status: "online" | "away",
     signal: AbortSignal,
-  ): Promise<boolean>;
+  ): Promise<boolean | null>;
   retry(): void;
   dispose(): void;
 };
@@ -571,9 +569,9 @@ export function subscribeRelayTraffic(
         closed ||
         !authenticated
       )
-        return false;
+        return null;
       const release = admission.tryPresence();
-      if (!release) return false;
+      if (!release) return null;
       const current = generation;
       const bounded = AbortSignal.any([signal, AbortSignal.timeout(10000)]);
       try {
@@ -593,7 +591,7 @@ export function subscribeRelayTraffic(
           socket?.readyState !== 1 ||
           !admission.presenceReady()
         )
-          return false;
+          return null;
         if (
           event.pubkey !== viewer ||
           event.kind !== 20001 ||
diff --git a/tests/browser/presence.spec.mjs b/tests/browser/presence.spec.mjs
index 1410633d..ba49b85b 100644
--- a/tests/browser/presence.spec.mjs
+++ b/tests/browser/presence.spec.mjs
@@ -88,6 +88,15 @@ test("foreground send and cold channel entry remain available during a profile s
   page,
   app,
 }) => {
+  // Hold preferences outside broker admission so roster warming cannot pre-load
+  // Beta. Demand reads and presence still use their real owners and admission.
+  const preferences = Promise.withResolvers();
+  let preferencesPending = false;
+  await page.route("**/sidebar-preferences", async (route) => {
+    preferencesPending = true;
+    await preferences.promise;
+    await route.fallback();
+  });
   app.relay.holdPresence();
   await open(page, app);
   await expect.poll(() => app.relay.hasRoute("primary", "alpha")).toBe(true);
@@ -135,52 +144,51 @@ test("foreground send and cold channel entry remain available during a profile s
           filter["#h"]?.includes("beta") &&
           filter.until === undefined,
       );
+    await expect.poll(() => preferencesPending).toBe(true);
     expect(betaHeads()).toHaveLength(0);
-    const visibleMs = await page
-      .getByRole("button", { name: "Beta", exact: true })
-      .evaluate(
-        async (button, ids) => {
-          const start = performance.now();
-          button.click();
-          await new Promise((resolve, reject) => {
-            const deadline = setTimeout(
-              () => reject(new Error("cold channel did not paint")),
-              5000,
+    const visibleMs = await page.locator('[data-channel-id="beta"]').evaluate(
+      async (button, ids) => {
+        const start = performance.now();
+        button.click();
+        await new Promise((resolve, reject) => {
+          const deadline = setTimeout(
+            () => reject(new Error("cold channel did not paint")),
+            5000,
+          );
+          const check = () => {
+            const history = document.querySelector(
+              '[aria-label="Channel message history"]',
             );
-            const check = () => {
-              const history = document.querySelector(
-                '[aria-label="Channel message history"]',
-              );
-              const bounds = history?.getBoundingClientRect();
-              const visible =
-                bounds &&
-                [...history.querySelectorAll("[data-message-id]")].some(
-                  (row) => {
-                    const rect = row.getBoundingClientRect();
-                    return (
-                      ids.includes(row.dataset.messageId) &&
-                      rect.height > 0 &&
-                      rect.bottom > bounds.top &&
-                      rect.top < bounds.bottom
-                    );
-                  },
+            const bounds = history?.getBoundingClientRect();
+            const visible =
+              bounds &&
+              [...history.querySelectorAll("[data-message-id]")].some((row) => {
+                const rect = row.getBoundingClientRect();
+                return (
+                  ids.includes(row.dataset.messageId) &&
+                  rect.height > 0 &&
+                  rect.bottom > bounds.top &&
+                  rect.top < bounds.bottom
                 );
-              if (
-                !visible ||
-                !document.querySelector('textarea[placeholder="Message #Beta"]')
-              )
-                return requestAnimationFrame(check);
-              requestAnimationFrame(() => {
-                clearTimeout(deadline);
-                resolve();
               });
-            };
-            requestAnimationFrame(check);
-          });
-          return performance.now() - start;
-        },
-        app.histories.get("primary/beta").map(({ id }) => id),
-      );
+            if (
+              !visible ||
+              !document.querySelector(
+                '[role="textbox"][aria-label="Message #Beta"]',
+              )
+            )
+              return requestAnimationFrame(check);
+            requestAnimationFrame(() => {
+              clearTimeout(deadline);
+              resolve();
+            });
+          };
+          requestAnimationFrame(check);
+        });
+        return performance.now() - start;
+      },
+      app.histories.get("primary/beta").map(({ id }) => id),
+    );
     expect(betaHeads().length).toBeGreaterThan(0);
     // Closing the contextual profile may abort optional work; do not require
     // an unnecessary snapshot to survive navigation just to satisfy this test.
@@ -190,6 +198,7 @@ test("foreground send and cold channel entry remain available during a profile s
       note: "send includes automation/polling; cold uses browser click-to-paint clock",
     });
   } finally {
+    preferences.resolve();
     app.relay.releasePresence();
   }
 });
@@ -394,3 +403,71 @@ test("real same-origin windows queue one publisher and transfer its Web Lock on
     await second.close();
   }
 });
+
+test("presence becomes usable during held HTTP work and unfinished subscription setup", async ({
+  page,
+  app,
+}) => {
+  app.relay.holdEose("alpha");
+  app.relay.holdUnread();
+  const snapshotStart = Promise.withResolvers();
+  await page.route("**/presence-snapshot", async (route) => {
+    await snapshotStart.promise;
+    await route.fallback();
+  });
+  const receipts = [];
+  page.on("response", async (response) => {
+    if (response.url().endsWith("/stream-presence"))
+      receipts.push(await response.json());
+  });
+  try {
+    await open(page, app);
+    await expect
+      .poll(() => app.report.unreadHolds.some((hold) => hold.pending))
+      .toBe(true);
+    await expect.poll(() => app.relay.hasRoute("primary", "alpha")).toBe(true);
+    snapshotStart.resolve(); // Begin broker dispatch only after ordinary HTTP is held.
+    await expect
+      .poll(() => receipts.some(({ accepted }) => accepted === true))
+      .toBe(true);
+    await expect(
+      page
+        .locator("[data-channel-timeline]")
+        .getByRole("img", { name: "Presence: online" })
+        .first(),
+    ).toBeVisible();
+    expect(app.report.unreadHolds.some((hold) => hold.pending)).toBe(true);
+    expect(
+      app.report.wireFrames.some(
+        ([kind, id]) =>
+          kind === "EOSE" &&
+          app.relay.requests.some(
+            (req) => req.id === id && req.route === "alpha",
+          ),
+      ),
+    ).toBe(false);
+    const composer = page.getByRole("textbox", {
+      name: "Message #Alpha",
+      exact: true,
+    });
+    await composer.fill("Presence and chat during startup");
+    await composer.press("Enter");
+    await expect
+      .poll(() =>
+        app.report.publications.some(
+          ({ event }) => event.content === "Presence and chat during startup",
+        ),
+      )
+      .toBe(true);
+    expect(app.report.unreadHolds.some((hold) => hold.pending)).toBe(true);
+    expect(
+      app.report.presencePublications.some(
+        ({ event }) => event.content === "online",
+      ),
+    ).toBe(true);
+  } finally {
+    snapshotStart.resolve();
+    app.relay.releaseUnread();
+    app.relay.releaseEose("alpha");
+  }
+});
diff --git a/tests/fixtures/link-messages.tsx b/tests/fixtures/link-messages.tsx
index 56d27833..f6bbc497 100644
--- a/tests/fixtures/link-messages.tsx
+++ b/tests/fixtures/link-messages.tsx
@@ -124,6 +124,14 @@ const typing = Object.freeze([]);
 const sent: Array<{ text: string; mentions: readonly string[] }> = [];
 Object.assign(window, { linkComposerFixture: { sent } });
 const previewSession = {
+  presence: {
+    status: () => "unknown",
+    limited: () => false,
+    subscribe: () => () => {},
+  } satisfies Pick<
+    RelaySession["presence"],
+    "status" | "limited" | "subscribe"
+  >,
   typing: {
     snapshot: () => typing,
     subscribe: () => () => {},

From 7063d6976894d92499e51bc2d30be96714250b31 Mon Sep 17 00:00:00 2001
From: Brain
 <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
Date: Tue, 15 Sep 2026 15:12:16 +0200
Subject: [PATCH 6/6] Expose resized emoji picker before viewport hit tests

Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 tests/browser/emoji.spec.mjs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/browser/emoji.spec.mjs b/tests/browser/emoji.spec.mjs
index c36d7f8a..84044075 100644
--- a/tests/browser/emoji.spec.mjs
+++ b/tests/browser/emoji.spec.mjs
@@ -511,6 +511,9 @@ test("community picker uses keyboard, proxy thumbnails, event-local history and
     );
     await expect(search).toHaveValue("party");
     await expect(page.locator("em-emoji-picker nav")).toHaveCount(0);
+    // Reflow can move this standalone fixture below the viewport. CSS visibility
+    // alone does not establish that elementFromPoint can reach every result.
+    await region.scrollIntoViewIfNeeded();
     const narrowRegion = await region.boundingBox();
     const narrowSurface = await surface.boundingBox();
     expect(narrowRegion.width).toBe(narrowSurface.width + 2);