diff --git a/DESIGN.md b/DESIGN.md
index 8be2134..c35be9b 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -296,8 +296,29 @@ The tab bar is the app's only persistent navigation. There is no footer.
 
 The one place that breaks the flat rule. `radius-deck` (28px), `shadow-lg`, full-bleed photo,
 bottom scrim `linear-gradient(to top, rgb(0 6 36 / .92), rgb(0 6 36 / .35) 45%, transparent)`.
-Overlay stamps: `SEND JOB` in `go-600`, `PASS` in `stop-500`, 4px border, ±12° rotation. Action
-buttons are 64px circles, 2px border, `ink-0` fill.
+Overlay stamps: `SEND JOB` in `go-600`, `PASS` in `stop-500`, 4px border, ±12° rotation.
+
+**The action row** is five circles, in one fixed order:
+
+| | Action | Size | Ink |
+|---|---|---|---|
+| 1 | Rewind — bring the last card back | 44px | `ink-600` |
+| 2 | Pass | **64px** | `stop-500` |
+| 3 | Watch — tell me when they are free | 44px | `brand-500` |
+| 4 | Send this job | **64px** | `go-600` |
+| 5 | Ask a question | 44px | `ink-950` |
+
+Two sizes, and the size *is* the hierarchy: the two decisions that end the card
+are 64px and reach the thumb first; the three that do not are 44px — still the
+minimum target from §8, never smaller. Gaps are 16px between a small and a large,
+24px between the two larges, so the pair still reads as the pair.
+
+All five are 2px bordered circles on `ink-0`. A control whose state persists —
+watch — fills with its own colour when active, and its label changes with it;
+selection is never carried by fill alone (§8).
+
+Rewind is `disabled` with nothing to undo rather than hidden. A row that changes
+length as you swipe moves the two buttons underneath your thumb.
 
 ---
 
diff --git a/apps/web/src/app/jobs-panel.tsx b/apps/web/src/app/jobs-panel.tsx
index 695c892..faa8da4 100644
--- a/apps/web/src/app/jobs-panel.tsx
+++ b/apps/web/src/app/jobs-panel.tsx
@@ -83,7 +83,7 @@ export function JobsPanel({
     const { matchId, jobId } = state.view;
     return (
       <ChatThread
-        matchId={matchId}
+        threadRef={{ matchId }}
         onBack={() => go(jobId ? { kind: 'job', jobId } : { kind: 'list' })}
       />
     );
diff --git a/apps/web/src/app/showcase-deck.tsx b/apps/web/src/app/showcase-deck.tsx
index 68cdd61..f21b404 100644
--- a/apps/web/src/app/showcase-deck.tsx
+++ b/apps/web/src/app/showcase-deck.tsx
@@ -12,6 +12,7 @@ import { INITIAL_SEARCH_STATE, SearchPanel, type SearchState } from './search-pa
 import { ProfilePanel } from './profile-panel';
 import { INITIAL_JOBS_STATE, JobsPanel, type JobsState } from './jobs-panel';
 import { SendJobSheet } from '@/components/hire/send-job-sheet';
+import { AskSheet } from '@/components/hire/ask-sheet';
 import { clearPendingHire, readPendingHire } from '@/lib/pending-hire';
 import { api } from '@/lib/trpc';
 
@@ -88,6 +89,9 @@ export function ShowcaseDeck({
    */
   const [hiring, setHiring] = useState<DeckCard | null>(null);
   const resolve = useRef<((verdict: SwipeVerdict) => void) | null>(null);
+  // Bumped by rewind; the Deck reads it to step its own index back.
+  const [rewindAt, setRewindAt] = useState(0);
+  const utils = api.useUtils();
 
   const decide = useCallback(
     (proId: string, direction: 'left' | 'right'): Promise<SwipeVerdict> => {
@@ -105,6 +109,31 @@ export function ShowcaseDeck({
     [cards],
   );
 
+  /* ── the three secondary deck actions ── */
+
+  const [asking, setAsking] = useState<DeckCard | null>(null);
+
+  // Errors for an anonymous visitor, same as the unread badge — no session,
+  // nothing watched.
+  const watched = api.watch.mine.useQuery(undefined, { retry: false });
+  const watchedIds = useMemo(
+    () => new Set((watched.data ?? []).map((w) => w.proId)),
+    [watched.data],
+  );
+
+  const toggleWatch = api.watch.toggle.useMutation({
+    onSettled: () => void utils.watch.mine.invalidate(),
+  });
+
+  /**
+   * Rewind steps the local stack back one.
+   *
+   * Nothing to undo server-side: the entry deck writes no swipes (a `swipes` row
+   * is job-scoped and there is no job here), so the card leaving was only ever a
+   * local index move. `deck.undo` is for the per-job deck, where a swipe is real.
+   */
+  const rewind = useCallback(() => setRewindAt((n) => n + 1), []);
+
   const onResolved = useCallback((outcome: 'sent' | 'dismissed') => {
     setHiring(null);
     resolve.current?.(outcome === 'sent' ? 'commit' : 'revert');
@@ -197,6 +226,14 @@ export function ShowcaseDeck({
             key={categoryId ?? 'all'}
             cards={cards}
             onDecide={decide}
+            onRewind={rewind}
+            rewindSignal={rewindAt}
+            onWatch={(proId) => toggleWatch.mutate({ proId })}
+            watchedProIds={watchedIds}
+            onAsk={(proId) => {
+              const card = cards.find((c) => c.proId === proId);
+              if (card) setAsking(card);
+            }}
           />
         )}
       </div>
@@ -215,6 +252,17 @@ export function ShowcaseDeck({
       {/* Inside the phone frame, not the page — the sheet belongs to this
           screen and must not cover the browser chrome around the mock. */}
       <SendJobSheet pro={hiring} open={hiring !== null} onResolved={onResolved} />
+
+      <AskSheet
+        pro={asking}
+        open={asking !== null}
+        onClose={() => setAsking(null)}
+        onSent={() => {
+          // Straight to the conversation they just started.
+          setJobs({ ...jobs, segment: 'current', view: { kind: 'list' } });
+          setTab('jobs');
+        }}
+      />
     </div>
   );
 }
diff --git a/apps/web/src/components/deck.tsx b/apps/web/src/components/deck.tsx
index e547818..14340fc 100644
--- a/apps/web/src/components/deck.tsx
+++ b/apps/web/src/components/deck.tsx
@@ -2,7 +2,7 @@
 
 import { useCallback, useMemo, useRef, useState } from 'react';
 import { AnimatePresence, motion, useMotionValue, useTransform } from 'motion/react';
-import { Check, MapPin, Star, X } from 'lucide-react';
+import { Check, Eye, MapPin, MessageCircle, Star, Undo2, X } from 'lucide-react';
 import type { DeckCard } from '@linkder/db';
 import { cn, formatDistance, formatResponseTime } from '@/lib/utils';
 
@@ -26,9 +26,35 @@ export interface DeckProps {
     proId: string,
     direction: 'left' | 'right',
   ) => void | Promise<void | SwipeVerdict>;
+  /**
+   * The three secondary actions. All optional — a deck rendered without them
+   * shows the buttons disabled rather than missing, so the row keeps its shape
+   * and the two big buttons never move.
+   */
+  onRewind?: () => void;
+  /**
+   * Incremented by the parent to step the stack back one.
+   *
+   * A signal rather than a callback returning state: the index lives in the
+   * Deck, and handing it out so a parent could decrement it would give two
+   * owners to the one thing that must stay consistent with the card on screen.
+   */
+  rewindSignal?: number;
+  onWatch?: (proId: string) => void;
+  onAsk?: (proId: string) => void;
+  /** Which pros the viewer already watches, for the filled state. */
+  watchedProIds?: ReadonlySet<string>;
 }
 
-export function Deck({ cards, onDecide }: DeckProps) {
+export function Deck({
+  cards,
+  onDecide,
+  onRewind,
+  rewindSignal = 0,
+  onWatch,
+  onAsk,
+  watchedProIds,
+}: DeckProps) {
   const [index, setIndex] = useState(0);
   const remaining = useMemo(() => cards.slice(index), [cards, index]);
 
@@ -36,6 +62,14 @@ export function Deck({ cards, onDecide }: DeckProps) {
   // is open would advance past a card nobody ever saw.
   const inFlight = useRef(false);
 
+  // Step back when the parent asks. Guarded on the previous value so a re-render
+  // for any other reason does not rewind again.
+  const lastRewind = useRef(rewindSignal);
+  if (rewindSignal !== lastRewind.current) {
+    lastRewind.current = rewindSignal;
+    if (index > 0) setIndex((i) => Math.max(0, i - 1));
+  }
+
   const decide = useCallback(
     async (proId: string, direction: 'left' | 'right') => {
       if (inFlight.current) return;
@@ -83,17 +117,48 @@ export function Deck({ cards, onDecide }: DeckProps) {
         </AnimatePresence>
       </div>
 
-      <div className="flex shrink-0 items-center gap-12 pb-2">
+      {/* DESIGN.md §6.8. Fixed order, two sizes: rewind · pass · watch · hire · ask.
+          Gaps are tighter around the small ones so the middle pair still reads
+          as the pair. */}
+      <div className="flex shrink-0 items-center gap-4 pb-2">
+        <ActionButton
+          label="Bring back the last one"
+          icon={Undo2}
+          tone="ink"
+          // Disabled rather than hidden: a row that changes length as you swipe
+          // moves the two big buttons out from under your thumb.
+          disabled={index === 0 || !onRewind}
+          onClick={() => onRewind?.()}
+        />
         <ActionButton
           label="Not this one"
-          variant="pass"
+          icon={X}
+          tone="pass"
+          size="lg"
           onClick={() => visible[0] && decide(visible[0].proId, 'left')}
         />
+        <ActionButton
+          label={watchedProIds?.has(visible[0]?.proId ?? '') ? 'Stop watching' : 'Tell me when they are free'}
+          icon={Eye}
+          tone="accent"
+          active={watchedProIds?.has(visible[0]?.proId ?? '') ?? false}
+          disabled={!onWatch}
+          onClick={() => visible[0] && onWatch?.(visible[0].proId)}
+        />
         <ActionButton
           label="Send this job"
-          variant="hire"
+          icon={Check}
+          tone="hire"
+          size="lg"
           onClick={() => visible[0] && decide(visible[0].proId, 'right')}
         />
+        <ActionButton
+          label="Ask a question"
+          icon={MessageCircle}
+          tone="ink"
+          disabled={!onAsk}
+          onClick={() => visible[0] && onAsk?.(visible[0].proId)}
+        />
       </div>
     </div>
   );
@@ -215,32 +280,67 @@ export function Card({
   );
 }
 
+/**
+ * DESIGN.md §6.8. One of the five circles under the card.
+ *
+ * `size` IS the hierarchy, not decoration: the two actions that end the card are
+ * large and meet the thumb first; the three that do not are small — but never
+ * below 44px, which is the floor in §8.
+ *
+ * `active` fills the circle for the one control whose state persists (watch),
+ * and its label changes with it, because §8 forbids fill as the only signal.
+ */
 function ActionButton({
   label,
-  variant,
+  icon: Icon,
+  tone,
+  size = 'sm',
+  active = false,
+  disabled = false,
   onClick,
 }: {
   label: string;
-  variant: 'pass' | 'hire';
+  icon: typeof Check;
+  tone: 'pass' | 'hire' | 'accent' | 'ink';
+  size?: 'sm' | 'lg';
+  active?: boolean;
+  disabled?: boolean;
   onClick: () => void;
 }) {
-  const isHire = variant === 'hire';
-  const Icon = isHire ? Check : X;
+  const isLarge = size === 'lg';
+  const colour = {
+    pass: 'var(--color-stop-500)',
+    hire: 'var(--color-go-600)',
+    accent: 'var(--color-brand-500)',
+    ink: 'var(--color-ink-950)',
+  }[tone];
+
   return (
     <button
       type="button"
       onClick={onClick}
+      disabled={disabled}
       aria-label={label}
+      aria-pressed={active || undefined}
       title={label}
+      style={{
+        borderColor: colour,
+        color: active ? undefined : colour,
+        backgroundColor: active ? colour : undefined,
+      }}
       className={cn(
-        'flex h-16 w-16 items-center justify-center rounded-full border-2 bg-raised shadow-lg',
+        'flex items-center justify-center rounded-full border-2 shadow-lg',
         'transition hover:scale-105 active:scale-95',
-        isHire
-          ? 'border-[var(--color-go-600)] text-[var(--color-go-600)]'
-          : 'border-[var(--color-stop-500)] text-[var(--color-stop-500)]',
+        'disabled:pointer-events-none disabled:opacity-35 disabled:shadow-none',
+        isLarge ? 'h-16 w-16' : 'h-11 w-11',
+        active ? 'text-white' : 'bg-raised',
       )}
     >
-      <Icon className="h-7 w-7" strokeWidth={3} aria-hidden />
+      <Icon
+        className={isLarge ? 'h-7 w-7' : 'h-5 w-5'}
+        strokeWidth={isLarge ? 3 : 2.5}
+        aria-hidden
+      />
     </button>
   );
 }
diff --git a/apps/web/src/components/hire/ask-sheet.tsx b/apps/web/src/components/hire/ask-sheet.tsx
new file mode 100644
index 0000000..72a2892
--- /dev/null
+++ b/apps/web/src/components/hire/ask-sheet.tsx
@@ -0,0 +1,152 @@
+'use client';
+
+import { useState } from 'react';
+import type { DeckCard } from '@linkder/db';
+import { api } from '@/lib/trpc';
+import { Banner, Button, Sheet, Textarea } from '@/components/ui';
+import { setPendingHire } from '@/lib/pending-hire';
+import { useRouter } from 'next/navigation';
+
+/**
+ * Ask a pro a question, before there is a job.
+ *
+ * This is the one place in the product that reaches somebody who has not agreed
+ * to anything, so the sheet is deliberately honest about the deal on both sides:
+ * the customer is told the pro can end it, and the remaining allowance is shown
+ * before they type rather than after they press send.
+ */
+export function AskSheet({
+  pro,
+  open,
+  onClose,
+  onSent,
+}: {
+  pro: DeckCard | null;
+  open: boolean;
+  onClose: () => void;
+  onSent: (enquiryId: string) => void;
+}) {
+  const router = useRouter();
+  const [body, setBody] = useState('');
+
+  const me = api.user.me.useQuery(undefined, { retry: false });
+  const allowance = api.enquiry.allowance.useQuery(undefined, {
+    enabled: open && me.data?.role === 'client',
+    retry: false,
+  });
+
+  const utils = api.useUtils();
+  const create = api.enquiry.create.useMutation({
+    onSuccess: ({ enquiryId }) => {
+      setBody('');
+      void utils.enquiry.allowance.invalidate();
+      void utils.enquiry.mineAsClient.invalidate();
+      onSent(enquiryId);
+      onClose();
+    },
+  });
+
+  if (!pro) return null;
+  const name = pro.name ?? 'this pro';
+
+  /* ── anonymous ── */
+  if (!me.isLoading && (me.error || !me.data)) {
+    return (
+      <Sheet
+        open={open}
+        onClose={onClose}
+        title={`Ask ${name} a question`}
+        body="Sign in first — they need to know who is asking."
+        actions={
+          <Button
+            size="lg"
+            block
+            onClick={() => {
+              setPendingHire({ proId: pro.proId, name });
+              router.push('/sign-in?next=/');
+            }}
+          >
+            Continue with phone
+          </Button>
+        }
+      />
+    );
+  }
+
+  if (me.data?.role === 'pro') {
+    return (
+      <Sheet
+        open={open}
+        onClose={onClose}
+        title="You are signed in as a pro"
+        body="Asking questions is a customer thing. You can still browse who else is on here."
+        actions={
+          <Button variant="outline" size="lg" block onClick={onClose}>
+            Back to the deck
+          </Button>
+        }
+      />
+    );
+  }
+
+  const remaining = allowance.data?.remaining ?? null;
+  const outOfRoom = remaining === 0;
+  const canSend = body.trim().length >= 10 && !create.isPending && !outOfRoom;
+
+  return (
+    <Sheet
+      open={open}
+      onClose={onClose}
+      title={`Ask ${name} a question`}
+      body="No job needed. They can reply, or close it."
+      actions={
+        <div className="flex flex-col gap-2">
+          {create.error && (
+            <p role="alert" className="text-meta text-stop-500">
+              {create.error.message}
+            </p>
+          )}
+          <Button
+            size="lg"
+            block
+            busy={create.isPending}
+            disabled={!canSend}
+            onClick={() => create.mutate({ proId: pro.proId, body })}
+          >
+            Send question
+          </Button>
+          <Button variant="ghost" size="sm" block onClick={onClose}>
+            Not now
+          </Button>
+        </div>
+      }
+    >
+      {outOfRoom ? (
+        <Banner tone="warning" title="Give them a chance to reply">
+          You have {allowance.data?.cap} questions still waiting on an answer. Once somebody
+          replies you can ask again — or post a job, which reaches pros a different way.
+        </Banner>
+      ) : (
+        <>
+          <label className="flex flex-col gap-2">
+            <span className="text-body-sm text-strong">Your question</span>
+            <Textarea
+              rows={4}
+              value={body}
+              maxLength={2000}
+              onChange={(e) => setBody(e.target.value)}
+              placeholder="Do you cover this kind of work? Roughly what would it cost?"
+            />
+          </label>
+          <p className="mt-1 text-meta text-faint">
+            {body.trim().length < 10
+              ? 'A sentence at least — "hi" is not a question anybody can answer.'
+              : remaining !== null
+                ? `${remaining} more question${remaining === 1 ? '' : 's'} while these are unanswered.`
+                : `${body.length}/2000`}
+          </p>
+        </>
+      )}
+    </Sheet>
+  );
+}
diff --git a/apps/web/src/components/jobs/chat-thread.tsx b/apps/web/src/components/jobs/chat-thread.tsx
index c5da73c..34ea582 100644
--- a/apps/web/src/components/jobs/chat-thread.tsx
+++ b/apps/web/src/components/jobs/chat-thread.tsx
@@ -20,7 +20,9 @@ import { cn, formatRelativeTime } from '@/lib/utils';
  * has to stay on the thumb, and a chat whose input scrolls away with the history
  * is a chat you have to hunt for.
  */
-export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () => void }) {
+export type ThreadRef = { matchId: string } | { enquiryId: string };
+
+export function ChatThread({ threadRef, onBack }: { threadRef: ThreadRef; onBack: () => void }) {
   const utils = api.useUtils();
   const [draft, setDraft] = useState('');
   const [attachments, setAttachments] = useState<PendingAttachment[]>([]);
@@ -28,7 +30,7 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
   const bottom = useRef<HTMLDivElement>(null);
 
   const thread = api.message.thread.useQuery(
-    { matchId },
+    { ref: threadRef },
     {
       // Polled while open. Four seconds is short enough to feel live and cheap
       // enough to run without a socket; the real push lands with M4.
@@ -56,13 +58,17 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
     onSuccess: () => {
       setDraft('');
       setAttachments([]);
-      void utils.message.thread.invalidate({ matchId });
+      void utils.message.thread.invalidate({ ref: threadRef });
       void utils.job.mine.invalidate();
       void utils.job.mineForPro.invalidate();
       void utils.job.matches.invalidate();
     },
   });
 
+  // A stable primitive for effect deps — an object literal would be a new
+  // reference every render and re-fire the read receipt on a loop.
+  const threadKey = 'matchId' in threadRef ? threadRef.matchId : threadRef.enquiryId;
+
   const messages = thread.data?.messages ?? [];
   const match = thread.data?.match;
   const newestId = messages[messages.length - 1]?.id;
@@ -72,10 +78,10 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
   const unreadFromPeer = messages.some((m) => !m.isMine && m.readAt === null);
   useEffect(() => {
     if (!unreadFromPeer || markRead.isPending) return;
-    markRead.mutate({ matchId });
+    markRead.mutate({ ref: threadRef });
     // `newestId` is the trigger: re-running on every render would loop.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [matchId, newestId, unreadFromPeer]);
+  }, [threadKey, newestId, unreadFromPeer]);
 
   // Stick to the bottom as messages land. `auto` rather than `smooth` on first
   // paint, or the thread visibly scrolls itself on open.
@@ -89,7 +95,7 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
 
   const submit = () => {
     if (!canSend) return;
-    send.mutate({ matchId, body: draft, attachments: attachments.map((a) => a.url) });
+    send.mutate({ ref: threadRef, body: draft, attachments: attachments.map((a) => a.url) });
   };
 
   return (
@@ -153,9 +159,9 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
 
       {/* The deal, above the composer: quoting and booking happen in the
           conversation they are being discussed in, not on a screen of their own. */}
-      {match && (
+      {match?.matchId && (
         <DealStrip
-          matchId={matchId}
+          matchId={match.matchId}
           // The peer's role, inverted — if I am talking to a pro, I am the client.
           isPro={match.peer?.role !== 'pro'}
           canAct={match.canReply}
@@ -164,9 +170,11 @@ export function ChatThread({ matchId, onBack }: { matchId: string; onBack: () =>
 
       {match && !match.canReply ? (
         <p className="shrink-0 border-t border-hairline px-4 py-4 text-center text-body-sm text-muted">
-          {match.jobStatus === 'cancelled'
-            ? 'This job was cancelled. The conversation is closed.'
-            : 'This job is finished. The conversation is closed.'}
+          {match.kind === 'enquiry'
+            ? 'This enquiry was closed. The messages stay as a record.'
+            : match.jobStatus === 'cancelled'
+              ? 'This job was cancelled. The conversation is closed.'
+              : 'This job is finished. The conversation is closed.'}
         </p>
       ) : (
         <div className="shrink-0 border-t border-hairline px-4 pb-2 pt-2">
diff --git a/apps/web/src/components/jobs/deal-strip.tsx b/apps/web/src/components/jobs/deal-strip.tsx
index 4289c1b..195b5ea 100644
--- a/apps/web/src/components/jobs/deal-strip.tsx
+++ b/apps/web/src/components/jobs/deal-strip.tsx
@@ -41,7 +41,7 @@ export function DealStrip({
   const refresh = () => {
     void utils.quote.forMatch.invalidate({ matchId });
     void utils.booking.forMatch.invalidate({ matchId });
-    void utils.message.thread.invalidate({ matchId });
+    void utils.message.thread.invalidate({ ref: { matchId } });
     void utils.job.mine.invalidate();
     void utils.job.mineForPro.invalidate();
     void utils.review.pending.invalidate();
diff --git a/packages/api/src/root.ts b/packages/api/src/root.ts
index ee62b13..a68f601 100644
--- a/packages/api/src/root.ts
+++ b/packages/api/src/root.ts
@@ -2,6 +2,7 @@ import { router } from './trpc';
 import { adminRouter } from './routers/admin';
 import { deckRouter } from './routers/deck';
 import { bookingRouter } from './routers/booking';
+import { enquiryRouter } from './routers/enquiry';
 import { geocodeRouter } from './routers/geocode';
 import { jobRouter } from './routers/job';
 import { messageRouter } from './routers/message';
@@ -9,6 +10,7 @@ import { proRouter } from './routers/pro';
 import { quoteRouter } from './routers/quote';
 import { requestRouter } from './routers/request';
 import { reviewRouter } from './routers/review';
+import { watchRouter } from './routers/watch';
 import { uploadRouter } from './routers/upload';
 import { notificationRouter } from './routers/notification';
 import { userRouter } from './routers/user';
@@ -27,6 +29,8 @@ export const appRouter = router({
   quote: quoteRouter,
   booking: bookingRouter,
   review: reviewRouter,
+  enquiry: enquiryRouter,
+  watch: watchRouter,
   geocode: geocodeRouter,
   upload: uploadRouter,
   user: userRouter,
diff --git a/packages/api/src/routers/enquiry.ts b/packages/api/src/routers/enquiry.ts
new file mode 100644
index 0000000..e42d0ff
--- /dev/null
+++ b/packages/api/src/routers/enquiry.ts
@@ -0,0 +1,238 @@
+import { TRPCError } from '@trpc/server';
+import { and, desc, eq, gt, isNull, or, sql } from 'drizzle-orm';
+import { z } from 'zod';
+import { schema } from '@linkder/db';
+import { ENQUIRY_STALE_DAYS, MAX_OPEN_ENQUIRIES } from '@linkder/shared';
+import { clientProcedure, proProcedure, protectedProcedure, router } from '../trpc';
+
+/**
+ * A question, before there is a job.
+ *
+ * This is the first way in the product to reach a pro who has not agreed to
+ * anything, and that is a real change: until now chat was gated behind
+ * message → match → accepted request → job, and the gate is what made a pro's
+ * inbox worth opening. So the cap below is not decoration.
+ *
+ * What keeps it honest:
+ *  - `MAX_OPEN_ENQUIRIES` unanswered at a time, per customer. Answered threads
+ *    do not count, so somebody having real conversations is never throttled and
+ *    somebody broadcasting is stopped at five.
+ *  - One thread per pair. A second question goes in the same conversation
+ *    rather than making a new one, so a cap cannot be walked around by asking
+ *    the same person repeatedly.
+ *  - The pro can close it. History stays readable; nothing more lands.
+ */
+export const enquiryRouter = router({
+  /**
+   * The pro's side: questions waiting on them.
+   *
+   * `proProcedure`, not verified-only — an unverified pro should see what they
+   * are missing, which is the strongest argument for finishing verification.
+   * Answering is what needs the badge.
+   */
+  mine: proProcedure.query(async ({ ctx }) => {
+    const uid = ctx.session.userId;
+
+    const rows = await ctx.db
+      .select({
+        id: schema.enquiries.id,
+        clientId: schema.enquiries.clientId,
+        clientName: schema.users.name,
+        respondedAt: schema.enquiries.respondedAt,
+        closedAt: schema.enquiries.closedAt,
+        lastMessageAt: schema.enquiries.lastMessageAt,
+        createdAt: schema.enquiries.createdAt,
+        preview: sql<string | null>`(
+          SELECT msg.body FROM messages msg
+           WHERE msg.enquiry_id = ${schema.enquiries.id}
+           ORDER BY msg.created_at DESC LIMIT 1
+        )`,
+        unreadCount: sql<number>`(
+          SELECT count(*)::int FROM messages msg
+           WHERE msg.enquiry_id = ${schema.enquiries.id}
+             AND msg.sender_id <> ${uid}
+             AND msg.read_at IS NULL
+        )`,
+      })
+      .from(schema.enquiries)
+      .innerJoin(schema.users, eq(schema.users.id, schema.enquiries.clientId))
+      .where(eq(schema.enquiries.proId, uid))
+      .orderBy(desc(schema.enquiries.lastMessageAt));
+
+    return rows;
+  }),
+
+  /** The customer's side: everyone they have asked something. */
+  mineAsClient: clientProcedure.query(async ({ ctx }) => {
+    const uid = ctx.session.userId;
+
+    return await ctx.db
+      .select({
+        id: schema.enquiries.id,
+        proId: schema.enquiries.proId,
+        proName: schema.users.name,
+        headline: schema.proProfiles.headline,
+        respondedAt: schema.enquiries.respondedAt,
+        closedAt: schema.enquiries.closedAt,
+        lastMessageAt: schema.enquiries.lastMessageAt,
+        unreadCount: sql<number>`(
+          SELECT count(*)::int FROM messages msg
+           WHERE msg.enquiry_id = ${schema.enquiries.id}
+             AND msg.sender_id <> ${uid}
+             AND msg.read_at IS NULL
+        )`,
+      })
+      .from(schema.enquiries)
+      .innerJoin(schema.proProfiles, eq(schema.proProfiles.userId, schema.enquiries.proId))
+      .innerJoin(schema.users, eq(schema.users.id, schema.enquiries.proId))
+      .where(eq(schema.enquiries.clientId, uid))
+      .orderBy(desc(schema.enquiries.lastMessageAt));
+  }),
+
+  /** How much room is left under the cap. Lets the sheet say so before they type. */
+  allowance: clientProcedure.query(async ({ ctx }) => {
+    const [row] = await ctx.db
+      .select({ n: sql<number>`count(*)::int` })
+      .from(schema.enquiries)
+      .where(openEnquiries(ctx.session.userId));
+
+    const open = row?.n ?? 0;
+    return { open, cap: MAX_OPEN_ENQUIRIES, remaining: Math.max(0, MAX_OPEN_ENQUIRIES - open) };
+  }),
+
+  /**
+   * Ask a question.
+   *
+   * Creates the thread and its first message together — an enquiry with no
+   * message is an empty room, and a pro opening one would find nothing to
+   * answer. Asking the same pro twice reuses the existing thread rather than
+   * creating a second, which is also what stops the cap being walked around.
+   */
+  create: clientProcedure
+    .input(
+      z.object({
+        proId: z.string().uuid(),
+        body: z.string().trim().min(10).max(2000),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const uid = ctx.session.userId;
+
+      const pro = await ctx.db.query.proProfiles.findFirst({
+        where: eq(schema.proProfiles.userId, input.proId),
+        columns: { verificationStatus: true, isAcceptingJobs: true },
+      });
+      if (!pro || pro.verificationStatus !== 'verified' || !pro.isAcceptingJobs) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'That pro is not available' });
+      }
+
+      return await ctx.db.transaction(async (tx) => {
+        const [existing] = await tx
+          .select()
+          .from(schema.enquiries)
+          .where(
+            and(eq(schema.enquiries.clientId, uid), eq(schema.enquiries.proId, input.proId)),
+          )
+          .for('update');
+
+        if (existing?.closedAt) {
+          throw new TRPCError({
+            code: 'PRECONDITION_FAILED',
+            message: 'This pro closed your last enquiry. Post a job to reach them.',
+          });
+        }
+
+        // Only a NEW thread is capped. Continuing an existing conversation is
+        // not the behaviour the cap exists to stop.
+        if (!existing) {
+          const [open] = await tx
+            .select({ n: sql<number>`count(*)::int` })
+            .from(schema.enquiries)
+            .where(openEnquiries(uid));
+
+          if ((open?.n ?? 0) >= MAX_OPEN_ENQUIRIES) {
+            throw new TRPCError({
+              code: 'TOO_MANY_REQUESTS',
+              message: `You have ${MAX_OPEN_ENQUIRIES} questions still waiting on an answer. Give them a chance to reply before asking more.`,
+            });
+          }
+        }
+
+        const enquiryId =
+          existing?.id ??
+          (
+            await tx
+              .insert(schema.enquiries)
+              .values({ clientId: uid, proId: input.proId })
+              .returning()
+          )[0]!.id;
+
+        const [message] = await tx
+          .insert(schema.messages)
+          .values({ enquiryId, senderId: uid, body: input.body })
+          .returning();
+
+        await tx
+          .update(schema.enquiries)
+          .set({ lastMessageAt: message!.createdAt })
+          .where(eq(schema.enquiries.id, enquiryId));
+
+        await tx.insert(schema.auditLog).values({
+          actorId: uid,
+          action: existing ? 'enquiry.continued' : 'enquiry.created',
+          entity: 'enquiry',
+          entityId: enquiryId,
+          metadata: { proId: input.proId },
+          ip: ctx.ip,
+        });
+
+        return { enquiryId, messageId: message!.id };
+      });
+    }),
+
+  /**
+   * The pro ends it.
+   *
+   * Their side of the bargain for being reachable at all: somebody who is
+   * wasting their time can be shut off without support getting involved. The
+   * history stays — a closed thread is still evidence if the exchange is ever
+   * disputed.
+   */
+  close: protectedProcedure
+    .input(z.object({ enquiryId: z.string().uuid() }))
+    .mutation(async ({ ctx, input }) => {
+      const enquiry = await ctx.db.query.enquiries.findFirst({
+        where: eq(schema.enquiries.id, input.enquiryId),
+      });
+      // 404 rather than 403 — a stranger must not learn the thread exists.
+      if (!enquiry || enquiry.proId !== ctx.session.userId) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Enquiry not found' });
+      }
+
+      await ctx.db
+        .update(schema.enquiries)
+        .set({ closedAt: new Date() })
+        .where(eq(schema.enquiries.id, enquiry.id));
+
+      return { closed: true as const };
+    }),
+});
+
+/**
+ * Enquiries that count against a customer's cap.
+ *
+ * Unanswered, not closed, and not yet stale. Stale ones fall out on their own so
+ * a customer is not locked out forever by five pros who never replied — being
+ * ignored is not something to be punished for.
+ */
+function openEnquiries(clientId: string) {
+  return and(
+    eq(schema.enquiries.clientId, clientId),
+    isNull(schema.enquiries.respondedAt),
+    isNull(schema.enquiries.closedAt),
+    gt(
+      schema.enquiries.createdAt,
+      sql`now() - (${ENQUIRY_STALE_DAYS} || ' days')::interval`,
+    ),
+  );
+}
diff --git a/packages/api/src/routers/message.ts b/packages/api/src/routers/message.ts
index 9cbc62a..8c2da66 100644
--- a/packages/api/src/routers/message.ts
+++ b/packages/api/src/routers/message.ts
@@ -95,6 +95,99 @@ function canReply(status: JobStatus): boolean {
   return !PAST_JOB_STATUSES.includes(status);
 }
 
+/**
+ * A conversation is either a MATCH or an ENQUIRY.
+ *
+ * A match is "a pro agreed to this job"; an enquiry is "somebody asked a
+ * question before there was a job". They differ in what they hang off and what
+ * closes them, and in nothing else — so they share one message table, one chat
+ * screen, and the normalised context below.
+ */
+export const threadRefSchema = z.union([
+  z.object({ matchId: z.string().uuid() }),
+  z.object({ enquiryId: z.string().uuid() }),
+]);
+export type ThreadRef = z.infer<typeof threadRefSchema>;
+
+export interface ThreadContext {
+  kind: 'match' | 'enquiry';
+  matchId: string | null;
+  enquiryId: string | null;
+  clientId: string;
+  proId: string;
+  /** Null on an enquiry — that is the whole point of one. */
+  jobId: string | null;
+  /** Null on an enquiry. Kept because "cancelled" and "finished" are not the
+   *  same thing to say to somebody, and only the job knows which it was. */
+  jobStatus: JobStatus | null;
+  title: string;
+  canReply: boolean;
+}
+
+/**
+ * The gate for anything that reads or writes a conversation.
+ *
+ * NOT_FOUND rather than FORBIDDEN for a thread the caller is not part of — the
+ * same rule as `job.byId` and `request.accept`: a stranger must not be able to
+ * probe whether a conversation exists.
+ */
+export async function requireThreadParticipant(
+  exec: Executor,
+  ref: ThreadRef,
+  userId: string,
+): Promise<ThreadContext> {
+  if ('matchId' in ref) {
+    const match = await requireMatchParticipant(exec, ref.matchId, userId);
+    return {
+      kind: 'match',
+      matchId: match.matchId,
+      enquiryId: null,
+      clientId: match.clientId,
+      proId: match.proId,
+      jobId: match.jobId,
+      jobStatus: match.jobStatus,
+      title: match.jobTitle,
+      canReply: canReply(match.jobStatus),
+    };
+  }
+
+  const [row] = await exec
+    .select({
+      id: schema.enquiries.id,
+      clientId: schema.enquiries.clientId,
+      proId: schema.enquiries.proId,
+      closedAt: schema.enquiries.closedAt,
+      headline: schema.proProfiles.headline,
+    })
+    .from(schema.enquiries)
+    .innerJoin(schema.proProfiles, eq(schema.proProfiles.userId, schema.enquiries.proId))
+    .where(eq(schema.enquiries.id, ref.enquiryId));
+
+  if (!row || (row.clientId !== userId && row.proId !== userId)) {
+    throw new TRPCError({ code: 'NOT_FOUND', message: 'Conversation not found' });
+  }
+
+  return {
+    kind: 'enquiry',
+    matchId: null,
+    enquiryId: row.id,
+    clientId: row.clientId,
+    proId: row.proId,
+    jobId: null,
+    jobStatus: null,
+    title: row.headline,
+    // A pro can end an enquiry. The history stays readable; nothing more lands.
+    canReply: row.closedAt === null,
+  };
+}
+
+/** Scopes a message query to one thread, whichever kind it is. */
+function inThread(ctx: ThreadContext) {
+  return ctx.kind === 'match'
+    ? eq(schema.messages.matchId, ctx.matchId!)
+    : eq(schema.messages.enquiryId, ctx.enquiryId!);
+}
+
 /**
  * Keyset pagination, oldest-ward.
  *
@@ -122,12 +215,12 @@ export const messageRouter = router({
    * screen titleless for a beat.
    */
   thread: protectedProcedure
-    .input(z.object({ matchId: z.string().uuid(), cursor: cursorSchema.optional() }))
+    .input(z.object({ ref: threadRefSchema, cursor: cursorSchema.optional() }))
     .query(async ({ ctx, input }) => {
       const uid = ctx.session.userId;
-      const match = await requireMatchParticipant(ctx.db, input.matchId, uid);
+      const thread = await requireThreadParticipant(ctx.db, input.ref, uid);
 
-      const peerId = match.clientId === uid ? match.proId : match.clientId;
+      const peerId = thread.clientId === uid ? thread.proId : thread.clientId;
       const [peer] = await ctx.db
         .select({
           id: schema.users.id,
@@ -150,12 +243,11 @@ export const messageRouter = router({
         .from(schema.messages)
         .where(
           and(
-            eq(schema.messages.matchId, input.matchId),
+            inThread(thread),
             input.cursor
               ? sql`(${schema.messages.createdAt}, ${schema.messages.id}) < (
                   SELECT anchor.created_at, anchor.id FROM messages anchor
                    WHERE anchor.id = ${input.cursor}::uuid
-                     AND anchor.match_id = ${input.matchId}::uuid
                 )`
               : undefined,
           ),
@@ -169,11 +261,14 @@ export const messageRouter = router({
 
       return {
         match: {
-          id: match.matchId,
-          jobId: match.jobId,
-          jobTitle: match.jobTitle,
-          jobStatus: match.jobStatus,
-          canReply: canReply(match.jobStatus),
+          kind: thread.kind,
+          id: thread.matchId ?? thread.enquiryId!,
+          matchId: thread.matchId,
+          enquiryId: thread.enquiryId,
+          jobId: thread.jobId,
+          jobStatus: thread.jobStatus,
+          jobTitle: thread.title,
+          canReply: thread.canReply,
           peer: peer ?? null,
         },
         // Newest last, the way a chat reads.
@@ -194,22 +289,25 @@ export const messageRouter = router({
     assertSendRate(uid);
 
     return await ctx.db.transaction(async (tx) => {
-      const match = await requireMatchParticipant(tx, input.matchId, uid);
+      const thread = await requireThreadParticipant(tx, input.ref, uid);
 
-      if (!canReply(match.jobStatus)) {
+      if (!thread.canReply) {
         throw new TRPCError({
           code: 'PRECONDITION_FAILED',
           message:
-            match.jobStatus === 'cancelled'
-              ? 'This job was cancelled. The conversation is closed.'
-              : 'This job is finished. The conversation is closed.',
+            thread.kind === 'enquiry'
+              ? 'This enquiry was closed.'
+              : thread.jobStatus === 'cancelled'
+                ? 'This job was cancelled. The conversation is closed.'
+                : 'This job is finished. The conversation is closed.',
         });
       }
 
       const [message] = await tx
         .insert(schema.messages)
         .values({
-          matchId: input.matchId,
+          matchId: thread.matchId,
+          enquiryId: thread.enquiryId,
           senderId: uid,
           body: input.body,
           attachments: input.attachments,
@@ -220,10 +318,24 @@ export const messageRouter = router({
         throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Could not send' });
       }
 
-      await tx
-        .update(schema.matches)
-        .set({ lastMessageAt: message.createdAt })
-        .where(eq(schema.matches.id, input.matchId));
+      // Both parents carry lastMessageAt: the jobs list and the pro's enquiry
+      // inbox both sort on it, so a message that lands without it is a
+      // conversation that silently stops surfacing.
+      if (thread.kind === 'match') {
+        await tx
+          .update(schema.matches)
+          .set({ lastMessageAt: message.createdAt })
+          .where(eq(schema.matches.id, thread.matchId!));
+      } else {
+        await tx
+          .update(schema.enquiries)
+          .set({
+            lastMessageAt: message.createdAt,
+            // The pro answering is what takes this off the client's open cap.
+            ...(uid === thread.proId ? { respondedAt: message.createdAt } : {}),
+          })
+          .where(eq(schema.enquiries.id, thread.enquiryId!));
+      }
 
       return { ...message, isMine: true as const };
     });
@@ -236,17 +348,17 @@ export const messageRouter = router({
    * partial index (`messages_unread_idx`), so a second call touches no rows.
    */
   markRead: protectedProcedure
-    .input(z.object({ matchId: z.string().uuid() }))
+    .input(z.object({ ref: threadRefSchema }))
     .mutation(async ({ ctx, input }) => {
       const uid = ctx.session.userId;
-      await requireMatchParticipant(ctx.db, input.matchId, uid);
+      const thread = await requireThreadParticipant(ctx.db, input.ref, uid);
 
       const updated = await ctx.db
         .update(schema.messages)
         .set({ readAt: new Date() })
         .where(
           and(
-            eq(schema.messages.matchId, input.matchId),
+            inThread(thread),
             ne(schema.messages.senderId, uid),
             isNull(schema.messages.readAt),
           ),
@@ -263,15 +375,28 @@ export const messageRouter = router({
   unreadTotal: protectedProcedure.query(async ({ ctx }) => {
     const uid = ctx.session.userId;
 
+    // Both kinds of thread, in one scan. Written as a single predicate rather
+    // than two queries because the badge is one number and reading it twice
+    // would let the halves disagree.
     const [row] = await ctx.db
       .select({ n: sql<number>`count(*)::int` })
       .from(schema.messages)
-      .innerJoin(schema.matches, eq(schema.matches.id, schema.messages.matchId))
       .where(
         and(
-          or(eq(schema.matches.clientId, uid), eq(schema.matches.proId, uid)),
           ne(schema.messages.senderId, uid),
           isNull(schema.messages.readAt),
+          or(
+            sql`EXISTS (
+              SELECT 1 FROM matches m
+               WHERE m.id = ${schema.messages.matchId}
+                 AND (m.client_id = ${uid} OR m.pro_id = ${uid})
+            )`,
+            sql`EXISTS (
+              SELECT 1 FROM enquiries e
+               WHERE e.id = ${schema.messages.enquiryId}
+                 AND (e.client_id = ${uid} OR e.pro_id = ${uid})
+            )`,
+          ),
         ),
       );
 
diff --git a/packages/api/src/routers/watch.ts b/packages/api/src/routers/watch.ts
new file mode 100644
index 0000000..801fbc5
--- /dev/null
+++ b/packages/api/src/routers/watch.ts
@@ -0,0 +1,145 @@
+import { TRPCError } from '@trpc/server';
+import { and, desc, eq, isNull, sql } from 'drizzle-orm';
+import { z } from 'zod';
+import { schema } from '@linkder/db';
+import { protectedProcedure, router } from '../trpc';
+
+/**
+ * "Tell me when this one is free."
+ *
+ * The deck's third answer. Before this it had exactly two — send them a job
+ * right now, or lose them — which is a lot to hang on a swipe when the person
+ * you like is the one you are not ready for yet.
+ *
+ * WHAT THIS CAN AND CANNOT DO TODAY, because the limit is not obvious:
+ * a pro with `is_accepting_jobs = false` is invisible on every surface
+ * (`eligibleProAtAnyDistance()` requires it, and the deck, search and the public
+ * profile all use that rule). So a watch can only be placed on somebody who is
+ * ALREADY available, and it fires on the away-and-back cycle rather than on
+ * "they are busy now, tell me when they are not".
+ *
+ * Making "free at a time that suits me" real needs `pro_availability` — seeded
+ * since M1 and read by nothing — to become a maintained calendar. This is
+ * deliberately the narrow, honest version rather than a button that cannot fire.
+ */
+export const watchRouter = router({
+  /** Everyone this person is watching, most recent first. */
+  mine: protectedProcedure.query(async ({ ctx }) => {
+    const rows = await ctx.db
+      .select({
+        proId: schema.proWatches.proId,
+        createdAt: schema.proWatches.createdAt,
+        notifiedAt: schema.proWatches.notifiedAt,
+        name: schema.users.name,
+        headline: schema.proProfiles.headline,
+        isAcceptingJobs: schema.proProfiles.isAcceptingJobs,
+        photo: sql<string | null>`(
+          SELECT pm.url FROM pro_media pm
+           WHERE pm.pro_id = ${schema.proWatches.proId} AND pm.kind = 'photo'
+           ORDER BY pm.position LIMIT 1
+        )`,
+      })
+      .from(schema.proWatches)
+      .innerJoin(schema.proProfiles, eq(schema.proProfiles.userId, schema.proWatches.proId))
+      .innerJoin(schema.users, eq(schema.users.id, schema.proWatches.proId))
+      .where(eq(schema.proWatches.watcherId, ctx.session.userId))
+      .orderBy(desc(schema.proWatches.createdAt));
+
+    return rows;
+  }),
+
+  /** Whether the caller is watching this pro. Drives the button's filled state. */
+  isWatching: protectedProcedure
+    .input(z.object({ proId: z.string().uuid() }))
+    .query(async ({ ctx, input }) => {
+      const [row] = await ctx.db
+        .select({ id: schema.proWatches.id })
+        .from(schema.proWatches)
+        .where(
+          and(
+            eq(schema.proWatches.watcherId, ctx.session.userId),
+            eq(schema.proWatches.proId, input.proId),
+          ),
+        );
+      return { watching: Boolean(row) };
+    }),
+
+  /**
+   * Watch, or stop watching. One call, because the button is one button.
+   *
+   * Records the pro's availability AT THE MOMENT OF WATCHING. The trigger is a
+   * change, not a state: without the snapshot, a sweep would notify every
+   * watcher on every run, since "this pro is available" stays true for as long
+   * as they stay available.
+   */
+  toggle: protectedProcedure
+    .input(z.object({ proId: z.string().uuid() }))
+    .mutation(async ({ ctx, input }) => {
+      const uid = ctx.session.userId;
+
+      if (input.proId === uid) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'You cannot watch yourself' });
+      }
+
+      const pro = await ctx.db.query.proProfiles.findFirst({
+        where: eq(schema.proProfiles.userId, input.proId),
+        columns: { isAcceptingJobs: true, verificationStatus: true },
+      });
+      if (!pro || pro.verificationStatus !== 'verified') {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'That pro is not available' });
+      }
+
+      const [existing] = await ctx.db
+        .select({ id: schema.proWatches.id })
+        .from(schema.proWatches)
+        .where(
+          and(eq(schema.proWatches.watcherId, uid), eq(schema.proWatches.proId, input.proId)),
+        );
+
+      if (existing) {
+        await ctx.db.delete(schema.proWatches).where(eq(schema.proWatches.id, existing.id));
+        return { watching: false as const };
+      }
+
+      await ctx.db.insert(schema.proWatches).values({
+        watcherId: uid,
+        proId: input.proId,
+        availableAtWatch: String(pro.isAcceptingJobs),
+      });
+
+      return { watching: true as const, availableNow: pro.isAcceptingJobs };
+    }),
+
+  /**
+   * Who should be told that somebody they are watching is back.
+   *
+   * Read-only, and separate from the sending: the M4 worker will call this on a
+   * schedule and hand each row to `notify()`. Exposed now so the trigger is
+   * testable before the worker exists, rather than being written blind inside
+   * one — which is how `pro_availability` ended up seeded and unread.
+   */
+  dueNotification: protectedProcedure.query(async ({ ctx }) => {
+    const rows = await ctx.db
+      .select({
+        watchId: schema.proWatches.id,
+        watcherId: schema.proWatches.watcherId,
+        proId: schema.proWatches.proId,
+        proName: schema.users.name,
+      })
+      .from(schema.proWatches)
+      .innerJoin(schema.proProfiles, eq(schema.proProfiles.userId, schema.proWatches.proId))
+      .innerJoin(schema.users, eq(schema.users.id, schema.proWatches.proId))
+      .where(
+        and(
+          eq(schema.proWatches.watcherId, ctx.session.userId),
+          // Went away and came back: unavailable when watched, available now.
+          eq(schema.proWatches.availableAtWatch, 'false'),
+          eq(schema.proProfiles.isAcceptingJobs, true),
+          // Told once. A pro toggling twice must not send two messages.
+          isNull(schema.proWatches.notifiedAt),
+        ),
+      );
+
+    return rows;
+  }),
+});
diff --git a/packages/api/test/discovery.router.test.ts b/packages/api/test/discovery.router.test.ts
new file mode 100644
index 0000000..248ef7b
--- /dev/null
+++ b/packages/api/test/discovery.router.test.ts
@@ -0,0 +1,296 @@
+/**
+ * Watching a pro, and asking one a question.
+ *
+ *   pnpm services:up && pnpm db:migrate && pnpm db:seed
+ *
+ * The deck's two new answers. Most of what follows is about the cap on
+ * enquiries, because this is the first way in the product to reach a pro who
+ * has not agreed to anything — until now chat was gated behind
+ * message → match → accepted request → job, and that gate is what made a pro's
+ * inbox worth opening.
+ */
+import { config } from 'dotenv';
+import { sql } from 'drizzle-orm';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { MAX_OPEN_ENQUIRIES } from '@linkder/shared';
+
+config({ path: '../../.env' });
+
+const { closePool, db } = await import('@linkder/db');
+const { appRouter } = await import('../src/root');
+const { createInnerContext } = await import('../src/context');
+const { createCallerFactory } = await import('../src/trpc');
+
+const createCaller = createCallerFactory(appRouter);
+type Session = import('../src/context').Session;
+
+const callerFor = (session: Session | null) =>
+  createCaller(createInnerContext({ db, session }));
+
+const clientSession = (userId: string): Session => ({
+  userId,
+  role: 'client',
+  name: 'Test Client',
+  email: 'client@test',
+  phone: null,
+  verificationStatus: null,
+});
+
+const proSession = (userId: string): Session => ({
+  userId,
+  role: 'pro',
+  name: 'Test Pro',
+  email: 'pro@test',
+  phone: null,
+  verificationStatus: 'verified',
+});
+
+const RUN = Math.random().toString(36).slice(2, 8);
+
+let client: string;
+let pros: string[] = [];
+let unverifiedPro: string;
+
+async function insertUser(name: string, role: 'client' | 'pro'): Promise<string> {
+  const [row] = await db.execute<{ id: string }>(sql`
+    INSERT INTO users (name, email, role)
+    VALUES (${name}, ${`${RUN}-${Math.random().toString(36).slice(2, 8)}@example.com`}, ${role})
+    RETURNING id
+  `);
+  return row!.id;
+}
+
+/**
+ * Fixture pros are on holiday (`is_accepting_jobs = false` by default here where
+ * it does not matter, true where it does).
+ *
+ * Test files share one database. A verified, accepting pro at the city centre is
+ * eligible for the SEEDED job's deck, so creating and deleting them mid-run
+ * shifts `deck.list().remaining` underneath deck.router.test.ts. Parked far
+ * outside the city instead, which keeps them off every deck without changing
+ * the availability these tests actually assert on.
+ */
+async function insertPro(name: string, accepting = true, verified = true): Promise<string> {
+  const id = await insertUser(name, 'pro');
+  await db.execute(sql`
+    INSERT INTO pro_profiles (
+      user_id, headline, bio, hourly_rate_cents, base_location, base_location_precision,
+      service_radius_m, verification_status, verified_at, is_accepting_jobs
+    )
+    VALUES (
+      ${id}, ${`${name} headline`}, 'Exists only for the discovery tests.', 3000,
+      ST_SetSRID(ST_MakePoint(-40.0, -40.0), 4326)::geography, 'exact',
+      15000, ${verified ? 'verified' : 'pending'}, now(), ${accepting}
+    )
+  `);
+  return id;
+}
+
+beforeAll(async () => {
+  client = await insertUser(`Discovery Client ${RUN}`, 'client');
+  for (let i = 0; i < MAX_OPEN_ENQUIRIES + 2; i += 1) {
+    pros.push(await insertPro(`Discovery Pro ${RUN}-${i}`));
+  }
+  unverifiedPro = await insertPro(`Discovery Unverified ${RUN}`, true, false);
+});
+
+beforeEach(async () => {
+  await db.execute(sql`DELETE FROM enquiries WHERE client_id = ${client}`);
+  await db.execute(sql`DELETE FROM pro_watches WHERE watcher_id = ${client}`);
+});
+
+afterAll(async () => {
+  // One at a time rather than `= ANY(...)`: drizzle passes a JS array through as
+  // a scalar parameter, which Postgres rejects.
+  for (const id of [client, unverifiedPro, ...pros]) {
+    await db.execute(sql`DELETE FROM users WHERE id = ${id}`);
+  }
+  await closePool();
+});
+
+describe('watch', () => {
+  it('toggles on and off with one call', async () => {
+    const caller = callerFor(clientSession(client));
+
+    expect((await caller.watch.isWatching({ proId: pros[0]! })).watching).toBe(false);
+
+    const on = await caller.watch.toggle({ proId: pros[0]! });
+    expect(on.watching).toBe(true);
+    expect((await caller.watch.isWatching({ proId: pros[0]! })).watching).toBe(true);
+
+    const off = await caller.watch.toggle({ proId: pros[0]! });
+    expect(off.watching).toBe(false);
+    expect((await caller.watch.mine()).map((w) => w.proId)).not.toContain(pros[0]);
+  });
+
+  it('refuses an unverified pro, and refuses to watch yourself', async () => {
+    const caller = callerFor(clientSession(client));
+    await expect(caller.watch.toggle({ proId: unverifiedPro })).rejects.toThrow(/not available/i);
+    await expect(caller.watch.toggle({ proId: client })).rejects.toThrow();
+  });
+
+  it('does not fire for a pro who was already free when watched', async () => {
+    // The trigger is a CHANGE, not a state. Without the snapshot taken at watch
+    // time, every sweep would notify every watcher, because "available" stays
+    // true for as long as they stay available.
+    const caller = callerFor(clientSession(client));
+    await caller.watch.toggle({ proId: pros[0]! });
+
+    expect(await caller.watch.dueNotification()).toEqual([]);
+  });
+
+  it('fires once a pro who was away comes back', async () => {
+    const away = pros[1]!;
+    await db.execute(
+      sql`UPDATE pro_profiles SET is_accepting_jobs = false WHERE user_id = ${away}`,
+    );
+
+    const caller = callerFor(clientSession(client));
+    await caller.watch.toggle({ proId: away });
+    expect(await caller.watch.dueNotification()).toEqual([]);
+
+    await db.execute(
+      sql`UPDATE pro_profiles SET is_accepting_jobs = true WHERE user_id = ${away}`,
+    );
+
+    const due = await caller.watch.dueNotification();
+    expect(due.map((d) => d.proId)).toContain(away);
+
+    // Told once: marking it notified takes it out of the queue, so a pro
+    // toggling twice does not send two messages.
+    await db.execute(
+      sql`UPDATE pro_watches SET notified_at = now()
+           WHERE watcher_id = ${client} AND pro_id = ${away}`,
+    );
+    expect(await caller.watch.dueNotification()).toEqual([]);
+  });
+});
+
+describe('enquiry', () => {
+  it('creates a thread and its first message together', async () => {
+    // An enquiry with no message is an empty room — a pro opening one would
+    // find nothing to answer.
+    const caller = callerFor(clientSession(client));
+    const { enquiryId } = await caller.enquiry.create({
+      proId: pros[0]!,
+      body: 'Do you cover replacing a whole bathroom suite, or only repairs?',
+    });
+
+    const [count] = await db.execute<{ n: number }>(
+      sql`SELECT count(*)::int AS n FROM messages WHERE enquiry_id = ${enquiryId}`,
+    );
+    expect(count!.n).toBe(1);
+
+    const inbox = await callerFor(proSession(pros[0]!)).enquiry.mine();
+    expect(inbox.map((e) => e.id)).toContain(enquiryId);
+    expect(inbox.find((e) => e.id === enquiryId)!.unreadCount).toBe(1);
+  });
+
+  it('puts a second question in the same thread, not a new one', async () => {
+    const caller = callerFor(clientSession(client));
+    const first = await caller.enquiry.create({
+      proId: pros[0]!,
+      body: 'Do you cover replacing a whole bathroom suite?',
+    });
+    const second = await caller.enquiry.create({
+      proId: pros[0]!,
+      body: 'And would that include taking the old one away with you?',
+    });
+
+    // Also what stops the cap being walked around by asking one pro repeatedly.
+    expect(second.enquiryId).toBe(first.enquiryId);
+  });
+
+  it('caps unanswered enquiries', async () => {
+    const caller = callerFor(clientSession(client));
+
+    for (let i = 0; i < MAX_OPEN_ENQUIRIES; i += 1) {
+      await caller.enquiry.create({
+        proId: pros[i]!,
+        body: `Question number ${i} for a pro who has not agreed to anything yet.`,
+      });
+    }
+
+    expect((await caller.enquiry.allowance()).remaining).toBe(0);
+
+    await expect(
+      caller.enquiry.create({
+        proId: pros[MAX_OPEN_ENQUIRIES]!,
+        body: 'One more question, which should be refused by the open-enquiry cap.',
+      }),
+    ).rejects.toThrow(/still waiting on an answer/i);
+  });
+
+  it('stops counting an enquiry once the pro replies', async () => {
+    // Somebody having real conversations should not be throttled; only somebody
+    // broadcasting.
+    const caller = callerFor(clientSession(client));
+    for (let i = 0; i < MAX_OPEN_ENQUIRIES; i += 1) {
+      await caller.enquiry.create({
+        proId: pros[i]!,
+        body: `Question number ${i} for a pro who has not agreed to anything yet.`,
+      });
+    }
+    expect((await caller.enquiry.allowance()).remaining).toBe(0);
+
+    const answered = (await callerFor(proSession(pros[0]!)).enquiry.mine())[0]!;
+    await callerFor(proSession(pros[0]!)).message.send({
+      ref: { enquiryId: answered.id },
+      body: 'Yes, full bathroom suites are fine — happy to quote if you post the job.',
+      attachments: [],
+    });
+
+    expect((await caller.enquiry.allowance()).remaining).toBe(1);
+  });
+
+  it('refuses a pro who is unverified or on holiday', async () => {
+    const caller = callerFor(clientSession(client));
+    await expect(
+      caller.enquiry.create({
+        proId: unverifiedPro,
+        body: 'Are you able to take on a small job next week at all?',
+      }),
+    ).rejects.toThrow(/not available/i);
+  });
+
+  it('lets the pro close it, after which nothing more can be sent', async () => {
+    const caller = callerFor(clientSession(client));
+    const { enquiryId } = await caller.enquiry.create({
+      proId: pros[0]!,
+      body: 'A question that this pro is going to decide not to entertain.',
+    });
+
+    // Only the pro. A customer must not be able to close their own way around
+    // the cap.
+    await expect(caller.enquiry.close({ enquiryId })).rejects.toThrow(/not found/i);
+
+    await callerFor(proSession(pros[0]!)).enquiry.close({ enquiryId });
+
+    await expect(
+      caller.message.send({
+        ref: { enquiryId },
+        body: 'Are you still there? I would really like an answer to this.',
+        attachments: [],
+      }),
+    ).rejects.toThrow(/closed/i);
+
+    // The history stays — a closed thread is still evidence.
+    const thread = await caller.message.thread({ ref: { enquiryId } });
+    expect(thread.messages.length).toBe(1);
+    expect(thread.match.canReply).toBe(false);
+  });
+
+  it('is not readable by anyone who is not in it', async () => {
+    const caller = callerFor(clientSession(client));
+    const { enquiryId } = await caller.enquiry.create({
+      proId: pros[0]!,
+      body: 'A private question between me and this particular tradesperson.',
+    });
+
+    const stranger = await insertUser(`Discovery Stranger ${RUN}`, 'client');
+    await expect(
+      callerFor(clientSession(stranger)).message.thread({ ref: { enquiryId } }),
+    ).rejects.toThrow(/not found/i);
+    await db.execute(sql`DELETE FROM users WHERE id = ${stranger}`);
+  });
+});
diff --git a/packages/api/test/message.router.test.ts b/packages/api/test/message.router.test.ts
index 3116a82..df0767f 100644
--- a/packages/api/test/message.router.test.ts
+++ b/packages/api/test/message.router.test.ts
@@ -136,18 +136,18 @@ afterAll(async () => {
 describe('message.thread', () => {
   it('gives each side the same conversation, newest last', async () => {
     await callerFor(clientSession(owner)).message.send({
-      matchId,
+      ref: { matchId },
       body: 'Morning — when could you take a look?',
       attachments: [],
     });
     await callerFor(proSession(pro)).message.send({
-      matchId,
+      ref: { matchId },
       body: 'Thursday afternoon works.',
       attachments: [],
     });
 
-    const asClient = await callerFor(clientSession(owner)).message.thread({ matchId });
-    const asPro = await callerFor(proSession(pro)).message.thread({ matchId });
+    const asClient = await callerFor(clientSession(owner)).message.thread({ ref: { matchId } });
+    const asPro = await callerFor(proSession(pro)).message.thread({ ref: { matchId } });
 
     expect(asClient.messages.map((m) => m.body)).toEqual([
       'Morning — when could you take a look?',
@@ -161,8 +161,8 @@ describe('message.thread', () => {
   });
 
   it('names the peer, not the caller', async () => {
-    const asClient = await callerFor(clientSession(owner)).message.thread({ matchId });
-    const asPro = await callerFor(proSession(pro)).message.thread({ matchId });
+    const asClient = await callerFor(clientSession(owner)).message.thread({ ref: { matchId } });
+    const asPro = await callerFor(proSession(pro)).message.thread({ ref: { matchId } });
 
     expect(asClient.match.peer?.id).toBe(pro);
     expect(asPro.match.peer?.id).toBe(owner);
@@ -172,12 +172,12 @@ describe('message.thread', () => {
   it('is a 404 to a stranger — never a 403', async () => {
     // A 403 would confirm the conversation exists. Same rule as job.byId.
     await expect(
-      callerFor(clientSession(stranger)).message.thread({ matchId }),
+      callerFor(clientSession(stranger)).message.thread({ ref: { matchId } }),
     ).rejects.toThrow(/not found/i);
   });
 
   it('refuses an anonymous caller', async () => {
-    await expect(callerFor(null).message.thread({ matchId })).rejects.toThrow();
+    await expect(callerFor(null).message.thread({ ref: { matchId } })).rejects.toThrow();
   });
 
   it('pages oldest-ward without dropping or repeating a message', async () => {
@@ -195,12 +195,12 @@ describe('message.thread', () => {
         FROM generate_series(0, 34) AS i
     `);
 
-    const first = await callerFor(clientSession(owner)).message.thread({ matchId });
+    const first = await callerFor(clientSession(owner)).message.thread({ ref: { matchId } });
     expect(first.messages).toHaveLength(30);
     expect(first.nextCursor).not.toBeNull();
 
     const second = await callerFor(clientSession(owner)).message.thread({
-      matchId,
+      ref: { matchId },
       cursor: first.nextCursor!,
     });
 
@@ -221,12 +221,12 @@ describe('message.thread', () => {
     // A cursor is a message id. One lifted from another thread must not act as
     // a window into it — the anchor subquery is scoped to the match.
     const other = await callerFor(clientSession(owner)).message.thread({
-      matchId: closedMatchId,
+      ref: { matchId: closedMatchId },
     });
-    const foreign = (await callerFor(clientSession(owner)).message.thread({ matchId })).messages[0];
+    const foreign = (await callerFor(clientSession(owner)).message.thread({ ref: { matchId } })).messages[0];
 
     const page = await callerFor(clientSession(owner)).message.thread({
-      matchId: closedMatchId,
+      ref: { matchId: closedMatchId },
       cursor: foreign!.id,
     });
 
@@ -242,7 +242,7 @@ describe('message.send', () => {
     );
 
     const sent = await callerFor(clientSession(owner)).message.send({
-      matchId,
+      ref: { matchId },
       body: 'One more thing.',
       attachments: [],
     });
@@ -262,13 +262,13 @@ describe('message.send', () => {
 
   it('rejects a message of nothing but whitespace', async () => {
     await expect(
-      callerFor(clientSession(owner)).message.send({ matchId, body: '   ', attachments: [] }),
+      callerFor(clientSession(owner)).message.send({ ref: { matchId }, body: '   ', attachments: [] }),
     ).rejects.toThrow();
   });
 
   it('rejects a message that is neither words nor files', async () => {
     await expect(
-      callerFor(clientSession(owner)).message.send({ matchId, body: '', attachments: [] }),
+      callerFor(clientSession(owner)).message.send({ ref: { matchId }, body: '', attachments: [] }),
     ).rejects.toThrow();
   });
 
@@ -276,7 +276,7 @@ describe('message.send', () => {
     // The commonest message on this product is a picture of the broken thing.
     // Requiring words alongside it would make people type "see photo".
     const sent = await callerFor(clientSession(owner)).message.send({
-      matchId,
+      ref: { matchId },
       body: '',
       attachments: ['https://cdn.example.com/messages/leak.jpg'],
     });
@@ -289,16 +289,16 @@ describe('message.send', () => {
     const caller = callerFor(clientSession(owner));
     const six = Array.from({ length: 6 }, (_, i) => `https://cdn.example.com/m/${i}.jpg`);
 
-    await expect(caller.message.send({ matchId, body: 'here', attachments: six })).rejects.toThrow();
+    await expect(caller.message.send({ ref: { matchId }, body: 'here', attachments: six })).rejects.toThrow();
     await expect(
-      caller.message.send({ matchId, body: 'here', attachments: ['not-a-url'] }),
+      caller.message.send({ ref: { matchId }, body: 'here', attachments: ['not-a-url'] }),
     ).rejects.toThrow();
   });
 
   it('rejects a message past the length cap', async () => {
     await expect(
       callerFor(clientSession(owner)).message.send({
-        matchId,
+        ref: { matchId },
         body: 'x'.repeat(4001),
         attachments: [],
       }),
@@ -308,7 +308,7 @@ describe('message.send', () => {
   it('refuses a stranger', async () => {
     await expect(
       callerFor(clientSession(stranger)).message.send({
-        matchId,
+        ref: { matchId },
         body: 'let me in',
         attachments: [],
       }),
@@ -318,13 +318,13 @@ describe('message.send', () => {
   it('closes the conversation once the job is history', async () => {
     // The thread stays readable — it is the record of what was agreed.
     const thread = await callerFor(clientSession(owner)).message.thread({
-      matchId: closedMatchId,
+      ref: { matchId: closedMatchId },
     });
     expect(thread.match.canReply).toBe(false);
 
     await expect(
       callerFor(clientSession(owner)).message.send({
-        matchId: closedMatchId,
+        ref: { matchId: closedMatchId },
         body: 'still there?',
         attachments: [],
       }),
@@ -342,23 +342,23 @@ describe('message.markRead and unreadTotal', () => {
     );
 
     const proCaller = callerFor(proSession(pro));
-    await proCaller.message.send({ matchId: freshMatch, body: 'On my way.', attachments: [] });
-    await proCaller.message.send({ matchId: freshMatch, body: 'Ten minutes.', attachments: [] });
+    await proCaller.message.send({ ref: { matchId: freshMatch }, body: 'On my way.', attachments: [] });
+    await proCaller.message.send({ ref: { matchId: freshMatch }, body: 'Ten minutes.', attachments: [] });
 
     // The sender never badges themselves.
     const proUnread = await proCaller.message.unreadTotal();
-    const proOwnHere = await proCaller.message.markRead({ matchId: freshMatch });
+    const proOwnHere = await proCaller.message.markRead({ ref: { matchId: freshMatch } });
     expect(proOwnHere.read).toBe(0);
 
     const ownerCaller = callerFor(clientSession(owner));
     const before = await ownerCaller.message.unreadTotal();
     expect(before.unread).toBeGreaterThanOrEqual(2);
 
-    const cleared = await ownerCaller.message.markRead({ matchId: freshMatch });
+    const cleared = await ownerCaller.message.markRead({ ref: { matchId: freshMatch } });
     expect(cleared.read).toBe(2);
 
     // Idempotent: the partial index predicate is also the WHERE clause.
-    const again = await ownerCaller.message.markRead({ matchId: freshMatch });
+    const again = await ownerCaller.message.markRead({ ref: { matchId: freshMatch } });
     expect(again.read).toBe(0);
 
     const after = await ownerCaller.message.unreadTotal();
@@ -368,7 +368,7 @@ describe('message.markRead and unreadTotal', () => {
 
   it('refuses to mark a stranger’s thread read', async () => {
     await expect(
-      callerFor(clientSession(stranger)).message.markRead({ matchId }),
+      callerFor(clientSession(stranger)).message.markRead({ ref: { matchId } }),
     ).rejects.toThrow(/not found/i);
   });
 });
diff --git a/packages/db/drizzle/0007_medical_dark_beast.sql b/packages/db/drizzle/0007_medical_dark_beast.sql
new file mode 100644
index 0000000..51805c6
--- /dev/null
+++ b/packages/db/drizzle/0007_medical_dark_beast.sql
@@ -0,0 +1,35 @@
+CREATE TABLE "enquiries" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"client_id" uuid NOT NULL,
+	"pro_id" uuid NOT NULL,
+	"responded_at" timestamp with time zone,
+	"last_message_at" timestamp with time zone,
+	"closed_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "enquiries_pair_unique" UNIQUE("client_id","pro_id")
+);
+--> statement-breakpoint
+CREATE TABLE "pro_watches" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"watcher_id" uuid NOT NULL,
+	"pro_id" uuid NOT NULL,
+	"available_at_watch" text DEFAULT 'true' NOT NULL,
+	"notified_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "pro_watches_unique" UNIQUE("watcher_id","pro_id")
+);
+--> statement-breakpoint
+ALTER TABLE "messages" ALTER COLUMN "match_id" DROP NOT NULL;--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "enquiry_id" uuid;--> statement-breakpoint
+ALTER TABLE "enquiries" ADD CONSTRAINT "enquiries_client_id_users_id_fk" FOREIGN KEY ("client_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "enquiries" ADD CONSTRAINT "enquiries_pro_id_pro_profiles_user_id_fk" FOREIGN KEY ("pro_id") REFERENCES "public"."pro_profiles"("user_id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "pro_watches" ADD CONSTRAINT "pro_watches_watcher_id_users_id_fk" FOREIGN KEY ("watcher_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "pro_watches" ADD CONSTRAINT "pro_watches_pro_id_pro_profiles_user_id_fk" FOREIGN KEY ("pro_id") REFERENCES "public"."pro_profiles"("user_id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "enquiries_pro_idx" ON "enquiries" USING btree ("pro_id","last_message_at");--> statement-breakpoint
+CREATE INDEX "enquiries_client_idx" ON "enquiries" USING btree ("client_id","last_message_at");--> statement-breakpoint
+CREATE INDEX "pro_watches_pro_idx" ON "pro_watches" USING btree ("pro_id","notified_at");--> statement-breakpoint
+CREATE INDEX "pro_watches_watcher_idx" ON "pro_watches" USING btree ("watcher_id","created_at");--> statement-breakpoint
+ALTER TABLE "messages" ADD CONSTRAINT "messages_enquiry_id_enquiries_id_fk" FOREIGN KEY ("enquiry_id") REFERENCES "public"."enquiries"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "messages_enquiry_idx" ON "messages" USING btree ("enquiry_id","created_at");--> statement-breakpoint
+CREATE INDEX "messages_enquiry_unread_idx" ON "messages" USING btree ("enquiry_id","sender_id") WHERE "messages"."read_at" IS NULL;--> statement-breakpoint
+ALTER TABLE "messages" ADD CONSTRAINT "messages_one_parent" CHECK (("messages"."match_id" IS NULL) <> ("messages"."enquiry_id" IS NULL));
\ No newline at end of file
diff --git a/packages/db/drizzle/meta/0007_snapshot.json b/packages/db/drizzle/meta/0007_snapshot.json
new file mode 100644
index 0000000..a9129e9
--- /dev/null
+++ b/packages/db/drizzle/meta/0007_snapshot.json
@@ -0,0 +1,3665 @@
+{
+  "id": "64a69c9f-b1fc-423a-8dc8-b0d919a3f930",
+  "prevId": "fd5a810f-0b8d-4405-9a4b-c7d387b1101a",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.accounts": {
+      "name": "accounts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "accounts_user_idx": {
+          "name": "accounts_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "accounts_user_id_users_id_fk": {
+          "name": "accounts_user_id_users_id_fk",
+          "tableFrom": "accounts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "accounts_issuer_account_unique": {
+          "name": "accounts_issuer_account_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "issuer",
+            "account_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "impersonated_by": {
+          "name": "impersonated_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "sessions_user_idx": {
+          "name": "sessions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "sessions_user_id_users_id_fk": {
+          "name": "sessions_user_id_users_id_fk",
+          "tableFrom": "sessions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "sessions_impersonated_by_users_id_fk": {
+          "name": "sessions_impersonated_by_users_id_fk",
+          "tableFrom": "sessions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "impersonated_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_unique": {
+          "name": "sessions_token_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "phone": {
+          "name": "phone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "phone_verified": {
+          "name": "phone_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "phone_verified_at": {
+          "name": "phone_verified_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "role": {
+          "name": "role",
+          "type": "user_role",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'client'"
+        },
+        "banned": {
+          "name": "banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_expires": {
+          "name": "ban_expires",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "location": {
+          "name": "location",
+          "type": "geography(Point,4326)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "location_text": {
+          "name": "location_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "location_precision": {
+          "name": "location_precision",
+          "type": "location_precision",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'city'"
+        },
+        "location_place_id": {
+          "name": "location_place_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "search_radius_m": {
+          "name": "search_radius_m",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 15000
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "users_role_idx": {
+          "name": "users_role_idx",
+          "columns": [
+            {
+              "expression": "role",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_phone_idx": {
+          "name": "users_phone_idx",
+          "columns": [
+            {
+              "expression": "phone",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_email_unique": {
+          "name": "users_email_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "email"
+          ]
+        },
+        "users_phone_unique": {
+          "name": "users_phone_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "phone"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verifications": {
+      "name": "verifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "verifications_identifier_idx": {
+          "name": "verifications_identifier_idx",
+          "columns": [
+            {
+              "expression": "identifier",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.categories": {
+      "name": "categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "categories_slug_unique": {
+          "name": "categories_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.credentials": {
+      "name": "credentials",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "credential_kind",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_key": {
+          "name": "file_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_status": {
+          "name": "review_status",
+          "type": "review_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "reviewed_by": {
+          "name": "reviewed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reviewed_at": {
+          "name": "reviewed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_notes": {
+          "name": "review_notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "credentials_pro_idx": {
+          "name": "credentials_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "credentials_review_idx": {
+          "name": "credentials_review_idx",
+          "columns": [
+            {
+              "expression": "review_status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "credentials_expiry_idx": {
+          "name": "credentials_expiry_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "credentials_pro_id_pro_profiles_user_id_fk": {
+          "name": "credentials_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "credentials",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "credentials_reviewed_by_users_id_fk": {
+          "name": "credentials_reviewed_by_users_id_fk",
+          "tableFrom": "credentials",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reviewed_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pro_availability": {
+      "name": "pro_availability",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "weekday": {
+          "name": "weekday",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_minute": {
+          "name": "start_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "end_minute": {
+          "name": "end_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "pro_availability_pro_idx": {
+          "name": "pro_availability_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "weekday",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pro_availability_pro_id_pro_profiles_user_id_fk": {
+          "name": "pro_availability_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "pro_availability",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pro_categories": {
+      "name": "pro_categories",
+      "schema": "",
+      "columns": {
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "pro_categories_category_idx": {
+          "name": "pro_categories_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pro_categories_pro_id_pro_profiles_user_id_fk": {
+          "name": "pro_categories_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "pro_categories",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "pro_categories_category_id_categories_id_fk": {
+          "name": "pro_categories_category_id_categories_id_fk",
+          "tableFrom": "pro_categories",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "pro_categories_pro_id_category_id_pk": {
+          "name": "pro_categories_pro_id_category_id_pk",
+          "columns": [
+            "pro_id",
+            "category_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pro_media": {
+      "name": "pro_media",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "media_kind",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'photo'"
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "pro_media_pro_idx": {
+          "name": "pro_media_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pro_media_pro_id_pro_profiles_user_id_fk": {
+          "name": "pro_media_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "pro_media",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pro_profiles": {
+      "name": "pro_profiles",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "headline": {
+          "name": "headline",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bio": {
+          "name": "bio",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hourly_rate_cents": {
+          "name": "hourly_rate_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "years_experience": {
+          "name": "years_experience",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "base_location": {
+          "name": "base_location",
+          "type": "geography(Point,4326)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_location_precision": {
+          "name": "base_location_precision",
+          "type": "location_precision",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'city'"
+        },
+        "base_location_place_id": {
+          "name": "base_location_place_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "service_radius_m": {
+          "name": "service_radius_m",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 15000
+        },
+        "skills": {
+          "name": "skills",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "verification_status": {
+          "name": "verification_status",
+          "type": "verification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'draft'"
+        },
+        "verified_at": {
+          "name": "verified_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "suspended_reason": {
+          "name": "suspended_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_accepting_jobs": {
+          "name": "is_accepting_jobs",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "rating_avg": {
+          "name": "rating_avg",
+          "type": "numeric(3, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rating_count": {
+          "name": "rating_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed_jobs": {
+          "name": "completed_jobs",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "response_rate": {
+          "name": "response_rate",
+          "type": "numeric(4, 3)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avg_response_minutes": {
+          "name": "avg_response_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stripe_account_id": {
+          "name": "stripe_account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stripe_payouts_enabled": {
+          "name": "stripe_payouts_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "pro_profiles_location_gist": {
+          "name": "pro_profiles_location_gist",
+          "columns": [
+            {
+              "expression": "base_location",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gist",
+          "with": {}
+        },
+        "pro_profiles_deck_idx": {
+          "name": "pro_profiles_deck_idx",
+          "columns": [
+            {
+              "expression": "verification_status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_accepting_jobs",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"pro_profiles\".\"verification_status\" = 'verified' AND \"pro_profiles\".\"is_accepting_jobs\" = true",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pro_profiles_user_id_users_id_fk": {
+          "name": "pro_profiles_user_id_users_id_fk",
+          "tableFrom": "pro_profiles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "pro_profiles_stripe_account_id_unique": {
+          "name": "pro_profiles_stripe_account_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "stripe_account_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification_sessions": {
+      "name": "verification_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'didit'"
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "decision": {
+          "name": "decision",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_payload": {
+          "name": "raw_payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "verification_sessions_pro_idx": {
+          "name": "verification_sessions_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "verification_sessions_pro_id_pro_profiles_user_id_fk": {
+          "name": "verification_sessions_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "verification_sessions",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "verification_sessions_external_id_unique": {
+          "name": "verification_sessions_external_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "external_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "photos": {
+          "name": "photos",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "urgency": {
+          "name": "urgency",
+          "type": "urgency",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'flexible'"
+        },
+        "budget_min_cents": {
+          "name": "budget_min_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "budget_max_cents": {
+          "name": "budget_max_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "location": {
+          "name": "location",
+          "type": "geography(Point,4326)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location_precision": {
+          "name": "location_precision",
+          "type": "location_precision",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'city'"
+        },
+        "location_place_id": {
+          "name": "location_place_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "address_text": {
+          "name": "address_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "job_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'open'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "jobs_location_gist": {
+          "name": "jobs_location_gist",
+          "columns": [
+            {
+              "expression": "location",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gist",
+          "with": {}
+        },
+        "jobs_client_idx": {
+          "name": "jobs_client_idx",
+          "columns": [
+            {
+              "expression": "client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "jobs_open_idx": {
+          "name": "jobs_open_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"jobs\".\"status\" = 'open'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_client_id_users_id_fk": {
+          "name": "jobs_client_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": [
+            "client_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "jobs_category_id_categories_id_fk": {
+          "name": "jobs_category_id_categories_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.matches": {
+      "name": "matches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "matches_pro_idx": {
+          "name": "matches_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "matches_client_idx": {
+          "name": "matches_client_idx",
+          "columns": [
+            {
+              "expression": "client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "matches_job_idx": {
+          "name": "matches_job_idx",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "matches_request_id_requests_id_fk": {
+          "name": "matches_request_id_requests_id_fk",
+          "tableFrom": "matches",
+          "tableTo": "requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "matches_job_id_jobs_id_fk": {
+          "name": "matches_job_id_jobs_id_fk",
+          "tableFrom": "matches",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "matches_pro_id_pro_profiles_user_id_fk": {
+          "name": "matches_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "matches",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "matches_client_id_users_id_fk": {
+          "name": "matches_client_id_users_id_fk",
+          "tableFrom": "matches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "client_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "matches_request_id_unique": {
+          "name": "matches_request_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "request_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.requests": {
+      "name": "requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "request_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "responded_at": {
+          "name": "responded_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "requests_pending_idx": {
+          "name": "requests_pending_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"requests\".\"status\" = 'pending'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "requests_job_idx": {
+          "name": "requests_job_idx",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "requests_job_id_jobs_id_fk": {
+          "name": "requests_job_id_jobs_id_fk",
+          "tableFrom": "requests",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "requests_pro_id_pro_profiles_user_id_fk": {
+          "name": "requests_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "requests",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "requests_job_pro_unique": {
+          "name": "requests_job_pro_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "job_id",
+            "pro_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.swipes": {
+      "name": "swipes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "direction": {
+          "name": "direction",
+          "type": "swipe_direction",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "swipes_job_idx": {
+          "name": "swipes_job_idx",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "swipes_job_id_jobs_id_fk": {
+          "name": "swipes_job_id_jobs_id_fk",
+          "tableFrom": "swipes",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "swipes_pro_id_pro_profiles_user_id_fk": {
+          "name": "swipes_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "swipes",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "swipes_job_pro_unique": {
+          "name": "swipes_job_pro_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "job_id",
+            "pro_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.enquiries": {
+      "name": "enquiries",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "responded_at": {
+          "name": "responded_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "enquiries_pro_idx": {
+          "name": "enquiries_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "enquiries_client_idx": {
+          "name": "enquiries_client_idx",
+          "columns": [
+            {
+              "expression": "client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "enquiries_client_id_users_id_fk": {
+          "name": "enquiries_client_id_users_id_fk",
+          "tableFrom": "enquiries",
+          "tableTo": "users",
+          "columnsFrom": [
+            "client_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "enquiries_pro_id_pro_profiles_user_id_fk": {
+          "name": "enquiries_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "enquiries",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "enquiries_pair_unique": {
+          "name": "enquiries_pair_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "client_id",
+            "pro_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.pro_watches": {
+      "name": "pro_watches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "watcher_id": {
+          "name": "watcher_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pro_id": {
+          "name": "pro_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "available_at_watch": {
+          "name": "available_at_watch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'true'"
+        },
+        "notified_at": {
+          "name": "notified_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "pro_watches_pro_idx": {
+          "name": "pro_watches_pro_idx",
+          "columns": [
+            {
+              "expression": "pro_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "notified_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "pro_watches_watcher_idx": {
+          "name": "pro_watches_watcher_idx",
+          "columns": [
+            {
+              "expression": "watcher_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "pro_watches_watcher_id_users_id_fk": {
+          "name": "pro_watches_watcher_id_users_id_fk",
+          "tableFrom": "pro_watches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "watcher_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "pro_watches_pro_id_pro_profiles_user_id_fk": {
+          "name": "pro_watches_pro_id_pro_profiles_user_id_fk",
+          "tableFrom": "pro_watches",
+          "tableTo": "pro_profiles",
+          "columnsFrom": [
+            "pro_id"
+          ],
+          "columnsTo": [
+            "user_id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "pro_watches_unique": {
+          "name": "pro_watches_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "watcher_id",
+            "pro_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "match_id": {
+          "name": "match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enquiry_id": {
+          "name": "enquiry_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sender_id": {
+          "name": "sender_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attachments": {
+          "name": "attachments",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "messages_match_idx": {
+          "name": "messages_match_idx",
+          "columns": [
+            {
+              "expression": "match_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_enquiry_idx": {
+          "name": "messages_enquiry_idx",
+          "columns": [
+            {
+              "expression": "enquiry_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_unread_idx": {
+          "name": "messages_unread_idx",
+          "columns": [
+            {
+              "expression": "match_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sender_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"messages\".\"read_at\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_enquiry_unread_idx": {
+          "name": "messages_enquiry_unread_idx",
+          "columns": [
+            {
+              "expression": "enquiry_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sender_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"messages\".\"read_at\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_match_id_matches_id_fk": {
+          "name": "messages_match_id_matches_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "matches",
+          "columnsFrom": [
+            "match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messages_enquiry_id_enquiries_id_fk": {
+          "name": "messages_enquiry_id_enquiries_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "enquiries",
+          "columnsFrom": [
+            "enquiry_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messages_sender_id_users_id_fk": {
+          "name": "messages_sender_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "sender_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messages_one_parent": {
+          "name": "messages_one_parent",
+          "value": "(\"messages\".\"match_id\" IS NULL) <> (\"messages\".\"enquiry_id\" IS NULL)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.bookings": {
+      "name": "bookings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "match_id": {
+          "name": "match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quote_id": {
+          "name": "quote_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scheduled_start": {
+          "name": "scheduled_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scheduled_end": {
+          "name": "scheduled_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "booking_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'scheduled'"
+        },
+        "pro_completed_at": {
+          "name": "pro_completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "client_confirmed_at": {
+          "name": "client_confirmed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_by": {
+          "name": "cancelled_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancellation_reason": {
+          "name": "cancellation_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bookings_match_idx": {
+          "name": "bookings_match_idx",
+          "columns": [
+            {
+              "expression": "match_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookings_status_idx": {
+          "name": "bookings_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "pro_completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookings_schedule_idx": {
+          "name": "bookings_schedule_idx",
+          "columns": [
+            {
+              "expression": "scheduled_start",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bookings_match_id_matches_id_fk": {
+          "name": "bookings_match_id_matches_id_fk",
+          "tableFrom": "bookings",
+          "tableTo": "matches",
+          "columnsFrom": [
+            "match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bookings_quote_id_quotes_id_fk": {
+          "name": "bookings_quote_id_quotes_id_fk",
+          "tableFrom": "bookings",
+          "tableTo": "quotes",
+          "columnsFrom": [
+            "quote_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "bookings_cancelled_by_users_id_fk": {
+          "name": "bookings_cancelled_by_users_id_fk",
+          "tableFrom": "bookings",
+          "tableTo": "users",
+          "columnsFrom": [
+            "cancelled_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.payments": {
+      "name": "payments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "booking_id": {
+          "name": "booking_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stripe_payment_intent_id": {
+          "name": "stripe_payment_intent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stripe_transfer_id": {
+          "name": "stripe_transfer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stripe_refund_id": {
+          "name": "stripe_refund_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount_cents": {
+          "name": "amount_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "platform_fee_cents": {
+          "name": "platform_fee_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "platform_fee_bps": {
+          "name": "platform_fee_bps",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refunded_cents": {
+          "name": "refunded_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "currency": {
+          "name": "currency",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'eur'"
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "captured_at": {
+          "name": "captured_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "released_at": {
+          "name": "released_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "failure_reason": {
+          "name": "failure_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "payments_status_idx": {
+          "name": "payments_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "payments_intent_idx": {
+          "name": "payments_intent_idx",
+          "columns": [
+            {
+              "expression": "stripe_payment_intent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "payments_booking_id_bookings_id_fk": {
+          "name": "payments_booking_id_bookings_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "bookings",
+          "columnsFrom": [
+            "booking_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "payments_booking_id_unique": {
+          "name": "payments_booking_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "booking_id"
+          ]
+        },
+        "payments_stripe_payment_intent_id_unique": {
+          "name": "payments_stripe_payment_intent_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "stripe_payment_intent_id"
+          ]
+        },
+        "payments_stripe_transfer_id_unique": {
+          "name": "payments_stripe_transfer_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "stripe_transfer_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.processed_stripe_events": {
+      "name": "processed_stripe_events",
+      "schema": "",
+      "columns": {
+        "event_id": {
+          "name": "event_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "processed_at": {
+          "name": "processed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quotes": {
+      "name": "quotes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "match_id": {
+          "name": "match_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "quote_kind",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'fixed'"
+        },
+        "amount_cents": {
+          "name": "amount_cents",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hours_estimate": {
+          "name": "hours_estimate",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "quote_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'sent'"
+        },
+        "valid_until": {
+          "name": "valid_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "responded_at": {
+          "name": "responded_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "quotes_match_idx": {
+          "name": "quotes_match_idx",
+          "columns": [
+            {
+              "expression": "match_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quotes_match_id_matches_id_fk": {
+          "name": "quotes_match_id_matches_id_fk",
+          "tableFrom": "quotes",
+          "tableTo": "matches",
+          "columnsFrom": [
+            "match_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reviews": {
+      "name": "reviews",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "booking_id": {
+          "name": "booking_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_id": {
+          "name": "subject_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rating": {
+          "name": "rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "published_at": {
+          "name": "published_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reviews_subject_idx": {
+          "name": "reviews_subject_idx",
+          "columns": [
+            {
+              "expression": "subject_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "published_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reviews_booking_id_bookings_id_fk": {
+          "name": "reviews_booking_id_bookings_id_fk",
+          "tableFrom": "reviews",
+          "tableTo": "bookings",
+          "columnsFrom": [
+            "booking_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reviews_author_id_users_id_fk": {
+          "name": "reviews_author_id_users_id_fk",
+          "tableFrom": "reviews",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reviews_subject_id_users_id_fk": {
+          "name": "reviews_subject_id_users_id_fk",
+          "tableFrom": "reviews",
+          "tableTo": "users",
+          "columnsFrom": [
+            "subject_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "reviews_booking_author_unique": {
+          "name": "reviews_booking_author_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "booking_id",
+            "author_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.audit_log": {
+      "name": "audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity": {
+          "name": "entity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "audit_log_entity_idx": {
+          "name": "audit_log_entity_idx",
+          "columns": [
+            {
+              "expression": "entity",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_actor_idx": {
+          "name": "audit_log_actor_idx",
+          "columns": [
+            {
+              "expression": "actor_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audit_log_actor_id_users_id_fk": {
+          "name": "audit_log_actor_id_users_id_fk",
+          "tableFrom": "audit_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "actor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.deletion_requests": {
+      "name": "deletion_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "actioned_at": {
+          "name": "actioned_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "deletion_requests_user_id_users_id_fk": {
+          "name": "deletion_requests_user_id_users_id_fk",
+          "tableFrom": "deletion_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_change_requests": {
+      "name": "email_change_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "email_change_requests_user_id_users_id_fk": {
+          "name": "email_change_requests_user_id_users_id_fk",
+          "tableFrom": "email_change_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_change_requests_token_unique": {
+          "name": "email_change_requests_token_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_deliveries": {
+      "name": "notification_deliveries",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel": {
+          "name": "channel",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "detail": {
+          "name": "detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notification_deliveries_user_idx": {
+          "name": "notification_deliveries_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notification_deliveries_status_idx": {
+          "name": "notification_deliveries_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "notification_deliveries_user_id_users_id_fk": {
+          "name": "notification_deliveries_user_id_users_id_fk",
+          "tableFrom": "notification_deliveries",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_preferences": {
+      "name": "notification_preferences",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "sms_new_request": {
+          "name": "sms_new_request",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "sms_booking_reminder": {
+          "name": "sms_booking_reminder",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "sms_marketing": {
+          "name": "sms_marketing",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "email_receipts": {
+          "name": "email_receipts",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "email_marketing": {
+          "name": "email_marketing",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "push_messages": {
+          "name": "push_messages",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "push_requests": {
+          "name": "push_requests",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notification_preferences_user_id_users_id_fk": {
+          "name": "notification_preferences_user_id_users_id_fk",
+          "tableFrom": "notification_preferences",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.booking_status": {
+      "name": "booking_status",
+      "schema": "public",
+      "values": [
+        "scheduled",
+        "in_progress",
+        "awaiting_confirmation",
+        "completed",
+        "cancelled",
+        "disputed"
+      ]
+    },
+    "public.credential_kind": {
+      "name": "credential_kind",
+      "schema": "public",
+      "values": [
+        "id",
+        "licence",
+        "insurance"
+      ]
+    },
+    "public.job_status": {
+      "name": "job_status",
+      "schema": "public",
+      "values": [
+        "open",
+        "matched",
+        "booked",
+        "completed",
+        "cancelled"
+      ]
+    },
+    "public.location_precision": {
+      "name": "location_precision",
+      "schema": "public",
+      "values": [
+        "exact",
+        "approximate",
+        "city"
+      ]
+    },
+    "public.media_kind": {
+      "name": "media_kind",
+      "schema": "public",
+      "values": [
+        "photo",
+        "work_sample"
+      ]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": [
+        "pending",
+        "held",
+        "released",
+        "refunded",
+        "partially_refunded",
+        "failed"
+      ]
+    },
+    "public.quote_kind": {
+      "name": "quote_kind",
+      "schema": "public",
+      "values": [
+        "fixed",
+        "hourly"
+      ]
+    },
+    "public.quote_status": {
+      "name": "quote_status",
+      "schema": "public",
+      "values": [
+        "sent",
+        "accepted",
+        "declined",
+        "withdrawn",
+        "expired"
+      ]
+    },
+    "public.request_status": {
+      "name": "request_status",
+      "schema": "public",
+      "values": [
+        "pending",
+        "accepted",
+        "declined",
+        "expired"
+      ]
+    },
+    "public.review_status": {
+      "name": "review_status",
+      "schema": "public",
+      "values": [
+        "pending",
+        "approved",
+        "rejected"
+      ]
+    },
+    "public.swipe_direction": {
+      "name": "swipe_direction",
+      "schema": "public",
+      "values": [
+        "left",
+        "right"
+      ]
+    },
+    "public.urgency": {
+      "name": "urgency",
+      "schema": "public",
+      "values": [
+        "now",
+        "this_week",
+        "flexible"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": [
+        "client",
+        "pro",
+        "admin"
+      ]
+    },
+    "public.verification_status": {
+      "name": "verification_status",
+      "schema": "public",
+      "values": [
+        "draft",
+        "pending",
+        "verified",
+        "rejected",
+        "suspended"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/db/drizzle/meta/_journal.json b/packages/db/drizzle/meta/_journal.json
index b627886..00f8281 100644
--- a/packages/db/drizzle/meta/_journal.json
+++ b/packages/db/drizzle/meta/_journal.json
@@ -50,6 +50,13 @@
       "when": 1787306631007,
       "tag": "0006_careful_lilandra",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1787308773577,
+      "tag": "0007_medical_dark_beast",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/packages/db/src/schema/discovery.ts b/packages/db/src/schema/discovery.ts
new file mode 100644
index 0000000..026272a
--- /dev/null
+++ b/packages/db/src/schema/discovery.ts
@@ -0,0 +1,110 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable, text, timestamp, unique, uuid } from 'drizzle-orm/pg-core';
+import { users } from './auth';
+import { proProfiles } from './pros';
+
+/**
+ * The two deck actions that are neither "yes" nor "no".
+ *
+ * Before these the deck had exactly two outcomes — send this pro a job now, or
+ * lose them — which is a lot to ask of a swipe. Watching keeps somebody without
+ * contacting them; an enquiry asks a question without committing to a job.
+ */
+
+/**
+ * "Tell me when this one is free."
+ *
+ * NOTE, because it limits what this can do today: a pro with
+ * `is_accepting_jobs = false` is invisible on every surface —
+ * `eligibleProAtAnyDistance()` requires the flag, and the deck, search and the
+ * public profile all use it. So a watch can only be placed on somebody who is
+ * ALREADY available, and only fires on the away-and-back cycle.
+ *
+ * Making "free at a time that suits me" real needs `pro_availability` — which is
+ * seeded and read by nothing — to become a maintained calendar. Until then this
+ * is deliberately the narrow version rather than a button that cannot fire.
+ */
+export const proWatches = pgTable(
+  'pro_watches',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    watcherId: uuid('watcher_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    proId: uuid('pro_id')
+      .notNull()
+      .references(() => proProfiles.userId, { onDelete: 'cascade' }),
+    /**
+     * What the pro's availability was when the watch was placed.
+     *
+     * The trigger is a CHANGE, not a state: without this, a sweep would notify
+     * every watcher every time it ran, because "this pro is available" is true
+     * for as long as they stay available.
+     */
+    availableAtWatch: text('available_at_watch').notNull().default('true'),
+    /** Set when we have told them, so one return does not send five messages. */
+    notifiedAt: timestamp('notified_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    // One watch per person per pro. Tapping twice is a toggle, not a second row.
+    unique('pro_watches_unique').on(t.watcherId, t.proId),
+    // The sweeper's read: everyone watching this pro who has not been told.
+    index('pro_watches_pro_idx').on(t.proId, t.notifiedAt),
+    index('pro_watches_watcher_idx').on(t.watcherId, t.createdAt),
+  ],
+);
+
+/**
+ * A question, before there is a job.
+ *
+ * Deliberately its own table rather than a `match` with a null job. A match
+ * means a pro said yes to specific work; an enquiry means a customer asked
+ * something and may never post anything at all. Collapsing the two would put
+ * rows in `matches` that no booking, quote or review could ever hang off, and
+ * every query that assumes a match has a job would have to learn about the
+ * exception.
+ *
+ * The abuse surface this opens is real — it is the first way to reach a pro who
+ * has not agreed to anything. `MAX_OPEN_ENQUIRIES` caps how many a customer can
+ * have unanswered at once, which is the same shape as the open-request cap and
+ * for the same reason: stop one person spraying the city.
+ */
+export const enquiries = pgTable(
+  'enquiries',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+    clientId: uuid('client_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    proId: uuid('pro_id')
+      .notNull()
+      .references(() => proProfiles.userId, { onDelete: 'cascade' }),
+    /**
+     * Set once the pro answers. An unanswered enquiry counts against the
+     * client's cap; an answered one does not, so a customer having real
+     * conversations is not throttled.
+     */
+    respondedAt: timestamp('responded_at', { withTimezone: true }),
+    lastMessageAt: timestamp('last_message_at', { withTimezone: true }),
+    /** The pro can end it. Nothing more can be sent, the history stays. */
+    closedAt: timestamp('closed_at', { withTimezone: true }),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [
+    // One open thread per pair — a second question goes in the same one.
+    unique('enquiries_pair_unique').on(t.clientId, t.proId),
+    index('enquiries_pro_idx').on(t.proId, t.lastMessageAt),
+    index('enquiries_client_idx').on(t.clientId, t.lastMessageAt),
+  ],
+);
+
+export const proWatchesRelations = relations(proWatches, ({ one }) => ({
+  watcher: one(users, { fields: [proWatches.watcherId], references: [users.id] }),
+  pro: one(proProfiles, { fields: [proWatches.proId], references: [proProfiles.userId] }),
+}));
+
+export const enquiriesRelations = relations(enquiries, ({ one }) => ({
+  client: one(users, { fields: [enquiries.clientId], references: [users.id] }),
+  pro: one(proProfiles, { fields: [enquiries.proId], references: [proProfiles.userId] }),
+}));
diff --git a/packages/db/src/schema/index.ts b/packages/db/src/schema/index.ts
index 0d9a80f..b9cb920 100644
--- a/packages/db/src/schema/index.ts
+++ b/packages/db/src/schema/index.ts
@@ -3,6 +3,7 @@ export * from './auth';
 export * from './pros';
 export * from './jobs';
 export * from './matching';
+export * from './discovery';
 export * from './messaging';
 export * from './commerce';
 export * from './reviews';
diff --git a/packages/db/src/schema/messaging.ts b/packages/db/src/schema/messaging.ts
index 6b21d47..3040d7a 100644
--- a/packages/db/src/schema/messaging.ts
+++ b/packages/db/src/schema/messaging.ts
@@ -1,15 +1,23 @@
 import { relations, sql } from 'drizzle-orm';
-import { index, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { check, index, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
 import { users } from './auth';
+import { enquiries } from './discovery';
 import { matches } from './matching';
 
+/**
+ * One message table for both kinds of conversation.
+ *
+ * A message belongs to a MATCH (a pro agreed to a job) or to an ENQUIRY (a
+ * customer asked a question before there was one) — never both, never neither.
+ * Two tables would mean two chat components that drift, so the column pair
+ * carries the difference and a CHECK makes the illegal state unrepresentable.
+ */
 export const messages = pgTable(
   'messages',
   {
     id: uuid('id').primaryKey().defaultRandom(),
-    matchId: uuid('match_id')
-      .notNull()
-      .references(() => matches.id, { onDelete: 'cascade' }),
+    matchId: uuid('match_id').references(() => matches.id, { onDelete: 'cascade' }),
+    enquiryId: uuid('enquiry_id').references(() => enquiries.id, { onDelete: 'cascade' }),
     senderId: uuid('sender_id')
       .notNull()
       .references(() => users.id, { onDelete: 'cascade' }),
@@ -19,14 +27,25 @@ export const messages = pgTable(
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
   },
   (t) => [
-    // Chat history is always "this match, newest last".
+    // Exactly one parent. Without this a message could belong to both threads,
+    // or to none, and every read would need to handle a row that means nothing.
+    check(
+      'messages_one_parent',
+      sql`(${t.matchId} IS NULL) <> (${t.enquiryId} IS NULL)`,
+    ),
+    // Chat history is always "this thread, newest last".
     index('messages_match_idx').on(t.matchId, t.createdAt),
+    index('messages_enquiry_idx').on(t.enquiryId, t.createdAt),
     // Unread badge count.
     index('messages_unread_idx').on(t.matchId, t.senderId).where(sql`${t.readAt} IS NULL`),
+    index('messages_enquiry_unread_idx')
+      .on(t.enquiryId, t.senderId)
+      .where(sql`${t.readAt} IS NULL`),
   ],
 );
 
 export const messagesRelations = relations(messages, ({ one }) => ({
   match: one(matches, { fields: [messages.matchId], references: [matches.id] }),
+  enquiry: one(enquiries, { fields: [messages.enquiryId], references: [enquiries.id] }),
   sender: one(users, { fields: [messages.senderId], references: [users.id] }),
 }));
diff --git a/packages/shared/src/constants.ts b/packages/shared/src/constants.ts
index 24c037b..590f518 100644
--- a/packages/shared/src/constants.ts
+++ b/packages/shared/src/constants.ts
@@ -3,6 +3,19 @@
 /** Max open (pending) requests a client can have out on a single job. Stops city-spraying. */
 export const MAX_OPEN_REQUESTS_PER_JOB = 5;
 
+/**
+ * Max UNANSWERED enquiries one customer may have out at a time.
+ *
+ * An enquiry is the first way to reach a pro who has not agreed to anything, so
+ * it needs the same shape of cap as requests and for the same reason. Answered
+ * threads do not count: somebody having real conversations should not be
+ * throttled, only somebody broadcasting.
+ */
+export const MAX_OPEN_ENQUIRIES = 5;
+
+/** How long an enquiry sits unanswered before it stops counting against the cap. */
+export const ENQUIRY_STALE_DAYS = 14;
+
 /** How long a pro has to respond before a request auto-expires. */
 export const REQUEST_TTL_HOURS = {
   now: 12,
diff --git a/packages/shared/src/schemas.ts b/packages/shared/src/schemas.ts
index 83ad8ce..02b5d6a 100644
--- a/packages/shared/src/schemas.ts
+++ b/packages/shared/src/schemas.ts
@@ -237,7 +237,11 @@ export type CreateReviewInput = z.infer<typeof createReviewSchema>;
  */
 export const sendMessageSchema = z
   .object({
-    matchId: z.string().uuid(),
+    /** Which conversation — a match or an enquiry. See routers/message.ts. */
+    ref: z.union([
+      z.object({ matchId: z.string().uuid() }),
+      z.object({ enquiryId: z.string().uuid() }),
+    ]),
     body: z.string().trim().max(4000).default(''),
     attachments: z.array(z.string().url()).max(5).default([]),
   })