From 4e2aeddb69789a558c0989b15c757bb82de96482 Mon Sep 17 00:00:00 2001
From: Void <void@minds.void.gamecult.org>
Date: Fri, 6 Nov 2026 13:39:29 +0000
Subject: [PATCH 1/5] auth: training notice on login and registration;
 registration needs an acknowledgement

One TrainingNotice component above the submit button on both screens. Login
shows the notice only; registration adds a ticked checkbox that gates the
Register button.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 src/app/pages/auth/TrainingNotice.tsx         | 45 +++++++++++++++++++
 .../pages/auth/login/PasswordLoginForm.tsx    |  2 +
 .../auth/register/PasswordRegisterForm.tsx    | 10 ++++-
 3 files changed, 56 insertions(+), 1 deletion(-)
 create mode 100644 src/app/pages/auth/TrainingNotice.tsx

diff --git a/src/app/pages/auth/TrainingNotice.tsx b/src/app/pages/auth/TrainingNotice.tsx
new file mode 100644
index 00000000..28847e4f
--- /dev/null
+++ b/src/app/pages/auth/TrainingNotice.tsx
@@ -0,0 +1,45 @@
+import { Box, Checkbox, Text, color, config } from 'folds';
+import React from 'react';
+
+export const TRAINING_NOTICE =
+  "Everything said on this server may be used to train GameCult's AI stewards. We never ingest Discord content.";
+
+type TrainingNoticeProps = {
+  // Registration passes this to require a ticked acknowledgement; login shows the notice only.
+  acknowledge?: { checked: boolean; onToggle: () => void };
+};
+
+export function TrainingNotice({ acknowledge }: TrainingNoticeProps) {
+  return (
+    <Box
+      direction="Column"
+      gap="200"
+      style={{
+        padding: config.space.S300,
+        borderRadius: config.radii.R300,
+        backgroundColor: color.SurfaceVariant.Container,
+        color: color.SurfaceVariant.OnContainer,
+        border: `${config.borderWidth.B300} solid ${color.SurfaceVariant.ContainerLine}`,
+      }}
+    >
+      <Text size="T300">{TRAINING_NOTICE}</Text>
+      {acknowledge && (
+        <Text
+          as="label"
+          size="T300"
+          style={{ display: 'flex', alignItems: 'center', gap: config.space.S200 }}
+        >
+          <Checkbox
+            name="trainingAck"
+            size="300"
+            variant="Primary"
+            required
+            checked={acknowledge.checked}
+            onClick={acknowledge.onToggle}
+          />
+          I understand and agree.
+        </Text>
+      )}
+    </Box>
+  );
+}
diff --git a/src/app/pages/auth/login/PasswordLoginForm.tsx b/src/app/pages/auth/login/PasswordLoginForm.tsx
index 3c8641d9..6ad6e1b0 100644
--- a/src/app/pages/auth/login/PasswordLoginForm.tsx
+++ b/src/app/pages/auth/login/PasswordLoginForm.tsx
@@ -35,6 +35,7 @@ import {
 } from './loginUtil';
 import { PasswordInput } from '../../../components/password-input';
 import { FieldError } from '../FiledError';
+import { TrainingNotice } from '../TrainingNotice';
 import { getResetPasswordPath } from '../../pathUtils';
 import { stopPropagation } from '../../../utils/keyboard';
 
@@ -255,6 +256,7 @@ export function PasswordLoginForm({ defaultUsername, defaultEmail }: PasswordLog
           </Box>
         </Box>
       </Box>
+      <TrainingNotice />
       <Button type="submit" variant="Primary" size="500">
         <Text as="span" size="B500">
           Login
diff --git a/src/app/pages/auth/register/PasswordRegisterForm.tsx b/src/app/pages/auth/register/PasswordRegisterForm.tsx
index c9b1924c..c48c53cf 100644
--- a/src/app/pages/auth/register/PasswordRegisterForm.tsx
+++ b/src/app/pages/auth/register/PasswordRegisterForm.tsx
@@ -32,6 +32,7 @@ import { AsyncState, AsyncStatus, useAsyncCallback } from '../../../hooks/useAsy
 import { useAutoDiscoveryInfo } from '../../../hooks/useAutoDiscoveryInfo';
 import { RegisterError, RegisterResult, register, useRegisterComplete } from './registerUtil';
 import { FieldError } from '../FiledError';
+import { TrainingNotice } from '../TrainingNotice';
 import {
   AutoDummyStageDialog,
   AutoTermsStageDialog,
@@ -192,6 +193,7 @@ export function PasswordRegisterForm({
   const [formData, setFormData] = useState<FormData>();
 
   const [ongoingFlow, setOngoingFlow] = useState<UIAFlow>();
+  const [trainingAck, setTrainingAck] = useState(false);
 
   const [registerEmailState, registerEmail] = useRegisterEmail(mx);
 
@@ -389,7 +391,13 @@ export function PasswordRegisterForm({
           <FieldError message={registerError.data.error ?? 'Failed to register. Unknown Reason.'} />
         )}
         <span data-spacing-node />
-        <Button variant="Primary" size="500" type="submit">
+        <TrainingNotice
+          acknowledge={{
+            checked: trainingAck,
+            onToggle: () => setTrainingAck((ack) => !ack),
+          }}
+        />
+        <Button variant="Primary" size="500" type="submit" disabled={!trainingAck}>
           <Text as="span" size="B500">
             Register
           </Text>
-- 
2.47.3


From e38ebda1c54c59ac2a4f4613aced928c4e08152c Mon Sep 17 00:00:00 2001
From: Void <void@minds.void.gamecult.org>
Date: Fri, 6 Nov 2026 19:52:07 +0000
Subject: [PATCH 2/5] auth: training notice at registration only, versioned;
 one train line per room

Login no longer shows the notice. Registration shows the ruled sentence with a
plain tick, and records {noticeVersion, acceptedAt} on submit (newcomers only;
a changed TRAINING_NOTICE_VERSION is a fresh acceptance). Each room carries one
line above the composer. The Discord sentence and "on this server" are gone.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 src/app/features/room/RoomTrainingLine.tsx    | 15 ++++++
 src/app/features/room/RoomView.tsx            |  2 +
 src/app/pages/auth/TrainingNotice.tsx         | 44 ++++++++--------
 .../pages/auth/login/PasswordLoginForm.tsx    |  2 -
 .../auth/register/PasswordRegisterForm.tsx    |  9 ++--
 src/app/utils/trainingNotice.test.ts          | 51 +++++++++++++++++++
 src/app/utils/trainingNotice.ts               | 43 ++++++++++++++++
 7 files changed, 134 insertions(+), 32 deletions(-)
 create mode 100644 src/app/features/room/RoomTrainingLine.tsx
 create mode 100644 src/app/utils/trainingNotice.test.ts
 create mode 100644 src/app/utils/trainingNotice.ts

diff --git a/src/app/features/room/RoomTrainingLine.tsx b/src/app/features/room/RoomTrainingLine.tsx
new file mode 100644
index 00000000..21877c3a
--- /dev/null
+++ b/src/app/features/room/RoomTrainingLine.tsx
@@ -0,0 +1,15 @@
+import { Text, color, config } from 'folds';
+import React from 'react';
+import { TRAINING_NOTICE_TEXT } from '../../utils/trainingNotice';
+
+// One line per room, pinned above the composer.
+export function RoomTrainingLine() {
+  return (
+    <Text
+      size="T200"
+      style={{ padding: `${config.space.S100} 0`, color: color.SurfaceVariant.OnContainer }}
+    >
+      {TRAINING_NOTICE_TEXT}
+    </Text>
+  );
+}
diff --git a/src/app/features/room/RoomView.tsx b/src/app/features/room/RoomView.tsx
index a4f0d7af..6e2a315a 100644
--- a/src/app/features/room/RoomView.tsx
+++ b/src/app/features/room/RoomView.tsx
@@ -13,6 +13,7 @@ import { RoomTimeline } from './RoomTimeline';
 import { RoomViewTyping } from './RoomViewTyping';
 import { RoomTombstone } from './RoomTombstone';
 import { RoomInput } from './RoomInput';
+import { RoomTrainingLine } from './RoomTrainingLine';
 import { RoomViewFollowing, RoomViewFollowingPlaceholder } from './RoomViewFollowing';
 import { Page } from '../../components/page';
 import { useKeyDown } from '../../hooks/useKeyDown';
@@ -104,6 +105,7 @@ export function RoomView({ eventId }: { eventId?: string }) {
       </Box>
       <Box shrink="No" direction="Column">
         <div style={{ padding: `0 ${config.space.S400}` }}>
+          <RoomTrainingLine />
           {tombstoneEvent ? (
             <RoomTombstone
               roomId={roomId}
diff --git a/src/app/pages/auth/TrainingNotice.tsx b/src/app/pages/auth/TrainingNotice.tsx
index 28847e4f..73b1caa0 100644
--- a/src/app/pages/auth/TrainingNotice.tsx
+++ b/src/app/pages/auth/TrainingNotice.tsx
@@ -1,15 +1,14 @@
 import { Box, Checkbox, Text, color, config } from 'folds';
 import React from 'react';
-
-export const TRAINING_NOTICE =
-  "Everything said on this server may be used to train GameCult's AI stewards. We never ingest Discord content.";
+import { TRAINING_NOTICE_TEXT } from '../../utils/trainingNotice';
 
 type TrainingNoticeProps = {
-  // Registration passes this to require a ticked acknowledgement; login shows the notice only.
-  acknowledge?: { checked: boolean; onToggle: () => void };
+  checked: boolean;
+  onToggle: () => void;
 };
 
-export function TrainingNotice({ acknowledge }: TrainingNoticeProps) {
+// Registration only: ticking it is the newcomer's acceptance of the current notice version.
+export function TrainingNotice({ checked, onToggle }: TrainingNoticeProps) {
   return (
     <Box
       direction="Column"
@@ -22,24 +21,21 @@ export function TrainingNotice({ acknowledge }: TrainingNoticeProps) {
         border: `${config.borderWidth.B300} solid ${color.SurfaceVariant.ContainerLine}`,
       }}
     >
-      <Text size="T300">{TRAINING_NOTICE}</Text>
-      {acknowledge && (
-        <Text
-          as="label"
-          size="T300"
-          style={{ display: 'flex', alignItems: 'center', gap: config.space.S200 }}
-        >
-          <Checkbox
-            name="trainingAck"
-            size="300"
-            variant="Primary"
-            required
-            checked={acknowledge.checked}
-            onClick={acknowledge.onToggle}
-          />
-          I understand and agree.
-        </Text>
-      )}
+      <Text
+        as="label"
+        size="T300"
+        style={{ display: 'flex', alignItems: 'center', gap: config.space.S200 }}
+      >
+        <Checkbox
+          name="trainingAck"
+          size="300"
+          variant="Primary"
+          required
+          checked={checked}
+          onClick={onToggle}
+        />
+        {TRAINING_NOTICE_TEXT}
+      </Text>
     </Box>
   );
 }
diff --git a/src/app/pages/auth/login/PasswordLoginForm.tsx b/src/app/pages/auth/login/PasswordLoginForm.tsx
index 6ad6e1b0..3c8641d9 100644
--- a/src/app/pages/auth/login/PasswordLoginForm.tsx
+++ b/src/app/pages/auth/login/PasswordLoginForm.tsx
@@ -35,7 +35,6 @@ import {
 } from './loginUtil';
 import { PasswordInput } from '../../../components/password-input';
 import { FieldError } from '../FiledError';
-import { TrainingNotice } from '../TrainingNotice';
 import { getResetPasswordPath } from '../../pathUtils';
 import { stopPropagation } from '../../../utils/keyboard';
 
@@ -256,7 +255,6 @@ export function PasswordLoginForm({ defaultUsername, defaultEmail }: PasswordLog
           </Box>
         </Box>
       </Box>
-      <TrainingNotice />
       <Button type="submit" variant="Primary" size="500">
         <Text as="span" size="B500">
           Login
diff --git a/src/app/pages/auth/register/PasswordRegisterForm.tsx b/src/app/pages/auth/register/PasswordRegisterForm.tsx
index c48c53cf..f11e6240 100644
--- a/src/app/pages/auth/register/PasswordRegisterForm.tsx
+++ b/src/app/pages/auth/register/PasswordRegisterForm.tsx
@@ -33,6 +33,7 @@ import { useAutoDiscoveryInfo } from '../../../hooks/useAutoDiscoveryInfo';
 import { RegisterError, RegisterResult, register, useRegisterComplete } from './registerUtil';
 import { FieldError } from '../FiledError';
 import { TrainingNotice } from '../TrainingNotice';
+import { recordNoticeAcceptance } from '../../../utils/trainingNotice';
 import {
   AutoDummyStageDialog,
   AutoTermsStageDialog,
@@ -242,6 +243,7 @@ export function PasswordRegisterForm({
       terms,
       clientSecret: mx.generateClientSecret(),
     };
+    recordNoticeAcceptance(localStorage);
     const pickedStages = pickStages(uiaFlows, fData);
     const pickedFlow = getUIAFlowForStages(uiaFlows, pickedStages);
     setOngoingFlow(pickedFlow);
@@ -391,12 +393,7 @@ export function PasswordRegisterForm({
           <FieldError message={registerError.data.error ?? 'Failed to register. Unknown Reason.'} />
         )}
         <span data-spacing-node />
-        <TrainingNotice
-          acknowledge={{
-            checked: trainingAck,
-            onToggle: () => setTrainingAck((ack) => !ack),
-          }}
-        />
+        <TrainingNotice checked={trainingAck} onToggle={() => setTrainingAck((ack) => !ack)} />
         <Button variant="Primary" size="500" type="submit" disabled={!trainingAck}>
           <Text as="span" size="B500">
             Register
diff --git a/src/app/utils/trainingNotice.test.ts b/src/app/utils/trainingNotice.test.ts
new file mode 100644
index 00000000..7890a005
--- /dev/null
+++ b/src/app/utils/trainingNotice.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import {
+  TRAINING_NOTICE_TEXT,
+  TRAINING_NOTICE_VERSION,
+  getNoticeAcceptance,
+  needsFreshAcceptance,
+  recordNoticeAcceptance,
+} from './trainingNotice';
+
+const memoryStorage = () => {
+  const data = new Map<string, string>();
+  return {
+    getItem: (k: string) => data.get(k) ?? null,
+    setItem: (k: string, v: string) => void data.set(k, v),
+  };
+};
+
+describe('training notice', () => {
+  it('says exactly the ruled sentence and never mentions Discord', () => {
+    expect(TRAINING_NOTICE_TEXT).toBe(
+      "Everything said here may be used to train GameCult's AI stewards."
+    );
+    expect(TRAINING_NOTICE_TEXT.toLowerCase()).not.toContain('discord');
+  });
+
+  it('records the current version and time on acceptance', () => {
+    const storage = memoryStorage();
+    recordNoticeAcceptance(storage, new Date('2026-11-06T20:00:00Z'));
+    expect(getNoticeAcceptance(storage)).toEqual({
+      noticeVersion: TRAINING_NOTICE_VERSION,
+      acceptedAt: '2026-11-06T20:00:00.000Z',
+    });
+    expect(needsFreshAcceptance(storage)).toBe(false);
+  });
+
+  it('asks again when the notice version changes', () => {
+    const storage = memoryStorage();
+    recordNoticeAcceptance(storage, new Date(), TRAINING_NOTICE_VERSION);
+    expect(needsFreshAcceptance(storage, TRAINING_NOTICE_VERSION + 1)).toBe(true);
+  });
+
+  it('does not re-ask members who never registered here (no record)', () => {
+    expect(needsFreshAcceptance(memoryStorage())).toBe(false);
+  });
+
+  it('treats a corrupt record as none', () => {
+    const storage = memoryStorage();
+    storage.setItem('trainingNoticeAcceptance', '{nope');
+    expect(getNoticeAcceptance(storage)).toBeUndefined();
+  });
+});
diff --git a/src/app/utils/trainingNotice.ts b/src/app/utils/trainingNotice.ts
new file mode 100644
index 00000000..709476b9
--- /dev/null
+++ b/src/app/utils/trainingNotice.ts
@@ -0,0 +1,43 @@
+export const TRAINING_NOTICE_TEXT =
+  "Everything said here may be used to train GameCult's AI stewards.";
+
+// Any change to the wording or scope is a new version, and a new version needs a fresh acceptance.
+export const TRAINING_NOTICE_VERSION = 1;
+
+const ACCEPTANCE_KEY = 'trainingNoticeAcceptance';
+
+export type NoticeAcceptance = { noticeVersion: number; acceptedAt: string };
+
+type NoticeStorage = Pick<Storage, 'getItem' | 'setItem'>;
+
+/** Written at registration only, so only newcomers have one; earlier members are never re-asked. */
+export const recordNoticeAcceptance = (
+  storage: NoticeStorage,
+  now: Date = new Date(),
+  noticeVersion: number = TRAINING_NOTICE_VERSION
+): NoticeAcceptance => {
+  const acceptance = { noticeVersion, acceptedAt: now.toISOString() };
+  storage.setItem(ACCEPTANCE_KEY, JSON.stringify(acceptance));
+  return acceptance;
+};
+
+export const getNoticeAcceptance = (storage: NoticeStorage): NoticeAcceptance | undefined => {
+  try {
+    const parsed = JSON.parse(storage.getItem(ACCEPTANCE_KEY) ?? 'null');
+    if (typeof parsed?.noticeVersion === 'number' && typeof parsed?.acceptedAt === 'string') {
+      return parsed;
+    }
+  } catch {
+    // unreadable record counts as none
+  }
+  return undefined;
+};
+
+/** True when a newcomer's recorded acceptance is for an older notice version and must be renewed. */
+export const needsFreshAcceptance = (
+  storage: NoticeStorage,
+  currentVersion: number = TRAINING_NOTICE_VERSION
+): boolean => {
+  const accepted = getNoticeAcceptance(storage);
+  return accepted !== undefined && accepted.noticeVersion !== currentVersion;
+};
-- 
2.47.3


From 3fcf1cf9dd441260f2609e8df4e2d1826cf48d24 Mon Sep 17 00:00:00 2001
From: Void <void@minds.void.gamecult.org>
Date: Fri, 6 Nov 2026 22:27:47 +0000
Subject: [PATCH 3/5] auth: train line comes from the room's pinned notice;
 drop browser-side acceptance

The collector reads the notice version from the room's pinned notice and takes
the member's first reply as the acceptance (Heimdall answer-collector-consent.md),
so a localStorage record at registration was a second, unread copy. Deleted it
and its unused re-ask helpers. RoomTrainingLine now reads the room's own pinned
notice and shows the train sentence only where that notice declares train; no
notice, no line (DMs included). The pinned event's encoding is not fixed by the
doc; the key is provisional and isolated in trainingNotice.ts.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 src/app/features/room/RoomTrainingLine.tsx    | 45 +++++++++++++--
 src/app/features/room/RoomView.tsx            |  2 +-
 .../auth/register/PasswordRegisterForm.tsx    |  2 -
 src/app/utils/trainingNotice.test.ts          | 49 ++++++----------
 src/app/utils/trainingNotice.ts               | 57 ++++++++-----------
 5 files changed, 80 insertions(+), 75 deletions(-)

diff --git a/src/app/features/room/RoomTrainingLine.tsx b/src/app/features/room/RoomTrainingLine.tsx
index 21877c3a..8855f0ff 100644
--- a/src/app/features/room/RoomTrainingLine.tsx
+++ b/src/app/features/room/RoomTrainingLine.tsx
@@ -1,15 +1,50 @@
 import { Text, color, config } from 'folds';
-import React from 'react';
-import { TRAINING_NOTICE_TEXT } from '../../utils/trainingNotice';
+import { Room } from 'matrix-js-sdk';
+import React, { useEffect, useState } from 'react';
+import { useMatrixClient } from '../../hooks/useMatrixClient';
+import { useRoomPinnedEvents } from '../../hooks/useRoomPinnedEvents';
+import { RoomNotice, parseRoomNotice, roomTrainingLine } from '../../utils/trainingNotice';
 
-// One line per room, pinned above the composer.
-export function RoomTrainingLine() {
+// The room's own pinned notice decides the line, newest pin first; no notice, no line. The version
+// is read by the collector from the same pinned event, so nothing is stored in the browser.
+const useRoomNotice = (room: Room): RoomNotice | undefined => {
+  const mx = useMatrixClient();
+  const pinned = useRoomPinnedEvents(room);
+  const [notice, setNotice] = useState<RoomNotice>();
+
+  useEffect(() => {
+    let live = true;
+    setNotice(undefined);
+    (async () => {
+      for (let i = pinned.length - 1; i >= 0; i -= 1) {
+        const id = pinned[i];
+        const local = room.findEventById(id)?.getContent();
+        // eslint-disable-next-line no-await-in-loop
+        const content = local ?? (await mx.fetchRoomEvent(room.roomId, id).catch(() => undefined))?.content;
+        const found = parseRoomNotice(content);
+        if (found) {
+          if (live) setNotice(found);
+          return;
+        }
+      }
+    })();
+    return () => {
+      live = false;
+    };
+  }, [mx, room, pinned]);
+
+  return notice;
+};
+
+export function RoomTrainingLine({ room }: { room: Room }) {
+  const line = roomTrainingLine(useRoomNotice(room));
+  if (!line) return null;
   return (
     <Text
       size="T200"
       style={{ padding: `${config.space.S100} 0`, color: color.SurfaceVariant.OnContainer }}
     >
-      {TRAINING_NOTICE_TEXT}
+      {line}
     </Text>
   );
 }
diff --git a/src/app/features/room/RoomView.tsx b/src/app/features/room/RoomView.tsx
index 6e2a315a..3fbd81fa 100644
--- a/src/app/features/room/RoomView.tsx
+++ b/src/app/features/room/RoomView.tsx
@@ -105,7 +105,7 @@ export function RoomView({ eventId }: { eventId?: string }) {
       </Box>
       <Box shrink="No" direction="Column">
         <div style={{ padding: `0 ${config.space.S400}` }}>
-          <RoomTrainingLine />
+          <RoomTrainingLine room={room} />
           {tombstoneEvent ? (
             <RoomTombstone
               roomId={roomId}
diff --git a/src/app/pages/auth/register/PasswordRegisterForm.tsx b/src/app/pages/auth/register/PasswordRegisterForm.tsx
index f11e6240..99feed1a 100644
--- a/src/app/pages/auth/register/PasswordRegisterForm.tsx
+++ b/src/app/pages/auth/register/PasswordRegisterForm.tsx
@@ -33,7 +33,6 @@ import { useAutoDiscoveryInfo } from '../../../hooks/useAutoDiscoveryInfo';
 import { RegisterError, RegisterResult, register, useRegisterComplete } from './registerUtil';
 import { FieldError } from '../FiledError';
 import { TrainingNotice } from '../TrainingNotice';
-import { recordNoticeAcceptance } from '../../../utils/trainingNotice';
 import {
   AutoDummyStageDialog,
   AutoTermsStageDialog,
@@ -243,7 +242,6 @@ export function PasswordRegisterForm({
       terms,
       clientSecret: mx.generateClientSecret(),
     };
-    recordNoticeAcceptance(localStorage);
     const pickedStages = pickStages(uiaFlows, fData);
     const pickedFlow = getUIAFlowForStages(uiaFlows, pickedStages);
     setOngoingFlow(pickedFlow);
diff --git a/src/app/utils/trainingNotice.test.ts b/src/app/utils/trainingNotice.test.ts
index 7890a005..c3b03a24 100644
--- a/src/app/utils/trainingNotice.test.ts
+++ b/src/app/utils/trainingNotice.test.ts
@@ -1,19 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import {
+  ROOM_NOTICE_CONTENT_KEY,
   TRAINING_NOTICE_TEXT,
-  TRAINING_NOTICE_VERSION,
-  getNoticeAcceptance,
-  needsFreshAcceptance,
-  recordNoticeAcceptance,
+  parseRoomNotice,
+  roomTrainingLine,
 } from './trainingNotice';
 
-const memoryStorage = () => {
-  const data = new Map<string, string>();
-  return {
-    getItem: (k: string) => data.get(k) ?? null,
-    setItem: (k: string, v: string) => void data.set(k, v),
-  };
-};
+const pinned = (notice: unknown) => ({ body: 'sample', [ROOM_NOTICE_CONTENT_KEY]: notice });
 
 describe('training notice', () => {
   it('says exactly the ruled sentence and never mentions Discord', () => {
@@ -23,29 +16,19 @@ describe('training notice', () => {
     expect(TRAINING_NOTICE_TEXT.toLowerCase()).not.toContain('discord');
   });
 
-  it('records the current version and time on acceptance', () => {
-    const storage = memoryStorage();
-    recordNoticeAcceptance(storage, new Date('2026-11-06T20:00:00Z'));
-    expect(getNoticeAcceptance(storage)).toEqual({
-      noticeVersion: TRAINING_NOTICE_VERSION,
-      acceptedAt: '2026-11-06T20:00:00.000Z',
-    });
-    expect(needsFreshAcceptance(storage)).toBe(false);
+  it('shows the train line only where the room declares train', () => {
+    const train = parseRoomNotice(pinned({ version: 2, scope: 'train' }));
+    expect(train).toEqual({ version: 2, scope: 'train' });
+    expect(roomTrainingLine(train)).toBe(TRAINING_NOTICE_TEXT);
+    expect(roomTrainingLine(parseRoomNotice(pinned({ version: 1, scope: 'study' })))).toBeUndefined();
+    expect(roomTrainingLine(parseRoomNotice(pinned({ version: 1, scope: 'show' })))).toBeUndefined();
   });
 
-  it('asks again when the notice version changes', () => {
-    const storage = memoryStorage();
-    recordNoticeAcceptance(storage, new Date(), TRAINING_NOTICE_VERSION);
-    expect(needsFreshAcceptance(storage, TRAINING_NOTICE_VERSION + 1)).toBe(true);
-  });
-
-  it('does not re-ask members who never registered here (no record)', () => {
-    expect(needsFreshAcceptance(memoryStorage())).toBe(false);
-  });
-
-  it('treats a corrupt record as none', () => {
-    const storage = memoryStorage();
-    storage.setItem('trainingNoticeAcceptance', '{nope');
-    expect(getNoticeAcceptance(storage)).toBeUndefined();
+  it('shows nothing where no notice is declared, and never infers train', () => {
+    expect(roomTrainingLine(undefined)).toBeUndefined();
+    expect(parseRoomNotice({ body: 'plain message' })).toBeUndefined();
+    expect(parseRoomNotice(pinned({ scope: 'train' }))).toBeUndefined();
+    expect(parseRoomNotice(pinned({ version: 0, scope: 'train' }))).toBeUndefined();
+    expect(parseRoomNotice(pinned({ version: 1, scope: 'everything' }))).toBeUndefined();
   });
 });
diff --git a/src/app/utils/trainingNotice.ts b/src/app/utils/trainingNotice.ts
index 709476b9..c5cd7aa1 100644
--- a/src/app/utils/trainingNotice.ts
+++ b/src/app/utils/trainingNotice.ts
@@ -1,43 +1,32 @@
 export const TRAINING_NOTICE_TEXT =
   "Everything said here may be used to train GameCult's AI stewards.";
 
-// Any change to the wording or scope is a new version, and a new version needs a fresh acceptance.
-export const TRAINING_NOTICE_VERSION = 1;
+/**
+ * Where a room declares its notice. Heimdall's answer-collector-consent.md says the notice is pinned
+ * with the sample and carries `notice_version` and a scope, but does not fix the pinned event's
+ * encoding; this key is this client's provisional reading of it, and the one place to change.
+ */
+export const ROOM_NOTICE_CONTENT_KEY = 'org.gamecult.notice';
 
-const ACCEPTANCE_KEY = 'trainingNoticeAcceptance';
+export type RoomNotice = { version: number; scope: 'show' | 'study' | 'train' };
 
-export type NoticeAcceptance = { noticeVersion: number; acceptedAt: string };
-
-type NoticeStorage = Pick<Storage, 'getItem' | 'setItem'>;
-
-/** Written at registration only, so only newcomers have one; earlier members are never re-asked. */
-export const recordNoticeAcceptance = (
-  storage: NoticeStorage,
-  now: Date = new Date(),
-  noticeVersion: number = TRAINING_NOTICE_VERSION
-): NoticeAcceptance => {
-  const acceptance = { noticeVersion, acceptedAt: now.toISOString() };
-  storage.setItem(ACCEPTANCE_KEY, JSON.stringify(acceptance));
-  return acceptance;
-};
-
-export const getNoticeAcceptance = (storage: NoticeStorage): NoticeAcceptance | undefined => {
-  try {
-    const parsed = JSON.parse(storage.getItem(ACCEPTANCE_KEY) ?? 'null');
-    if (typeof parsed?.noticeVersion === 'number' && typeof parsed?.acceptedAt === 'string') {
-      return parsed;
-    }
-  } catch {
-    // unreadable record counts as none
+/** The notice a pinned event declares, or undefined: no scope is ever inferred. */
+export const parseRoomNotice = (content: unknown): RoomNotice | undefined => {
+  const raw = (content as Record<string, unknown> | undefined)?.[ROOM_NOTICE_CONTENT_KEY] as
+    | { version?: unknown; scope?: unknown }
+    | undefined;
+  if (
+    raw &&
+    typeof raw.version === 'number' &&
+    Number.isInteger(raw.version) &&
+    raw.version > 0 &&
+    (raw.scope === 'show' || raw.scope === 'study' || raw.scope === 'train')
+  ) {
+    return { version: raw.version, scope: raw.scope };
   }
   return undefined;
 };
 
-/** True when a newcomer's recorded acceptance is for an older notice version and must be renewed. */
-export const needsFreshAcceptance = (
-  storage: NoticeStorage,
-  currentVersion: number = TRAINING_NOTICE_VERSION
-): boolean => {
-  const accepted = getNoticeAcceptance(storage);
-  return accepted !== undefined && accepted.noticeVersion !== currentVersion;
-};
+/** The line a room shows: only a notice that says `train` in terms gets the train sentence. */
+export const roomTrainingLine = (notice: RoomNotice | undefined): string | undefined =>
+  notice?.scope === 'train' ? TRAINING_NOTICE_TEXT : undefined;
-- 
2.47.3


From c2673a698d36550385de9b47da48a44646b7737a Mon Sep 17 00:00:00 2001
From: Void <void@minds.void.gamecult.org>
Date: Fri, 6 Nov 2026 23:30:54 +0000
Subject: [PATCH 4/5] auth: a room's notice is a state event
 (org.gamecult.notice), not a pinned message

Heimdall's ruling: type org.gamecult.notice, state_key '', content {version, scope}.
version is a positive integer, scope exactly show, study or train; absent or
malformed means no train line. ROOM_NOTICE_CONTENT_KEY becomes
ROOM_NOTICE_EVENT_TYPE; RoomTrainingLine reads the state event through useStateEvent.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 src/app/features/room/RoomTrainingLine.tsx | 47 +++++---------------
 src/app/utils/trainingNotice.test.ts       | 51 ++++++++++++++++------
 src/app/utils/trainingNotice.ts            | 28 ++++++------
 src/types/matrix/room.ts                   |  1 +
 4 files changed, 63 insertions(+), 64 deletions(-)

diff --git a/src/app/features/room/RoomTrainingLine.tsx b/src/app/features/room/RoomTrainingLine.tsx
index 8855f0ff..147932de 100644
--- a/src/app/features/room/RoomTrainingLine.tsx
+++ b/src/app/features/room/RoomTrainingLine.tsx
@@ -1,43 +1,18 @@
 import { Text, color, config } from 'folds';
 import { Room } from 'matrix-js-sdk';
-import React, { useEffect, useState } from 'react';
-import { useMatrixClient } from '../../hooks/useMatrixClient';
-import { useRoomPinnedEvents } from '../../hooks/useRoomPinnedEvents';
-import { RoomNotice, parseRoomNotice, roomTrainingLine } from '../../utils/trainingNotice';
-
-// The room's own pinned notice decides the line, newest pin first; no notice, no line. The version
-// is read by the collector from the same pinned event, so nothing is stored in the browser.
-const useRoomNotice = (room: Room): RoomNotice | undefined => {
-  const mx = useMatrixClient();
-  const pinned = useRoomPinnedEvents(room);
-  const [notice, setNotice] = useState<RoomNotice>();
-
-  useEffect(() => {
-    let live = true;
-    setNotice(undefined);
-    (async () => {
-      for (let i = pinned.length - 1; i >= 0; i -= 1) {
-        const id = pinned[i];
-        const local = room.findEventById(id)?.getContent();
-        // eslint-disable-next-line no-await-in-loop
-        const content = local ?? (await mx.fetchRoomEvent(room.roomId, id).catch(() => undefined))?.content;
-        const found = parseRoomNotice(content);
-        if (found) {
-          if (live) setNotice(found);
-          return;
-        }
-      }
-    })();
-    return () => {
-      live = false;
-    };
-  }, [mx, room, pinned]);
-
-  return notice;
-};
+import React from 'react';
+import { useStateEvent } from '../../hooks/useStateEvent';
+import {
+  ROOM_NOTICE_EVENT_TYPE,
+  parseRoomNotice,
+  roomTrainingLine,
+} from '../../utils/trainingNotice';
 
+// The room's notice state event decides the line; no event, or a malformed one, no line. The
+// collector reads the version from the same event, so nothing is stored in the browser.
 export function RoomTrainingLine({ room }: { room: Room }) {
-  const line = roomTrainingLine(useRoomNotice(room));
+  const event = useStateEvent(room, ROOM_NOTICE_EVENT_TYPE);
+  const line = roomTrainingLine(parseRoomNotice(event?.getContent()));
   if (!line) return null;
   return (
     <Text
diff --git a/src/app/utils/trainingNotice.test.ts b/src/app/utils/trainingNotice.test.ts
index c3b03a24..ccf56435 100644
--- a/src/app/utils/trainingNotice.test.ts
+++ b/src/app/utils/trainingNotice.test.ts
@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import {
-  ROOM_NOTICE_CONTENT_KEY,
+  ROOM_NOTICE_EVENT_TYPE,
   TRAINING_NOTICE_TEXT,
   parseRoomNotice,
   roomTrainingLine,
 } from './trainingNotice';
 
-const pinned = (notice: unknown) => ({ body: 'sample', [ROOM_NOTICE_CONTENT_KEY]: notice });
+const lineFor = (content: unknown) => roomTrainingLine(parseRoomNotice(content));
 
 describe('training notice', () => {
   it('says exactly the ruled sentence and never mentions Discord', () => {
@@ -16,19 +16,42 @@ describe('training notice', () => {
     expect(TRAINING_NOTICE_TEXT.toLowerCase()).not.toContain('discord');
   });
 
-  it('shows the train line only where the room declares train', () => {
-    const train = parseRoomNotice(pinned({ version: 2, scope: 'train' }));
-    expect(train).toEqual({ version: 2, scope: 'train' });
-    expect(roomTrainingLine(train)).toBe(TRAINING_NOTICE_TEXT);
-    expect(roomTrainingLine(parseRoomNotice(pinned({ version: 1, scope: 'study' })))).toBeUndefined();
-    expect(roomTrainingLine(parseRoomNotice(pinned({ version: 1, scope: 'show' })))).toBeUndefined();
+  it('reads the notice from the org.gamecult.notice state event', () => {
+    expect(ROOM_NOTICE_EVENT_TYPE).toBe('org.gamecult.notice');
   });
 
-  it('shows nothing where no notice is declared, and never infers train', () => {
-    expect(roomTrainingLine(undefined)).toBeUndefined();
-    expect(parseRoomNotice({ body: 'plain message' })).toBeUndefined();
-    expect(parseRoomNotice(pinned({ scope: 'train' }))).toBeUndefined();
-    expect(parseRoomNotice(pinned({ version: 0, scope: 'train' }))).toBeUndefined();
-    expect(parseRoomNotice(pinned({ version: 1, scope: 'everything' }))).toBeUndefined();
+  it('shows the train line only where the room declares train', () => {
+    expect(parseRoomNotice({ version: 2, scope: 'train' })).toEqual({ version: 2, scope: 'train' });
+    expect(lineFor({ version: 2, scope: 'train' })).toBe(TRAINING_NOTICE_TEXT);
+    expect(lineFor({ version: 1, scope: 'study' })).toBeUndefined();
+    expect(lineFor({ version: 1, scope: 'show' })).toBeUndefined();
+  });
+
+  it('shows nothing where the notice is absent', () => {
+    expect(lineFor(undefined)).toBeUndefined();
+    expect(lineFor(null)).toBeUndefined();
+    expect(lineFor({})).toBeUndefined();
+  });
+
+  it('shows nothing where the notice is malformed in any way', () => {
+    expect(lineFor('train')).toBeUndefined();
+    expect(lineFor({ scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: 1 })).toBeUndefined();
+    expect(lineFor({ version: 0, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: -1, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: 1.5, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: '1', scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: null, scope: 'train' })).toBeUndefined();
+  });
+
+  it('rejects a version written with leading zeros', () => {
+    expect(lineFor({ version: '01', scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: '007', scope: 'train' })).toBeUndefined();
+  });
+
+  it('rejects an unknown or wrongly cased scope', () => {
+    expect(lineFor({ version: 1, scope: 'everything' })).toBeUndefined();
+    expect(lineFor({ version: 1, scope: 'Train' })).toBeUndefined();
+    expect(lineFor({ version: 1, scope: ['train'] })).toBeUndefined();
   });
 });
diff --git a/src/app/utils/trainingNotice.ts b/src/app/utils/trainingNotice.ts
index c5cd7aa1..84918920 100644
--- a/src/app/utils/trainingNotice.ts
+++ b/src/app/utils/trainingNotice.ts
@@ -1,28 +1,28 @@
+import { StateEvent } from '../../types/matrix/room';
+
 export const TRAINING_NOTICE_TEXT =
   "Everything said here may be used to train GameCult's AI stewards.";
 
 /**
- * Where a room declares its notice. Heimdall's answer-collector-consent.md says the notice is pinned
- * with the sample and carries `notice_version` and a scope, but does not fix the pinned event's
- * encoding; this key is this client's provisional reading of it, and the one place to change.
+ * Heimdall's ruling: a room's notice is a room state event, not a pinned message. Type below,
+ * state_key '', content `{version, scope}`; version a positive integer, scope exactly one of
+ * show, study or train. Absent or malformed in any way means no train line.
  */
-export const ROOM_NOTICE_CONTENT_KEY = 'org.gamecult.notice';
+export const ROOM_NOTICE_EVENT_TYPE = StateEvent.GameCultNotice;
 
 export type RoomNotice = { version: number; scope: 'show' | 'study' | 'train' };
 
-/** The notice a pinned event declares, or undefined: no scope is ever inferred. */
+/** The notice a state event's content declares, or undefined: no scope is ever inferred. */
 export const parseRoomNotice = (content: unknown): RoomNotice | undefined => {
-  const raw = (content as Record<string, unknown> | undefined)?.[ROOM_NOTICE_CONTENT_KEY] as
-    | { version?: unknown; scope?: unknown }
-    | undefined;
+  if (typeof content !== 'object' || content === null) return undefined;
+  const { version, scope } = content as { version?: unknown; scope?: unknown };
   if (
-    raw &&
-    typeof raw.version === 'number' &&
-    Number.isInteger(raw.version) &&
-    raw.version > 0 &&
-    (raw.scope === 'show' || raw.scope === 'study' || raw.scope === 'train')
+    typeof version === 'number' &&
+    Number.isSafeInteger(version) &&
+    version > 0 &&
+    (scope === 'show' || scope === 'study' || scope === 'train')
   ) {
-    return { version: raw.version, scope: raw.scope };
+    return { version, scope };
   }
   return undefined;
 };
diff --git a/src/types/matrix/room.ts b/src/types/matrix/room.ts
index c73c0f0b..8d6b89dd 100644
--- a/src/types/matrix/room.ts
+++ b/src/types/matrix/room.ts
@@ -23,6 +23,7 @@ export enum StateEvent {
   RoomMember = 'm.room.member',
   RoomThirdPartyInvite = 'm.room.third_party_invite',
   RoomPowerLevels = 'm.room.power_levels',
+  GameCultNotice = 'org.gamecult.notice',
   RoomName = 'm.room.name',
   RoomTopic = 'm.room.topic',
   RoomAvatar = 'm.room.avatar',
-- 
2.47.3


From b9c5e3d1a549f9d4a37870aa403902eace227ae7 Mon Sep 17 00:00:00 2001
From: Void <void@minds.void.gamecult.org>
Date: Sat, 7 Nov 2026 00:31:31 +0000
Subject: [PATCH 5/5] auth: room notice version is bounded at 4294967295
 (Heimdall's one version rule)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 src/app/utils/trainingNotice.test.ts | 11 +++++++++++
 src/app/utils/trainingNotice.ts      |  7 +++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/app/utils/trainingNotice.test.ts b/src/app/utils/trainingNotice.test.ts
index ccf56435..0663d2f9 100644
--- a/src/app/utils/trainingNotice.test.ts
+++ b/src/app/utils/trainingNotice.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import {
+  MAX_NOTICE_VERSION,
   ROOM_NOTICE_EVENT_TYPE,
   TRAINING_NOTICE_TEXT,
   parseRoomNotice,
@@ -49,6 +50,16 @@ describe('training notice', () => {
     expect(lineFor({ version: '007', scope: 'train' })).toBeUndefined();
   });
 
+  it('bounds the version at 4294967295', () => {
+    expect(MAX_NOTICE_VERSION).toBe(4294967295);
+    expect(lineFor({ version: 4294967295, scope: 'train' })).toBe(TRAINING_NOTICE_TEXT);
+    expect(parseRoomNotice({ version: 4294967295, scope: 'train' })?.version).toBe(4294967295);
+    expect(lineFor({ version: 4294967296, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: Number.MAX_SAFE_INTEGER, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: 4294967295.5, scope: 'train' })).toBeUndefined();
+    expect(lineFor({ version: '4294967295', scope: 'train' })).toBeUndefined();
+  });
+
   it('rejects an unknown or wrongly cased scope', () => {
     expect(lineFor({ version: 1, scope: 'everything' })).toBeUndefined();
     expect(lineFor({ version: 1, scope: 'Train' })).toBeUndefined();
diff --git a/src/app/utils/trainingNotice.ts b/src/app/utils/trainingNotice.ts
index 84918920..7f60cce4 100644
--- a/src/app/utils/trainingNotice.ts
+++ b/src/app/utils/trainingNotice.ts
@@ -5,9 +5,11 @@ export const TRAINING_NOTICE_TEXT =
 
 /**
  * Heimdall's ruling: a room's notice is a room state event, not a pinned message. Type below,
- * state_key '', content `{version, scope}`; version a positive integer, scope exactly one of
- * show, study or train. Absent or malformed in any way means no train line.
+ * state_key '', content `{version, scope}`; scope exactly one of show, study or train. Heimdall's
+ * one version rule: a positive integer, no leading zeros, no greater than 4294967295; anything
+ * else is malformed. Absent or malformed in any way means no train line.
  */
+export const MAX_NOTICE_VERSION = 4294967295;
 export const ROOM_NOTICE_EVENT_TYPE = StateEvent.GameCultNotice;
 
 export type RoomNotice = { version: number; scope: 'show' | 'study' | 'train' };
@@ -20,6 +22,7 @@ export const parseRoomNotice = (content: unknown): RoomNotice | undefined => {
     typeof version === 'number' &&
     Number.isSafeInteger(version) &&
     version > 0 &&
+    version <= MAX_NOTICE_VERSION &&
     (scope === 'show' || scope === 'study' || scope === 'train')
   ) {
     return { version, scope };
-- 
2.47.3