@@ -42,6 +42,9 @@ next-env.d.ts
 dist
 .cursor
 
+# genai
+CLAUDE.md
+
 # playwright
 /test-results/
 /playwright-report/
 
@@ -646,7 +646,7 @@ export default function RideDetailPage({
         const body = await res.json();
         throw new Error(body.error ?? res.statusText);
       }
-      socketRef.current?.emit("endRoute");
+      socketRef.current?.emit("closeRouteRoom");
       setShowCancelModal(false);
       router.push("/rides");
     } catch (e) {
@@ -673,7 +673,7 @@ export default function RideDetailPage({
         }
         const updated: RouteData = await res.json();
         setRoute(updated);
-        if (terminal) socketRef.current?.emit("endRoute");
+        if (terminal) socketRef.current?.emit("closeRouteRoom");
       } catch (e) {
         setDriverActionError(e instanceof Error ? e.message : errorMsg);
       } finally {
@@ -720,7 +720,7 @@ export default function RideDetailPage({
       }
       const updated: RouteData = await res.json();
       setRoute(updated);
-      socketRef.current?.emit("endRoute");
+      socketRef.current?.emit("closeRouteRoom");
     } catch (e) {
       setMissingError(
         e instanceof Error ? e.message : "Failed to mark as missing.",
 
@@ -3,6 +3,7 @@ import RouteModel, { RouteStatus } from "../models/RouteModel";
 import LocationModel from "../models/LocationModel";
 import UserModel from "../models/UserModel";
 import VehicleModel from "../models/VehicleModel";
+import Chatlog from "../models/ChatlogModel";
 import { createRouteSchema, type CreateRouteInput } from "@/utils/types";
 import {
   RouteAlreadyExistsException,
@@ -138,6 +139,13 @@ export async function getRoutes(filters?: {
   return routes;
 }
 
+async function archiveChatlogForRoute(routeId: string) {
+  await Chatlog.findOneAndUpdate(
+    { routeId, status: "active" },
+    { $set: { status: "archived", archivedAt: new Date() } },
+  );
+}
+
 export async function completeRoute(routeId: string) {
   await connectMongoDB();
   const route = await RouteModel.findById(routeId);
@@ -165,6 +173,8 @@ export async function completeRoute(routeId: string) {
     );
   }
 
+  await archiveChatlogForRoute(routeId);
+  
   return route.toObject();
 }
 export async function cancelRoute(routeId: string, status?: string) {
@@ -219,6 +229,8 @@ export async function cancelRoute(routeId: string, status?: string) {
     }
   }
 
+  await archiveChatlogForRoute(routeId);
+  
   return route.toObject();
 }
 
@@ -278,6 +290,7 @@ export async function markRouteMissing(routeId: string) {
   }
   route.status = RouteStatus.Missing;
   await route.save();
+  await archiveChatlogForRoute(routeId);
   return route.toObject();
 }
 
@@ -390,6 +403,29 @@ export async function scheduleRoute(
         time: `${formatEstDate(route.scheduledPickupTime)} ${formatEstTime(route.scheduledPickupTime)}`,
       },
     );
+  // Upsert (not create) so this is safe even if a chat record already
+  // exists for this route; the unique index on routeId means a genuine
+  // race between two concurrent schedule calls can still surface as a
+  // duplicate-key error on the losing side, which is expected, not a bug.
+  try {
+    await Chatlog.findOneAndUpdate(
+      { routeId: route._id },
+      {
+        $setOnInsert: {
+          routeId: route._id,
+          student: route.student,
+          driver: driverEmbed,
+          time: new Date(),
+          status: "active",
+          messages: [],
+        },
+      },
+      { upsert: true },
+    );
+  } catch (error) {
+    if ((error as { code?: number }).code !== 11000) {
+      throw error;
+    }
   }
 
   return route.toObject();
 
@@ -4,7 +4,9 @@ import type { IBaseUser, IStudentUser } from "./UserModel";
 
 interface IMessage {
   time: Date;
-  senderType: "Student" | "Driver";
+  // Lowercase to match the room UI's comparison against the session's
+  // userType.toLowerCase() (see src/app/rides/[id]/page.tsx).
+  senderType: "student" | "driver" | "admin";
   text: string;
 }
 
@@ -13,12 +15,18 @@ export interface IChatlog {
   student: IStudentUser & { _id: mongoose.Types.ObjectId };
   driver: IBaseUser & { _id: mongoose.Types.ObjectId };
   time: Date;
+  status: "active" | "archived";
+  archivedAt?: Date;
   messages: IMessage[];
 }
 
 const MessageSchema = new Schema<IMessage>({
   time: { type: Date, required: true },
-  senderType: { type: String, enum: ["Student", "Driver"], required: true },
+  senderType: {
+    type: String,
+    enum: ["student", "driver", "admin"],
+    required: true,
+  },
   text: { type: String, required: true },
 });
 
@@ -37,10 +45,17 @@ const ChatlogSchema = new Schema<IChatlog>({
     required: true,
   },
   time: { type: Date, required: true },
+  status: {
+    type: String,
+    enum: ["active", "archived"],
+    required: true,
+    default: "active",
+  },
+  archivedAt: { type: Date },
   messages: [MessageSchema],
 });
 
-ChatlogSchema.index({ routeId: 1 });
+ChatlogSchema.index({ routeId: 1 }, { unique: true });
 ChatlogSchema.index({ time: 1 });
 
 const Chatlog =
 
@@ -0,0 +1,75 @@
+import jwt from "jsonwebtoken";
+import { debugLog } from "./utils/logger.mjs";
+import { getRouteForAuth } from "./utils/db.mjs";
+
+// Compare dates in America/New_York using Intl (works reliably in Node).
+function estDateStr(date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  const get = (type) => parts.find((p) => p.type === type)?.value;
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+
+// Socket.IO middleware: verifies the client's JWT, loads the route, and
+// authorizes the connecting user (student/driver/super admin, same-day only).
+export async function authenticateSocket(socket, next) {
+  const { routeId, token } = socket.handshake.auth;
+  try {
+    debugLog(
+      `Auth attempt for routeId: ${routeId} and token is ${token ? "present" : "missing"} `,
+    );
+    if (!routeId || !token) {
+      return next(new Error("Route ID or token missing"));
+    }
+
+    let decoded;
+    try {
+      const secret = process.env.NEXTAUTH_SECRET;
+      decoded = jwt.verify(token, secret);
+      debugLog("JWT decoded successfully:", decoded);
+    } catch (error) {
+      console.error("JWT verify failed:", error.message);
+      return next(new Error("Invalid JWT token"));
+    }
+
+    const userId = decoded.userId;
+    debugLog("User ID from token:", userId);
+
+    const route = await getRouteForAuth(routeId);
+    if (!route) {
+      return next(new Error("Route not found"));
+    }
+
+    const routeDateStr = estDateStr(new Date(route.scheduledPickupTime));
+    const todayStr = estDateStr(new Date());
+    const isSameDay = routeDateStr === todayStr;
+    debugLog(
+      `Date check: route=${routeDateStr}, today=${todayStr}, same=${isSameDay}`,
+    );
+    if (!isSameDay) {
+      return next(new Error("Route is not scheduled for today"));
+    }
+
+    const isStudent = route.student?._id?.toString() === userId;
+    const isDriver = route.driver?._id?.toString() === userId;
+    const isSuperAdmin = decoded.type === "SuperAdmin";
+
+    if (!isStudent && !isDriver && !isSuperAdmin) {
+      return next(new Error("User not authorized for this route"));
+    }
+
+    socket.routeId = routeId;
+    socket.user = userId;
+    socket.userType = decoded.type;
+    socket.routeStudent = route.student;
+    socket.routeDriver = route.driver;
+    next();
+  } catch (error) {
+    console.error(`Auth error for routeId ${routeId}:`, error);
+    return next(new Error("Authentication failed"));
+  }
+}
@@ -0,0 +1,40 @@
+import { appendMessage } from "../utils/db.mjs";
+import { debugLog } from "../utils/logger.mjs";
+
+export function registerChatHandler(io, socket, room, chatReady) {
+  socket.on("sendChatMessage", async (text) => {
+    try {
+      await chatReady;
+
+      if (typeof text !== "string") {
+        throw new Error("Message text is required");
+      }
+
+      const routeId = socket.routeId;
+      // Lowercase to match the client's senderType === userType.toLowerCase()
+      // comparison (src/app/rides/[id]/page.tsx).
+      const senderType =
+        socket.routeDriver?._id?.toString() === socket.user
+          ? "driver"
+          : socket.routeStudent?._id?.toString() === socket.user
+            ? "student"
+            : "admin";
+
+      const message = { senderType, text, time: new Date() };
+      const saved = await appendMessage(routeId, message);
+      if (!saved) {
+        socket.emit("chatError", "This ride's chat has ended");
+        return;
+      }
+
+      io.to(room).emit("receiveChatMessage", message);
+      debugLog(`User ${socket.user} sent a message to room ${room}`);
+    } catch (error) {
+      console.error(
+        `sendChatMessage failed for user ${socket.user} in room ${room}:`,
+        error,
+      );
+      socket.emit("chatError", "Invalid message format");
+    }
+  });
+}
@@ -0,0 +1,24 @@
+// Purely a socket.io room operation now — creating and archiving the chat
+// record lives in RouteAction.ts (Next.js), tied to the route's actual
+// status transitions rather than to a client's socket being connected.
+export function registerCloseRouteRoomHandler(io, socket, room) {
+  socket.on("closeRouteRoom", async () => {
+    try {
+      const routeId = socket.routeId;
+
+      io.to(room).emit("routeClosed");
+
+      const sockets = await io.in(routeId).fetchSockets();
+      for (const s of sockets) {
+        s.disconnect(true);
+      }
+      console.log(`Route ${routeId} closed`);
+    } catch (error) {
+      console.error(
+        `closeRouteRoom failed for user ${socket.user} in room ${room}:`,
+        error,
+      );
+      socket.emit("closeRouteRoomError", "Failed to close route room");
+    }
+  });
+}
@@ -0,0 +1,48 @@
+import { debugLog } from "../utils/logger.mjs";
+import { getChatHistory } from "../utils/db.mjs";
+import { registerChatHandler } from "./chat.mjs";
+import { registerLocationHandler } from "./location.mjs";
+import { registerCloseRouteRoomHandler } from "./closeRouteRoom.mjs";
+
+export function handleConnection(io, socket) {
+  console.log("A user connected", socket.id);
+
+  const room = socket.routeId;
+  try {
+    socket.join(room);
+    debugLog(`User ${socket.user} joined room ${room}`);
+  } catch (error) {
+    console.error(
+      `Failed to set up connection for user ${socket.user} in room ${room}:`,
+      error,
+    );
+    socket.emit("connectionError", "Failed to join route");
+    socket.disconnect(true);
+    return;
+  }
+
+  // Handler is registered immediately (below) so a fast client's events
+  // can't be dropped while this resolves; the chat handler awaits this
+  // promise before touching the chat record. The record itself is created
+  // by RouteAction.ts when the ride is scheduled — this only reads it.
+  const chatReady = getChatHistory(room)
+    .then((history) => {
+      socket.emit("chatHistory", history);
+      debugLog(
+        `Sent chat history to user ${socket.user} for room ${room} with ${history.length} messages`,
+      );
+    })
+    .catch((error) => {
+      console.error(
+        `Failed to load chat history for user ${socket.user} in room ${room}:`,
+        error,
+      );
+      socket.emit("connectionError", "Failed to join route");
+      socket.disconnect(true);
+      throw error;
+    });
+
+  registerChatHandler(io, socket, room, chatReady);
+  registerLocationHandler(socket, room);
+  registerCloseRouteRoomHandler(io, socket, room);
+}
@@ -0,0 +1,22 @@
+import { debugLog } from "../utils/logger.mjs";
+
+export function registerLocationHandler(socket, room) {
+  socket.on("updateLocation", async (location) => {
+    try {
+      if (
+        typeof location.latitude !== "number" ||
+        typeof location.longitude !== "number"
+      ) {
+        throw new Error("Coordinates are invalid");
+      }
+      socket.to(room).emit("broadcastLocation", location);
+      debugLog(`User ${socket.user} updated location in room ${room}`);
+    } catch (error) {
+      console.error(
+        `updateLocation failed for user ${socket.user} in room ${room}:`,
+        error,
+      );
+      socket.emit("locationError", "Failed to update location");
+    }
+  });
+}
@@ -0,0 +1,8 @@
+export function registerHttpRoutes(app) {
+  app.get("/", (req, res) => {
+    res.json({ message: "Express server running", ok: true });
+  });
+  app.get("/health", (req, res) => {
+    res.status(200).send("OK");
+  });
+}