From 9093915f701d571e210f666a5c0f48a8bafe1d6f Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 09:47:07 +0200
Subject: [PATCH 1/9] ver 1

---
 features/session/use-live-session.ts | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index ffdb8da..701d205 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -44,6 +44,7 @@ const CHAT_STORAGE_PREFIX = "eduverse:session-chat:v1"
 const MAX_CHAT_MESSAGES = 200
 
 type MediaDeviceKind = "microphone" | "camera" | "screen"
+type SessionTokenUser = Pick<User, "avatar" | "id" | "name" | "role">
 type LiveSessionError =
   | Error
   | string
@@ -799,7 +800,7 @@ function mapParticipant(
   } satisfies SessionParticipant
 }
 
-async function fetchSessionToken(classId: string, user: User) {
+async function fetchSessionToken(classId: string, user: SessionTokenUser) {
   const response = await fetch("/api/livekit/token", {
     method: "POST",
     headers: {
@@ -852,6 +853,10 @@ export function useLiveSession({
   const [whiteboardMessages, setWhiteboardMessages] = useState<
     LiveSessionWhiteboardMessage[]
   >([])
+  const currentUserId = currentUser.id
+  const currentUserName = currentUser.name
+  const currentUserAvatar = currentUser.avatar
+  const currentUserRole = currentUser.role
 
   const upsertNotice = useCallback((notice: LiveSessionNotice) => {
     setNotices((prev) =>
@@ -1080,7 +1085,12 @@ export function useLiveSession({
       try {
         const { participantToken, serverUrl } = await fetchSessionToken(
           classId,
-          currentUser,
+          {
+            id: currentUserId,
+            name: currentUserName,
+            avatar: currentUserAvatar,
+            role: currentUserRole,
+          },
         )
 
         if (isCancelled) {
@@ -1102,13 +1112,13 @@ export function useLiveSession({
         if (roomSid) {
           const nextChatStorageKey = getSessionChatStorageKey({
             classId,
-            userId: currentUser.id,
+            userId: currentUserId,
             roomSid,
           })
 
           pruneStoredSessionChats({
             classId,
-            userId: currentUser.id,
+            userId: currentUserId,
             activeStorageKey: nextChatStorageKey,
           })
           setChatStorageKey(nextChatStorageKey)
@@ -1167,7 +1177,10 @@ export function useLiveSession({
     }
   }, [
     classId,
-    currentUser,
+    currentUserAvatar,
+    currentUserId,
+    currentUserName,
+    currentUserRole,
     enabled,
     syncParticipants,
     updateMediaDevice,

From 9bf1ce41d6d10385fc5f6f032f8d5ccbb8bd452a Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 10:02:52 +0200
Subject: [PATCH 2/9] ver 2

---
 features/session/live-session-provider.tsx |  4 +++
 features/session/live-session-types.ts     |  6 ++++
 features/session/session-screen.tsx        |  2 +-
 features/session/use-live-session.ts       | 16 ++++++++++
 features/session/use-whiteboard.ts         | 36 ++++++++++++++++++----
 5 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/features/session/live-session-provider.tsx b/features/session/live-session-provider.tsx
index 3b9588d..502b643 100644
--- a/features/session/live-session-provider.tsx
+++ b/features/session/live-session-provider.tsx
@@ -154,6 +154,10 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
       return
     }
 
+    if (isTeacher) {
+      await liveSession.clearWhiteboards().catch(() => false)
+    }
+
     liveSession.disconnect()
     setSessionActive(false)
     setSessionScope(null)
diff --git a/features/session/live-session-types.ts b/features/session/live-session-types.ts
index ceba989..e30f1b1 100644
--- a/features/session/live-session-types.ts
+++ b/features/session/live-session-types.ts
@@ -206,6 +206,11 @@ export type LiveSessionWhiteboardMessage =
       version: number
       operations: WhiteboardOperation[]
     }
+  | {
+      id: string
+      senderId: string
+      type: "session:clear"
+    }
 
 export interface LiveSessionChatMessage {
   id: string
@@ -239,6 +244,7 @@ export interface LiveSessionState {
     message: LiveSessionWhiteboardMessage,
     options?: { reliable?: boolean },
   ) => Promise<boolean>
+  clearWhiteboards: () => Promise<boolean>
   sendChatMessage: (content: string) => Promise<boolean>
   dismissNotice: (noticeId: string) => void
   disconnect: () => void
diff --git a/features/session/session-screen.tsx b/features/session/session-screen.tsx
index c8fe309..4a11e40 100644
--- a/features/session/session-screen.tsx
+++ b/features/session/session-screen.tsx
@@ -159,7 +159,7 @@ export function SessionScreen({ cls }: { cls: Class }) {
     height: number
   } | null>(null)
   const presentationSessionId = liveSession.presentation
-    ? `presentation:${liveSession.presentation.publication.trackSid}`
+    ? `presentation:${cls.id}`
     : null
   const presentationDimensions =
     liveSession.presentation?.publication.dimensions
diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index 701d205..93037ba 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -434,6 +434,10 @@ function isWhiteboardMessage(
     return true
   }
 
+  if (value.type === "session:clear") {
+    return value.boardId === undefined
+  }
+
   if (
     value.type === "state:sync" &&
     typeof value.version === "number" &&
@@ -1222,6 +1226,17 @@ export function useLiveSession({
     [upsertNotice],
   )
 
+  const clearWhiteboards = useCallback(() => {
+    return sendWhiteboardMessage(
+      {
+        id: createChatMessageId(currentUserId),
+        senderId: currentUserId,
+        type: "session:clear",
+      },
+      { reliable: true },
+    )
+  }, [currentUserId, sendWhiteboardMessage])
+
   const sendChatMessage = useCallback(
     async (content: string) => {
       const trimmed = content.trim()
@@ -1482,6 +1497,7 @@ export function useLiveSession({
     toggleCamera,
     toggleScreenShare,
     sendWhiteboardMessage,
+    clearWhiteboards,
     sendChatMessage,
     dismissNotice,
     disconnect,
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index 3c06401..df509f2 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -135,6 +135,10 @@ function createEmptyBoardState(): BoardState {
 }
 
 function getMessageBoardId(message: LiveSessionWhiteboardMessage) {
+  if (message.type === "session:clear") {
+    return REGULAR_WHITEBOARD_BOARD_ID
+  }
+
   return message.boardId ?? REGULAR_WHITEBOARD_BOARD_ID
 }
 
@@ -1158,6 +1162,20 @@ export function useWhiteboard({
     pendingStrokePoints.current = []
   }, [])
 
+  const clearAllBoards = useCallback(() => {
+    boardStates.current.clear()
+    operations.current = []
+    redoOperations.current = []
+    boardVersion.current = 0
+    selectedOperationIds.current = new Set()
+    remoteStrokes.current.clear()
+    stateRequested.current.clear()
+    setHasSelection(false)
+    setRedoCount(0)
+    resetDrawingState()
+    resetBoard()
+  }, [resetBoard, resetDrawingState])
+
   const handlePointerDown = (event: ReactPointerEvent<HTMLCanvasElement>) => {
     if (
       !isTeacher ||
@@ -1689,11 +1707,11 @@ export function useWhiteboard({
       return
     }
 
-    if (!isTeacher && !stateRequested.current.has(boardId)) {
+    if (!stateRequested.current.has(boardId)) {
       stateRequested.current.add(boardId)
       sendWhiteboardMessage({ type: "state:request" }, { reliable: true })
     }
-  }, [boardId, isTeacher, sendWhiteboardMessage, syncEnabled])
+  }, [boardId, sendWhiteboardMessage, syncEnabled])
 
   useEffect(() => {
     if (!isTeacher || !syncEnabled) {
@@ -1723,14 +1741,19 @@ export function useWhiteboard({
         continue
       }
 
-      if (getMessageBoardId(message) !== boardId) {
+      processedMessageIds.current.add(message.id)
+
+      if (message.type === "session:clear") {
+        clearAllBoards()
         continue
       }
 
-      processedMessageIds.current.add(message.id)
+      if (getMessageBoardId(message) !== boardId) {
+        continue
+      }
 
-      if (isTeacher) {
-        if (message.type === "state:request") {
+      if (message.type === "state:request") {
+        if (operations.current.length > 0 || boardVersion.current > 0) {
           sendStateSync()
         }
         continue
@@ -1881,6 +1904,7 @@ export function useWhiteboard({
     }
   }, [
     boardId,
+    clearAllBoards,
     currentUserId,
     getContext,
     incomingMessages,

From fceca9c1c06b4227d8a7ebef728514a5a512e6a9 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 10:08:48 +0200
Subject: [PATCH 3/9] ver 3

---
 features/session/live-session-provider.tsx |  8 ++++++++
 features/session/live-session-types.ts     |  6 ++++++
 features/session/session-screen.tsx        | 12 +++++++++--
 features/session/use-live-session.ts       | 24 +++++++++++++++++++++-
 features/session/use-whiteboard.ts         |  4 ++--
 5 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/features/session/live-session-provider.tsx b/features/session/live-session-provider.tsx
index 502b643..a670636 100644
--- a/features/session/live-session-provider.tsx
+++ b/features/session/live-session-provider.tsx
@@ -105,12 +105,19 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   const disconnectRef = useRef<() => void>(() => {})
   const isTeacher = currentUser.role === "teacher"
   const currentSessionScope = `${activeOrganization?.id ?? ""}:${currentUser.id}:${currentUser.role}`
+  const handleRemoteSessionEnded = useCallback(() => {
+    setSessionActive(false)
+    setSessionScope(null)
+    setHasJoinedSession(true)
+    void refreshClassLiveSessions({ force: true }).catch(() => {})
+  }, [refreshClassLiveSessions])
   const liveSession = useLiveSession({
     classId: activeClass?.id ?? "",
     currentUser,
     enabled: Boolean(
       activeClass && sessionActive && sessionScope === currentSessionScope,
     ),
+    onSessionEnded: handleRemoteSessionEnded,
   })
   const connected = liveSession.connectionState === ConnectionState.Connected
 
@@ -156,6 +163,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
 
     if (isTeacher) {
       await liveSession.clearWhiteboards().catch(() => false)
+      await liveSession.endSessionForEveryone().catch(() => false)
     }
 
     liveSession.disconnect()
diff --git a/features/session/live-session-types.ts b/features/session/live-session-types.ts
index e30f1b1..b614006 100644
--- a/features/session/live-session-types.ts
+++ b/features/session/live-session-types.ts
@@ -211,6 +211,11 @@ export type LiveSessionWhiteboardMessage =
       senderId: string
       type: "session:clear"
     }
+  | {
+      id: string
+      senderId: string
+      type: "session:end"
+    }
 
 export interface LiveSessionChatMessage {
   id: string
@@ -245,6 +250,7 @@ export interface LiveSessionState {
     options?: { reliable?: boolean },
   ) => Promise<boolean>
   clearWhiteboards: () => Promise<boolean>
+  endSessionForEveryone: () => Promise<boolean>
   sendChatMessage: (content: string) => Promise<boolean>
   dismissNotice: (noticeId: string) => void
   disconnect: () => void
diff --git a/features/session/session-screen.tsx b/features/session/session-screen.tsx
index 4a11e40..c2acd45 100644
--- a/features/session/session-screen.tsx
+++ b/features/session/session-screen.tsx
@@ -135,7 +135,7 @@ function SessionNoticeStack({
 }
 
 export function SessionScreen({ cls }: { cls: Class }) {
-  const { currentUser } = useApp()
+  const { classLiveSessions, currentUser } = useApp()
   const {
     activeClass,
     endSession,
@@ -150,6 +150,11 @@ export function SessionScreen({ cls }: { cls: Class }) {
   )
 
   const isTeacher = currentUser.role === "teacher"
+  const canStartSession = currentUser.role !== "student"
+  const classHasLiveSession = classLiveSessions.some(
+    (session) => session.class_id === cls.id,
+  )
+  const canJoinSession = canStartSession || classHasLiveSession
   const isThisClassSession = activeClass?.id === cls.id && sessionActive
   const hasJoinedThisClass = activeClass?.id === cls.id && hasJoinedSession
   const presentationStageRef = useRef<HTMLDivElement | null>(null)
@@ -274,7 +279,9 @@ export function SessionScreen({ cls }: { cls: Class }) {
     const title = hasJoinedThisClass ? "Session ended" : "Ready to join"
     const description = hasJoinedThisClass
       ? `You left the live session for ${cls.name}.`
-      : `Join the live session for ${cls.name} when you are ready.`
+      : canJoinSession
+        ? `Join the live session for ${cls.name} when you are ready.`
+        : `The live session for ${cls.name} has not started yet.`
     const buttonLabel = hasJoinedThisClass ? "Rejoin" : "Join session"
 
     return (
@@ -284,6 +291,7 @@ export function SessionScreen({ cls }: { cls: Class }) {
         <p className="text-sm text-muted-foreground">{description}</p>
         <Button
           size="sm"
+          disabled={!canJoinSession}
           onClick={() => {
             joinSession(cls)
           }}
diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index 93037ba..4b39828 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -434,7 +434,7 @@ function isWhiteboardMessage(
     return true
   }
 
-  if (value.type === "session:clear") {
+  if (value.type === "session:clear" || value.type === "session:end") {
     return value.boardId === undefined
   }
 
@@ -838,10 +838,12 @@ export function useLiveSession({
   classId,
   currentUser,
   enabled,
+  onSessionEnded,
 }: {
   classId: string
   currentUser: User
   enabled: boolean
+  onSessionEnded?: () => void
 }): LiveSessionState {
   const roomRef = useRef<Room | null>(null)
   const [participants, setParticipants] = useState<SessionParticipant[]>([])
@@ -1005,6 +1007,13 @@ export function useLiveSession({
           return
         }
 
+        if (parsed.type === "session:end") {
+          setWhiteboardMessages((prev) => [...prev.slice(-199), parsed])
+          room.disconnect()
+          onSessionEnded?.()
+          return
+        }
+
         setWhiteboardMessages((prev) => [...prev.slice(-199), parsed])
       } catch {
         upsertNotice({
@@ -1186,6 +1195,7 @@ export function useLiveSession({
     currentUserName,
     currentUserRole,
     enabled,
+    onSessionEnded,
     syncParticipants,
     updateMediaDevice,
     upsertNotice,
@@ -1237,6 +1247,17 @@ export function useLiveSession({
     )
   }, [currentUserId, sendWhiteboardMessage])
 
+  const endSessionForEveryone = useCallback(() => {
+    return sendWhiteboardMessage(
+      {
+        id: createChatMessageId(currentUserId),
+        senderId: currentUserId,
+        type: "session:end",
+      },
+      { reliable: true },
+    )
+  }, [currentUserId, sendWhiteboardMessage])
+
   const sendChatMessage = useCallback(
     async (content: string) => {
       const trimmed = content.trim()
@@ -1498,6 +1519,7 @@ export function useLiveSession({
     toggleScreenShare,
     sendWhiteboardMessage,
     clearWhiteboards,
+    endSessionForEveryone,
     sendChatMessage,
     dismissNotice,
     disconnect,
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index df509f2..59d0301 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -135,7 +135,7 @@ function createEmptyBoardState(): BoardState {
 }
 
 function getMessageBoardId(message: LiveSessionWhiteboardMessage) {
-  if (message.type === "session:clear") {
+  if (message.type === "session:clear" || message.type === "session:end") {
     return REGULAR_WHITEBOARD_BOARD_ID
   }
 
@@ -1743,7 +1743,7 @@ export function useWhiteboard({
 
       processedMessageIds.current.add(message.id)
 
-      if (message.type === "session:clear") {
+      if (message.type === "session:clear" || message.type === "session:end") {
         clearAllBoards()
         continue
       }

From 980f852a8d10def282c5c44d25514bbf1697fcf9 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 10:17:35 +0200
Subject: [PATCH 4/9] ver 4

---
 features/session/session-screen.tsx | 109 ++++++++++++++++++----------
 1 file changed, 72 insertions(+), 37 deletions(-)

diff --git a/features/session/session-screen.tsx b/features/session/session-screen.tsx
index c2acd45..f22047d 100644
--- a/features/session/session-screen.tsx
+++ b/features/session/session-screen.tsx
@@ -139,7 +139,6 @@ export function SessionScreen({ cls }: { cls: Class }) {
   const {
     activeClass,
     endSession,
-    hasJoinedSession,
     joinSession,
     leaveSession,
     liveSession,
@@ -156,7 +155,9 @@ export function SessionScreen({ cls }: { cls: Class }) {
   )
   const canJoinSession = canStartSession || classHasLiveSession
   const isThisClassSession = activeClass?.id === cls.id && sessionActive
-  const hasJoinedThisClass = activeClass?.id === cls.id && hasJoinedSession
+  const isTeacherPreviewSession = isTeacher && !isThisClassSession
+  const teacherReconnectAvailable =
+    isTeacherPreviewSession && classHasLiveSession
   const presentationStageRef = useRef<HTMLDivElement | null>(null)
   const [videoAspectRatio, setVideoAspectRatio] = useState<number | undefined>()
   const [presentationStageSize, setPresentationStageSize] = useState<{
@@ -203,7 +204,11 @@ export function SessionScreen({ cls }: { cls: Class }) {
     ? "Connecting"
     : liveSession.connectionState === ConnectionState.Connected
       ? "Live Session"
-      : "Offline"
+      : teacherReconnectAvailable
+        ? "Disconnected"
+        : isTeacherPreviewSession
+          ? "Not Live"
+          : "Offline"
   const micBusy = isBusyMediaState(liveSession.media.microphone.state)
   const cameraBusy = isBusyMediaState(liveSession.media.camera.state)
   const screenBusy = isBusyMediaState(liveSession.media.screen.state)
@@ -275,29 +280,44 @@ export function SessionScreen({ cls }: { cls: Class }) {
     }
   }, [liveSession.presentation, presentationAspectRatio])
 
-  if (!isThisClassSession) {
-    const title = hasJoinedThisClass ? "Session ended" : "Ready to join"
-    const description = hasJoinedThisClass
-      ? `You left the live session for ${cls.name}.`
-      : canJoinSession
-        ? `Join the live session for ${cls.name} when you are ready.`
-        : `The live session for ${cls.name} has not started yet.`
-    const buttonLabel = hasJoinedThisClass ? "Rejoin" : "Join session"
+  if (!isThisClassSession && !isTeacher) {
+    const title = classHasLiveSession
+      ? "Live session is open"
+      : "Waiting for teacher"
+    const description = classHasLiveSession
+      ? `Join the live session for ${cls.name}.`
+      : `The teacher has not started the live session for ${cls.name} yet.`
+    const buttonLabel = classHasLiveSession
+      ? "Join live session"
+      : "Not live yet"
 
     return (
-      <div className="p-6 flex flex-col items-center justify-center gap-3 text-center">
-        <Phone className="w-10 h-10 text-muted-foreground" />
-        <p className="text-lg font-semibold text-foreground">{title}</p>
-        <p className="text-sm text-muted-foreground">{description}</p>
-        <Button
-          size="sm"
-          disabled={!canJoinSession}
-          onClick={() => {
-            joinSession(cls)
-          }}
-        >
-          {buttonLabel}
-        </Button>
+      <div className="flex h-full items-center justify-center bg-background p-6">
+        <div className="flex w-full max-w-md flex-col items-center gap-4 text-center">
+          <span
+            className={cn(
+              "flex h-12 w-12 items-center justify-center rounded-xl",
+              classHasLiveSession
+                ? "bg-emerald-100 text-emerald-700 dark:bg-emerald-900/40 dark:text-emerald-300"
+                : "bg-muted text-muted-foreground",
+            )}
+          >
+            <Video className="h-6 w-6" />
+          </span>
+          <div className="space-y-1">
+            <p className="text-lg font-semibold text-foreground">{title}</p>
+            <p className="text-sm text-muted-foreground">{description}</p>
+          </div>
+          <Button
+            size="sm"
+            disabled={!canJoinSession}
+            onClick={() => {
+              joinSession(cls)
+            }}
+          >
+            {buttonLabel}
+          </Button>
+        </div>
       </div>
     )
   }
@@ -355,16 +375,27 @@ export function SessionScreen({ cls }: { cls: Class }) {
               />
             ) : null}
             <Separator orientation="vertical" className="h-6 mx-1" />
-            <Button
-              size="sm"
-              variant="outline"
-              className="gap-1.5 text-xs h-8"
-              onClick={leaveSession}
-            >
-              <Phone className="w-3.5 h-3.5" />
-              Leave
-            </Button>
-            {isTeacher ? (
+            {isTeacherPreviewSession ? (
+              <Button
+                size="sm"
+                className="gap-1.5 text-xs h-8"
+                onClick={() => joinSession(cls)}
+              >
+                <Video className="w-3.5 h-3.5" />
+                {teacherReconnectAvailable ? "Reconnect" : "Go Live"}
+              </Button>
+            ) : (
+              <Button
+                size="sm"
+                variant="outline"
+                className="gap-1.5 text-xs h-8"
+                onClick={leaveSession}
+              >
+                <Phone className="w-3.5 h-3.5" />
+                Leave
+              </Button>
+            )}
+            {isTeacher && !isTeacherPreviewSession ? (
               <Button
                 size="sm"
                 variant="destructive"
@@ -705,9 +736,13 @@ export function SessionScreen({ cls }: { cls: Class }) {
           ))}
           <div className="ml-auto hidden md:flex items-center gap-2 text-xs text-muted-foreground pr-2">
             <ArrowUpRight className="w-3.5 h-3.5" />
-            {liveSession.presentation
-              ? "Presentation synced live"
-              : "Whiteboard synced live"}
+            {teacherReconnectAvailable
+              ? "Live session is waiting for you to reconnect"
+              : isTeacherPreviewSession
+                ? "Whiteboard is local until you go live"
+                : liveSession.presentation
+                  ? "Presentation synced live"
+                  : "Whiteboard synced live"}
           </div>
         </div>
       </div>

From 813c09add1439504b94e0723269c978d96502205 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 10:36:29 +0200
Subject: [PATCH 5/9] ver 5

---
 features/session/live-session-provider.tsx | 93 +++++++++++++++++++++-
 features/session/live-session-types.ts     |  3 +
 features/session/use-live-session.ts       |  8 +-
 features/session/use-whiteboard.ts         | 85 ++++++++++++++++++--
 4 files changed, 179 insertions(+), 10 deletions(-)

diff --git a/features/session/live-session-provider.tsx b/features/session/live-session-provider.tsx
index a670636..3bf0b33 100644
--- a/features/session/live-session-provider.tsx
+++ b/features/session/live-session-provider.tsx
@@ -96,13 +96,25 @@ function terminateClassLiveSession(
 }
 
 export function LiveSessionProvider({ children }: { children: ReactNode }) {
-  const { activeOrganization, currentUser, refreshClassLiveSessions } = useApp()
+  const {
+    activeOrganization,
+    classLiveSessions,
+    classLiveSessionsStatus,
+    currentUser,
+    refreshClassLiveSessions,
+  } = useApp()
   const [activeClass, setActiveClass] = useState<Class | null>(null)
   const [sessionActive, setSessionActive] = useState(false)
   const [hasJoinedSession, setHasJoinedSession] = useState(false)
   const [sessionScope, setSessionScope] = useState<string | null>(null)
   const activeTeacherSessionRef = useRef<string | null>(null)
   const disconnectRef = useRef<() => void>(() => {})
+  const mountedRef = useRef(false)
+  const sessionPresenceRef = useRef({
+    activeClassId: null as string | null,
+    isTeacher: false,
+    sessionActive: false,
+  })
   const isTeacher = currentUser.role === "teacher"
   const currentSessionScope = `${activeOrganization?.id ?? ""}:${currentUser.id}:${currentUser.role}`
   const handleRemoteSessionEnded = useCallback(() => {
@@ -121,6 +133,14 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   })
   const connected = liveSession.connectionState === ConnectionState.Connected
 
+  useEffect(() => {
+    mountedRef.current = true
+
+    return () => {
+      mountedRef.current = false
+    }
+  }, [])
+
   useEffect(() => {
     activeTeacherSessionRef.current =
       activeClass && sessionActive && isTeacher ? activeClass.id : null
@@ -130,6 +150,77 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     disconnectRef.current = liveSession.disconnect
   }, [liveSession.disconnect])
 
+  useEffect(() => {
+    sessionPresenceRef.current = {
+      activeClassId: activeClass?.id ?? null,
+      isTeacher,
+      sessionActive,
+    }
+  }, [activeClass?.id, isTeacher, sessionActive])
+
+  useEffect(() => {
+    const activeClassId = activeClass?.id
+
+    if (
+      isTeacher ||
+      !activeClassId ||
+      !sessionActive ||
+      classLiveSessionsStatus !== "ready"
+    ) {
+      return
+    }
+
+    const sessionIsStillLive = classLiveSessions.some(
+      (session) => session.class_id === activeClassId,
+    )
+
+    if (sessionIsStillLive) {
+      return
+    }
+
+    let cancelled = false
+    let recheckStarted = false
+    const recheckTimer = window.setTimeout(() => {
+      recheckStarted = true
+      void refreshClassLiveSessions({ force: true })
+        .then((freshSessions) => {
+          const currentPresence = sessionPresenceRef.current
+
+          if (
+            cancelled ||
+            !mountedRef.current ||
+            currentPresence.activeClassId !== activeClassId ||
+            currentPresence.isTeacher ||
+            !currentPresence.sessionActive ||
+            freshSessions.some((session) => session.class_id === activeClassId)
+          ) {
+            return
+          }
+
+          disconnectRef.current()
+          setSessionActive(false)
+          setSessionScope(null)
+          setHasJoinedSession(true)
+        })
+        .catch(() => {})
+    }, 1500)
+
+    return () => {
+      window.clearTimeout(recheckTimer)
+
+      if (!recheckStarted) {
+        cancelled = true
+      }
+    }
+  }, [
+    activeClass?.id,
+    classLiveSessions,
+    classLiveSessionsStatus,
+    isTeacher,
+    refreshClassLiveSessions,
+    sessionActive,
+  ])
+
   const joinSession = useCallback(
     (cls: Class) => {
       const currentTeacherClassId = activeTeacherSessionRef.current
diff --git a/features/session/live-session-types.ts b/features/session/live-session-types.ts
index b614006..cd94a6a 100644
--- a/features/session/live-session-types.ts
+++ b/features/session/live-session-types.ts
@@ -197,12 +197,15 @@ export type LiveSessionWhiteboardMessage =
       senderId: string
       boardId?: string
       type: "state:request"
+      requestId: string
+      requesterRole?: Role
     }
   | {
       id: string
       senderId: string
       boardId?: string
       type: "state:sync"
+      requestId?: string
       version: number
       operations: WhiteboardOperation[]
     }
diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index 4b39828..2e71169 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -431,7 +431,12 @@ function isWhiteboardMessage(
   }
 
   if (value.type === "state:request") {
-    return true
+    return (
+      typeof value.requestId === "string" &&
+      (value.requesterRole === undefined ||
+        (typeof value.requesterRole === "string" &&
+          isRole(value.requesterRole)))
+    )
   }
 
   if (value.type === "session:clear" || value.type === "session:end") {
@@ -440,6 +445,7 @@ function isWhiteboardMessage(
 
   if (
     value.type === "state:sync" &&
+    (value.requestId === undefined || typeof value.requestId === "string") &&
     typeof value.version === "number" &&
     isWhiteboardOperationList(value.operations)
   ) {
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index 59d0301..b9953b4 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -98,6 +98,16 @@ function createMessageId() {
   return `${Date.now()}-${Math.random().toString(36).slice(2)}`
 }
 
+function getStateResponseDelay(userId: string) {
+  let hash = 0
+
+  for (let index = 0; index < userId.length; index += 1) {
+    hash = (hash * 31 + userId.charCodeAt(index)) % 997
+  }
+
+  return 120 + (hash % 600)
+}
+
 function createStrokeId() {
   return `stroke-${createMessageId()}`
 }
@@ -758,10 +768,19 @@ export function useWhiteboard({
   const activeBoardId = useRef(boardId)
   const lastParticipantCount = useRef(participantCount)
   const stateRequested = useRef(new Set<string>())
+  const stateRequestIds = useRef(new Map<string, string>())
+  const stateResponseTimers = useRef(new Set<number>())
   const operations = useRef<WhiteboardOperation[]>([])
   const redoOperations = useRef<WhiteboardOperation[]>([])
   const boardVersion = useRef(0)
 
+  const clearStateResponseTimers = useCallback(() => {
+    stateResponseTimers.current.forEach((timerId) => {
+      window.clearTimeout(timerId)
+    })
+    stateResponseTimers.current.clear()
+  }, [])
+
   const getContext = useCallback(() => {
     const canvas = canvasRef.current
     const ctx = canvas?.getContext("2d")
@@ -891,10 +910,11 @@ export function useWhiteboard({
     [boardId, currentUserId, sendMessage, syncEnabled],
   )
 
-  const sendStateSync = useCallback(() => {
+  const sendStateSync = useCallback((requestId?: string) => {
     sendWhiteboardMessage(
       {
         type: "state:sync",
+        ...(requestId ? { requestId } : {}),
         version: boardVersion.current,
         operations: getStateSyncOperations(operations.current),
       },
@@ -1170,11 +1190,13 @@ export function useWhiteboard({
     selectedOperationIds.current = new Set()
     remoteStrokes.current.clear()
     stateRequested.current.clear()
+    stateRequestIds.current.clear()
+    clearStateResponseTimers()
     setHasSelection(false)
     setRedoCount(0)
     resetDrawingState()
     resetBoard()
-  }, [resetBoard, resetDrawingState])
+  }, [clearStateResponseTimers, resetBoard, resetDrawingState])
 
   const handlePointerDown = (event: ReactPointerEvent<HTMLCanvasElement>) => {
     if (
@@ -1698,20 +1720,39 @@ export function useWhiteboard({
       if (strokeFlushFrame.current !== null) {
         cancelAnimationFrame(strokeFlushFrame.current)
       }
+      clearStateResponseTimers()
     }
-  }, [])
+  }, [clearStateResponseTimers])
 
   useEffect(() => {
     if (!syncEnabled) {
       stateRequested.current.clear()
+      stateRequestIds.current.clear()
+      clearStateResponseTimers()
       return
     }
 
     if (!stateRequested.current.has(boardId)) {
+      const requestId = createMessageId()
+
       stateRequested.current.add(boardId)
-      sendWhiteboardMessage({ type: "state:request" }, { reliable: true })
+      stateRequestIds.current.set(boardId, requestId)
+      sendWhiteboardMessage(
+        {
+          type: "state:request",
+          requestId,
+          requesterRole: isTeacher ? "teacher" : "student",
+        },
+        { reliable: true },
+      )
     }
-  }, [boardId, sendWhiteboardMessage, syncEnabled])
+  }, [
+    boardId,
+    clearStateResponseTimers,
+    isTeacher,
+    sendWhiteboardMessage,
+    syncEnabled,
+  ])
 
   useEffect(() => {
     if (!isTeacher || !syncEnabled) {
@@ -1753,17 +1794,45 @@ export function useWhiteboard({
       }
 
       if (message.type === "state:request") {
-        if (operations.current.length > 0 || boardVersion.current > 0) {
-          sendStateSync()
+        const hasBoardState =
+          operations.current.length > 0 || boardVersion.current > 0
+
+        if (!hasBoardState) {
+          continue
+        }
+
+        if (isTeacher) {
+          sendStateSync(message.requestId)
+          continue
+        }
+
+        if (message.requesterRole === "teacher") {
+          const timerId = window.setTimeout(() => {
+            stateResponseTimers.current.delete(timerId)
+            sendStateSync(message.requestId)
+          }, getStateResponseDelay(currentUserId))
+
+          stateResponseTimers.current.add(timerId)
         }
+
         continue
       }
 
       if (message.type === "state:sync") {
-        if (message.version < boardVersion.current) {
+        const currentRequestId = stateRequestIds.current.get(boardId)
+
+        if (message.requestId && message.requestId !== currentRequestId) {
+          continue
+        }
+
+        if (message.version <= boardVersion.current) {
           continue
         }
 
+        if (message.requestId) {
+          stateRequestIds.current.delete(boardId)
+        }
+
         boardVersion.current = message.version
         operations.current = message.operations
         redoOperations.current = []

From 4067471d05aa8a58033911e3f56c93214b4fe487 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 10:43:20 +0200
Subject: [PATCH 6/9] ver 6

---
 features/session/live-session-provider.tsx | 13 ++++++++++++-
 features/session/session-screen.tsx        |  2 ++
 features/session/use-whiteboard.ts         | 12 ++++++++++++
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/features/session/live-session-provider.tsx b/features/session/live-session-provider.tsx
index 3bf0b33..6c14162 100644
--- a/features/session/live-session-provider.tsx
+++ b/features/session/live-session-provider.tsx
@@ -24,6 +24,7 @@ type LiveSessionContextValue = {
   activeClass: Class | null
   hasJoinedSession: boolean
   sessionActive: boolean
+  whiteboardResetKey: number
   liveSession: LiveSessionState
   joinSession: (cls: Class) => void
   leaveSession: () => void
@@ -107,6 +108,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   const [sessionActive, setSessionActive] = useState(false)
   const [hasJoinedSession, setHasJoinedSession] = useState(false)
   const [sessionScope, setSessionScope] = useState<string | null>(null)
+  const [whiteboardResetKey, setWhiteboardResetKey] = useState(0)
   const activeTeacherSessionRef = useRef<string | null>(null)
   const disconnectRef = useRef<() => void>(() => {})
   const mountedRef = useRef(false)
@@ -117,12 +119,16 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   })
   const isTeacher = currentUser.role === "teacher"
   const currentSessionScope = `${activeOrganization?.id ?? ""}:${currentUser.id}:${currentUser.role}`
+  const resetLocalWhiteboards = useCallback(() => {
+    setWhiteboardResetKey((key) => key + 1)
+  }, [])
   const handleRemoteSessionEnded = useCallback(() => {
+    resetLocalWhiteboards()
     setSessionActive(false)
     setSessionScope(null)
     setHasJoinedSession(true)
     void refreshClassLiveSessions({ force: true }).catch(() => {})
-  }, [refreshClassLiveSessions])
+  }, [refreshClassLiveSessions, resetLocalWhiteboards])
   const liveSession = useLiveSession({
     classId: activeClass?.id ?? "",
     currentUser,
@@ -198,6 +204,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
           }
 
           disconnectRef.current()
+          resetLocalWhiteboards()
           setSessionActive(false)
           setSessionScope(null)
           setHasJoinedSession(true)
@@ -255,6 +262,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     if (isTeacher) {
       await liveSession.clearWhiteboards().catch(() => false)
       await liveSession.endSessionForEveryone().catch(() => false)
+      resetLocalWhiteboards()
     }
 
     liveSession.disconnect()
@@ -272,6 +280,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     leaveSession,
     liveSession,
     refreshClassLiveSessions,
+    resetLocalWhiteboards,
   ])
 
   useEffect(() => {
@@ -367,6 +376,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
       activeClass,
       hasJoinedSession,
       sessionActive,
+      whiteboardResetKey,
       liveSession,
       joinSession,
       leaveSession,
@@ -380,6 +390,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
       leaveSession,
       liveSession,
       sessionActive,
+      whiteboardResetKey,
     ],
   )
 
diff --git a/features/session/session-screen.tsx b/features/session/session-screen.tsx
index f22047d..e56623b 100644
--- a/features/session/session-screen.tsx
+++ b/features/session/session-screen.tsx
@@ -143,6 +143,7 @@ export function SessionScreen({ cls }: { cls: Class }) {
     leaveSession,
     liveSession,
     sessionActive,
+    whiteboardResetKey,
   } = usePersistentLiveSession()
   const [rightPanel, setRightPanel] = useState<"participants" | "chat" | null>(
     "participants",
@@ -187,6 +188,7 @@ export function SessionScreen({ cls }: { cls: Class }) {
     participantCount,
     overlayActive: Boolean(liveSession.presentation),
     overlayAspectRatio: presentationAspectRatio,
+    resetKey: whiteboardResetKey,
     syncEnabled: connected,
     sendMessage: liveSession.sendWhiteboardMessage,
   })
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index b9953b4..ca86da5 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -74,6 +74,7 @@ interface WhiteboardOptions {
   participantCount: number
   overlayActive: boolean
   overlayAspectRatio?: number
+  resetKey: number
   syncEnabled: boolean
   sendMessage: (
     message: LiveSessionWhiteboardMessage,
@@ -740,6 +741,7 @@ export function useWhiteboard({
   participantCount,
   overlayActive,
   overlayAspectRatio,
+  resetKey,
   syncEnabled,
   sendMessage,
 }: WhiteboardOptions): WhiteboardState {
@@ -767,6 +769,7 @@ export function useWhiteboard({
   const boardStates = useRef(new Map<string, BoardState>())
   const activeBoardId = useRef(boardId)
   const lastParticipantCount = useRef(participantCount)
+  const lastResetKey = useRef(resetKey)
   const stateRequested = useRef(new Set<string>())
   const stateRequestIds = useRef(new Map<string, string>())
   const stateResponseTimers = useRef(new Set<number>())
@@ -1198,6 +1201,15 @@ export function useWhiteboard({
     resetBoard()
   }, [clearStateResponseTimers, resetBoard, resetDrawingState])
 
+  useEffect(() => {
+    if (lastResetKey.current === resetKey) {
+      return
+    }
+
+    lastResetKey.current = resetKey
+    clearAllBoards()
+  }, [clearAllBoards, resetKey])
+
   const handlePointerDown = (event: ReactPointerEvent<HTMLCanvasElement>) => {
     if (
       !isTeacher ||

From 21aaf800ede2ee981158666625cf73cd8341c548 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 11:43:39 +0200
Subject: [PATCH 7/9] ver 7

---
 .../classes/[classId]/live-session/route.ts   | 119 +++++++++++-------
 app/api/livekit/token/route.ts                |  34 ++++-
 features/session/live-session-provider.tsx    |  75 +++++++++--
 features/session/live-session-types.ts        |  14 ++-
 features/session/use-live-session.ts          |  67 +++++++---
 features/session/use-whiteboard.ts            |  32 ++---
 lib/store.tsx                                 |   3 +-
 ...0505120000_add_live_session_generation.sql |   5 +
 ...0260505121000_claim_class_live_session.sql |  99 +++++++++++++++
 ...260505122000_harden_live_session_claim.sql | 115 +++++++++++++++++
 ...00_restrict_claim_live_session_execute.sql |   5 +
 ...05124000_fix_claim_live_session_return.sql | 117 +++++++++++++++++
 12 files changed, 596 insertions(+), 89 deletions(-)
 create mode 100644 supabase/migrations/20260505120000_add_live_session_generation.sql
 create mode 100644 supabase/migrations/20260505121000_claim_class_live_session.sql
 create mode 100644 supabase/migrations/20260505122000_harden_live_session_claim.sql
 create mode 100644 supabase/migrations/20260505123000_restrict_claim_live_session_execute.sql
 create mode 100644 supabase/migrations/20260505124000_fix_claim_live_session_return.sql

diff --git a/app/api/classes/[classId]/live-session/route.ts b/app/api/classes/[classId]/live-session/route.ts
index 79a26eb..e9e5b44 100644
--- a/app/api/classes/[classId]/live-session/route.ts
+++ b/app/api/classes/[classId]/live-session/route.ts
@@ -13,6 +13,7 @@ type RouteContext = {
 
 type LiveSessionRequestBody = {
   action?: "end"
+  liveSessionId?: string
   roomName?: string
 }
 
@@ -80,12 +81,14 @@ async function endLiveSession({
   roomName,
   supabase,
   userId,
+  liveSessionId,
 }: {
   canManage: boolean
   classId: string
   roomName: string
   supabase: SupabaseClient
   userId: string
+  liveSessionId?: string
 }) {
   const now = new Date().toISOString()
   let query = supabase
@@ -97,15 +100,30 @@ async function endLiveSession({
     })
     .eq("class_id", classId)
     .eq("room_name", roomName)
-    .eq("status", "live")
+    .in("status", ["pending", "live"])
+
+  if (liveSessionId) {
+    query = query.eq("live_session_id", liveSessionId)
+  }
 
   if (!canManage) {
     query = query.eq("started_by_user_id", userId)
   }
 
-  const { error } = await query
+  const { data, error } = await query.select("id").maybeSingle()
 
-  return error
+  if (error) {
+    return { message: error.message, status: 500 as const }
+  }
+
+  if (!data) {
+    return {
+      message: "No matching live session is active.",
+      status: 409 as const,
+    }
+  }
+
+  return null
 }
 
 export async function POST(request: Request, context: RouteContext) {
@@ -123,13 +141,17 @@ export async function POST(request: Request, context: RouteContext) {
     const error = await endLiveSession({
       canManage: false,
       classId,
+      liveSessionId: body.liveSessionId,
       roomName: routeRoomName,
       supabase,
       userId: user.id,
     })
 
     if (error) {
-      return NextResponse.json({ error: error.message }, { status: 500 })
+      return NextResponse.json(
+        { error: error.message },
+        { status: error.status },
+      )
     }
 
     return NextResponse.json({ ok: true })
@@ -153,58 +175,44 @@ export async function POST(request: Request, context: RouteContext) {
     )
   }
 
-  const now = new Date().toISOString()
-  const staleBefore = Date.now() - LIVE_SESSION_STALE_MS
-  const { data: existingSession, error: existingError } = await supabase
-    .from("class_live_sessions")
-    .select("id, status, last_seen_at")
-    .eq("class_id", result.classData.id)
-    .maybeSingle()
-
-  if (existingError) {
-    return NextResponse.json({ error: existingError.message }, { status: 500 })
-  }
-
-  const hasFreshLiveSession =
-    existingSession?.status === "live" &&
-    Date.parse(existingSession.last_seen_at) > staleBefore
-
-  if (hasFreshLiveSession) {
-    const { error } = await supabase
-      .from("class_live_sessions")
-      .update({
-        room_name: roomName,
-        started_by_user_id: user.id,
-        last_seen_at: now,
-        ended_at: null,
-      })
-      .eq("id", existingSession.id)
-
-    if (error) {
-      return NextResponse.json({ error: error.message }, { status: 500 })
-    }
-
-    return NextResponse.json({ ok: true })
+  if (!body?.liveSessionId) {
+    return NextResponse.json(
+      { error: "A liveSessionId is required to mark a session live." },
+      { status: 400 },
+    )
   }
 
-  const { error } = await supabase.from("class_live_sessions").upsert(
-    {
-      organization_id: result.classData.organization_id,
-      class_id: result.classData.id,
+  const now = new Date().toISOString()
+  const staleBefore = new Date(Date.now() - LIVE_SESSION_STALE_MS).toISOString()
+  const { data: liveSession, error } = await supabase
+    .from("class_live_sessions")
+    .update({
       room_name: roomName,
       started_by_user_id: user.id,
       status: "live",
-      started_at: now,
       last_seen_at: now,
       ended_at: null,
-    },
-    { onConflict: "class_id" },
-  )
+    })
+    .eq("class_id", result.classData.id)
+    .eq("room_name", roomName)
+    .eq("live_session_id", body.liveSessionId)
+    .in("status", ["pending", "live"])
+    .is("ended_at", null)
+    .gt("last_seen_at", staleBefore)
+    .select("live_session_id")
+    .maybeSingle()
 
   if (error) {
     return NextResponse.json({ error: error.message }, { status: 500 })
   }
 
+  if (!liveSession) {
+    return NextResponse.json(
+      { error: "No matching claimed live session is active." },
+      { status: 409 },
+    )
+  }
+
   if (result.classData.teacher_user_id === user.id) {
     const cooldownBucket = Math.floor(Date.now() / (10 * 60 * 1000))
 
@@ -227,7 +235,10 @@ export async function POST(request: Request, context: RouteContext) {
     }).catch(() => null)
   }
 
-  return NextResponse.json({ ok: true })
+  return NextResponse.json({
+    ok: true,
+    liveSessionId: liveSession.live_session_id,
+  })
 }
 
 export async function PATCH(request: Request, context: RouteContext) {
@@ -248,7 +259,7 @@ export async function PATCH(request: Request, context: RouteContext) {
 
   const body = await readLiveSessionBody(request)
   const roomName = body?.roomName || `class-${result.classData.id}`
-  const { error } = await supabase
+  let query = supabase
     .from("class_live_sessions")
     .update({ last_seen_at: new Date().toISOString() })
     .eq("class_id", result.classData.id)
@@ -256,10 +267,23 @@ export async function PATCH(request: Request, context: RouteContext) {
     .eq("status", "live")
     .is("ended_at", null)
 
+  if (body?.liveSessionId) {
+    query = query.eq("live_session_id", body.liveSessionId)
+  }
+
+  const { data, error } = await query.select("id").maybeSingle()
+
   if (error) {
     return NextResponse.json({ error: error.message }, { status: 500 })
   }
 
+  if (!data) {
+    return NextResponse.json(
+      { error: "No matching live session is active." },
+      { status: 409 },
+    )
+  }
+
   return NextResponse.json({ ok: true })
 }
 
@@ -282,13 +306,14 @@ export async function DELETE(request: Request, context: RouteContext) {
   const error = await endLiveSession({
     canManage: result.canManage,
     classId: result.classData.id,
+    liveSessionId: body?.liveSessionId,
     roomName,
     supabase,
     userId: user.id,
   })
 
   if (error) {
-    return NextResponse.json({ error: error.message }, { status: 500 })
+    return NextResponse.json({ error: error.message }, { status: error.status })
   }
 
   return NextResponse.json({ ok: true })
diff --git a/app/api/livekit/token/route.ts b/app/api/livekit/token/route.ts
index 4ac1140..157f571 100644
--- a/app/api/livekit/token/route.ts
+++ b/app/api/livekit/token/route.ts
@@ -8,6 +8,7 @@ const LIVE_SESSION_STALE_MS = 5 * 60 * 1000
 
 interface TokenRequestBody {
   classId?: string
+  liveSessionId?: string
   user?: {
     id?: string
     name?: string
@@ -111,6 +112,7 @@ export async function POST(request: Request) {
 
   const classId = classData.id
   const roomName = `class-${classId}`
+  let liveSessionId = body.liveSessionId
 
   if (!canManage) {
     const staleBefore = new Date(
@@ -118,7 +120,7 @@ export async function POST(request: Request) {
     ).toISOString()
     const { data: liveSession, error: liveSessionError } = await supabase
       .from("class_live_sessions")
-      .select("id")
+      .select("id, live_session_id")
       .eq("class_id", classId)
       .eq("room_name", roomName)
       .eq("status", "live")
@@ -139,12 +141,41 @@ export async function POST(request: Request) {
         { status: 409 },
       )
     }
+
+    if (liveSessionId && liveSession.live_session_id !== liveSessionId) {
+      return NextResponse.json(
+        { error: "This live session is no longer active." },
+        { status: 409 },
+      )
+    }
+
+    liveSessionId = liveSession.live_session_id
+  } else {
+    const staleBefore = new Date(
+      Date.now() - LIVE_SESSION_STALE_MS,
+    ).toISOString()
+    const { data: claimedLiveSession, error: claimError } = await supabase
+      .rpc("claim_class_live_session", {
+        target_org_id: classData.organization_id,
+        target_class_id: classId,
+        target_room_name: roomName,
+        stale_before: staleBefore,
+      })
+      .single()
+
+    if (claimError) {
+      return NextResponse.json({ error: claimError.message }, { status: 500 })
+    }
+
+    const liveSession = claimedLiveSession as { live_session_id: string }
+    liveSessionId = liveSession.live_session_id
   }
 
   const metadata = JSON.stringify({
     avatar: body.user.avatar ?? body.user.name.slice(0, 2).toUpperCase(),
     role: body.user.role ?? "student",
     classId,
+    liveSessionId,
   })
 
   const token = new AccessToken(apiKey, apiSecret, {
@@ -164,6 +195,7 @@ export async function POST(request: Request) {
   return NextResponse.json({
     serverUrl,
     roomName,
+    liveSessionId,
     participantToken: await token.toJwt(),
   })
 }
diff --git a/features/session/live-session-provider.tsx b/features/session/live-session-provider.tsx
index 6c14162..ebd20ed 100644
--- a/features/session/live-session-provider.tsx
+++ b/features/session/live-session-provider.tsx
@@ -39,9 +39,11 @@ function getRoomName(classId: string) {
 
 async function syncClassLiveSession({
   classId,
+  liveSessionId,
   method,
 }: {
   classId: string
+  liveSessionId?: string | null
   method: "POST" | "PATCH" | "DELETE"
 }) {
   const response = await fetch(
@@ -51,7 +53,7 @@ async function syncClassLiveSession({
       headers: {
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ roomName: getRoomName(classId) }),
+      body: JSON.stringify({ liveSessionId, roomName: getRoomName(classId) }),
     },
   )
 
@@ -62,15 +64,21 @@ async function syncClassLiveSession({
 
     throw new Error(payload?.error ?? "Could not update live session.")
   }
+
+  return (await response.json().catch(() => null)) as {
+    liveSessionId?: string
+    ok?: boolean
+  } | null
 }
 
 function terminateClassLiveSession(
   classId: string,
-  options: { useBeacon?: boolean } = {},
+  options: { liveSessionId?: string | null; useBeacon?: boolean } = {},
 ) {
   const url = `/api/classes/${encodeURIComponent(classId)}/live-session`
   const body = JSON.stringify({
     action: "end",
+    liveSessionId: options.liveSessionId,
     roomName: getRoomName(classId),
   })
 
@@ -108,9 +116,11 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   const [sessionActive, setSessionActive] = useState(false)
   const [hasJoinedSession, setHasJoinedSession] = useState(false)
   const [sessionScope, setSessionScope] = useState<string | null>(null)
+  const [liveSessionId, setLiveSessionId] = useState<string | null>(null)
   const [whiteboardResetKey, setWhiteboardResetKey] = useState(0)
   const activeTeacherSessionRef = useRef<string | null>(null)
   const disconnectRef = useRef<() => void>(() => {})
+  const liveSessionIdRef = useRef<string | null>(null)
   const mountedRef = useRef(false)
   const sessionPresenceRef = useRef({
     activeClassId: null as string | null,
@@ -122,8 +132,15 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   const resetLocalWhiteboards = useCallback(() => {
     setWhiteboardResetKey((key) => key + 1)
   }, [])
+  const handleLiveSessionIdResolved = useCallback(
+    (nextLiveSessionId: string) => {
+      setLiveSessionId(nextLiveSessionId)
+    },
+    [],
+  )
   const handleRemoteSessionEnded = useCallback(() => {
     resetLocalWhiteboards()
+    setLiveSessionId(null)
     setSessionActive(false)
     setSessionScope(null)
     setHasJoinedSession(true)
@@ -135,6 +152,8 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     enabled: Boolean(
       activeClass && sessionActive && sessionScope === currentSessionScope,
     ),
+    liveSessionId,
+    onLiveSessionIdResolved: handleLiveSessionIdResolved,
     onSessionEnded: handleRemoteSessionEnded,
   })
   const connected = liveSession.connectionState === ConnectionState.Connected
@@ -156,6 +175,10 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     disconnectRef.current = liveSession.disconnect
   }, [liveSession.disconnect])
 
+  useEffect(() => {
+    liveSessionIdRef.current = liveSessionId
+  }, [liveSessionId])
+
   useEffect(() => {
     sessionPresenceRef.current = {
       activeClassId: activeClass?.id ?? null,
@@ -205,6 +228,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
 
           disconnectRef.current()
           resetLocalWhiteboards()
+          setLiveSessionId(null)
           setSessionActive(false)
           setSessionScope(null)
           setHasJoinedSession(true)
@@ -231,17 +255,27 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
   const joinSession = useCallback(
     (cls: Class) => {
       const currentTeacherClassId = activeTeacherSessionRef.current
+      const existingLiveSessionId =
+        classLiveSessions.find((session) => session.class_id === cls.id)
+          ?.live_session_id ?? null
+
+      if (!isTeacher && !existingLiveSessionId) {
+        return
+      }
 
       if (currentTeacherClassId && currentTeacherClassId !== cls.id) {
-        void terminateClassLiveSession(currentTeacherClassId)
+        void terminateClassLiveSession(currentTeacherClassId, {
+          liveSessionId: liveSessionIdRef.current,
+        })
       }
 
       setActiveClass(cls)
+      setLiveSessionId(existingLiveSessionId)
       setSessionScope(currentSessionScope)
       setHasJoinedSession(true)
       setSessionActive(true)
     },
-    [currentSessionScope],
+    [classLiveSessions, currentSessionScope, isTeacher],
   )
 
   const leaveSession = useCallback(() => {
@@ -266,25 +300,37 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     }
 
     liveSession.disconnect()
+    setLiveSessionId(null)
     setSessionActive(false)
     setSessionScope(null)
     setHasJoinedSession(true)
 
     if (isTeacher) {
-      await syncClassLiveSession({ classId, method: "DELETE" }).catch(() => {})
+      await syncClassLiveSession({
+        classId,
+        liveSessionId,
+        method: "DELETE",
+      }).catch(() => {})
       await refreshClassLiveSessions({ force: true }).catch(() => {})
     }
   }, [
     activeClass?.id,
     isTeacher,
     leaveSession,
+    liveSessionId,
     liveSession,
     refreshClassLiveSessions,
     resetLocalWhiteboards,
   ])
 
   useEffect(() => {
-    if (!activeClass || !sessionActive || !isTeacher || !connected) {
+    if (
+      !activeClass ||
+      !liveSessionId ||
+      !sessionActive ||
+      !isTeacher ||
+      !connected
+    ) {
       return
     }
 
@@ -295,7 +341,12 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
 
       await syncClassLiveSession({
         classId: activeClass.id,
+        liveSessionId,
         method: "POST",
+      }).then((payload) => {
+        if (!cancelled && payload?.liveSessionId) {
+          setLiveSessionId(payload.liveSessionId)
+        }
       })
       if (!cancelled) {
         await refreshClassLiveSessions({ force: true }).catch(() => {})
@@ -307,6 +358,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     const heartbeat = window.setInterval(() => {
       void syncClassLiveSession({
         classId: activeClass.id,
+        liveSessionId,
         method: "PATCH",
       }).catch(() => {})
     }, 60_000)
@@ -319,6 +371,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     activeClass,
     connected,
     isTeacher,
+    liveSessionId,
     refreshClassLiveSessions,
     sessionActive,
   ])
@@ -331,7 +384,9 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
     const classId = activeTeacherSessionRef.current
 
     if (classId) {
-      void terminateClassLiveSession(classId)
+      void terminateClassLiveSession(classId, {
+        liveSessionId: liveSessionIdRef.current,
+      })
         .catch(() => {})
         .finally(() => {
           void refreshClassLiveSessions({ force: true }).catch(() => {})
@@ -340,6 +395,7 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
 
     disconnectRef.current()
     setActiveClass(null)
+    setLiveSessionId(null)
     setSessionActive(false)
     setHasJoinedSession(false)
     setSessionScope(null)
@@ -350,7 +406,10 @@ export function LiveSessionProvider({ children }: { children: ReactNode }) {
       const classId = activeTeacherSessionRef.current
 
       if (classId) {
-        void terminateClassLiveSession(classId, options)
+        void terminateClassLiveSession(classId, {
+          ...options,
+          liveSessionId: liveSessionIdRef.current,
+        })
           .catch(() => {})
           .finally(() => {
             if (!options?.useBeacon) {
diff --git a/features/session/live-session-types.ts b/features/session/live-session-types.ts
index cd94a6a..2a21fdb 100644
--- a/features/session/live-session-types.ts
+++ b/features/session/live-session-types.ts
@@ -115,7 +115,9 @@ export type WhiteboardOperation =
       delta: WhiteboardPoint
     }
 
-export type LiveSessionWhiteboardMessage =
+export type LiveSessionWhiteboardMessage = {
+  liveSessionId: string
+} & (
   | {
       id: string
       senderId: string
@@ -219,6 +221,14 @@ export type LiveSessionWhiteboardMessage =
       senderId: string
       type: "session:end"
     }
+)
+
+export type LiveSessionWhiteboardMessagePayload =
+  LiveSessionWhiteboardMessage extends infer Message
+    ? Message extends LiveSessionWhiteboardMessage
+      ? Omit<Message, "liveSessionId">
+      : never
+    : never
 
 export interface LiveSessionChatMessage {
   id: string
@@ -249,7 +259,7 @@ export interface LiveSessionState {
   toggleCamera: () => Promise<void>
   toggleScreenShare: () => Promise<void>
   sendWhiteboardMessage: (
-    message: LiveSessionWhiteboardMessage,
+    message: LiveSessionWhiteboardMessagePayload,
     options?: { reliable?: boolean },
   ) => Promise<boolean>
   clearWhiteboards: () => Promise<boolean>
diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index 2e71169..df2790d 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -21,6 +21,7 @@ import type {
   LiveSessionNotice,
   LiveSessionState,
   LiveSessionWhiteboardMessage,
+  LiveSessionWhiteboardMessagePayload,
   SessionParticipant,
   SessionPresentation,
   WhiteboardOperation,
@@ -424,6 +425,7 @@ function isWhiteboardMessage(
     !isJsonObject(value) ||
     typeof value.id !== "string" ||
     typeof value.senderId !== "string" ||
+    typeof value.liveSessionId !== "string" ||
     typeof value.type !== "string" ||
     (value.boardId !== undefined && typeof value.boardId !== "string")
   ) {
@@ -810,7 +812,11 @@ function mapParticipant(
   } satisfies SessionParticipant
 }
 
-async function fetchSessionToken(classId: string, user: SessionTokenUser) {
+async function fetchSessionToken(
+  classId: string,
+  liveSessionId: string | null,
+  user: SessionTokenUser,
+) {
   const response = await fetch("/api/livekit/token", {
     method: "POST",
     headers: {
@@ -818,6 +824,7 @@ async function fetchSessionToken(classId: string, user: SessionTokenUser) {
     },
     body: JSON.stringify({
       classId,
+      liveSessionId,
       user: {
         id: user.id,
         name: user.name,
@@ -829,26 +836,40 @@ async function fetchSessionToken(classId: string, user: SessionTokenUser) {
 
   const payload = (await response.json().catch(() => null)) as {
     error?: string
+    liveSessionId?: string
     participantToken?: string
     serverUrl?: string
   } | null
 
-  if (!response.ok || !payload?.participantToken || !payload.serverUrl) {
+  if (
+    !response.ok ||
+    !payload?.liveSessionId ||
+    !payload.participantToken ||
+    !payload.serverUrl
+  ) {
     throw new Error(payload?.error ?? "Unable to create a live session token.")
   }
 
-  return payload as { participantToken: string; serverUrl: string }
+  return payload as {
+    liveSessionId: string
+    participantToken: string
+    serverUrl: string
+  }
 }
 
 export function useLiveSession({
   classId,
   currentUser,
   enabled,
+  liveSessionId,
+  onLiveSessionIdResolved,
   onSessionEnded,
 }: {
   classId: string
   currentUser: User
   enabled: boolean
+  liveSessionId: string | null
+  onLiveSessionIdResolved?: (liveSessionId: string) => void
   onSessionEnded?: () => void
 }): LiveSessionState {
   const roomRef = useRef<Room | null>(null)
@@ -1013,6 +1034,10 @@ export function useLiveSession({
           return
         }
 
+        if (parsed.liveSessionId !== liveSessionId) {
+          return
+        }
+
         if (parsed.type === "session:end") {
           setWhiteboardMessages((prev) => [...prev.slice(-199), parsed])
           room.disconnect()
@@ -1102,20 +1127,26 @@ export function useLiveSession({
 
     const connect = async () => {
       try {
-        const { participantToken, serverUrl } = await fetchSessionToken(
-          classId,
-          {
-            id: currentUserId,
-            name: currentUserName,
-            avatar: currentUserAvatar,
-            role: currentUserRole,
-          },
-        )
+        const {
+          liveSessionId: resolvedLiveSessionId,
+          participantToken,
+          serverUrl,
+        } = await fetchSessionToken(classId, liveSessionId, {
+          id: currentUserId,
+          name: currentUserName,
+          avatar: currentUserAvatar,
+          role: currentUserRole,
+        })
 
         if (isCancelled) {
           return
         }
 
+        if (resolvedLiveSessionId !== liveSessionId) {
+          onLiveSessionIdResolved?.(resolvedLiveSessionId)
+          return
+        }
+
         await room.connect(serverUrl, participantToken, ROOM_CONNECT_OPTIONS)
 
         if (isCancelled) {
@@ -1201,6 +1232,8 @@ export function useLiveSession({
     currentUserName,
     currentUserRole,
     enabled,
+    liveSessionId,
+    onLiveSessionIdResolved,
     onSessionEnded,
     syncParticipants,
     updateMediaDevice,
@@ -1209,17 +1242,19 @@ export function useLiveSession({
 
   const sendWhiteboardMessage = useCallback(
     async (
-      message: LiveSessionWhiteboardMessage,
+      message: LiveSessionWhiteboardMessagePayload,
       options?: { reliable?: boolean },
     ) => {
       const room = roomRef.current
 
-      if (!room || room.state !== ConnectionState.Connected) {
+      if (!liveSessionId || !room || room.state !== ConnectionState.Connected) {
         return false
       }
 
       try {
-        const encoded = new TextEncoder().encode(JSON.stringify(message))
+        const encoded = new TextEncoder().encode(
+          JSON.stringify({ ...message, liveSessionId }),
+        )
         await room.localParticipant.publishData(encoded, {
           reliable: options?.reliable ?? true,
           topic: WHITEBOARD_TOPIC,
@@ -1239,7 +1274,7 @@ export function useLiveSession({
         return false
       }
     },
-    [upsertNotice],
+    [liveSessionId, upsertNotice],
   )
 
   const clearWhiteboards = useCallback(() => {
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index ca86da5..3a992d1 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -6,6 +6,7 @@ import type {
 } from "react"
 import type {
   LiveSessionWhiteboardMessage,
+  LiveSessionWhiteboardMessagePayload,
   WhiteboardOperation,
   WhiteboardPoint,
   WhiteboardShape,
@@ -39,7 +40,7 @@ type OperationBounds = {
 type OutgoingWhiteboardMessage =
   LiveSessionWhiteboardMessage extends infer Message
     ? Message extends LiveSessionWhiteboardMessage
-      ? Omit<Message, "id" | "senderId" | "boardId">
+      ? Omit<Message, "id" | "senderId" | "boardId" | "liveSessionId">
       : never
     : never
 
@@ -77,7 +78,7 @@ interface WhiteboardOptions {
   resetKey: number
   syncEnabled: boolean
   sendMessage: (
-    message: LiveSessionWhiteboardMessage,
+    message: LiveSessionWhiteboardMessagePayload,
     options?: { reliable?: boolean },
   ) => Promise<boolean>
 }
@@ -906,24 +907,27 @@ export function useWhiteboard({
           senderId: currentUserId,
           boardId,
           ...message,
-        } as LiveSessionWhiteboardMessage,
+        } as LiveSessionWhiteboardMessagePayload,
         options,
       )
     },
     [boardId, currentUserId, sendMessage, syncEnabled],
   )
 
-  const sendStateSync = useCallback((requestId?: string) => {
-    sendWhiteboardMessage(
-      {
-        type: "state:sync",
-        ...(requestId ? { requestId } : {}),
-        version: boardVersion.current,
-        operations: getStateSyncOperations(operations.current),
-      },
-      { reliable: true },
-    )
-  }, [sendWhiteboardMessage])
+  const sendStateSync = useCallback(
+    (requestId?: string) => {
+      sendWhiteboardMessage(
+        {
+          type: "state:sync",
+          ...(requestId ? { requestId } : {}),
+          version: boardVersion.current,
+          operations: getStateSyncOperations(operations.current),
+        },
+        { reliable: true },
+      )
+    },
+    [sendWhiteboardMessage],
+  )
 
   const commitOperation = useCallback((operation: WhiteboardOperation) => {
     operations.current = [...operations.current, operation]
diff --git a/lib/store.tsx b/lib/store.tsx
index 13ce12e..5c2f14a 100644
--- a/lib/store.tsx
+++ b/lib/store.tsx
@@ -70,6 +70,7 @@ export type ClassLiveSessionRow = {
   organization_id: string
   class_id: string
   room_name: string
+  live_session_id: string
   started_by_user_id: string
   status: "live" | "ended"
   started_at: string
@@ -854,7 +855,7 @@ async function loadClassLiveSessions(organizationId: string) {
   const { data, error } = await supabase
     .from("class_live_sessions")
     .select(
-      "id, organization_id, class_id, room_name, started_by_user_id, status, started_at, last_seen_at, ended_at",
+      "id, organization_id, class_id, room_name, live_session_id, started_by_user_id, status, started_at, last_seen_at, ended_at",
     )
     .eq("organization_id", organizationId)
     .eq("status", "live")
diff --git a/supabase/migrations/20260505120000_add_live_session_generation.sql b/supabase/migrations/20260505120000_add_live_session_generation.sql
new file mode 100644
index 0000000..d4ff9b1
--- /dev/null
+++ b/supabase/migrations/20260505120000_add_live_session_generation.sql
@@ -0,0 +1,5 @@
+alter table public.class_live_sessions
+  add column if not exists live_session_id uuid not null default gen_random_uuid();
+
+create index if not exists idx_class_live_sessions_live_session_id
+  on public.class_live_sessions (live_session_id);
diff --git a/supabase/migrations/20260505121000_claim_class_live_session.sql b/supabase/migrations/20260505121000_claim_class_live_session.sql
new file mode 100644
index 0000000..ef3115e
--- /dev/null
+++ b/supabase/migrations/20260505121000_claim_class_live_session.sql
@@ -0,0 +1,99 @@
+create or replace function public.claim_class_live_session(
+  target_org_id uuid,
+  target_class_id uuid,
+  target_room_name text,
+  stale_before timestamptz
+)
+returns table (live_session_id uuid)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  current_session public.class_live_sessions%rowtype;
+  next_live_session_id uuid;
+begin
+  if not public.can_manage_class(target_org_id, target_class_id) then
+    raise exception 'Only class managers can start live sessions.';
+  end if;
+
+  loop
+    select *
+      into current_session
+      from public.class_live_sessions
+      where class_id = target_class_id
+      for update;
+
+    if found then
+      if
+        current_session.status = 'live'
+        and current_session.ended_at is null
+        and current_session.last_seen_at > stale_before
+      then
+        update public.class_live_sessions
+          set room_name = target_room_name,
+              started_by_user_id = auth.uid(),
+              last_seen_at = now(),
+              ended_at = null
+          where id = current_session.id
+          returning public.class_live_sessions.live_session_id
+            into live_session_id;
+
+        return next;
+      end if;
+
+      next_live_session_id := gen_random_uuid();
+
+      update public.class_live_sessions
+        set room_name = target_room_name,
+            live_session_id = next_live_session_id,
+            started_by_user_id = auth.uid(),
+            status = 'live',
+            started_at = now(),
+            last_seen_at = now(),
+            ended_at = null
+        where id = current_session.id
+        returning public.class_live_sessions.live_session_id
+          into live_session_id;
+
+      return next;
+    end if;
+
+    begin
+      next_live_session_id := gen_random_uuid();
+
+      insert into public.class_live_sessions (
+        organization_id,
+        class_id,
+        room_name,
+        live_session_id,
+        started_by_user_id,
+        status,
+        started_at,
+        last_seen_at,
+        ended_at
+      )
+      values (
+        target_org_id,
+        target_class_id,
+        target_room_name,
+        next_live_session_id,
+        auth.uid(),
+        'live',
+        now(),
+        now(),
+        null
+      )
+      returning public.class_live_sessions.live_session_id
+        into live_session_id;
+
+      return next;
+    exception
+      when unique_violation then
+    end;
+  end loop;
+end;
+$$;
+
+grant execute on function public.claim_class_live_session(uuid, uuid, text, timestamptz)
+  to authenticated;
diff --git a/supabase/migrations/20260505122000_harden_live_session_claim.sql b/supabase/migrations/20260505122000_harden_live_session_claim.sql
new file mode 100644
index 0000000..31b1447
--- /dev/null
+++ b/supabase/migrations/20260505122000_harden_live_session_claim.sql
@@ -0,0 +1,115 @@
+alter table public.class_live_sessions
+  drop constraint if exists class_live_sessions_status_valid;
+
+alter table public.class_live_sessions
+  add constraint class_live_sessions_status_valid
+  check (status in ('pending', 'live', 'ended'));
+
+create or replace function public.claim_class_live_session(
+  target_org_id uuid,
+  target_class_id uuid,
+  target_room_name text,
+  stale_before timestamptz
+)
+returns table (live_session_id uuid)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  class_org_id uuid;
+  current_session public.class_live_sessions%rowtype;
+  next_live_session_id uuid;
+begin
+  select organization_id
+    into class_org_id
+    from public.classes
+    where id = target_class_id
+      and organization_id = target_org_id
+      and is_archived = false;
+
+  if class_org_id is null then
+    raise exception 'Class not found.';
+  end if;
+
+  if not public.can_manage_class(class_org_id, target_class_id) then
+    raise exception 'Only class managers can start live sessions.';
+  end if;
+
+  loop
+    select *
+      into current_session
+      from public.class_live_sessions
+      where class_id = target_class_id
+      for update;
+
+    if found then
+      if
+        current_session.status in ('pending', 'live')
+        and current_session.ended_at is null
+        and current_session.last_seen_at > stale_before
+      then
+        update public.class_live_sessions
+          set room_name = target_room_name,
+              started_by_user_id = auth.uid(),
+              last_seen_at = now(),
+              ended_at = null
+          where id = current_session.id
+          returning public.class_live_sessions.live_session_id
+            into live_session_id;
+
+        return next;
+      end if;
+
+      next_live_session_id := gen_random_uuid();
+
+      update public.class_live_sessions
+        set room_name = target_room_name,
+            live_session_id = next_live_session_id,
+            started_by_user_id = auth.uid(),
+            status = 'pending',
+            started_at = now(),
+            last_seen_at = now(),
+            ended_at = null
+        where id = current_session.id
+        returning public.class_live_sessions.live_session_id
+          into live_session_id;
+
+      return next;
+    end if;
+
+    begin
+      next_live_session_id := gen_random_uuid();
+
+      insert into public.class_live_sessions (
+        organization_id,
+        class_id,
+        room_name,
+        live_session_id,
+        started_by_user_id,
+        status,
+        started_at,
+        last_seen_at,
+        ended_at
+      )
+      values (
+        class_org_id,
+        target_class_id,
+        target_room_name,
+        next_live_session_id,
+        auth.uid(),
+        'pending',
+        now(),
+        now(),
+        null
+      )
+      returning public.class_live_sessions.live_session_id
+        into live_session_id;
+
+      return next;
+    exception
+      when unique_violation then
+    end;
+  end loop;
+end;
+$$;
diff --git a/supabase/migrations/20260505123000_restrict_claim_live_session_execute.sql b/supabase/migrations/20260505123000_restrict_claim_live_session_execute.sql
new file mode 100644
index 0000000..e2ac793
--- /dev/null
+++ b/supabase/migrations/20260505123000_restrict_claim_live_session_execute.sql
@@ -0,0 +1,5 @@
+revoke all on function public.claim_class_live_session(uuid, uuid, text, timestamptz)
+  from public;
+
+grant execute on function public.claim_class_live_session(uuid, uuid, text, timestamptz)
+  to authenticated;
diff --git a/supabase/migrations/20260505124000_fix_claim_live_session_return.sql b/supabase/migrations/20260505124000_fix_claim_live_session_return.sql
new file mode 100644
index 0000000..8181896
--- /dev/null
+++ b/supabase/migrations/20260505124000_fix_claim_live_session_return.sql
@@ -0,0 +1,117 @@
+create or replace function public.claim_class_live_session(
+  target_org_id uuid,
+  target_class_id uuid,
+  target_room_name text,
+  stale_before timestamptz
+)
+returns table (live_session_id uuid)
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  class_org_id uuid;
+  current_session public.class_live_sessions%rowtype;
+  next_live_session_id uuid;
+begin
+  select organization_id
+    into class_org_id
+    from public.classes
+    where id = target_class_id
+      and organization_id = target_org_id
+      and is_archived = false;
+
+  if class_org_id is null then
+    raise exception 'Class not found.';
+  end if;
+
+  if not public.can_manage_class(class_org_id, target_class_id) then
+    raise exception 'Only class managers can start live sessions.';
+  end if;
+
+  loop
+    select *
+      into current_session
+      from public.class_live_sessions
+      where class_id = target_class_id
+      for update;
+
+    if found then
+      if
+        current_session.status in ('pending', 'live')
+        and current_session.ended_at is null
+        and current_session.last_seen_at > stale_before
+      then
+        update public.class_live_sessions
+          set room_name = target_room_name,
+              started_by_user_id = auth.uid(),
+              last_seen_at = now(),
+              ended_at = null
+          where id = current_session.id
+          returning public.class_live_sessions.live_session_id
+            into live_session_id;
+
+        return next;
+        return;
+      end if;
+
+      next_live_session_id := gen_random_uuid();
+
+      update public.class_live_sessions
+        set room_name = target_room_name,
+            live_session_id = next_live_session_id,
+            started_by_user_id = auth.uid(),
+            status = 'pending',
+            started_at = now(),
+            last_seen_at = now(),
+            ended_at = null
+        where id = current_session.id
+        returning public.class_live_sessions.live_session_id
+          into live_session_id;
+
+      return next;
+      return;
+    end if;
+
+    begin
+      next_live_session_id := gen_random_uuid();
+
+      insert into public.class_live_sessions (
+        organization_id,
+        class_id,
+        room_name,
+        live_session_id,
+        started_by_user_id,
+        status,
+        started_at,
+        last_seen_at,
+        ended_at
+      )
+      values (
+        class_org_id,
+        target_class_id,
+        target_room_name,
+        next_live_session_id,
+        auth.uid(),
+        'pending',
+        now(),
+        now(),
+        null
+      )
+      returning public.class_live_sessions.live_session_id
+        into live_session_id;
+
+      return next;
+      return;
+    exception
+      when unique_violation then
+    end;
+  end loop;
+end;
+$$;
+
+revoke all on function public.claim_class_live_session(uuid, uuid, text, timestamptz)
+  from public;
+
+grant execute on function public.claim_class_live_session(uuid, uuid, text, timestamptz)
+  to authenticated;

From 9cbd2b6c4a629eeb06de7ebf64c19ded85d12577 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 12:00:47 +0200
Subject: [PATCH 8/9] ver 8

---
 features/session/use-live-session.ts | 75 +++++++++++++++++++++-------
 features/session/use-whiteboard.ts   | 12 +++--
 2 files changed, 67 insertions(+), 20 deletions(-)

diff --git a/features/session/use-live-session.ts b/features/session/use-live-session.ts
index df2790d..6b68d9e 100644
--- a/features/session/use-live-session.ts
+++ b/features/session/use-live-session.ts
@@ -166,6 +166,10 @@ function isRole(value: string | undefined): value is Role {
   return value === "student" || value === "teacher" || value === "admin"
 }
 
+function isConnectedRoom(room: Room | null): room is Room {
+  return room?.state === ConnectionState.Connected
+}
+
 function getInitials(name: string) {
   return name
     .split(" ")
@@ -914,6 +918,29 @@ export function useLiveSession({
     [],
   )
 
+  const disconnectRoom = useCallback((room: Room | null = roomRef.current) => {
+    if (!room) {
+      return
+    }
+
+    if (roomRef.current === room) {
+      roomRef.current = null
+    }
+
+    void room.disconnect().catch(() => {})
+  }, [])
+
+  const noticeMediaNotConnected = useCallback(() => {
+    upsertNotice({
+      id: "media-not-connected",
+      scope: "session",
+      severity: "info",
+      title: "Session is reconnecting",
+      description: "Media controls are available after reconnection.",
+      nextStep: "Wait a moment, then try again.",
+    })
+  }, [upsertNotice])
+
   useEffect(() => {
     if (!chatStorageKey) {
       return
@@ -978,8 +1005,7 @@ export function useLiveSession({
 
   useEffect(() => {
     if (!enabled) {
-      roomRef.current?.disconnect()
-      roomRef.current = null
+      disconnectRoom()
       setParticipants([])
       setConnectionState(ConnectionState.Disconnected)
       setIsConnecting(false)
@@ -1040,7 +1066,7 @@ export function useLiveSession({
 
         if (parsed.type === "session:end") {
           setWhiteboardMessages((prev) => [...prev.slice(-199), parsed])
-          room.disconnect()
+          disconnectRoom(room)
           onSessionEnded?.()
           return
         }
@@ -1198,7 +1224,7 @@ export function useLiveSession({
         setIsConnecting(false)
         setConnectionState(ConnectionState.Disconnected)
         setMedia(INITIAL_MEDIA_STATUS)
-        room.disconnect()
+        disconnectRoom(room)
       }
     }
 
@@ -1220,10 +1246,7 @@ export function useLiveSession({
       room.off(RoomEvent.DataReceived, handleDataReceived)
       room.off(RoomEvent.MediaDevicesError, handleMediaDevicesError)
       room.unregisterTextStreamHandler(CHAT_TOPIC)
-      room.disconnect()
-      if (roomRef.current === room) {
-        roomRef.current = null
-      }
+      disconnectRoom(room)
     }
   }, [
     classId,
@@ -1231,6 +1254,7 @@ export function useLiveSession({
     currentUserId,
     currentUserName,
     currentUserRole,
+    disconnectRoom,
     enabled,
     liveSessionId,
     onLiveSessionIdResolved,
@@ -1376,7 +1400,8 @@ export function useLiveSession({
   const toggleMic = useCallback(async () => {
     const room = roomRef.current
 
-    if (!room) {
+    if (!isConnectedRoom(room)) {
+      noticeMediaNotConnected()
       return
     }
 
@@ -1416,12 +1441,18 @@ export function useLiveSession({
       upsertNotice(notice)
       setError(notice.description)
     }
-  }, [syncParticipants, updateMediaDevice, upsertNotice])
+  }, [
+    noticeMediaNotConnected,
+    syncParticipants,
+    updateMediaDevice,
+    upsertNotice,
+  ])
 
   const toggleCamera = useCallback(async () => {
     const room = roomRef.current
 
-    if (!room) {
+    if (!isConnectedRoom(room)) {
+      noticeMediaNotConnected()
       return
     }
 
@@ -1458,12 +1489,18 @@ export function useLiveSession({
       upsertNotice(notice)
       setError(notice.description)
     }
-  }, [syncParticipants, updateMediaDevice, upsertNotice])
+  }, [
+    noticeMediaNotConnected,
+    syncParticipants,
+    updateMediaDevice,
+    upsertNotice,
+  ])
 
   const toggleScreenShare = useCallback(async () => {
     const room = roomRef.current
 
-    if (!room) {
+    if (!isConnectedRoom(room)) {
+      noticeMediaNotConnected()
       return
     }
 
@@ -1507,11 +1544,15 @@ export function useLiveSession({
       upsertNotice(notice)
       setError(notice.description)
     }
-  }, [syncParticipants, updateMediaDevice, upsertNotice])
+  }, [
+    noticeMediaNotConnected,
+    syncParticipants,
+    updateMediaDevice,
+    upsertNotice,
+  ])
 
   const disconnect = useCallback(() => {
-    roomRef.current?.disconnect()
-    roomRef.current = null
+    disconnectRoom()
     setParticipants([])
     setConnectionState(ConnectionState.Disconnected)
     setIsConnecting(false)
@@ -1521,7 +1562,7 @@ export function useLiveSession({
     setChatMessages([])
     setChatStorageKey(null)
     setWhiteboardMessages([])
-  }, [])
+  }, [disconnectRoom])
 
   const localParticipant = participants.find(
     (participant) => participant.isLocal,
diff --git a/features/session/use-whiteboard.ts b/features/session/use-whiteboard.ts
index 3a992d1..3441ca7 100644
--- a/features/session/use-whiteboard.ts
+++ b/features/session/use-whiteboard.ts
@@ -1836,16 +1836,22 @@ export function useWhiteboard({
 
       if (message.type === "state:sync") {
         const currentRequestId = stateRequestIds.current.get(boardId)
+        const isRequestedSync = Boolean(
+          message.requestId && message.requestId === currentRequestId,
+        )
 
-        if (message.requestId && message.requestId !== currentRequestId) {
+        if (message.requestId && !isRequestedSync) {
           continue
         }
 
-        if (message.version <= boardVersion.current) {
+        if (
+          message.version < boardVersion.current ||
+          (!isRequestedSync && message.version === boardVersion.current)
+        ) {
           continue
         }
 
-        if (message.requestId) {
+        if (isRequestedSync) {
           stateRequestIds.current.delete(boardId)
         }
 

From baa7f06ba533d887e26123f8a606a7546865ac22 Mon Sep 17 00:00:00 2001
From: ShiboSoftwareDev <shibosoftwaredev@gmail.com>
Date: Tue, 5 May 2026 12:47:16 +0200
Subject: [PATCH 9/9] ver 9

---
 features/session/session-screen.tsx | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/features/session/session-screen.tsx b/features/session/session-screen.tsx
index e56623b..d0ab26d 100644
--- a/features/session/session-screen.tsx
+++ b/features/session/session-screen.tsx
@@ -736,16 +736,6 @@ export function SessionScreen({ cls }: { cls: Class }) {
           {liveSession.participants.map((participant) => (
             <VideoTile key={participant.id} participant={participant} />
           ))}
-          <div className="ml-auto hidden md:flex items-center gap-2 text-xs text-muted-foreground pr-2">
-            <ArrowUpRight className="w-3.5 h-3.5" />
-            {teacherReconnectAvailable
-              ? "Live session is waiting for you to reconnect"
-              : isTeacherPreviewSession
-                ? "Whiteboard is local until you go live"
-                : liveSession.presentation
-                  ? "Presentation synced live"
-                  : "Whiteboard synced live"}
-          </div>
         </div>
       </div>
     </TooltipProvider>