feat: record meeting join/leave in the chat, like start/end

Joining and leaving a meeting were pure local state (follow/unfollow), so the
meeting chat only ever showed "Started"/"ended" — you couldn't tell from the
minutes who actually attended. Now a joiner's client posts a follow-event
message to the meeting: "Joined the meeting." when they join, "Left the
meeting." when they explicitly leave.

- The signal is `followedSession` (the meeting of the leader a joiner follows);
  the leader is excluded (their arrival is the Start marker).
- A departure is recorded only while the meeting is still live —
  `postMeetingLeave` skips it once `meetingEndedAt` is set, so a leader's End
  doesn't make every follower's auto-unfollow spam "Left" on top of
  "The meeting has ended.".
- sessionStorage (per meeting, cleared on tab close) dedupes across reloads so
  a refresh mid-meeting doesn't re-announce, mirroring the leader's
  `meetingStorageKey`.

Covered by a new two-context e2e ("records join and leave in the meeting
chat"). Also reflows forks.spec.ts, which a path-quirk had skipped in the
earlier format check.

Claude-Session: https://claude.ai/code/session_01VddwtxveM8Zqsf765aQSHY

browser/data-browser/src/components/Presence/FollowContext.tsx

@@ -79,6 +79,39 @@ const FollowContext = createContext<FollowContextValue>({
 const meetingStorageKey = (drive: string): string =>
   `atomic.activeMeeting:${drive}`;
 
+/** sessionStorage key marking that this tab already announced joining a given
+ *  meeting. Per-tab + per-meeting, so a refresh mid-meeting doesn't re-post
+ *  "Joined", but a closed/reopened tab announces again. */
+const joinAnnounceKey = (meeting: string): string =>
+  `atomic.joinedMeeting:${meeting}`;
+
+/** Record that this agent joined a live meeting — the same follow-event trail
+ *  as Start/End, authored by the joiner so the chat shows who arrived. */
+async function postMeetingJoin(store: Store, meeting: string): Promise<void> {
+  await sendChatMessage(store, {
+    parent: meeting,
+    text: /* @wc-ignore */ 'Joined the meeting.',
+    extraClasses: [dataBrowser.classes.followEvent],
+  });
+}
+
+/** Record a departure — but only while the meeting is still live. Once it has
+ *  ended, "The meeting has ended." already closes the log, and every
+ *  follower's auto-unfollow would otherwise post a redundant "Left". */
+async function postMeetingLeave(store: Store, meeting: string): Promise<void> {
+  const resource = await store.getResource(meeting);
+
+  if (resource.get(dataBrowser.properties.meetingEndedAt)) {
+    return;
+  }
+
+  await sendChatMessage(store, {
+    parent: meeting,
+    text: /* @wc-ignore */ 'Left the meeting.',
+    extraClasses: [dataBrowser.classes.followEvent],
+  });
+}
+
 /** Post a trail entry: a plain chat message linking the visited resource. */
 async function postTrailMessage(
   store: Store,
@@ -253,6 +286,34 @@ export function FollowProvider({
       ?.session;
   }, [presence, followedAgent]);
 
+  // Record join/leave in the meeting chat, mirroring Start/End. The leader is
+  // already recorded by the Start marker, so only a *joiner* announces here —
+  // and the meeting a joiner is in is exactly `followedSession`. Announce when
+  // it appears, and a departure when we explicitly leave (unfollow); a meeting
+  // that simply ended is filtered out by `postMeetingLeave` so it doesn't spam
+  // "Left" for every follower on top of "The meeting has ended.".
+  const announcedJoinRef = useRef<string | undefined>(undefined);
+  useEffect(() => {
+    const joined = activeMeeting ? undefined : followedSession;
+    const previous = announcedJoinRef.current;
+
+    if (joined === previous || !agentSubject) {
+      return;
+    }
+
+    announcedJoinRef.current = joined;
+
+    if (previous && sessionStorage.getItem(joinAnnounceKey(previous))) {
+      sessionStorage.removeItem(joinAnnounceKey(previous));
+      void postMeetingLeave(store, previous).catch(() => undefined);
+    }
+
+    if (joined && !sessionStorage.getItem(joinAnnounceKey(joined))) {
+      sessionStorage.setItem(joinAnnounceKey(joined), '1');
+      void postMeetingJoin(store, joined).catch(() => undefined);
+    }
+  }, [activeMeeting, followedSession, agentSubject, store]);
+
   const follow = useCallback((subject: string) => {
     setFollowedAgent(subject);
   }, []);

browser/e2e/tests/forks.spec.ts

@@ -42,7 +42,9 @@ test.describe('forks', () => {
     await page.getByRole('button', { name: 'Merge' }).click();
 
     // Back on the original, now carrying the fork's title, with no fork bar.
-    await expect(page).toHaveURL(new RegExp(encodeURIComponent(originalSubject)));
+    await expect(page).toHaveURL(
+      new RegExp(encodeURIComponent(originalSubject)),
+    );
     await expect(editableTitle(page)).toHaveText('Revised Cheese');
     await expect(page.getByText('Fork of')).toBeHidden();
   });
@@ -83,7 +85,9 @@ test.describe('forks', () => {
     await page.getByRole('button', { name: 'Discard' }).click();
 
     // Back on the original, unchanged, and the fork is gone.
-    await expect(page).toHaveURL(new RegExp(encodeURIComponent(originalSubject)));
+    await expect(page).toHaveURL(
+      new RegExp(encodeURIComponent(originalSubject)),
+    );
     await expect(editableTitle(page)).toHaveText('Keep Me');
     await expect(page.getByText('Fork of')).toBeHidden();
     expect(forkSubject).not.toBe(originalSubject);
@@ -135,7 +139,9 @@ test.describe('forks', () => {
     await mergeButton.click();
 
     // Back on the original, now carrying the fork's body edit, no fork bar.
-    await expect(page).toHaveURL(new RegExp(encodeURIComponent(originalSubject)));
+    await expect(page).toHaveURL(
+      new RegExp(encodeURIComponent(originalSubject)),
+    );
     await expect(page.getByText('Fork of')).toBeHidden();
     await expect(page.getByText('The seed line.')).toBeVisible();
     await expect(page.getByText('Added on the fork.')).toBeVisible();

browser/e2e/tests/meetings.spec.ts

@@ -51,7 +51,9 @@ test('top-bar Meet starts a meeting and opens its panel', async ({ page }) => {
   expect(firstMeeting).not.toBe(initialSubject);
 
   await page.getByRole('button', { name: 'End meeting' }).click();
-  await expect(page.getByText('minutes', { exact: true }).first()).toBeVisible();
+  await expect(
+    page.getByText('minutes', { exact: true }).first(),
+  ).toBeVisible();
   await page
     .getByRole('button', { name: 'Meet', exact: true })
     .click({ timeout: 30_000 });
@@ -103,7 +105,9 @@ test('prepare an agenda, start it, and preserve minutes', async ({ page }) => {
   await expect(page.getByText(agendaText)).toBeVisible();
 
   await page.getByRole('button', { name: 'End meeting' }).click();
-  await expect(page.getByText('minutes', { exact: true }).first()).toBeVisible();
+  await expect(
+    page.getByText('minutes', { exact: true }).first(),
+  ).toBeVisible();
   await expect(page.getByText(agendaText)).toBeVisible();
 });
 
@@ -217,10 +221,73 @@ test('start a meeting, join it, follow along, and end it', async ({
     .getByTestId('follow-session-panel')
     .getByRole('link', { name: 'Open notes' })
     .click();
-  await expect(pageA.getByText('minutes', { exact: true }).first()).toBeVisible({
+  await expect(pageA.getByText('minutes', { exact: true }).first()).toBeVisible(
+    {
+      timeout: 30_000,
+    },
+  );
+  await expect(meetingBanner(pageB)).toHaveCount(0, { timeout: 30_000 });
+
+  await ctxA.close();
+  await ctxB.close();
+});
+
+test('records join and leave in the meeting chat', async ({ browser }) => {
+  test.setTimeout(120_000);
+
+  // Leader A on the dev drive.
+  const ctxA = await browser.newContext();
+  const pageA = await ctxA.newPage();
+  await before({ page: pageA });
+  await pageA.waitForLoadState('load');
+  const drive = await pageA.evaluate(() => window.store.getDrive());
+  const secret = await getDevDriveSecret(pageA);
+  await pageA.goto(
+    `${FRONTEND_URL}/app/show?subject=${encodeURIComponent(drive!)}`,
+  );
+
+  // Follower B: same agent, fresh context (no leader state of its own).
+  const ctxB = await browser.newContext();
+  const pageB = await ctxB.newPage();
+  await pageB.goto(FRONTEND_URL);
+  await signIn(pageB, secret);
+  await pageB.goto(
+    `${FRONTEND_URL}/app/show?subject=${encodeURIComponent(drive!)}`,
+  );
+
+  // Presence is live between the two sessions.
+  await expect(facepile(pageB).getByRole('button').first()).toBeVisible({
+    timeout: 30_000,
+  });
+
+  // A starts a meeting; its chat panel opens.
+  await pageA.getByRole('button', { name: 'More' }).click();
+  await pageA.getByTestId('menu-item-meeting').click();
+  const leaderPanel = pageA.getByTestId('follow-session-panel');
+  await expect(leaderPanel).toHaveAttribute('data-open', '', {
+    timeout: 30_000,
+  });
+
+  // B joins from the top-bar banner.
+  await expect(joinBanner(pageB)).toBeVisible({ timeout: 30_000 });
+  await joinBanner(pageB).click();
+  const followerPanel = pageB.getByTestId('follow-session-panel');
+  await expect(followerPanel.getByText('Started the meeting.')).toBeVisible({
+    timeout: 30_000,
+  });
+
+  // Joining is recorded as a follow-event, and syncs to the leader's chat.
+  await expect(leaderPanel.getByText('Joined the meeting.')).toBeVisible({
+    timeout: 30_000,
+  });
+
+  // B leaves from the panel header while the meeting is still live.
+  await pageB.getByRole('button', { name: 'Leave', exact: true }).click();
+
+  // Leaving is recorded too (it is filtered only when the meeting has ended).
+  await expect(leaderPanel.getByText('Left the meeting.')).toBeVisible({
     timeout: 30_000,
   });
-  await expect(meetingBanner(pageB)).toHaveCount(0, { timeout: 30_000 });
 
   await ctxA.close();
   await ctxB.close();