relaybrain 0.0.0-stage → 0.2.1

package/backend/lib/roomLocks.js

@@ -0,0 +1,201 @@
+const { EventEmitter } = require("events");
+
+const POLL_MS = 4000;
+// How long a lock may sit past its own expiry before the mirror drops it. Locks
+// carry a TTL of a few seconds and are renewed by heartbeat, so this is only
+// what keeps a lock from flickering out between two polls.
+const EXPIRY_GRACE_MS = 4000;
+// Consecutive failed polls before the host counts as unreachable. One dropped
+// tunnel request is normal; three in a row (~6s) is not.
+const MAX_MISSES = 3;
+// How long a push keeps the poller quiet. Long enough that a live socket does
+// all the work, short enough that a socket which dies without closing cleanly
+// (the normal way a tunnel disappears) is covered within one interval.
+const PUSH_TRUST_MS = 8000;
+
+/**
+ * A guest's own lock table is empty: its hooks claim against the host's
+ * coordinator (see coordinator/client.js), which is the whole point of a shared
+ * room. Without a mirror, every local read of the lock table — /api/locks, the
+ * SSE stream the Coordinator tab subscribes to, the dashboard — reports "no
+ * locks" and overwrites the host snapshot the dashboard just fetched.
+ *
+ * Two ways in, one authority. The host's lock table is the only writer; every
+ * change it makes is pushed down the room WebSocket and lands here via accept().
+ * That makes granting a lock and drawing it the SAME event rather than two
+ * subsystems that can disagree — which is exactly how a guest ended up with
+ * working locks and a permanently empty board. The poll below is no longer the
+ * delivery path, only reconciliation for whenever the socket is down.
+ *
+ * Only runs while a room is joined as a guest. Solo and host installs keep
+ * reading their own table exactly as before.
+ */
+class RoomLockMirror extends EventEmitter {
+  constructor({ fetchLocks }) {
+    super();
+    this.fetchLocks = fetchLocks;
+    this.locks = [];
+    this.reads = [];
+    this.updatedAt = 0;
+    this.timer = null;
+    this.room = null;
+    this.failures = 0;
+    this.lastPushAt = 0;
+  }
+
+  /**
+   * Whether the host is answering. The board is otherwise indistinguishable
+   * between "nobody is editing" and "the tunnel is down", which is exactly the
+   * confusion a guest hits when their Coordinator screen stays empty.
+   */
+  get health() {
+    if (!this.active) return { joined: false, reachable: true, lastContactAt: null };
+    return {
+      joined: true,
+      reachable: this.updatedAt > 0 && this.failures < MAX_MISSES,
+      lastContactAt: this.updatedAt || null,
+    };
+  }
+
+  get active() {
+    return Boolean(this.room?.url && this.room.role === "guest" && this.room.hostProjectId);
+  }
+
+  /** Has the host ever answered? Until it has, there is nothing to prefer. */
+  get fresh() {
+    return this.active && this.updatedAt > 0;
+  }
+
+  start(room) {
+    const sameRoom =
+      this.room?.url === room?.url &&
+      this.room?.hostProjectId === room?.hostProjectId &&
+      this.room?.memberToken === room?.memberToken;
+    // Nothing below may touch this.room while it is still the same room.
+    //
+    // loadRoom() re-parses room.json and hands back a NEW object every call, and
+    // the dashboard calls syncRoomLocks() on every poll — so this used to swap
+    // this.room's identity every few seconds. poll() drops any response whose
+    // room is no longer current, which meant a poll still in flight at that
+    // moment was thrown away. Over loopback a poll finishes in milliseconds and
+    // nothing is lost; over an ngrok tunnel it takes long enough that every poll
+    // could land inside that window, leaving updatedAt at 0 forever — a guest
+    // whose locks worked fine but whose Coordinator board never filled in.
+    if (sameRoom && this.timer) return undefined;
+    const sameHost =
+      this.room?.role === "guest" &&
+      room?.role === "guest" &&
+      this.room?.hostProjectId &&
+      this.room.hostProjectId === room.hostProjectId;
+    if (sameHost && this.timer) {
+      // Tunnel URL changed (ngrok recycle). Keep the last snapshot so the
+      // Coordinator board does not flash empty while we retarget.
+      this.room = room;
+      this.failures = 0;
+      this.poll();
+      return undefined;
+    }
+    this.room = room || null;
+    if (!this.active) {
+      this.stop({ clear: true });
+      return undefined;
+    }
+    this.stop();
+    this.room = room;
+    this.timer = setInterval(() => this.poll(), POLL_MS);
+    if (this.timer.unref) this.timer.unref();
+    this.poll();
+    return undefined;
+  }
+
+  stop({ clear } = {}) {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.failures = 0;
+    this.lastPushAt = 0;
+    if (clear && (this.locks.length || this.reads.length)) {
+      this.locks = [];
+      this.reads = [];
+      this.updatedAt = 0;
+      this.emit("change", { locks: [], reads: [] });
+    }
+    return undefined;
+  }
+
+  /**
+   * A lock change pushed straight from the host's table over the room socket.
+   * Same commit path as a successful poll, so both routes leave the mirror in
+   * exactly one state.
+   */
+  accept(locks, extras = {}) {
+    if (!this.active || !Array.isArray(locks)) return false;
+    this.lastPushAt = Date.now();
+    const readsChanged =
+      Array.isArray(extras.reads) && JSON.stringify(extras.reads) !== JSON.stringify(this.reads);
+    if (Array.isArray(extras.reads)) this.reads = extras.reads;
+    return this.commit(locks, readsChanged);
+  }
+
+  commit(locks, readsChanged = false) {
+    const changed = JSON.stringify(locks) !== JSON.stringify(this.locks) || readsChanged;
+    const wasDown = this.failures >= MAX_MISSES;
+    this.locks = locks;
+    this.updatedAt = Date.now();
+    this.failures = 0;
+    if (changed || wasDown) this.emit("change", { locks, reads: this.reads || [] });
+    return changed;
+  }
+
+  async poll() {
+    if (!this.active) return;
+    // The socket is delivering; a poll would only re-fetch what we already have.
+    if (Date.now() - this.lastPushAt < PUSH_TRUST_MS) return;
+    const room = this.room;
+    try {
+      const snap = await this.fetchLocks(room);
+      if (!snap || this.room !== room) return;
+      if (Array.isArray(snap)) {
+        this.commit(snap);
+        return;
+      }
+      if (!Array.isArray(snap.locks)) return;
+      const readsChanged =
+        Array.isArray(snap.reads) && JSON.stringify(snap.reads) !== JSON.stringify(this.reads);
+      if (Array.isArray(snap.reads)) this.reads = snap.reads;
+      this.commit(snap.locks, readsChanged);
+    } catch {
+      // Host unreachable: keep the last snapshot and let each lock age out on
+      // its own TTL, rather than flashing "all locks released" on every dropped
+      // tunnel request.
+      this.failures += 1;
+      if (this.failures === MAX_MISSES) this.emit("change", { locks: this.list() || [] });
+    }
+  }
+
+  /**
+   * The host's locks, minus anything that has since run out of TTL.
+   *
+   * A dropped poll used to blank this after 15s, which took the guest's whole
+   * Coordinator board down with it — including locks the host was still
+   * heartbeating. Ageing entries out by their own expiry instead means an
+   * unreachable host decays the board file by file, exactly as a host that went
+   * quiet would, and one slow tunnel request changes nothing.
+   */
+  list() {
+    if (!this.fresh) return null;
+    const cutoff = Date.now() - EXPIRY_GRACE_MS;
+    return this.locks.filter((l) => !l.expiresAt || l.expiresAt > cutoff);
+  }
+
+  /** Host reads, minus anything that has aged out of its own TTL. */
+  listReads() {
+    if (!this.fresh) return null;
+    const now = Date.now();
+    return (this.reads || []).filter((r) => {
+      const exp = r.expiresAt || (r.at || 0) + 30000;
+      return exp > now;
+    });
+  }
+}
+
+module.exports = { RoomLockMirror };

package/backend/lib/roomSignal.js

@@ -0,0 +1,265 @@
+const { spawn } = require("child_process");
+const { parseGithubRepo } = require("./githubRepo");
+const { inviteState, invitesOf, normLogin } = require("./roomAuth");
+
+const SIGNAL_PREFIX = "relay-room:";
+const SIGNAL_FILE = "relay-signal.json";
+const PROOF_FILE = "relay-proof.json";
+
+function repoKeyFromRemote(remoteUrl) {
+  const parsed = parseGithubRepo(remoteUrl);
+  return parsed ? `${parsed.owner}/${parsed.repo}` : null;
+}
+
+function signalDescription(repoKey) {
+  return `${SIGNAL_PREFIX}${repoKey}`;
+}
+
+function invitedLogins(room) {
+  return invitesOf(room)
+    .filter((i) => {
+      const state = inviteState(i);
+      return state === "pending" || state === "accepted";
+    })
+    .map((i) => normLogin(i.login))
+    .filter(Boolean);
+}
+
+function ghApi(pathname, { method = "GET", body } = {}) {
+  const args = ["api", pathname, "-H", "Accept: application/vnd.github+json"];
+  if (method && method !== "GET") args.push("-X", method);
+  if (body !== undefined) args.push("--input", "-");
+  return new Promise((resolve, reject) => {
+    const child = spawn("gh", args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, shell: false });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (c) => (out += c));
+    child.stderr.on("data", (c) => (err += c));
+    child.on("error", () => reject(new Error("gh_not_installed")));
+    child.on("exit", (code) => {
+      if (code !== 0) return reject(new Error(err.trim() || `gh exited ${code}`));
+      const text = out.trim();
+      if (!text) return resolve({});
+      try {
+        resolve(JSON.parse(text));
+      } catch {
+        resolve(text);
+      }
+    });
+    if (body !== undefined) child.stdin.write(JSON.stringify(body));
+    child.stdin.end();
+  });
+}
+
+async function readGist(id) {
+  if (!id) return null;
+  try {
+    return await ghApi(`gists/${id}`);
+  } catch {
+    try {
+      const res = await fetch(`https://api.github.com/gists/${id}`, {
+        headers: { "User-Agent": "relay-it", Accept: "application/vnd.github+json" },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) return null;
+      return res.json();
+    } catch {
+      return null;
+    }
+  }
+}
+
+function parseSignal(gist) {
+  if (!gist?.id) return null;
+  const desc = String(gist.description || "");
+  if (!desc.startsWith(SIGNAL_PREFIX)) return null;
+  const raw = gist.files?.[SIGNAL_FILE]?.content;
+  let body = {};
+  if (raw) {
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  return {
+    v: body.v || 1,
+    live: body.live !== false,
+    roomId: body.roomId || null,
+    url: body.url || null,
+    hostLogin: body.hostLogin || gist.owner?.login || null,
+    repoKey: body.repo || desc.slice(SIGNAL_PREFIX.length),
+    projectName: body.projectName || null,
+    nonce: body.nonce || null,
+    invited: Array.isArray(body.invited) ? body.invited.map(normLogin) : [],
+    updatedAt: body.updatedAt || null,
+    gistId: gist.id,
+  };
+}
+
+function signalPayload(room, { repoKey, hostLogin }) {
+  return {
+    v: 1,
+    live: room.live !== false,
+    roomId: room.roomId,
+    url: room.url || null,
+    hostLogin,
+    repo: repoKey,
+    projectName: room.hostProjectName || null,
+    nonce: room.nonce,
+    invited: invitedLogins(room),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+async function findOwnSignalGist(repoKey) {
+  try {
+    const mine = await ghApi("gists");
+    const description = signalDescription(repoKey);
+    return (Array.isArray(mine) ? mine : []).find((g) => g.description === description) || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Publishes the current tunnel URL under a well-known public gist so a guest
+ * can find the host again after ngrok recycles the URL. Membership credentials
+ * stay in room.json — the gist is only a pointer.
+ */
+async function publishSignal(room, { repoKey, hostLogin }) {
+  if (!room?.roomId || !repoKey || !hostLogin) {
+    return { ok: false, error: "signal_incomplete" };
+  }
+  const description = signalDescription(repoKey);
+  const files = { [SIGNAL_FILE]: { content: JSON.stringify(signalPayload(room, { repoKey, hostLogin }), null, 2) } };
+  const patch = async (id) => {
+    await ghApi(`gists/${id}`, { method: "PATCH", body: { description, files } });
+    return { ok: true, gistId: id };
+  };
+  if (room.signalGistId) {
+    try {
+      return await patch(room.signalGistId);
+    } catch {
+      /* gist was deleted — fall through and recreate */
+    }
+  }
+  const existing = await findOwnSignalGist(repoKey);
+  if (existing?.id) return patch(existing.id);
+  const created = await ghApi("gists", {
+    method: "POST",
+    body: { description, public: true, files },
+  });
+  if (!created?.id) return { ok: false, error: "gist_create_failed" };
+  return { ok: true, gistId: created.id };
+}
+
+async function findSignal({ gistId, hostLogin, repoKey, roomId } = {}) {
+  if (gistId) {
+    const signal = parseSignal(await readGist(gistId));
+    if (signal && (!roomId || signal.roomId === roomId) && (!repoKey || signal.repoKey === repoKey)) return signal;
+  }
+  if (!hostLogin || !repoKey) return null;
+  let gists = [];
+  try {
+    gists = await ghApi(`users/${encodeURIComponent(hostLogin)}/gists`);
+  } catch {
+    try {
+      const res = await fetch(`https://api.github.com/users/${encodeURIComponent(hostLogin)}/gists`, {
+        headers: { "User-Agent": "relay-it", Accept: "application/vnd.github+json" },
+        signal: AbortSignal.timeout(6000),
+      });
+      if (res.ok) gists = await res.json();
+    } catch {
+      gists = [];
+    }
+  }
+  const description = signalDescription(repoKey);
+  const match = (Array.isArray(gists) ? gists : []).find((g) => g.description === description);
+  if (!match?.id) return null;
+  const signal = parseSignal(await readGist(match.id));
+  if (!signal) return null;
+  if (roomId && signal.roomId !== roomId) return null;
+  return signal;
+}
+
+async function discoverRooms({ repoKey, logins, myLogin }) {
+  const me = normLogin(myLogin);
+  const hosts = [...new Set((logins || []).map(normLogin).filter((l) => l && l !== me))];
+  const rooms = [];
+  for (const hostLogin of hosts) {
+    try {
+      const signal = await findSignal({ hostLogin, repoKey });
+      if (!signal?.live || !signal.url) continue;
+      if (!signal.invited.includes(me)) continue;
+      rooms.push({
+        hostLogin: signal.hostLogin,
+        url: signal.url,
+        roomId: signal.roomId,
+        projectName: signal.projectName,
+        invited: true,
+        updatedAt: signal.updatedAt,
+        gistId: signal.gistId,
+      });
+    } catch {
+      /* one collaborator failing must not hide the others */
+    }
+  }
+  return rooms;
+}
+
+async function createProof({ roomId, nonce, login }) {
+  const gist = await ghApi("gists", {
+    method: "POST",
+    body: {
+      description: `relay-proof:${roomId}`,
+      public: false,
+      files: {
+        [PROOF_FILE]: {
+          content: JSON.stringify({ v: 1, roomId, nonce, login: normLogin(login), ts: Date.now() }),
+        },
+      },
+    },
+  });
+  if (!gist?.id) throw new Error("proof_create_failed");
+  return gist.id;
+}
+
+async function deleteGist(id) {
+  if (!id) return;
+  try {
+    await ghApi(`gists/${id}`, { method: "DELETE" });
+  } catch {
+    /* leftover proof gists are secret and expire from usefulness with the nonce */
+  }
+}
+
+async function verifyProof({ gistId, roomId, nonce, login }) {
+  const gist = await readGist(gistId);
+  if (!gist?.id) return { ok: false, reason: "proof_missing" };
+  if (normLogin(gist.owner?.login) !== normLogin(login)) return { ok: false, reason: "proof_wrong_user" };
+  const raw = gist.files?.[PROOF_FILE]?.content;
+  let body;
+  try {
+    body = JSON.parse(raw || "");
+  } catch {
+    return { ok: false, reason: "proof_invalid" };
+  }
+  if (!body || body.roomId !== roomId || body.nonce !== nonce) return { ok: false, reason: "proof_mismatch" };
+  return { ok: true };
+}
+
+const GIST_SCOPE_HINT =
+  "Sharing is up, but teammates cannot auto-find you yet. Run `gh auth refresh -s gist` once so Relay can publish a join signal. Until then, send them the invite link.";
+
+module.exports = {
+  repoKeyFromRemote,
+  invitedLogins,
+  publishSignal,
+  findSignal,
+  discoverRooms,
+  createProof,
+  deleteGist,
+  verifyProof,
+  GIST_SCOPE_HINT,
+};

package/backend/lib/roomSync.js

@@ -0,0 +1,194 @@
+const { loadMemory, saveMemory } = require("./store");
+const { loadLocalCollisions } = require("./collisionMetrics");
+
+// What one machine publishes to the room, and what it stores for every other
+// machine in the room. Kept in the same memory.json as local history so the
+// dashboard can merge both without a second store — but in a separate
+// `roomPeers` bucket, so a peer's history is never re-published as our own
+// (which would echo back and forth and grow without bound).
+const MAX_THREADS = 24;
+const MAX_MESSAGES = 80;
+const MAX_EDITS = 200;
+const MAX_ACTIVITY = 60;
+const MAX_TIMELINE = 40;
+// Transcript text is clipped to 8000 chars locally; at 24 threads x 80 messages
+// that is a 15MB request per poll over a home-broadband tunnel. Peers get a
+// shorter clip — enough to read the conversation, small enough to send often.
+const MAX_MESSAGE_CHARS = 3000;
+const PEER_TTL_MS = 6 * 60 * 60 * 1000;
+
+function trimThread(thread) {
+  return {
+    ...thread,
+    messages: (thread.messages || []).slice(-MAX_MESSAGES).map((m) => ({
+      ...m,
+      text: typeof m.text === "string" && m.text.length > MAX_MESSAGE_CHARS ? `${m.text.slice(0, MAX_MESSAGE_CHARS)}\n…` : m.text,
+    })),
+  };
+}
+
+/** The locally-owned slice of a workspace's memory, sized for the wire. */
+function localSnapshot(memory, login, projectId) {
+  const stats = { ...(memory.stats || {}) };
+  // Prefer file-backed collision counters so room peers see the durable totals.
+  if (projectId) stats.collisions = loadLocalCollisions(projectId);
+  return {
+    login,
+    updatedAt: Date.now(),
+    lastTranscriptSyncAt: memory.lastTranscriptSyncAt || 0,
+    chats: (memory.chats || []).slice(0, MAX_THREADS).map(trimThread),
+    timeline: (memory.timeline || []).slice(0, MAX_TIMELINE),
+    activity: (memory.activity || []).slice(0, MAX_ACTIVITY),
+    edits: (memory.edits || []).slice(0, MAX_EDITS),
+    agents: (memory.agents || []).filter((a) => a.status === "connected"),
+    stats,
+  };
+}
+
+function sanitize(snapshot, login) {
+  if (!snapshot || typeof snapshot !== "object") return null;
+  const owner = login || snapshot.login || "peer";
+  const stamp = (rows, cap) =>
+    (Array.isArray(rows) ? rows : []).slice(0, cap).map((row) => ({ ...row, ownerLogin: row.ownerLogin || owner, mine: false }));
+  return {
+    login: owner,
+    updatedAt: Date.now(),
+    lastTranscriptSyncAt: Number(snapshot.lastTranscriptSyncAt) || 0,
+    chats: stamp(snapshot.chats, MAX_THREADS).map(trimThread),
+    timeline: stamp(snapshot.timeline, MAX_TIMELINE),
+    activity: stamp(snapshot.activity, MAX_ACTIVITY),
+    edits: stamp(snapshot.edits, MAX_EDITS),
+    agents: Array.isArray(snapshot.agents) ? snapshot.agents.slice(0, 20).map((a) => ({ ...a, ownerLogin: owner })) : [],
+    stats: snapshot.stats && typeof snapshot.stats === "object" ? snapshot.stats : {},
+  };
+}
+
+/**
+ * Records what a peer reported. `key` is the peer's login on the host side and
+ * the literal "host" on a guest, so a guest holds exactly one aggregated bucket
+ * instead of one per room member.
+ */
+function savePeerSnapshot(projectId, key, snapshot, login) {
+  const clean = sanitize(snapshot, login || key);
+  if (!clean) return null;
+  const memory = loadMemory(projectId);
+  const peers = memory.roomPeers && typeof memory.roomPeers === "object" ? memory.roomPeers : {};
+  const now = Date.now();
+  for (const [name, row] of Object.entries(peers)) {
+    if (now - (row?.updatedAt || 0) > PEER_TTL_MS) delete peers[name];
+  }
+  peers[key] = clean;
+  memory.roomPeers = peers;
+  saveMemory(projectId, memory);
+  require("./falkor/bus").emit("peer", { projectId, key, login: clean.login, snapshot: clean });
+  return clean;
+}
+
+function clearPeers(projectId) {
+  const memory = loadMemory(projectId);
+  if (!memory.roomPeers) return;
+  delete memory.roomPeers;
+  saveMemory(projectId, memory);
+}
+
+function peerSnapshots(memory, { exclude } = {}) {
+  const peers = memory?.roomPeers && typeof memory.roomPeers === "object" ? memory.roomPeers : {};
+  return Object.entries(peers)
+    .filter(([key, row]) => row && key !== exclude && row.login !== exclude)
+    .map(([, row]) => row);
+}
+
+function dedupeById(rows, sortKey) {
+  const byId = new Map();
+  for (const row of rows) {
+    if (!row) continue;
+    const key = row.id || `${row.ownerLogin}:${row.ts || row.updatedAt}`;
+    const existing = byId.get(key);
+    // Two sides of a room can both hold a thread (the guest's own chats come
+    // back inside the host's aggregate). Keep the fuller copy rather than
+    // whichever arrived last, so merging never truncates a conversation.
+    if (!existing || (row.messages?.length || 0) > (existing.messages?.length || 0)) byId.set(key, row);
+  }
+  return [...byId.values()].sort((a, b) => (b[sortKey] || 0) - (a[sortKey] || 0));
+}
+
+// Room snapshots do not ship the raw history array (too large for the tunnel).
+// The Activity tab still reads history, so rebuild peer events from the chats
+// that did cross the wire — otherwise the joiner's feed is empty while Chat
+// and Code edits look fully synced.
+function historyFromChats(chats) {
+  const events = [];
+  for (const thread of chats || []) {
+    (thread.messages || []).forEach((m, i) => {
+      events.push({
+        id: `peer_${thread.ownerLogin || "peer"}_${thread.id}_${m.ts || 0}_${i}`,
+        ts: m.ts || thread.updatedAt || 0,
+        agent: thread.agent,
+        ownerLogin: thread.ownerLogin,
+        sessionId: thread.sessionId,
+        role: m.role,
+        kind: m.kind || "message",
+        text: m.text || "",
+        file: m.file || null,
+        path: m.file || null,
+        diff: "",
+      });
+    });
+  }
+  return events;
+}
+
+function mergeAgents(local, peers) {
+  const agents = [];
+  const seen = new Set();
+  const add = (agent, fallbackOwner) => {
+    if (!agent) return;
+    const ownerLogin = agent.ownerLogin || fallbackOwner || "";
+    const base = String(agent.id || agent.label || "agent")
+      .toLowerCase()
+      .replace(/\s+/g, "-");
+    const key = `${ownerLogin}::${agent.label || base}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    agents.push({
+      ...agent,
+      ownerLogin,
+      id: ownerLogin ? `${ownerLogin}:${base}` : base,
+    });
+  };
+  for (const agent of local || []) add(agent, agent.ownerLogin);
+  for (const peer of peers) {
+    for (const agent of peer.agents || []) add(agent, peer.login);
+  }
+  return agents;
+}
+
+/** Local view + every peer's view, deduped. Used for both the UI and the wire. */
+function mergeRoomViews(memory, opts = {}) {
+  const peers = peerSnapshots(memory, opts);
+  if (!peers.length) {
+    return {
+      chats: memory.chats || [],
+      timeline: memory.timeline || [],
+      activity: memory.activity || [],
+      edits: memory.edits || [],
+      history: memory.history || [],
+      agents: memory.agents || [],
+      peerLogins: [],
+    };
+  }
+  return {
+    chats: dedupeById([...(memory.chats || []), ...peers.flatMap((p) => p.chats || [])], "updatedAt"),
+    timeline: dedupeById([...(memory.timeline || []), ...peers.flatMap((p) => p.timeline || [])], "ts"),
+    activity: dedupeById([...(memory.activity || []), ...peers.flatMap((p) => p.activity || [])], "ts").slice(0, 120),
+    edits: dedupeById([...(memory.edits || []), ...peers.flatMap((p) => p.edits || [])], "ts").slice(0, 400),
+    history: dedupeById(
+      [...(memory.history || []), ...peers.flatMap((p) => historyFromChats(p.chats))],
+      "ts"
+    ).slice(0, 2000),
+    agents: mergeAgents(memory.agents, peers),
+    peerLogins: peers.map((p) => p.login).filter(Boolean),
+  };
+}
+
+module.exports = { localSnapshot, savePeerSnapshot, peerSnapshots, mergeRoomViews, clearPeers };