diff --git a/app/(api)/_utils/hackbot/stream/intent.ts b/app/(api)/_utils/hackbot/stream/intent.ts
new file mode 100644
index 00000000..088f878e
--- /dev/null
+++ b/app/(api)/_utils/hackbot/stream/intent.ts
@@ -0,0 +1,53 @@
+export function shouldDisableEventsToolForQuery(query: string): boolean {
+  const q = query.trim().toLowerCase();
+  if (!q) return false;
+
+  const factualIntent =
+    /\b(judging|judged|rubric|criteria|score|scoring|weights?|points?)\b/.test(
+      q
+    ) ||
+    /\b(deadline|deadlines|due date|cutoff|submission deadline)\b/.test(q) ||
+    /\b(rule|rules|policy|policies|code of conduct|eligib(?:le|ility)|requirements?)\b/.test(
+      q
+    ) ||
+    /\b(submit|submission|submissions|devpost|submission process|judging process)\b/.test(
+      q
+    ) ||
+    /\b(team number|table number|team size|max team|minimum team|min team)\b/.test(
+      q
+    ) ||
+    /\b(prize track|prize tracks|prizes?)\b/.test(q) ||
+    /\b(check[- ]?in|checkin code|invite|registration)\b/.test(q);
+
+  const eventIntent =
+    /\b(schedule|event|events|workshop|workshops|activit(?:y|ies)|meal|meals|breakfast|brunch|lunch|dinner|happening)\b/.test(
+      q
+    );
+
+  return factualIntent && !eventIntent;
+}
+
+export function isResourcesQuery(query: string): boolean {
+  const q = query.trim().toLowerCase();
+  if (!q) return false;
+
+  const asksForResources =
+    /\b(resource|resources|tools?|apis?|libraries|frameworks?|starter kit)\b/.test(
+      q
+    ) || /\b(figma|ui\s*kit|design\s*kit|palette|templates?)\b/.test(q);
+
+  const asksForRoleScopedResources =
+    /\b(developer|developers|dev)\b/.test(q) ||
+    /\b(designer|designers|design|ui\/?ux)\b/.test(q);
+
+  return asksForResources || asksForRoleScopedResources;
+}
+
+export function isExplicitEventQuery(query: string): boolean {
+  const q = query.trim().toLowerCase();
+  if (!q) return false;
+
+  return /\b(schedule|event|events|workshop|workshops|activit(?:y|ies)|meal|meals|breakfast|brunch|lunch|dinner|happening|attend|go to)\b/.test(
+    q
+  );
+}
diff --git a/app/(api)/_utils/hackbot/stream/linksTool.ts b/app/(api)/_utils/hackbot/stream/linksTool.ts
index f731abdf..b7c99a11 100644
--- a/app/(api)/_utils/hackbot/stream/linksTool.ts
+++ b/app/(api)/_utils/hackbot/stream/linksTool.ts
@@ -23,10 +23,82 @@ export const PROVIDE_LINKS_INPUT_SCHEMA = z.object({
     ),
 });
 
+function getAllowedHosts(): Set<string> {
+  const hosts = new Set<string>([
+    'hackdavis.io',
+    'hub.hackdavis.io',
+    'staging-hub.hackdavis.io',
+  ]);
+  const baseUrl = process.env.BASE_URL;
+
+  if (baseUrl) {
+    try {
+      hosts.add(new URL(baseUrl).hostname.toLowerCase());
+    } catch {
+      // Ignore invalid BASE_URL; fall back to static allow-list.
+    }
+  }
+
+  return hosts;
+}
+
+function normalizeToRelativeHubPath(url: string): string | null {
+  const raw = url.trim();
+  if (!raw) return null;
+
+  if (raw.startsWith('//')) {
+    return null;
+  }
+
+  if (raw.startsWith('/')) {
+    return raw.replace(/^\/+/, '/');
+  }
+
+  if (raw.startsWith('#')) {
+    return `/${raw}`;
+  }
+
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return null;
+  }
+
+  const hostname = parsed.hostname.toLowerCase();
+  if (!getAllowedHosts().has(hostname)) {
+    return null;
+  }
+
+  const path = parsed.pathname || '/';
+  const search = parsed.search || '';
+  const hash = parsed.hash || '';
+  return `${path}${search}${hash}`;
+}
+
 export async function executeProvideLinks({
   links,
 }: {
   links: Array<{ label: string; url: string }>;
 }) {
-  return { links };
+  const seen = new Set<string>();
+  const sanitized = links
+    .map((link) => {
+      const relativeUrl = normalizeToRelativeHubPath(link.url);
+      if (!relativeUrl) return null;
+
+      const label = link.label.trim().slice(0, 80);
+      if (!label) return null;
+
+      return { label, url: relativeUrl };
+    })
+    .filter((link): link is { label: string; url: string } => Boolean(link))
+    .filter((link) => {
+      if (seen.has(link.url)) return false;
+      seen.add(link.url);
+      return true;
+    })
+    .slice(0, 3);
+
+  return { links: sanitized };
 }
diff --git a/app/(api)/_utils/hackbot/stream/model.ts b/app/(api)/_utils/hackbot/stream/model.ts
index 7ccf4772..ae12e00a 100644
--- a/app/(api)/_utils/hackbot/stream/model.ts
+++ b/app/(api)/_utils/hackbot/stream/model.ts
@@ -18,8 +18,14 @@ export function getModelConfig() {
   return { model, maxOutputTokens, isReasoningModel };
 }
 
-export function shouldStopStreaming(state: any): boolean {
+export function shouldStopStreaming(
+  state: any,
+  opts?: { allowProvideLinksShortCircuit?: boolean }
+): boolean {
   const { steps } = state as { steps: any[] };
+  const allowProvideLinksShortCircuit =
+    opts?.allowProvideLinksShortCircuit ?? true;
+
   if (stepCountIs(5)({ steps })) return true;
   if (!steps.length) return false;
 
@@ -28,6 +34,7 @@ export function shouldStopStreaming(state: any): boolean {
     toolCalls.length > 0 &&
     toolCalls.every((t: any) => t.toolName === 'provide_links');
 
+  if (!allowProvideLinksShortCircuit) return false;
   if (!onlyProvideLinks) return false;
   return steps.some((s: any) => (s.text ?? '').trim().length > 0);
 }
diff --git a/app/(api)/_utils/hackbot/stream/request.ts b/app/(api)/_utils/hackbot/stream/request.ts
index bd9cb4c6..cc1d678f 100644
--- a/app/(api)/_utils/hackbot/stream/request.ts
+++ b/app/(api)/_utils/hackbot/stream/request.ts
@@ -6,7 +6,9 @@ import type {
 const MAX_USER_MESSAGE_CHARS = 200;
 const MAX_HISTORY_MESSAGES = 30;
 const MAX_MESSAGE_CHARS = 2000;
-const MAX_TOTAL_MESSAGE_CHARS = 12000;
+export const MAX_CONTEXT_HISTORY_MESSAGES = 6;
+const MAX_TOTAL_MESSAGE_CHARS =
+  MAX_CONTEXT_HISTORY_MESSAGES * MAX_MESSAGE_CHARS;
 const ALLOWED_MESSAGE_ROLES = new Set(['user', 'assistant']);
 
 export function validateRequestBody(
@@ -32,11 +34,19 @@ export function validateRequestBody(
   for (const message of messages) {
     const role = message?.role;
     const content = message?.content;
-    if (
-      !ALLOWED_MESSAGE_ROLES.has(role) ||
-      typeof content !== 'string' ||
-      !content.trim()
-    ) {
+    if (!ALLOWED_MESSAGE_ROLES.has(role) || typeof content !== 'string') {
+      return Response.json(
+        { error: 'Invalid message history format.' },
+        { status: 400 }
+      );
+    }
+
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+      // Tool-only replies can persist as empty assistant text in localStorage.
+      // Drop them from request history instead of failing the whole request.
+      if (role === 'assistant') continue;
+
       return Response.json(
         { error: 'Invalid message history format.' },
         { status: 400 }
@@ -68,6 +78,10 @@ export function validateRequestBody(
     });
   }
 
+  if (sanitizedMessages.length === 0) {
+    return Response.json({ error: 'Invalid request' }, { status: 400 });
+  }
+
   const lastMessage = sanitizedMessages[sanitizedMessages.length - 1];
 
   if (lastMessage.role !== 'user') {
diff --git a/app/(api)/_utils/hackbot/stream/responseStream.ts b/app/(api)/_utils/hackbot/stream/responseStream.ts
index b6dd9a2b..ff9dbb15 100644
--- a/app/(api)/_utils/hackbot/stream/responseStream.ts
+++ b/app/(api)/_utils/hackbot/stream/responseStream.ts
@@ -16,12 +16,14 @@ export function createResponseStream(
       const enq = (line: string) => controller.enqueue(enc.encode(line));
 
       let suppressText = false;
+      let hasEmittedText = false;
 
       try {
         for await (const part of result.fullStream) {
           if (part?.type === 'text-delta') {
             if (!suppressText) {
               enq(`0:${JSON.stringify(part.text ?? '')}\n`);
+              if (part.text) hasEmittedText = true;
             }
           } else if (part?.type === 'tool-call') {
             enq(
@@ -34,7 +36,9 @@ export function createResponseStream(
               ])}\n`
             );
           } else if (part?.type === 'tool-result') {
-            suppressText = true;
+            // Keep allowing text if no assistant text has been emitted yet.
+            // This preserves a tool-first "intro sentence + cards" UX.
+            if (hasEmittedText) suppressText = true;
             enq(
               `a:${JSON.stringify([
                 {
diff --git a/app/(api)/api/hackbot/stream/route.ts b/app/(api)/api/hackbot/stream/route.ts
index 36ff965a..f91480cb 100644
--- a/app/(api)/api/hackbot/stream/route.ts
+++ b/app/(api)/api/hackbot/stream/route.ts
@@ -4,6 +4,7 @@ import { FEW_SHOT_EXAMPLES } from '@utils/hackbot/stream/fewShots';
 import {
   validateRequestBody,
   isSimpleGreetingMessage,
+  MAX_CONTEXT_HISTORY_MESSAGES,
 } from '@utils/hackbot/stream/request';
 import {
   fetchSessionAndDocs,
@@ -14,6 +15,11 @@ import {
   getModelConfig,
   shouldStopStreaming,
 } from '@utils/hackbot/stream/model';
+import {
+  shouldDisableEventsToolForQuery,
+  isResourcesQuery,
+  isExplicitEventQuery,
+} from '@utils/hackbot/stream/intent';
 import {
   GET_EVENTS_INPUT_SCHEMA,
   executeGetEvents,
@@ -26,7 +32,20 @@ import {
 import { createResponseStream } from '@utils/hackbot/stream/responseStream';
 import { getPageContext, buildSystemPrompt } from '@utils/hackbot/systemPrompt';
 
-const MAX_HISTORY_MESSAGES = 6;
+function normalizeGetEventsInputForQuery(input: any, query: string): any {
+  const q = query.trim().toLowerCase();
+  if (!q) return input;
+
+  const asksForWorkshops = /\bworkshops?\b/.test(q);
+  if (!asksForWorkshops) return input;
+
+  // If the user explicitly asks for workshops, enforce WORKSHOPS so
+  // generic schedule items (e.g. "Hacking Ends") are not returned.
+  return {
+    ...input,
+    type: 'WORKSHOPS',
+  };
+}
 
 export async function POST(request: Request) {
   try {
@@ -60,34 +79,59 @@ export async function POST(request: Request) {
         role: 'system',
         content: `Knowledge context about HackDavis (rules, submission, judging, tracks, general info):\n\n${contextSummary}`,
       },
-      ...sanitizedMessages.slice(-MAX_HISTORY_MESSAGES),
+      ...sanitizedMessages.slice(-MAX_CONTEXT_HISTORY_MESSAGES),
     ];
 
     const { model, maxOutputTokens } = getModelConfig();
+    const disableEventsTool = shouldDisableEventsToolForQuery(
+      lastMessage.content
+    );
+    const resourcesQuery = isResourcesQuery(lastMessage.content);
+    const explicitEventQuery = isExplicitEventQuery(lastMessage.content);
+    const requireEventsTool = explicitEventQuery && !disableEventsTool;
+
+    const tools = {
+      ...(requireEventsTool
+        ? {}
+        : {
+            provide_links: tool({
+              description: PROVIDE_LINKS_DESCRIPTION,
+              inputSchema: PROVIDE_LINKS_INPUT_SCHEMA,
+              execute: executeProvideLinks,
+            }),
+          }),
+      ...(disableEventsTool
+        ? {}
+        : {
+            get_events: tool({
+              description:
+                'Fetch the live HackDavis event schedule from the database. Use this for ANY question about event times, locations, schedule, or what is happening when.',
+              inputSchema: GET_EVENTS_INPUT_SCHEMA,
+              execute: (input) =>
+                executeGetEvents(
+                  normalizeGetEventsInputForQuery(input, lastMessage.content),
+                  profile,
+                  lastMessage.content
+                ),
+            }),
+          }),
+    };
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result = streamText({
       model: openai(model) as any,
+      temperature: 0,
       messages: chatMessages.map((m: any) => ({
         role: m.role as 'system' | 'user' | 'assistant',
         content: m.content,
       })),
       maxOutputTokens,
-      stopWhen: shouldStopStreaming,
-      tools: {
-        get_events: tool({
-          description:
-            'Fetch the live HackDavis event schedule from the database. Use this for ANY question about event times, locations, schedule, or what is happening when.',
-          inputSchema: GET_EVENTS_INPUT_SCHEMA,
-          execute: (input) =>
-            executeGetEvents(input, profile, lastMessage.content),
+      ...(requireEventsTool ? { toolChoice: 'required' as const } : {}),
+      stopWhen: (state) =>
+        shouldStopStreaming(state, {
+          allowProvideLinksShortCircuit: !resourcesQuery,
         }),
-        provide_links: tool({
-          description: PROVIDE_LINKS_DESCRIPTION,
-          inputSchema: PROVIDE_LINKS_INPUT_SCHEMA,
-          execute: executeProvideLinks,
-        }),
-      },
+      tools,
     });
 
     const stream = createResponseStream(result, model);
diff --git a/app/(pages)/(hackers)/(hub)/layout.tsx b/app/(pages)/(hackers)/(hub)/layout.tsx
index 602aadd8..52a72640 100644
--- a/app/(pages)/(hackers)/(hub)/layout.tsx
+++ b/app/(pages)/(hackers)/(hub)/layout.tsx
@@ -1,7 +1,24 @@
+import { auth } from '@/auth';
 import ProtectedDisplay from '@components/ProtectedDisplay/ProtectedDisplay';
 import Navbar from '@components/Navbar/Navbar';
+import HackbotWidgetWrapper from '../_components/Hackbot/HackbotWidgetWrapper';
+import type { HackerProfile } from '@typeDefs/hackbot';
+
+export default async function Layout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const session = await auth();
+  const u = session?.user as any;
+  const profile: HackerProfile | null = u
+    ? {
+        name: u.name ?? undefined,
+        position: u.position ?? undefined,
+        is_beginner: u.is_beginner ?? undefined,
+      }
+    : null;
 
-export default function Layout({ children }: { children: React.ReactNode }) {
   return (
     <ProtectedDisplay
       allowedRoles={['hacker', 'admin']}
@@ -9,6 +26,7 @@ export default function Layout({ children }: { children: React.ReactNode }) {
     >
       <Navbar />
       {children}
+      <HackbotWidgetWrapper initialProfile={profile} />
     </ProtectedDisplay>
   );
 }
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotEventCard.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotEventCard.tsx
new file mode 100644
index 00000000..84d9699e
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotEventCard.tsx
@@ -0,0 +1,225 @@
+'use client';
+
+import { useState } from 'react';
+import { HiLocationMarker } from 'react-icons/hi';
+import { PiStarFourFill } from 'react-icons/pi';
+import { createUserToEvent } from '@actions/userToEvents/createUserToEvent';
+import { deleteUserToEvent } from '@actions/userToEvents/deleteUserToEvent';
+import type { HackbotEvent } from '@typeDefs/hackbot';
+
+// Matches scheduleEventStyles.ts
+const TYPE_STYLE: Record<string, { bg: string; text: string; label: string }> =
+  {
+    WORKSHOPS: { bg: '#E9FBBA', text: '#1A3819', label: 'Workshop' },
+    GENERAL: { bg: '#CCFFFE', text: '#003D3D', label: 'General' },
+    ACTIVITIES: { bg: '#FFE2D5', text: '#52230C', label: 'Activity' },
+    MEALS: { bg: '#FFE7B2', text: '#572700', label: 'Meal' },
+  };
+
+const TAG_LABEL: Record<string, string> = {
+  developer: 'Dev',
+  designer: 'Design',
+  beginner: 'Beginner',
+  pm: 'PM',
+  other: 'Other',
+};
+
+// Only show Add button for event types that make sense to save
+const ADDABLE_TYPES = new Set(['WORKSHOPS', 'ACTIVITIES']);
+
+function maskIconStyle(src: string): React.CSSProperties {
+  return {
+    backgroundColor: 'currentColor',
+    WebkitMaskImage: `url('${src}')`,
+    WebkitMaskRepeat: 'no-repeat',
+    WebkitMaskPosition: 'center',
+    WebkitMaskSize: 'contain',
+    maskImage: `url('${src}')`,
+    maskRepeat: 'no-repeat',
+    maskPosition: 'center',
+    maskSize: 'contain',
+  };
+}
+
+export default function HackbotEventCard({
+  event,
+  userId,
+}: {
+  event: HackbotEvent;
+  userId: string;
+}) {
+  const [added, setAdded] = useState(false);
+  const [adding, setAdding] = useState(false);
+  const [addError, setAddError] = useState(false);
+
+  const handleAdd = async () => {
+    if (!userId || adding) return;
+    setAdding(true);
+    setAddError(false);
+    try {
+      if (added) {
+        const result = await deleteUserToEvent({
+          user_id: userId,
+          event_id: event.id,
+        });
+        if (!result.ok) throw new Error('Failed to remove');
+        setAdded(false);
+      } else {
+        const result = await createUserToEvent(userId, event.id);
+        if (!result.ok) throw new Error(result.error ?? 'Failed');
+        setAdded(true);
+      }
+    } catch {
+      setAddError(true);
+    }
+    setAdding(false);
+  };
+
+  const style = TYPE_STYLE[event.type ?? ''];
+  const canAdd = userId && ADDABLE_TYPES.has(event.type ?? '');
+
+  return (
+    <div
+      className="rounded-xl border border-[#9EE7E5]/60 text-xs overflow-hidden animate-hackbot-slide-in"
+      style={{ backgroundColor: style?.bg ?? '#FAFAFF' }}
+    >
+      {/* Event name — full width */}
+      <div
+        className="px-3 pt-2.5 pb-1"
+        style={{ color: style?.text ?? '#005271' }}
+      >
+        <p className="font-semibold leading-snug">{event.name}</p>
+      </div>
+
+      {/* Two-column body */}
+      <div
+        className="px-3 pb-1.5 flex gap-2 min-w-0"
+        style={{ color: style?.text ?? '#003D3D' }}
+      >
+        {/* Left: datetime, location, tags */}
+        <div className="flex-1 min-w-0 space-y-1">
+          {event.start && (
+            <p className="text-xs opacity-80">
+              {event.start}
+              {event.end ? ` - ${event.end}` : ''}
+            </p>
+          )}
+          {event.location && (
+            <p className="text-xs opacity-80 flex items-center gap-1">
+              <HiLocationMarker className="shrink-0 w-3 h-3" />
+              <span className="truncate">{event.location}</span>
+            </p>
+          )}
+          {event.tags.length > 0 && (
+            <div className="flex flex-wrap gap-1 pt-0.5">
+              {event.tags.map((tag) => (
+                <span
+                  key={tag}
+                  className="text-xs px-1.5 py-0.5 rounded-full font-medium"
+                  style={{
+                    backgroundColor: style ? style.text + '15' : '#00527115',
+                    color: style?.text ?? '#005271',
+                    border: `1px solid ${style?.text ?? '#005271'}25`,
+                  }}
+                >
+                  {TAG_LABEL[tag] ?? tag}
+                </span>
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* Right: type badge, hosted by, recommended */}
+        <div className="shrink-0 flex flex-col items-end gap-1.5 pt-0.5">
+          {style && (
+            <span
+              className="text-xs px-1.5 py-0.5 rounded-full font-semibold uppercase tracking-wide border whitespace-nowrap"
+              style={{
+                borderColor: style.text + '40',
+                color: style.text,
+              }}
+            >
+              {style.label}
+            </span>
+          )}
+          {event.host && (
+            <p
+              className="text-xs opacity-60 text-right leading-tight"
+              // style={{ maxWidth: '100px' }}
+            >
+              {event.host}
+            </p>
+          )}
+          {event.isRecommended && (
+            <p
+              className="text-xs font-semibold flex items-center gap-0.5 whitespace-nowrap"
+              style={{ color: '#A07000' }}
+            >
+              <PiStarFourFill className="w-2.5 h-2.5 shrink-0" />
+              Recommended
+            </p>
+          )}
+          {canAdd && (
+            <button
+              type="button"
+              onClick={handleAdd}
+              disabled={adding}
+              className="text-xs px-2.5 py-1 rounded-full font-semibold border transition-colors disabled:cursor-default group/addbtn"
+              style={
+                added
+                  ? {
+                      backgroundColor: '#005271',
+                      color: '#fff',
+                      borderColor: '#005271',
+                    }
+                  : addError
+                  ? {
+                      backgroundColor: '#fee2e2',
+                      color: '#991b1b',
+                      borderColor: '#fca5a5',
+                    }
+                  : {
+                      backgroundColor: 'white',
+                      color: '#005271',
+                      borderColor: '#9EE7E5',
+                    }
+              }
+            >
+              {adding ? (
+                '…'
+              ) : addError ? (
+                'Retry'
+              ) : added ? (
+                <>
+                  <span className="inline-flex items-center gap-1 group-hover/addbtn:hidden">
+                    <span
+                      aria-hidden
+                      className="inline-block w-2.5 h-2.5"
+                      style={maskIconStyle('/icons/check.svg')}
+                    />
+                    Added
+                  </span>
+                  <span
+                    className="hidden group-hover/addbtn:inline-flex items-center gap-1"
+                    style={{ color: '#fca5a5' }}
+                  >
+                    Remove
+                  </span>
+                </>
+              ) : (
+                <span className="inline-flex items-center gap-1">
+                  <span
+                    aria-hidden
+                    className="inline-block w-2.5 h-2.5"
+                    style={maskIconStyle('/icons/plus.svg')}
+                  />
+                  Add
+                </span>
+              )}
+            </button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotHeader.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotHeader.tsx
new file mode 100644
index 00000000..57934394
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotHeader.tsx
@@ -0,0 +1,35 @@
+'use client';
+
+import { RxCross1 } from 'react-icons/rx';
+
+export default function HackbotHeader({
+  firstName,
+  onClose,
+}: {
+  firstName: string | undefined;
+  onClose: () => void;
+}) {
+  return (
+    <header
+      className="flex items-center justify-between px-4 py-3 shrink-0"
+      style={{ backgroundColor: '#005271' }}
+    >
+      <div>
+        <p className="text-base font-bold text-white">HackDavis Helper</p>
+        <p className="text-xs text-[#9EE7E5]">
+          {firstName
+            ? `Hi ${firstName}! Ask me anything about HackDavis.`
+            : 'Ask me anything about HackDavis!'}
+        </p>
+      </div>
+      <button
+        type="button"
+        onClick={onClose}
+        className="h-7 w-7 rounded-full flex items-center justify-center text-white hover:bg-white/10 transition-colors"
+        aria-label="Close chat"
+      >
+        <RxCross1 className="w-3.5 h-3.5" />
+      </button>
+    </header>
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotInputForm.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotInputForm.tsx
new file mode 100644
index 00000000..1de672a5
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotInputForm.tsx
@@ -0,0 +1,137 @@
+'use client';
+
+import { useState } from 'react';
+
+export default function HackbotInputForm({
+  input,
+  setInput,
+  canSend,
+  loading,
+  error,
+  maxChars,
+  onSubmit,
+  onSend,
+  onDismissError,
+  suggestionChips,
+  onChipSend,
+}: {
+  input: string;
+  setInput: (val: string) => void;
+  canSend: boolean;
+  loading: boolean;
+  error: string | null;
+  maxChars: number;
+  onSubmit: (e: React.FormEvent) => void;
+  onSend: () => void;
+  onDismissError: () => void;
+  suggestionChips: string[];
+  onChipSend: (text: string) => void;
+}) {
+  const [showSuggestions, setShowSuggestions] = useState(false);
+
+  return (
+    <form
+      onSubmit={onSubmit}
+      className="border-t border-[#9EE7E5]/60 px-3 py-2.5 space-y-2 shrink-0 bg-white"
+    >
+      {/* Suggestion chips accordion — one per line */}
+      {showSuggestions && (
+        <div className="flex flex-col gap-1.5 pb-0.5">
+          {suggestionChips.map((q) => (
+            <button
+              key={q}
+              type="button"
+              onClick={() => {
+                onChipSend(q);
+                setShowSuggestions(false);
+              }}
+              className="w-full text-left text-xs px-3 py-1.5 rounded-xl border border-[#9EE7E5] bg-[#FAFAFF] text-[#005271] hover:bg-[#CCFFFE] transition-colors font-medium"
+            >
+              {q}
+            </button>
+          ))}
+        </div>
+      )}
+
+      <div className="flex items-center gap-2">
+        <textarea
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+              e.preventDefault();
+              void onSend();
+            }
+          }}
+          rows={1}
+          maxLength={maxChars}
+          className="flex-1 resize-none rounded-xl border border-[#9EE7E5] bg-[#FAFAFF] px-3 py-2.5 text-sm text-[#003D3D] placeholder-[#005271]/40 outline-none focus:ring-2 focus:ring-[#005271]/30 focus:border-[#005271] transition-colors"
+          placeholder="Ask about HackDavis…"
+        />
+
+        {/* Suggestions toggle */}
+        <button
+          type="button"
+          onClick={() => setShowSuggestions((prev) => !prev)}
+          className="shrink-0 h-9 w-9 rounded-xl flex items-center justify-center transition-colors border border-[#9EE7E5] hover:bg-[#CCFFFE]"
+          style={{ backgroundColor: showSuggestions ? '#CCFFFE' : '#FAFAFF' }}
+          aria-label="Toggle suggested questions"
+          title="Suggested questions"
+        >
+          <svg
+            viewBox="0 0 16 16"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="1.8"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+            className="w-3.5 h-3.5"
+            style={{
+              color: '#005271',
+              transform: showSuggestions ? 'rotate(180deg)' : 'rotate(0deg)',
+              transition: 'transform 0.2s',
+            }}
+          >
+            <path d="M3 6l5 5 5-5" />
+          </svg>
+        </button>
+
+        {/* Send button */}
+        <button
+          type="submit"
+          disabled={!canSend}
+          className="shrink-0 h-9 w-9 rounded-xl flex items-center justify-center transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
+          style={{
+            backgroundColor: canSend ? '#005271' : '#9EE7E5',
+            color: '#fff',
+          }}
+        >
+          {loading ? (
+            <span className="w-3 h-3 border-2 border-white border-t-transparent rounded-full animate-spin" />
+          ) : (
+            <svg viewBox="0 0 16 16" fill="currentColor" className="w-4 h-4">
+              <path d="M1.5 1.5l13 6.5-13 6.5V9.5l9-3-9-3V1.5z" />
+            </svg>
+          )}
+        </button>
+      </div>
+
+      <p className="text-[10px] text-[#005271]/40 text-right">
+        {input.length}/{maxChars}
+      </p>
+
+      {error && (
+        <div className="text-xs bg-red-50 border border-red-200 rounded-lg px-2.5 py-1.5">
+          <p className="text-red-600">{error}</p>
+          <button
+            type="button"
+            onClick={onDismissError}
+            className="text-red-400 underline text-[10px] mt-0.5"
+          >
+            Dismiss
+          </button>
+        </div>
+      )}
+    </form>
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotMessageList.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotMessageList.tsx
new file mode 100644
index 00000000..feff108e
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotMessageList.tsx
@@ -0,0 +1,243 @@
+'use client';
+
+import Link from 'next/link';
+import { RefObject } from 'react';
+import type { HackbotChatMessage } from '@typeDefs/hackbot';
+import MarkdownText from './MarkdownText';
+import HackbotEventCard from './HackbotEventCard';
+
+function isSafeRelativeHref(href: string): boolean {
+  const trimmed = href.trim();
+  if (!trimmed) return false;
+  return trimmed.startsWith('/') && !trimmed.startsWith('//');
+}
+
+export default function HackbotMessageList({
+  messages,
+  loading,
+  toolPending,
+  retrying,
+  cascading,
+  suggestionChips,
+  userId,
+  onChipClick,
+  messagesEndRef,
+}: {
+  messages: HackbotChatMessage[];
+  loading: boolean;
+  toolPending: boolean;
+  retrying: number;
+  cascading: boolean;
+  suggestionChips: string[];
+  userId: string;
+  onChipClick: (text: string) => void;
+  messagesEndRef: RefObject<HTMLDivElement | null>;
+}) {
+  return (
+    <section className="flex-1 overflow-y-auto px-3 py-3 space-y-3 min-h-0 bg-[#FAFAFF]">
+      {messages.length === 0 && (
+        <div className="space-y-2">
+          <p className="text-xs text-[#005271]/60 font-medium">Try asking:</p>
+          {suggestionChips.map((q) => (
+            <button
+              key={q}
+              type="button"
+              onClick={() => onChipClick(q)}
+              className="block w-full text-left text-xs px-3 py-2 rounded-xl border border-[#9EE7E5] bg-white text-[#005271] hover:bg-[#CCFFFE] transition-colors font-medium"
+            >
+              {q}
+            </button>
+          ))}
+        </div>
+      )}
+
+      {messages.map((m, idx) => (
+        <div
+          key={idx}
+          className={`flex flex-col gap-1.5 ${
+            m.role === 'user' ? 'items-end' : 'items-start'
+          }`}
+        >
+          {/* Text bubble */}
+          {(m.content ||
+            (m.role === 'assistant' &&
+              loading &&
+              idx === messages.length - 1)) && (
+            <div
+              className={`max-w-[88%] rounded-2xl px-3 py-2 text-xs leading-relaxed whitespace-pre-wrap ${
+                m.role === 'user' ? 'rounded-br-sm' : 'rounded-bl-sm border'
+              }`}
+              style={
+                m.role === 'user'
+                  ? { backgroundColor: '#005271', color: '#fff' }
+                  : {
+                      backgroundColor: '#fff',
+                      color: '#003D3D',
+                      borderColor: '#9EE7E5',
+                    }
+              }
+            >
+              {/* Typing indicator — hidden while retrying to avoid conflict */}
+              {m.role === 'assistant' &&
+                !m.content &&
+                loading &&
+                retrying === 0 && (
+                  <span className="flex items-center gap-1">
+                    {[0, 150, 300].map((delay) => (
+                      <span
+                        key={delay}
+                        className="inline-block w-1.5 h-1.5 rounded-full bg-[#9EE7E5] animate-bounce"
+                        style={{ animationDelay: `${delay}ms` }}
+                      />
+                    ))}
+                  </span>
+                )}
+              {m.content && (
+                <p>
+                  <MarkdownText text={m.content} />
+                </p>
+              )}
+
+              {/* Retrying indicator */}
+              {m.role === 'assistant' &&
+                loading &&
+                retrying > 0 &&
+                idx === messages.length - 1 && (
+                  <span className="flex items-center gap-1.5 mt-1.5">
+                    {[0, 150, 300].map((delay) => (
+                      <span
+                        key={delay}
+                        className="inline-block w-1 h-1 rounded-full bg-[#005271]/40 animate-bounce"
+                        style={{ animationDelay: `${delay}ms` }}
+                      />
+                    ))}
+                    <span className="text-[10px] text-[#005271]/60">
+                      Retrying ({retrying}/2)…
+                    </span>
+                  </span>
+                )}
+
+              {/* Mid-stream indicator: text received but tool still running */}
+              {m.role === 'assistant' &&
+                m.content &&
+                loading &&
+                toolPending &&
+                retrying === 0 &&
+                idx === messages.length - 1 && (
+                  <span className="flex items-center gap-1 mt-1.5">
+                    {[0, 150, 300].map((delay) => (
+                      <span
+                        key={delay}
+                        className="inline-block w-1.5 h-1.5 rounded-full bg-[#9EE7E5] animate-bounce"
+                        style={{ animationDelay: `${delay}ms` }}
+                      />
+                    ))}
+                  </span>
+                )}
+
+              {/* Named links from provide_links tool */}
+              {m.links && m.links.length > 0 && (
+                <div className="mt-1.5 flex flex-col gap-1">
+                  {m.links
+                    .filter((link) => isSafeRelativeHref(link.url))
+                    .map((link, i) => (
+                      <Link
+                        key={`${i}-${link.url}`}
+                        href={link.url}
+                        className="inline-flex items-center gap-0.5 text-xs font-semibold underline underline-offset-2 hover:opacity-70 transition-opacity"
+                        style={{ color: '#005271' }}
+                      >
+                        {link.label} →
+                      </Link>
+                    ))}
+                </div>
+              )}
+
+              {/* Legacy single URL fallback (backwards compat with stored messages) */}
+              {!m.links?.length && m.url && isSafeRelativeHref(m.url) && (
+                <a
+                  href={m.url}
+                  className="mt-1.5 inline-flex items-center gap-0.5 text-xs font-semibold underline underline-offset-2"
+                  style={{ color: '#005271' }}
+                >
+                  More info →
+                </a>
+              )}
+            </div>
+          )}
+
+          {/* Cards-loading indicator — shown while stream is finishing (tools done, text flowing)
+              OR while events are cascading in after stream ends.
+              Positioned where event cards will appear so the user knows more is coming. */}
+          {m.role === 'assistant' &&
+            m.content &&
+            retrying === 0 &&
+            idx === messages.length - 1 &&
+            (m.events?.length ?? 0) === 0 &&
+            ((loading && !toolPending) || cascading) && (
+              <span className="flex items-center gap-1 px-1">
+                {[0, 150, 300].map((delay) => (
+                  <span
+                    key={delay}
+                    className="inline-block w-1.5 h-1.5 rounded-full bg-[#9EE7E5] animate-bounce"
+                    style={{ animationDelay: `${delay}ms` }}
+                  />
+                ))}
+              </span>
+            )}
+
+          {/* Event cards + compact event rows */}
+          {m.events &&
+            m.events.length > 0 &&
+            (() => {
+              const compactEvents = m.events.filter((ev) => ev.compact);
+              const fullEvents = m.events.filter((ev) => !ev.compact);
+              return (
+                <div className="w-full max-w-[88%] space-y-1.5">
+                  {/* Compact rows for GENERAL/MEALS */}
+                  {compactEvents.length > 0 && (
+                    <div
+                      className="rounded-xl border border-[#9EE7E5]/60 overflow-hidden animate-hackbot-slide-in divide-y divide-[#9EE7E5]/30"
+                      style={{ backgroundColor: '#fff' }}
+                    >
+                      {compactEvents.map((ev) => (
+                        <div
+                          key={ev.id}
+                          className="flex items-center gap-2 px-3 py-1.5"
+                        >
+                          <span className="text-xs font-semibold text-[#003D3D] flex-1 min-w-0 truncate">
+                            {ev.name}
+                          </span>
+                          {ev.start && (
+                            <span className="text-[10px] text-[#003D3D]/60 shrink-0 whitespace-nowrap">
+                              {ev.start}
+                            </span>
+                          )}
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                  {/* Full cards for WORKSHOPS/ACTIVITIES */}
+                  {fullEvents.map((ev) => (
+                    <HackbotEventCard key={ev.id} event={ev} userId={userId} />
+                  ))}
+                  {/* Shared View Schedule link */}
+                  <div className="px-1 pt-0.5">
+                    <Link
+                      href="/schedule"
+                      className="text-xs font-semibold underline underline-offset-2 hover:opacity-70 transition-opacity"
+                      style={{ color: '#005271' }}
+                    >
+                      View full schedule →
+                    </Link>
+                  </div>
+                </div>
+              );
+            })()}
+        </div>
+      ))}
+
+      <div ref={messagesEndRef as React.RefObject<HTMLDivElement>} />
+    </section>
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotWidget.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotWidget.tsx
new file mode 100644
index 00000000..e2700eec
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotWidget.tsx
@@ -0,0 +1,107 @@
+'use client';
+
+import { RxCross1 } from 'react-icons/rx';
+import type { HackerProfile } from '@typeDefs/hackbot';
+import HackbotHeader from './HackbotHeader';
+import HackbotMessageList from './HackbotMessageList';
+import HackbotInputForm from './HackbotInputForm';
+import {
+  MAX_USER_MESSAGE_CHARS,
+  useHackbotWidget,
+} from '@hooks/useHackbotWidget';
+
+export default function HackbotWidget({
+  userId,
+  initialProfile,
+}: {
+  userId: string;
+  initialProfile: HackerProfile | null;
+}) {
+  const {
+    open,
+    panelRef,
+    messagesEndRef,
+    messages,
+    input,
+    loading,
+    toolPending,
+    retrying,
+    cascading,
+    error,
+    canSend,
+    suggestionChips,
+    firstName,
+    panelStyle,
+    toggleOpen,
+    onResizeMouseDown,
+    setInput,
+    setError,
+    sendMessage,
+    handleSubmit,
+  } = useHackbotWidget({ initialProfile });
+
+  return (
+    <div className="fixed bottom-4 right-0 sm:right-4 z-50 flex flex-col items-end gap-2">
+      {/* Chat panel */}
+      {open && (
+        <div
+          ref={panelRef}
+          className="w-screen sm:w-[min(30vw,420px)] sm:min-w-[360px] max-h-[calc(100svh-5rem)] sm:max-h-[600px] min-h-[450px] rounded-none sm:rounded-2xl border-t sm:border border-[#9EE7E5] bg-[#FAFAFF] shadow-xl shadow-[#005271]/10 flex flex-col overflow-hidden relative"
+          style={{
+            fontFamily: 'var(--font-plus-jakarta-sans, sans-serif)',
+            ...panelStyle,
+          }}
+        >
+          {/* Resize handle — left edge, desktop only */}
+          <div
+            className="absolute left-0 top-0 bottom-0 w-1.5 cursor-ew-resize hidden sm:block hover:bg-[#9EE7E5]/50 transition-colors z-10"
+            onMouseDown={onResizeMouseDown}
+          />
+
+          <HackbotHeader firstName={firstName} onClose={toggleOpen} />
+
+          <HackbotMessageList
+            messages={messages}
+            loading={loading}
+            toolPending={toolPending}
+            retrying={retrying}
+            cascading={cascading}
+            suggestionChips={suggestionChips}
+            userId={userId}
+            onChipClick={(text) => void sendMessage(text)}
+            messagesEndRef={messagesEndRef}
+          />
+
+          <HackbotInputForm
+            input={input}
+            setInput={setInput}
+            canSend={canSend}
+            loading={loading}
+            error={error}
+            maxChars={MAX_USER_MESSAGE_CHARS}
+            onSubmit={handleSubmit}
+            onSend={sendMessage}
+            onDismissError={() => setError(null)}
+            suggestionChips={suggestionChips}
+            onChipSend={(text) => void sendMessage(text)}
+          />
+        </div>
+      )}
+
+      {/* FAB toggle */}
+      <button
+        type="button"
+        onClick={toggleOpen}
+        className="h-14 w-14 rounded-full text-white shadow-lg flex items-center justify-center font-bold text-sm hover:opacity-90 focus:outline-none focus:ring-2 focus:ring-[#9EE7E5] focus:ring-offset-2 transition-all"
+        style={{ backgroundColor: '#005271' }}
+        aria-label="Open HackDavis Helper chat"
+      >
+        {open ? (
+          <RxCross1 className="w-5 h-5" />
+        ) : (
+          <span className="text-xs font-extrabold tracking-tight">HD</span>
+        )}
+      </button>
+    </div>
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/HackbotWidgetWrapper.tsx b/app/(pages)/(hackers)/_components/Hackbot/HackbotWidgetWrapper.tsx
new file mode 100644
index 00000000..dd4b795d
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/HackbotWidgetWrapper.tsx
@@ -0,0 +1,25 @@
+'use client';
+
+import { useSession } from 'next-auth/react';
+import HackbotWidget from './HackbotWidget';
+import type { HackerProfile } from '@typeDefs/hackbot';
+
+export default function HackbotWidgetWrapper({
+  initialProfile,
+}: {
+  initialProfile: HackerProfile | null;
+}) {
+  const { data: session, status } = useSession();
+
+  if (status === 'loading' || !session) return null;
+
+  const role = (session.user as any)?.role;
+  if (role !== 'hacker' && role !== 'admin') return null;
+
+  return (
+    <HackbotWidget
+      userId={String((session.user as any)?.id ?? '')}
+      initialProfile={initialProfile}
+    />
+  );
+}
diff --git a/app/(pages)/(hackers)/_components/Hackbot/MarkdownText.tsx b/app/(pages)/(hackers)/_components/Hackbot/MarkdownText.tsx
new file mode 100644
index 00000000..09eca440
--- /dev/null
+++ b/app/(pages)/(hackers)/_components/Hackbot/MarkdownText.tsx
@@ -0,0 +1,36 @@
+'use client';
+
+/** Renders a single line, converting **bold** and *italic* to JSX. */
+function renderInline(line: string, key: number) {
+  const parts: React.ReactNode[] = [];
+  const re = /(\*\*(.+?)\*\*|\*(.+?)\*)/g;
+  let last = 0;
+  let match: RegExpExecArray | null;
+  let i = 0;
+  while ((match = re.exec(line)) !== null) {
+    if (match.index > last) parts.push(line.slice(last, match.index));
+    if (match[2] !== undefined) {
+      parts.push(<strong key={i++}>{match[2]}</strong>);
+    } else if (match[3] !== undefined) {
+      parts.push(<em key={i++}>{match[3]}</em>);
+    }
+    last = match.index + match[0].length;
+  }
+  if (last < line.length) parts.push(line.slice(last));
+  return <span key={key}>{parts}</span>;
+}
+
+/** Renders markdown text with **bold**, *italic*, and line breaks. */
+export default function MarkdownText({ text }: { text: string }) {
+  const lines = text.split('\n');
+  return (
+    <>
+      {lines.map((line, i) => (
+        <span key={i}>
+          {renderInline(line, i)}
+          {i < lines.length - 1 && <br />}
+        </span>
+      ))}
+    </>
+  );
+}
diff --git a/app/(pages)/_hooks/useHackbotWidget.ts b/app/(pages)/_hooks/useHackbotWidget.ts
new file mode 100644
index 00000000..495e0ac9
--- /dev/null
+++ b/app/(pages)/_hooks/useHackbotWidget.ts
@@ -0,0 +1,458 @@
+'use client';
+
+import {
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  type CSSProperties,
+  type FormEvent,
+  type MouseEvent as ReactMouseEvent,
+} from 'react';
+import { usePathname } from 'next/navigation';
+import type {
+  HackerProfile,
+  HackbotEvent,
+  HackbotLink,
+  HackbotChatMessage,
+} from '@typeDefs/hackbot';
+
+export const MAX_USER_MESSAGE_CHARS = 200;
+const STORAGE_KEY = 'hackbot_chat_history';
+const MAX_STORED_MESSAGES = 20;
+const MIN_WIDTH = 360;
+const MAX_WIDTH_FRACTION = 0.5;
+const CASCADE_DELAY_MS = 150;
+
+export function useHackbotWidget({
+  initialProfile,
+}: {
+  initialProfile: HackerProfile | null;
+}) {
+  const pathname = usePathname();
+  const messagesEndRef = useRef<HTMLDivElement>(null);
+  const panelRef = useRef<HTMLDivElement>(null);
+  const isResizing = useRef(false);
+  const resizeStartX = useRef(0);
+  const resizeStartWidth = useRef(0);
+  // Buffer events during streaming; cascade them in after text completes
+  const pendingEventsRef = useRef<HackbotEvent[]>([]);
+  const cascadeTimersRef = useRef<ReturnType<typeof setTimeout>[]>([]);
+  // Buffer links from provide_links tool result; apply after text completes
+  const pendingLinksRef = useRef<HackbotLink[]>([]);
+
+  const [open, setOpen] = useState(() => {
+    if (typeof window !== 'undefined') {
+      return localStorage.getItem('hackbot_open') === 'true';
+    }
+    return false;
+  });
+  const [panelWidth, setPanelWidth] = useState<number | null>(null);
+  const [messages, setMessages] = useState<HackbotChatMessage[]>(() => {
+    if (typeof window !== 'undefined') {
+      try {
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          if (Array.isArray(parsed)) return parsed.slice(-MAX_STORED_MESSAGES);
+        }
+      } catch {
+        // ignore
+      }
+    }
+    return [];
+  });
+  const [input, setInput] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [toolPending, setToolPending] = useState(false);
+  const [retrying, setRetrying] = useState(0);
+  const [cascading, setCascading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Set when a tool-result arrives mid-stream; next text chunk gets a separator
+  const addSeparatorRef = useRef(false);
+  const [hackerProfile] = useState<HackerProfile | null>(initialProfile);
+
+  const suggestionChips = [
+    ...(hackerProfile?.is_beginner !== false
+      ? ["I'm a beginner, where do I start?"]
+      : []),
+    hackerProfile?.position === 'developer'
+      ? 'What developer resources are there?'
+      : hackerProfile?.position === 'designer'
+      ? 'What designer resources are there?'
+      : 'What developer and designer resources are there?',
+    'When is the submission deadline?',
+    "What's my team number vs. table number?",
+    'How are projects judged?',
+  ];
+
+  // Persist messages to localStorage
+  useEffect(() => {
+    if (typeof window !== 'undefined' && messages.length > 0) {
+      try {
+        localStorage.setItem(
+          STORAGE_KEY,
+          JSON.stringify(messages.slice(-MAX_STORED_MESSAGES))
+        );
+      } catch {
+        // ignore
+      }
+    }
+  }, [messages]);
+
+  // Persist open state to localStorage
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      localStorage.setItem('hackbot_open', String(open));
+    }
+  }, [open]);
+
+  // Auto-scroll to bottom on new messages
+  useEffect(() => {
+    if (open) {
+      messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+    }
+  }, [messages, open]);
+
+  // Resize drag handlers
+  const onResizeMouseDown = useCallback((e: ReactMouseEvent) => {
+    e.preventDefault();
+    isResizing.current = true;
+    resizeStartX.current = e.clientX;
+    resizeStartWidth.current = panelRef.current?.offsetWidth ?? MIN_WIDTH;
+
+    const onMouseMove = (ev: MouseEvent) => {
+      if (!isResizing.current) return;
+      const delta = resizeStartX.current - ev.clientX;
+      const maxWidth = window.innerWidth * MAX_WIDTH_FRACTION;
+      const next = Math.min(
+        Math.max(resizeStartWidth.current + delta, MIN_WIDTH),
+        maxWidth
+      );
+      setPanelWidth(next);
+    };
+
+    const onMouseUp = () => {
+      isResizing.current = false;
+      document.removeEventListener('mousemove', onMouseMove);
+      document.removeEventListener('mouseup', onMouseUp);
+    };
+
+    document.addEventListener('mousemove', onMouseMove);
+    document.addEventListener('mouseup', onMouseUp);
+  }, []);
+
+  const canSend =
+    !loading &&
+    input.trim().length > 0 &&
+    input.trim().length <= MAX_USER_MESSAGE_CHARS;
+
+  const toggleOpen = () => {
+    setOpen((prev) => !prev);
+    setError(null);
+  };
+
+  const sendMessage = async (overrideText?: string) => {
+    const text = (overrideText ?? input).trim();
+    if (loading || !text || text.length > MAX_USER_MESSAGE_CHARS) return;
+
+    // Cancel any in-progress event cascade from a previous response
+    cascadeTimersRef.current.forEach(clearTimeout);
+    cascadeTimersRef.current = [];
+    pendingEventsRef.current = [];
+    pendingLinksRef.current = [];
+    addSeparatorRef.current = false;
+    setCascading(false);
+
+    const userMessage: HackbotChatMessage = { role: 'user', content: text };
+
+    // Capture conversation history before state updates so the same API messages
+    // are sent on every retry attempt.
+    const historyMessages = messages;
+
+    setMessages((prev) => [
+      ...prev,
+      userMessage,
+      { role: 'assistant', content: '' } as HackbotChatMessage,
+    ]);
+    setInput('');
+    setError(null);
+    setLoading(true);
+
+    const apiMessages = [
+      ...historyMessages.map((m) => ({ role: m.role, content: m.content })),
+      { role: 'user', content: userMessage.content },
+    ].filter((m) => m.content.trim().length > 0);
+
+    const MAX_ATTEMPTS = 3;
+    let succeeded = false;
+
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      if (attempt > 0) {
+        // Show retrying indicator, wait briefly, then reset the assistant bubble
+        setRetrying(attempt);
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((r) => setTimeout(r, 800 * attempt));
+        pendingEventsRef.current = [];
+        pendingLinksRef.current = [];
+        addSeparatorRef.current = false;
+        setMessages((prev) => {
+          const updated = [...prev];
+          for (let i = updated.length - 1; i >= 0; i--) {
+            if (updated[i].role === 'assistant') {
+              updated[i] = { role: 'assistant', content: '' };
+              break;
+            }
+          }
+          return updated;
+        });
+        setRetrying(0);
+      }
+
+      let accumulatedText = '';
+      let streamHadError = false;
+
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch('/api/hackbot/stream', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            messages: apiMessages,
+            currentPath: pathname + window.location.hash,
+          }),
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json();
+          throw new Error(errorData.error || 'Stream failed');
+        }
+
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+
+        if (!reader) {
+          throw new Error(
+            'Streaming unsupported: response body reader unavailable.'
+          );
+        }
+
+        let keepReading = true;
+        let lineBuffer = '';
+        while (keepReading) {
+          // eslint-disable-next-line no-await-in-loop
+          const { done, value } = await reader.read();
+          lineBuffer += done
+            ? decoder.decode()
+            : decoder.decode(value, { stream: true });
+
+          const lines = lineBuffer.split('\n');
+          if (done) {
+            keepReading = false;
+            lineBuffer = '';
+          } else {
+            lineBuffer = lines.pop() ?? '';
+          }
+
+          for (const line of lines) {
+            if (line.startsWith('9:')) {
+              // Tool call in flight — show loading indicator
+              setToolPending(true);
+            } else if (line.startsWith('0:')) {
+              // Text delta
+              let content: string;
+              try {
+                const parsed = JSON.parse(line.slice(2).replace(/\r$/, ''));
+                if (typeof parsed !== 'string') continue;
+                content = parsed;
+              } catch {
+                continue;
+              }
+
+              if (content) {
+                // Add a blank line between step-1 text and any step-2 text
+                if (addSeparatorRef.current && accumulatedText.length > 0) {
+                  accumulatedText += '\n\n';
+                  addSeparatorRef.current = false;
+                }
+                accumulatedText += content;
+                setMessages((prev) => {
+                  const updated = [...prev];
+                  updated[updated.length - 1] = {
+                    ...updated[updated.length - 1],
+                    content: accumulatedText,
+                  };
+                  return updated;
+                });
+              }
+            } else if (line.startsWith('3:')) {
+              // Server-emitted error — mark for retry
+              streamHadError = true;
+              setToolPending(false);
+              keepReading = false;
+            } else if (line.startsWith('8:')) {
+              // Message annotation — buffer links until streaming is done
+              try {
+                const annotations = JSON.parse(line.slice(2).trim());
+                const arr = Array.isArray(annotations)
+                  ? annotations
+                  : [annotations];
+                for (const ann of arr) {
+                  if (Array.isArray(ann.links) && ann.links.length > 0) {
+                    pendingLinksRef.current = ann.links as HackbotLink[];
+                  }
+                }
+              } catch {
+                // Malformed annotation — ignore
+              }
+            } else if (line.startsWith('a:')) {
+              // Tool result received — clear tool-pending indicator; mark that
+              // any subsequent text should be separated from the prior step's text
+              setToolPending(false);
+              if (accumulatedText.length > 0) addSeparatorRef.current = true;
+              // Buffer events and links; apply after text is done
+              try {
+                const toolResult = JSON.parse(line.slice(2).trim());
+                const results = Array.isArray(toolResult)
+                  ? toolResult
+                  : [toolResult];
+                for (const r of results) {
+                  if (r.result?.events?.length > 0) {
+                    const incoming = r.result.events as HackbotEvent[];
+                    const existing = pendingEventsRef.current;
+                    const existingIds = new Set(existing.map((e) => e.id));
+                    const merged = [
+                      ...existing,
+                      ...incoming.filter((e) => !existingIds.has(e.id)),
+                    ].sort(
+                      (a, b) =>
+                        (a.startMs ?? Infinity) - (b.startMs ?? Infinity)
+                    );
+                    pendingEventsRef.current = merged;
+                  }
+                  // Links from provide_links tool (dedup by URL)
+                  if (
+                    Array.isArray(r.result?.links) &&
+                    r.result.links.length > 0
+                  ) {
+                    const seen = new Set<string>();
+                    pendingLinksRef.current = (
+                      r.result.links as HackbotLink[]
+                    ).filter((l) => {
+                      if (seen.has(l.url)) return false;
+                      seen.add(l.url);
+                      return true;
+                    });
+                  }
+                }
+              } catch {
+                // Malformed tool result — ignore
+              }
+            }
+          }
+        }
+      } catch (err: any) {
+        console.error(`[hackbot] Stream error attempt ${attempt + 1}`, err);
+        streamHadError = true;
+      }
+
+      setToolPending(false);
+
+      if (!streamHadError) {
+        succeeded = true;
+        break;
+      }
+
+      console.warn(`[hackbot] Attempt ${attempt + 1}/${MAX_ATTEMPTS} failed`);
+    }
+
+    setLoading(false);
+    setRetrying(0);
+
+    if (!succeeded) {
+      setError('Something went wrong. Please try again.');
+      setMessages((prev) => prev.slice(0, -2)); // remove both the user message and empty assistant bubble
+      return;
+    }
+
+    // Apply buffered links immediately (no cascade delay)
+    const linksToApply = pendingLinksRef.current;
+    pendingLinksRef.current = [];
+    if (linksToApply.length > 0) {
+      setMessages((prev) => {
+        const updated = [...prev];
+        for (let i = updated.length - 1; i >= 0; i--) {
+          if (updated[i].role === 'assistant') {
+            updated[i] = { ...updated[i], links: linksToApply };
+            break;
+          }
+        }
+        return updated;
+      });
+    }
+
+    // Cascade buffered events in one by one with staggered delays
+    const eventsToShow = [...pendingEventsRef.current];
+    pendingEventsRef.current = [];
+    if (eventsToShow.length > 0) {
+      setCascading(true);
+      eventsToShow.forEach((event, idx) => {
+        const isLast = idx === eventsToShow.length - 1;
+        const t = setTimeout(
+          () => {
+            setMessages((prev) => {
+              // Find the last assistant message and append this event
+              for (let i = prev.length - 1; i >= 0; i--) {
+                if (prev[i].role === 'assistant') {
+                  const updated = [...prev];
+                  updated[i] = {
+                    ...prev[i],
+                    events: [...(prev[i].events ?? []), event],
+                  };
+                  return updated;
+                }
+              }
+              return prev;
+            });
+            if (isLast) setCascading(false);
+          },
+          (idx + 1) * CASCADE_DELAY_MS
+        );
+        cascadeTimersRef.current.push(t);
+      });
+    }
+  };
+
+  const handleSubmit = async (e: FormEvent) => {
+    e.preventDefault();
+    await sendMessage();
+  };
+
+  const firstName = hackerProfile?.name?.split(' ')[0];
+
+  const panelStyle: CSSProperties | undefined =
+    panelWidth !== null ? { width: `${panelWidth}px` } : undefined;
+
+  return {
+    open,
+    panelRef,
+    messagesEndRef,
+    messages,
+    input,
+    loading,
+    toolPending,
+    retrying,
+    cascading,
+    error,
+    canSend,
+    suggestionChips,
+    firstName,
+    panelStyle,
+    toggleOpen,
+    onResizeMouseDown,
+    setInput,
+    setError,
+    sendMessage,
+    handleSubmit,
+  };
+}