diff --git a/.github/SECRETS.md b/.github/SECRETS.md
index 4934d9c..8c3f960 100644
--- a/.github/SECRETS.md
+++ b/.github/SECRETS.md
@@ -1,113 +1,58 @@
 # GitHub Secrets Configuration
 
-This document lists all the secrets that need to be configured in GitHub repository settings for CI/CD pipelines to work properly.
+All secrets needed for CI/CD pipelines. Configure in **Settings → Secrets and variables → Actions**.
 
 ## Required Secrets
 
-### Docker Hub (for docker-build job)
+### VPS Deployment
 
-- **DOCKER_USERNAME** - Your Docker Hub username
-- **DOCKER_PASSWORD** - Your Docker Hub password or access token
+| Secret        | Description                         | Example       |
+| ------------- | ----------------------------------- | ------------- |
+| `VPS_HOST`    | VPS IP address or hostname          | `203.0.113.1` |
+| `VPS_USER`    | SSH username on VPS                 | `deploy`      |
+| `VPS_PORT`    | SSH port                            | `22`          |
+| `VPS_SSH_KEY` | Private SSH key for the deploy user | Full PEM key  |
 
-### Code Coverage (optional)
+### Container Registry (GHCR)
 
-- **CODECOV_TOKEN** - Codecov token for uploading coverage reports
-  - Get from: https://codecov.io/
-
-### Deployment Secrets
-
-#### Staging Environment
-
-- **STAGING_DATABASE_URL** - PostgreSQL connection string for staging
-  - Format: `postgresql://user:password@host:port/database`
-
-#### Production Environment
-
-- **PRODUCTION_DATABASE_URL** - PostgreSQL connection string for production
-  - Format: `postgresql://user:password@host:port/database`
-
-### Notifications (optional)
-
-- **SLACK_WEBHOOK_URL** - Slack webhook URL for deployment notifications
-  - Create at: https://api.slack.com/messaging/webhooks
+> [!NOTE]
+> GHCR uses `GITHUB_TOKEN` automatically — no additional secrets needed for pushing images.
 
 ## How to Add Secrets
 
 1. Go to your GitHub repository
-2. Click on **Settings** → **Secrets and variables** → **Actions**
+2. Click **Settings** → **Secrets and variables** → **Actions**
 3. Click **New repository secret**
-4. Add each secret with its corresponding value
+4. Add each secret listed above
 
-## Environment-Specific Secrets
+## VPS Setup Checklist
 
-### Staging
+Before the deploy workflow can succeed, ensure the VPS has:
 
-Go to **Settings** → **Environments** → **staging** → **Add secret**
+1. Docker and Docker Compose installed
+2. The `deploy` user with docker group access
+3. Project directory at `/opt/postly` with `.env` file (`chmod 600`)
+4. GHCR login configured: `docker login ghcr.io -u <github-user> -p <PAT>`
+5. SSH key added to `~/.ssh/authorized_keys` for the deploy user
 
-### Production
-
-Go to **Settings** → **Environments** → **production** → **Add secret**
-
-## Security Best Practices
-
-1. **Never commit secrets to the repository**
-2. **Rotate secrets regularly** (every 3-6 months)
-3. **Use environment-specific secrets** for staging vs production
-4. **Limit secret access** to specific workflows/environments
-5. **Enable branch protection** for main and develop branches
-6. **Require approval** for production deployments
-
-## Additional Configuration
-
-### Branch Protection Rules (Recommended)
+## Branch Protection Rules (Recommended)
 
 For `main` branch:
 
 - ✅ Require pull request reviews before merging
-- ✅ Require status checks to pass before merging
-  - lint
-  - type-check
-  - test
-  - build
+- ✅ Require status checks to pass (lint, type-check, test, build)
 - ✅ Require branches to be up to date before merging
-- ✅ Require conversation resolution before merging
 - ✅ Do not allow bypassing the above settings
 
-For `develop` branch:
-
-- ✅ Require status checks to pass before merging
-- ✅ Require branches to be up to date before merging
-
-### Environment Protection Rules
-
-For `production` environment:
-
-- ✅ Required reviewers (at least 1)
-- ✅ Wait timer: 5 minutes
-- ✅ Deployment branches: Only `main` and tags matching `v*`
-
-For `staging` environment:
-
-- ✅ Deployment branches: Only `main` and `develop`
-
-## Verifying Configuration
-
-After adding secrets, you can verify they're working by:
-
-1. Pushing to a feature branch
-2. Creating a pull request to `develop` or `main`
-3. Check that CI workflow runs successfully
-4. For deployment, merge to `main` and verify deployment workflow
-
-## Troubleshooting
-
-If workflows fail due to missing secrets:
-
-1. Check workflow logs for specific error messages
-2. Verify secret names match exactly (case-sensitive)
-3. Ensure secrets are set in the correct environment
-4. Check that workflow has permission to access the secret
+## Rollback
 
-## Contact
+Every deploy tags images with the Git SHA. To rollback:
 
-For questions about secrets configuration, contact your DevOps team or repository administrator.
+```bash
+ssh deploy@<VPS_HOST>
+cd /opt/postly
+export API_IMAGE=ghcr.io/<repo>/api:<previous-sha>
+export SCRAPER_IMAGE=ghcr.io/<repo>/scraper:<previous-sha>
+export BOT_IMAGE=ghcr.io/<repo>/bot:<previous-sha>
+docker compose -f docker-compose.prod.yml up -d --no-deps api bot scraper
+```
diff --git a/.gitignore b/.gitignore
index 580e5ca..335dcd6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,4 +108,5 @@ lerna-debug.log*
 test-results/
 playwright-report/
 blob-report/
-playwright/.cache/
\ No newline at end of file
+playwright/.cache/
+apps/scraper/.playwright_data
\ No newline at end of file
diff --git a/README.md b/README.md
index e69de29..85e1d0e 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1,182 @@
+# Postly — Production Deployment Guide
+
+Complete runbook for deploying Postly to a VPS.
+
+---
+
+## Architecture Overview
+
+```
+VPS Proxy (Nginx/Traefik) → API (Express)
+                          → Static Web (Vite build)
+
+Internal Docker Network:
+  API ←→ PostgreSQL (pgvector)
+  API ←→ Redis (BullMQ + Caching)
+  Scraper ←→ PostgreSQL
+  Bot ←→ PostgreSQL + Redis
+```
+
+**Stack:** Node.js API · Python Scraper · Python Discord Bot · PostgreSQL 16 + pgvector · Redis 7
+
+---
+
+## Quick-Start Checklist
+
+```
+□  1. Clone repo to /opt/postly, create .env
+□  2. docker compose -f docker-compose.prod.yml up -d
+□  3. Verify all services healthy
+□  4. Configure GitHub Actions secrets
+□  5. Push to main → verify pipeline runs
+□  6. Set up cron backup job
+□  7. Run a backup restore drill
+```
+
+---
+
+## Step-by-Step Deployment
+
+### 1. Clone and Configure
+
+Log into your VPS and run:
+
+```bash
+cd /opt/postly
+git clone https://github.com/<your-repo>.git .
+
+# Create production .env from template
+cp .env.production.example .env
+chmod 600 .env
+
+# Edit .env — fill in all CHANGE_ME values
+nano .env
+```
+
+**Critical .env values to set:**
+
+- `DB_PASSWORD` — Strong random password (`openssl rand -hex 16`)
+- `JWT_SECRET` / `JWT_REFRESH_SECRET` — (`openssl rand -hex 32`)
+- `DISCORD_BOT_TOKEN` — From Discord Developer Portal
+- `WEB_URL` — Your production domain (e.g., `https://postly.io`)
+
+### 2. Login to GHCR
+
+```bash
+# Login to pull pre-built images from GitHub Container Registry
+echo "<YOUR_PAT>" | docker login ghcr.io -u <github-username> --password-stdin
+```
+
+### 3. Start the Stack
+
+```bash
+docker compose -f docker-compose.prod.yml up -d
+```
+
+Verify all services are healthy:
+
+```bash
+docker compose -f docker-compose.prod.yml ps
+curl -s http://localhost:3000/health | jq
+```
+
+Expected health response:
+
+```json
+{
+  "status": "ok",
+  "checks": { "db": "ok", "redis": "ok" },
+  "uptime": 12.345
+}
+```
+
+### 4. Run HNSW Index Migration (One-time)
+
+```bash
+docker exec -i postly-postgres psql -U postly -d postly < scripts/add-hnsw-indexes.sql
+```
+
+### 5. Setup Backups
+
+```bash
+# Make backup script executable
+chmod +x scripts/backup.sh
+
+# Test it manually first
+bash scripts/backup.sh
+
+# Add to cron (runs daily at 2 AM)
+(crontab -l 2>/dev/null; echo "0 2 * * * /opt/postly/scripts/backup.sh >> /var/log/postly-backup.log 2>&1") | crontab -
+```
+
+### 6. Configure GitHub Actions
+
+Add these secrets in **Settings → Secrets → Actions**:
+
+| Secret        | Value                      |
+| ------------- | -------------------------- |
+| `VPS_HOST`    | Your VPS IP address        |
+| `VPS_USER`    | `deploy`                   |
+| `VPS_PORT`    | `22`                       |
+| `VPS_SSH_KEY` | Full private SSH key (PEM) |
+
+Push to `main` and verify the pipeline deploys successfully.
+
+---
+
+## Rollback
+
+Every deploy tags images with the Git SHA. To rollback:
+
+```bash
+cd /opt/postly
+export API_IMAGE=ghcr.io/<repo>/api:<previous-sha>
+export SCRAPER_IMAGE=ghcr.io/<repo>/scraper:<previous-sha>
+export BOT_IMAGE=ghcr.io/<repo>/bot:<previous-sha>
+docker compose -f docker-compose.prod.yml up -d --no-deps api bot scraper
+```
+
+---
+
+## Backup Restore Drill
+
+Run this monthly to verify backups work:
+
+```bash
+# Start a throwaway Postgres container
+docker run -d --name pg-restore-test -e POSTGRES_PASSWORD=test pgvector/pgvector:pg16
+
+# Restore latest backup into it
+docker exec -i pg-restore-test pg_restore -U postgres -d postgres --create < backups/local/$(ls -t backups/local/ | head -1)
+
+# Verify data
+docker exec pg-restore-test psql -U postgres -d postly -c "SELECT count(*) FROM users;"
+
+# Clean up
+docker rm -f pg-restore-test
+```
+
+---
+
+## Scaling Roadmap
+
+| Users   | Action                                          | Cost Impact |
+| ------- | ----------------------------------------------- | ----------- |
+| 0–1K    | Current setup, no changes                       | —           |
+| 1K–10K  | Add Postgres read replica (second VPS)          | +€4.5/mo    |
+| 10K–50K | Extract scraper to own VPS, add pgBouncer       | +€4.5/mo    |
+| 50K+    | Consider managed DB, split into domain services | Variable    |
+
+---
+
+## File Reference
+
+| File                           | Purpose                          |
+| ------------------------------ | -------------------------------- |
+| `docker-compose.prod.yml`      | Main production stack            |
+| `scripts/backup.sh`            | Daily PostgreSQL backup          |
+| `scripts/add-hnsw-indexes.sql` | pgvector HNSW indexes (run once) |
+| `.env.production.example`      | Production env template          |
+| `.github/workflows/deploy.yml` | CI/CD pipeline                   |
+| `.github/workflows/ci.yml`     | PR checks                        |
+| `.github/SECRETS.md`           | GitHub secrets reference         |
diff --git a/apps/api/package.json b/apps/api/package.json
index 6dba678..1867f2b 100644
--- a/apps/api/package.json
+++ b/apps/api/package.json
@@ -16,8 +16,9 @@
     "@dodopayments/express": "^0.2.6",
     "@postly/config": "*",
     "@postly/database": "*",
+    "@postly/logger": "*",
     "@postly/shared-types": "*",
-    "bcryptjs": "^2.4.3",
+    "bcrypt": "^5.1.1",
     "bullmq": "^5.31.3",
     "cors": "^2.8.6",
     "dotenv": "^16.4.7",
@@ -29,12 +30,13 @@
     "mammoth": "^1.11.0",
     "multer": "^2.0.2",
     "pdf-parse": "^2.4.5",
+    "resend": "^6.9.4",
     "zod": "^3.24.1"
   },
   "devDependencies": {
     "@postly/eslint-config": "*",
     "@postly/typescript-config": "*",
-    "@types/bcryptjs": "^2.4.6",
+    "@types/bcrypt": "^5.0.2",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/jsonwebtoken": "^9.0.7",
diff --git a/apps/api/src/config/secrets.ts b/apps/api/src/config/secrets.ts
index e506fa4..391634e 100644
--- a/apps/api/src/config/secrets.ts
+++ b/apps/api/src/config/secrets.ts
@@ -34,4 +34,6 @@ export {
   DODO_PAYMENTS_WEBHOOK_KEY,
   DODO_PAYMENTS_ENVIRONMENT,
   DODO_PAYMENTS_RETURN_URL,
+  RESEND_API_KEY,
+  RESEND_FROM_EMAIL,
 } from "@postly/config";
diff --git a/apps/api/src/controllers/auth.controller.ts b/apps/api/src/controllers/auth.controller.ts
index 4c990dd..16e89ad 100644
--- a/apps/api/src/controllers/auth.controller.ts
+++ b/apps/api/src/controllers/auth.controller.ts
@@ -1,17 +1,19 @@
 import { Request, Response, NextFunction } from "express";
-import bcrypt from "bcryptjs";
+import bcrypt from "bcrypt";
 import jwt, { type SignOptions } from "jsonwebtoken";
 import crypto from "crypto";
 import { z } from "zod";
-import { userQueries } from "@postly/database";
-import type { AuthResponse } from "@postly/shared-types";
+import { userQueries, otpQueries } from "@postly/database";
+import type { AuthResponse, UserRole } from "@postly/shared-types";
 import type { JwtPayload } from "../middleware/auth.js";
 import {
   JWT_SECRET,
   JWT_REFRESH_SECRET,
   JWT_EXPIRES_IN,
   JWT_REFRESH_EXPIRES_IN,
+  RESEND_FROM_EMAIL,
 } from "../config/secrets.js";
+import { resend } from "../lib/resend.js";
 
 // ─── Validation Schemas ──────────────────────────────────────────────────────
 
@@ -39,15 +41,28 @@ const resetPasswordSchema = z.object({
   password: z.string().min(8, "Password must be at least 8 characters"),
 });
 
+const verifyOtpSchema = z.object({
+  email: z.string().email("Invalid email address"),
+  code: z.string().length(6, "OTP must be 6 digits"),
+});
+
+const resendOtpSchema = z.object({
+  email: z.string().email("Invalid email address"),
+});
+
 // ─── Controller ──────────────────────────────────────────────────────────────
 
 export class AuthController {
   /**
    * Generate access + refresh token pair for a user.
    */
-  private generateTokens(user: { id: string; email: string; role: string }) {
+  private generateTokens(user: {
+    id: string;
+    email: string;
+    roles: UserRole[];
+  }) {
     const access_token = jwt.sign(
-      { id: user.id, email: user.email, role: user.role },
+      { id: user.id, email: user.email, roles: user.roles },
       JWT_SECRET,
       { expiresIn: JWT_EXPIRES_IN as SignOptions["expiresIn"] },
     );
@@ -97,22 +112,45 @@ export class AuthController {
         password_hash,
         full_name,
       });
-      const tokens = this.generateTokens(user);
 
-      const response: AuthResponse = {
-        user: {
-          id: user.id,
+      // Generate 6-digit OTP
+      const otpCode = Math.floor(100000 + Math.random() * 900000).toString();
+      const otpHash = await bcrypt.hash(otpCode, 10);
+      const otpExpiry = new Date(Date.now() + 10 * 60 * 1000); // 10 minutes
+
+      await otpQueries.upsertOtp(user.id, otpHash, otpExpiry);
+
+      // Send OTP via Resend
+      try {
+        await resend.emails.send({
+          from: RESEND_FROM_EMAIL,
+          to: email,
+          subject: "Verify your Postly account",
+          html: `
+            <div style="font-family: sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+              <h2 style="color: #333;">Welcome to Postly!</h2>
+              <p>Your verification code is:</p>
+              <div style="background: #f4f4f4; padding: 20px; font-size: 32px; font-weight: bold; letter-spacing: 5px; text-align: center; border-radius: 8px;">
+                ${otpCode}
+              </div>
+              <p>This code will expire in 10 minutes.</p>
+              <p>If you didn't create an account, you can safely ignore this email.</p>
+            </div>
+          `,
+        });
+      } catch (emailError) {
+        console.error("Failed to send verification email:", emailError);
+        // We still created the user, they can request a resend later
+      }
+
+      res.status(201).json({
+        success: true,
+        data: {
+          message:
+            "Registration successful. Please check your email for the verification code.",
           email: user.email,
-          full_name: user.full_name,
-          role: user.role,
-          is_verified: user.is_verified,
-          created_at: user.created_at,
-          updated_at: user.updated_at,
         },
-        ...tokens,
-      };
-
-      res.status(201).json({ success: true, data: response });
+      });
     } catch (error) {
       next(error);
     }
@@ -158,6 +196,18 @@ export class AuthController {
         return;
       }
 
+      // Check if email is verified
+      if (!user.is_verified) {
+        res.status(403).json({
+          success: false,
+          error: {
+            message: "Email not verified",
+            code: "EMAIL_NOT_VERIFIED",
+          },
+        });
+        return;
+      }
+
       // Track login timestamp
       await userQueries.updateLastLogin(user.id);
 
@@ -168,7 +218,7 @@ export class AuthController {
           id: user.id,
           email: user.email,
           full_name: user.full_name,
-          role: user.role,
+          roles: user.roles,
           is_verified: user.is_verified,
           created_at: user.created_at,
           updated_at: user.updated_at,
@@ -233,7 +283,7 @@ export class AuthController {
       }
 
       const access_token = jwt.sign(
-        { id: user.id, email: user.email, role: user.role },
+        { id: user.id, email: user.email, roles: user.roles },
         JWT_SECRET,
         { expiresIn: JWT_EXPIRES_IN as SignOptions["expiresIn"] },
       );
@@ -268,7 +318,7 @@ export class AuthController {
           id: user.id,
           email: user.email,
           full_name: user.full_name,
-          role: user.role,
+          roles: user.roles,
           is_verified: user.is_verified,
           last_login_at: user.last_login_at,
           created_at: user.created_at,
@@ -361,4 +411,193 @@ export class AuthController {
       next(error);
     }
   };
+
+  // ─── POST /verify-otp ────────────────────────────────────────────────────
+
+  verifyOtp = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const validation = verifyOtpSchema.safeParse(req.body);
+      if (!validation.success) {
+        res.status(400).json({
+          success: false,
+          error: { message: validation.error.errors[0].message },
+        });
+        return;
+      }
+
+      const { email, code } = validation.data;
+      const user = await userQueries.findByEmail(email);
+
+      if (!user) {
+        res.status(404).json({
+          success: false,
+          error: { message: "User not found" },
+        });
+        return;
+      }
+
+      if (user.is_verified) {
+        res.status(400).json({
+          success: false,
+          error: { message: "User is already verified" },
+        });
+        return;
+      }
+
+      const otp = await otpQueries.findOtpByUserId(user.id);
+      if (!otp) {
+        res.status(400).json({
+          success: false,
+          error: {
+            message: "No verification code found. Please request a new one.",
+          },
+        });
+        return;
+      }
+
+      // Check expiry
+      if (new Date() > new Date(otp.expires_at)) {
+        await otpQueries.deleteOtp(otp.id);
+        res.status(400).json({
+          success: false,
+          error: {
+            message: "Verification code expired. Please request a new one.",
+          },
+        });
+        return;
+      }
+
+      // Check attempts
+      if (otp.attempts >= 3) {
+        res.status(429).json({
+          success: false,
+          error: {
+            message: "Too many failed attempts. Please request a new code.",
+          },
+        });
+        return;
+      }
+
+      // Verify code
+      const isValid = await bcrypt.compare(code, otp.code_hash);
+      if (!isValid) {
+        await otpQueries.incrementOtpAttempts(otp.id);
+        res.status(400).json({
+          success: false,
+          error: { message: "Invalid verification code" },
+        });
+        return;
+      }
+
+      // Success
+      await otpQueries.verifyUser(user.id);
+      await otpQueries.deleteOtp(otp.id);
+
+      const tokens = this.generateTokens(user);
+      const response: AuthResponse = {
+        user: {
+          id: user.id,
+          email: user.email,
+          full_name: user.full_name,
+          roles: user.roles,
+          is_verified: true,
+          created_at: user.created_at,
+          updated_at: new Date(),
+        },
+        ...tokens,
+      };
+
+      res.json({ success: true, data: response });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  // ─── POST /resend-otp ────────────────────────────────────────────────────
+
+  resendOtp = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const validation = resendOtpSchema.safeParse(req.body);
+      if (!validation.success) {
+        res.status(400).json({
+          success: false,
+          error: { message: validation.error.errors[0].message },
+        });
+        return;
+      }
+
+      const { email } = validation.data;
+      const user = await userQueries.findByEmail(email);
+
+      if (!user) {
+        res.status(404).json({
+          success: false,
+          error: { message: "User not found" },
+        });
+        return;
+      }
+
+      if (user.is_verified) {
+        res.status(400).json({
+          success: false,
+          error: { message: "User is already verified" },
+        });
+        return;
+      }
+
+      const existingOtp = await otpQueries.findOtpByUserId(user.id);
+      if (existingOtp) {
+        const timeSinceCreation =
+          Date.now() - new Date(existingOtp.created_at || 0).getTime();
+        if (timeSinceCreation < 60 * 1000) {
+          const waitTime = Math.ceil((60 * 1000 - timeSinceCreation) / 1000);
+          res.status(429).json({
+            success: false,
+            error: {
+              message: `Please wait ${waitTime} seconds before requesting a new code.`,
+            },
+          });
+          return;
+        }
+      }
+
+      // Generate new OTP
+      const otpCode = Math.floor(100000 + Math.random() * 900000).toString();
+      const otpHash = await bcrypt.hash(otpCode, 10);
+      const otpExpiry = new Date(Date.now() + 10 * 60 * 1000);
+
+      await otpQueries.upsertOtp(user.id, otpHash, otpExpiry);
+
+      await resend.emails.send({
+        from: RESEND_FROM_EMAIL,
+        to: email,
+        subject: "Your new Postly verification code",
+        html: `
+          <div style="font-family: sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h2 style="color: #333;">Verification Code</h2>
+            <p>Your new verification code is:</p>
+            <div style="background: #f4f4f4; padding: 20px; font-size: 32px; font-weight: bold; letter-spacing: 5px; text-align: center; border-radius: 8px;">
+              ${otpCode}
+            </div>
+            <p>This code will expire in 10 minutes.</p>
+          </div>
+        `,
+      });
+
+      res.json({
+        success: true,
+        data: { message: "Verification code resent successfully." },
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
 }
diff --git a/apps/api/src/controllers/bot.controller.ts b/apps/api/src/controllers/bot.controller.ts
new file mode 100644
index 0000000..592091a
--- /dev/null
+++ b/apps/api/src/controllers/bot.controller.ts
@@ -0,0 +1,196 @@
+import { Request, Response, NextFunction } from "express";
+import { db, bot_configs, eq, and, botQueries } from "@postly/database";
+import { queueService } from "../services/queue.service.js";
+import type { JwtPayload } from "../middleware/auth.js";
+import { WEB_URL } from "../config/secrets.js";
+import type { BotPlatform } from "@postly/shared-types";
+
+export class BotController {
+  /**
+   * GET /api/v1/bots/callback
+   * Handles the redirect from OAuth providers (e.g. Discord).
+   */
+  handleDiscordCallback = async (
+    req: Request,
+    res: Response,
+    _next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const { guild_id } = req.query;
+      const user = req.user as JwtPayload;
+
+      if (!guild_id) {
+        res.redirect(`${WEB_URL}/dashboard?discord_error=missing_guild`);
+        return;
+      }
+
+      await botQueries.upsertConfig({
+        user_id: user.id,
+        platform: "discord",
+        target_id: guild_id as string,
+      });
+
+      res.redirect(
+        `${WEB_URL}/dashboard?discord_success=true&guild_id=${guild_id}`,
+      );
+    } catch (error) {
+      console.error("Discord callback error:", error);
+      res.redirect(`${WEB_URL}/dashboard?discord_error=true`);
+    }
+  };
+
+  /**
+   * GET /api/v1/bots/configs
+   * Returns all bot configurations for the current user.
+   */
+  getConfigs = async (
+    req: Request,
+    res: Response,
+    _next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const user = req.user as JwtPayload;
+      const configs = await db
+        .select()
+        .from(bot_configs)
+        .where(eq(bot_configs.user_id, user.id));
+
+      res.json({
+        success: true,
+        data: configs,
+      });
+    } catch (error) {
+      _next(error);
+    }
+  };
+
+  /**
+   * POST /api/v1/bots/configs
+   * Manually create or update a bot config (e.g. for Webhooks, Twitter, Reddit).
+   */
+  upsertConfig = async (
+    req: Request,
+    res: Response,
+    _next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const user = req.user as JwtPayload;
+      const {
+        platform,
+        target_id,
+        target_name,
+        webhook_url,
+        credentials,
+        filters,
+      } = req.body;
+
+      const result = await botQueries.upsertConfig({
+        user_id: user.id,
+        platform: platform as BotPlatform,
+        target_id,
+        target_name,
+        webhook_url,
+        credentials,
+        ...filters,
+      });
+
+      res.json({
+        success: true,
+        data: result,
+      });
+    } catch (error) {
+      _next(error);
+    }
+  };
+
+  /**
+   * PATCH /api/v1/bots/configs/:id
+   * Updates an existing bot configuration.
+   */
+  updateConfig = async (
+    req: Request,
+    res: Response,
+    _next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const { id } = req.params;
+      const user = req.user as JwtPayload;
+      const updateData = req.body;
+
+      const [existing] = await db
+        .select()
+        .from(bot_configs)
+        .where(
+          and(
+            eq(bot_configs.id, id as string),
+            eq(bot_configs.user_id, user.id),
+          ),
+        )
+        .limit(1);
+
+      if (!existing) {
+        res.status(404).json({ success: false, message: "Config not found" });
+        return;
+      }
+
+      const [updated] = await db
+        .update(bot_configs)
+        .set({
+          ...updateData,
+          updated_at: new Date(),
+        })
+        .where(eq(bot_configs.id, id as string))
+        .returning();
+
+      res.json({
+        success: true,
+        data: updated,
+      });
+    } catch (error) {
+      _next(error);
+    }
+  };
+
+  /**
+   * POST /api/v1/bots/configs/:id/test
+   * Manually trigger a test notification for a specific bot config.
+   */
+  triggerTestNotification = async (
+    req: Request,
+    res: Response,
+    _next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const { id } = req.params;
+      const user = req.user as JwtPayload;
+
+      const [config] = await db
+        .select()
+        .from(bot_configs)
+        .where(
+          and(
+            eq(bot_configs.id, id as string),
+            eq(bot_configs.user_id, user.id),
+          ),
+        )
+        .limit(1);
+
+      if (!config) {
+        res.status(404).json({
+          success: false,
+          message: "Bot configuration not found.",
+        });
+        return;
+      }
+
+      await queueService.dispatchForPlatform(config.id);
+
+      res.json({
+        success: true,
+        message: `Test notification queued for ${config.platform}!`,
+      });
+    } catch (error) {
+      _next(error);
+    }
+  };
+}
diff --git a/apps/api/src/controllers/user.controller.ts b/apps/api/src/controllers/user.controller.ts
index 8d2043b..5e21629 100644
--- a/apps/api/src/controllers/user.controller.ts
+++ b/apps/api/src/controllers/user.controller.ts
@@ -1,5 +1,6 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
+import bcrypt from "bcrypt";
 import {
   userQueries,
   seekerProfileQueries,
@@ -7,9 +8,18 @@ import {
   subscriptionQueries,
 } from "@postly/database";
 import type { JwtPayload } from "../middleware/auth.js";
+import { CacheService } from "../services/cache.service.js";
 
 const updateProfileSchema = z.object({
   full_name: z.string().min(1).max(100).optional(),
+  avatar_url: z.string().url().or(z.string().length(0)).optional(),
+  timezone: z.string().max(50).optional(),
+  locale: z.string().max(20).optional(),
+});
+
+const changePasswordSchema = z.object({
+  current_password: z.string().min(1),
+  new_password: z.string().min(8),
 });
 
 const updateSeekerProfileSchema = z.object({
@@ -50,7 +60,14 @@ export class UserController {
   ): Promise<void> => {
     try {
       const payload = req.user as JwtPayload;
-      const user = await userQueries.findById(payload.id);
+      const cacheKey = CacheService.generateKey("user:profile", payload.id);
+
+      const user = await CacheService.getOrSet(
+        cacheKey,
+        300, // 5 minutes TTL
+        async () => await userQueries.findById(payload.id),
+      );
+
       if (!user) {
         res
           .status(404)
@@ -63,7 +80,7 @@ export class UserController {
           id: user.id,
           email: user.email,
           full_name: user.full_name,
-          role: user.role,
+          roles: user.roles,
           is_verified: user.is_verified,
           last_login_at: user.last_login_at,
           created_at: user.created_at,
@@ -97,6 +114,11 @@ export class UserController {
           .json({ success: false, error: { message: "User not found" } });
         return;
       }
+
+      // Invalidate profile cache
+      const cacheKey = CacheService.generateKey("user:profile", payload.id);
+      await CacheService.invalidate(cacheKey);
+
       res.json({ success: true, data: updated });
     } catch (error) {
       next(error);
@@ -200,4 +222,84 @@ export class UserController {
       next(error);
     }
   };
+
+  changePassword = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const validation = changePasswordSchema.safeParse(req.body);
+      if (!validation.success) {
+        res.status(400).json({
+          success: false,
+          error: { message: validation.error.errors[0].message },
+        });
+        return;
+      }
+      const payload = req.user as JwtPayload;
+      const { current_password, new_password } = validation.data;
+
+      const user = await userQueries.findByEmail(payload.email);
+      if (!user || !user.password_hash) {
+        res
+          .status(404)
+          .json({ success: false, error: { message: "User not found" } });
+        return;
+      }
+
+      const isValid = await bcrypt.compare(
+        current_password,
+        user.password_hash,
+      );
+      if (!isValid) {
+        res.status(401).json({
+          success: false,
+          error: { message: "Invalid current password" },
+        });
+        return;
+      }
+
+      const salt = await bcrypt.genSalt(12);
+      const password_hash = await bcrypt.hash(new_password, salt);
+
+      await userQueries.updatePassword(payload.id, password_hash);
+
+      res.json({
+        success: true,
+        data: { message: "Password updated successfully" },
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  uploadAvatar = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      if (!req.file) {
+        res.status(400).json({
+          success: false,
+          error: { message: "No file uploaded" },
+        });
+        return;
+      }
+
+      // Construct the public URL for the image
+      // Note: In production, substitute with actual domain or CDN URL
+      const host = req.get("host");
+      const protocol = req.protocol;
+      const fileUrl = `${protocol}://${host}/uploads/avatars/${req.file.filename}`;
+
+      res.json({
+        success: true,
+        data: { url: fileUrl },
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
 }
diff --git a/apps/api/src/lib/redis.ts b/apps/api/src/lib/redis.ts
new file mode 100644
index 0000000..e2248d1
--- /dev/null
+++ b/apps/api/src/lib/redis.ts
@@ -0,0 +1,20 @@
+import { Redis } from "ioredis";
+import { REDIS_URL } from "../config/secrets.js";
+
+/**
+ * Shared Redis client for the API.
+ *
+ * Reuses the same connection pool for multiple features (rate limiting, health checks, etc.)
+ * to keep the connection count low and stable.
+ */
+export const redis = new Redis(REDIS_URL || "redis://localhost:6379", {
+  maxRetriesPerRequest: 1,
+  connectTimeout: 5000,
+});
+
+redis.on("error", (err) => {
+  // We log but don't crash — features should "fail open" if Redis is down
+  console.error("Shared Redis connection error:", err);
+});
+
+export default redis;
diff --git a/apps/api/src/lib/resend.ts b/apps/api/src/lib/resend.ts
new file mode 100644
index 0000000..8d4d430
--- /dev/null
+++ b/apps/api/src/lib/resend.ts
@@ -0,0 +1,4 @@
+import { Resend } from "resend";
+import { RESEND_API_KEY } from "../config/secrets.js";
+
+export const resend = new Resend(RESEND_API_KEY);
diff --git a/apps/api/src/middleware/auth.ts b/apps/api/src/middleware/auth.ts
index f01334d..122ef3f 100644
--- a/apps/api/src/middleware/auth.ts
+++ b/apps/api/src/middleware/auth.ts
@@ -13,7 +13,7 @@ import type { UserRole } from "@postly/shared-types";
 export interface JwtPayload {
   id: string;
   email: string;
-  role: UserRole;
+  roles: UserRole[];
   iat?: number;
   exp?: number;
 }
diff --git a/apps/api/src/middleware/strict-rate-limit.ts b/apps/api/src/middleware/strict-rate-limit.ts
deleted file mode 100644
index 70616de..0000000
--- a/apps/api/src/middleware/strict-rate-limit.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { Request, Response, NextFunction } from "express";
-import { Redis } from "ioredis";
-import { REDIS_URL, NODE_ENV } from "../config/secrets.js";
-import type { JwtPayload } from "./auth.js";
-
-// Initialize Redis client
-const redis = new Redis(REDIS_URL || "redis://localhost:6379");
-redis.on("error", (err) => {
-  console.error("Redis (strict-rate-limit) connection error:", err);
-});
-
-interface RateLimitConfig {
-  windowMs: number;
-  max: number | ((req: Request) => number | Promise<number>);
-  keyPrefix: string;
-  message: string;
-}
-
-/**
- * Creates a strict rate limiter middleware using Redis.
- * Persists limits across server restarts.
- */
-export const createStrictRateLimiter = (config: RateLimitConfig) => {
-  return async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      // Allow development and test environments to bypass limits
-      if (NODE_ENV !== "production") {
-        next();
-        return;
-      }
-
-      const user = req.user as JwtPayload | undefined;
-      if (!user?.id) {
-        res.status(401).json({
-          success: false,
-          error: { message: "Authentication required for rate limiting" },
-        });
-        return;
-      }
-
-      const userId = user.id;
-      const key = `${config.keyPrefix}:${userId}`;
-
-      // Get dynamic max limit
-      let maxLimit: number;
-      if (typeof config.max === "function") {
-        const dynamicMax = await config.max(req);
-        maxLimit = dynamicMax ?? 3;
-      } else {
-        maxLimit = config.max ?? 3;
-      }
-
-      // Get current count
-      const currentCount = await redis.get(key);
-      const count = currentCount ? parseInt(currentCount, 10) : 0;
-
-      if (count >= maxLimit && maxLimit !== Infinity) {
-        const ttl = await redis.ttl(key);
-        const resetDate = new Date(Date.now() + ttl * 1000);
-
-        res.status(429).json({
-          success: false,
-          error: {
-            message: config.message,
-            resetAt: resetDate.toISOString(),
-          },
-        });
-        return;
-      }
-
-      // Increment count
-      if (!currentCount) {
-        await redis.set(key, 1, "EX", Math.ceil(config.windowMs / 1000));
-      } else {
-        await redis.incr(key);
-      }
-
-      next();
-    } catch (error) {
-      console.error("Rate limiting error:", error);
-      // Fail open to avoid blocking users on redis error
-      next();
-    }
-  };
-};
-
-const isDev = NODE_ENV !== "production";
-
-export const chatRateLimiter = createStrictRateLimiter({
-  windowMs: isDev ? 60 * 60 * 1000 : 7 * 24 * 60 * 60 * 1000,
-  max: async (req: Request) => {
-    if (isDev) return 10000;
-
-    const user = req.user as JwtPayload | undefined;
-    if (!user) return 3;
-
-    if (user.role === "admin") return Infinity;
-    if (user.role === "employer") return 50;
-
-    return 3;
-  },
-  keyPrefix: "rate_limit:ai_chat",
-  message: "Weekly AI limit reached. Upgrade to Premium for more.",
-});
diff --git a/apps/api/src/middleware/token-bucket-rate-limit.ts b/apps/api/src/middleware/token-bucket-rate-limit.ts
new file mode 100644
index 0000000..bfd451c
--- /dev/null
+++ b/apps/api/src/middleware/token-bucket-rate-limit.ts
@@ -0,0 +1,159 @@
+import { Request, Response, NextFunction } from "express";
+import { redis } from "../lib/redis.js";
+import jwt from "jsonwebtoken";
+import { Redis } from "ioredis";
+
+interface RateLimitConfig {
+  maxTokens: number;
+  refillRateSec: number;
+  keyPrefix?: string;
+}
+
+interface RedisWithTokenBucket extends Redis {
+  consumeTokenBucket(
+    key: string,
+    maxTokens: number,
+    refillRateSec: number,
+    nowMs: number,
+    requested: number,
+  ): Promise<[number, string]>;
+}
+
+// Token Bucket algorithm using Redis Lua script to prevent race conditions.
+// KEYS[1] = bucket key
+// ARGV[1] = max capacity
+// ARGV[2] = refill rate per second
+// ARGV[3] = current time in ms
+// ARGV[4] = requested tokens
+const tokenBucketScript = `
+  local key = KEYS[1]
+  local capacity = tonumber(ARGV[1])
+  local refill_rate_per_sec = tonumber(ARGV[2])
+  local now_ms = tonumber(ARGV[3])
+  local requested = tonumber(ARGV[4])
+  
+  local bucket = redis.call("HMGET", key, "tokens", "last_refill")
+  local tokens = tonumber(bucket[1])
+  local last_refill = tonumber(bucket[2])
+  
+  if not tokens then
+    tokens = capacity
+    last_refill = now_ms
+  else
+    local time_passed_ms = math.max(0, now_ms - last_refill)
+    local accrued = (time_passed_ms / 1000) * refill_rate_per_sec
+    tokens = math.min(capacity, tokens + accrued)
+  end
+  
+  local granted = 0
+  if tokens >= requested then
+    tokens = tokens - requested
+    granted = 1
+  end
+  
+  redis.call("HMSET", key, "tokens", tostring(tokens), "last_refill", tostring(now_ms))
+  -- TTL is enough time for bucket to refill completely
+  local ttl = math.ceil(capacity / refill_rate_per_sec) + 1
+  redis.call("EXPIRE", key, ttl)
+  
+  return { granted, tostring(tokens) }
+`;
+
+// Register the Lua script.
+// ioredis adds it to the client instance as 'consumeTokenBucket'.
+redis.defineCommand("consumeTokenBucket", {
+  numberOfKeys: 1,
+  lua: tokenBucketScript,
+});
+
+/**
+ * Token Bucket API Rate Limiting Middleware
+ *
+ * - Algorithm: Token Bucket mapping directly to tokens refilled per second
+ * - Identifier: Decoded JWT User ID for authenticated users, falling back to IP Address.
+ * - Concurrency: Handled atomically via Redis Lua script.
+ * - Fail-Safe: If Redis is down, it fails open (allows traffic).
+ *
+ * @param config { RateLimitConfig }
+ */
+export const tokenBucketRateLimiter = (config: RateLimitConfig) => {
+  const { maxTokens, refillRateSec, keyPrefix = "rl:tb" } = config;
+
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      if (redis.status !== "ready") {
+        // Fail Open behavior if Redis is not connected
+        return next();
+      }
+
+      // Identifier: Start with IP Address
+      let identifier = req.ip || "unknown-ip";
+
+      // Attempt to decode the JWT to use User ID as identifier
+      const authHeader = req.headers["authorization"];
+      if (authHeader && authHeader.startsWith("Bearer ")) {
+        const token = authHeader.split(" ")[1];
+        try {
+          // We decode instead of verifying here because
+          // this middleware might run before the auth middleware
+          // and decoding is faster for identifying rate limits per user
+          const decoded = jwt.decode(token) as { id?: string };
+          if (decoded && decoded.id) {
+            identifier = decoded.id;
+          }
+        } catch {
+          // ignore invalid tokens, fallback to IP
+        }
+      }
+
+      const key = `${keyPrefix}:${identifier}`;
+      const nowMs = Date.now();
+      const requested = 1;
+
+      // Executing the predefined Lua Script
+      const [grantedResult, currentTokensResult] = await (
+        redis as RedisWithTokenBucket
+      ).consumeTokenBucket(key, maxTokens, refillRateSec, nowMs, requested);
+
+      const granted = grantedResult === 1;
+      const currentTokens = parseFloat(currentTokensResult);
+      const remaining = Math.max(0, Math.floor(currentTokens));
+
+      // Calculate when the user will have at least 1 token again
+      let resetMs = nowMs;
+      if (!granted && currentTokens < 1) {
+        const tokensNeeded = 1 - currentTokens;
+        resetMs = nowMs + (tokensNeeded / refillRateSec) * 1000;
+      }
+
+      // Inject standard HTTP headers
+      res.setHeader("X-RateLimit-Limit", maxTokens.toString());
+      res.setHeader("X-RateLimit-Remaining", remaining.toString());
+      // X-RateLimit-Reset is typically epoch timestamp in seconds
+      res.setHeader("X-RateLimit-Reset", Math.ceil(resetMs / 1000).toString());
+
+      if (granted) {
+        return next();
+      }
+
+      // Bucket is empty, return HTTP 429 Too Many Requests
+      return res.status(429).json({
+        success: false,
+        error: {
+          code: "too_many_requests",
+          message: "Too many requests. Please try again later.",
+          limit: maxTokens,
+          remaining: remaining,
+          reset_at: Math.ceil(resetMs / 1000),
+        },
+      });
+    } catch (err) {
+      // Fail Open logic: Allow traffic if Lua script fails or Redis throws an error
+      console.error("Token Bucket Rate Limiter Error:", err);
+      // Ensure we haven't already sent headers
+      if (!res.headersSent) {
+        return next();
+      }
+    }
+  };
+};
diff --git a/apps/api/src/routes/auth.routes.ts b/apps/api/src/routes/auth.routes.ts
index 103b0fd..52cc3bc 100644
--- a/apps/api/src/routes/auth.routes.ts
+++ b/apps/api/src/routes/auth.routes.ts
@@ -11,6 +11,8 @@ router.post("/login", authController.login);
 router.post("/refresh", authController.refresh);
 router.post("/forgot-password", authController.forgotPassword);
 router.post("/reset-password", authController.resetPassword);
+router.post("/verify-otp", authController.verifyOtp);
+router.post("/resend-otp", authController.resendOtp);
 
 // Protected
 router.get("/me", authenticateToken, authController.me);
diff --git a/apps/api/src/routes/bot.routes.ts b/apps/api/src/routes/bot.routes.ts
new file mode 100644
index 0000000..a789d38
--- /dev/null
+++ b/apps/api/src/routes/bot.routes.ts
@@ -0,0 +1,25 @@
+import { Router } from "express";
+import { authenticateToken } from "../middleware/auth.js";
+import { BotController } from "../controllers/bot.controller.js";
+
+const router = Router();
+const botController = new BotController();
+
+// Some bot platforms might use callbacks (OAuth)
+// We keep them separate and authenticate if possible, but usually these are handled via state/session.
+// Here we assume authenticateToken works for our flow.
+router.get(
+  "/discord/callback",
+  authenticateToken,
+  botController.handleDiscordCallback,
+);
+
+// Protected management routes
+router.use(authenticateToken);
+
+router.get("/configs", botController.getConfigs);
+router.post("/configs", botController.upsertConfig);
+router.patch("/configs/:id", botController.updateConfig);
+router.post("/configs/:id/test", botController.triggerTestNotification);
+
+export default router;
diff --git a/apps/api/src/routes/chat.routes.ts b/apps/api/src/routes/chat.routes.ts
index ebd0c4b..bc29037 100644
--- a/apps/api/src/routes/chat.routes.ts
+++ b/apps/api/src/routes/chat.routes.ts
@@ -1,6 +1,5 @@
 import { Router } from "express";
 import { authenticateToken } from "../middleware/auth.js";
-import { chatRateLimiter } from "../middleware/strict-rate-limit.js";
 import { ChatController } from "../controllers/chat.controller.js";
 
 const router = Router();
@@ -21,7 +20,7 @@ router.post("/messages/:id/edit", chatController.editMessage);
 router.post("/messages/:id/cancel", chatController.cancelMessage);
 router.get("/messages/:id/versions", chatController.getMessageVersions);
 
-// AI streaming (rate limited)
-router.post("/stream", chatRateLimiter, chatController.streamResponse);
+// AI streaming
+router.post("/stream", chatController.streamResponse);
 
 export default router;
diff --git a/apps/api/src/routes/user.routes.ts b/apps/api/src/routes/user.routes.ts
index cdc4a71..27595eb 100644
--- a/apps/api/src/routes/user.routes.ts
+++ b/apps/api/src/routes/user.routes.ts
@@ -1,10 +1,36 @@
 import { Router } from "express";
+import multer from "multer";
+import path from "path";
 import { UserController } from "../controllers/user.controller.js";
 import { authenticateToken } from "../middleware/auth.js";
 
 const router = Router();
 const userController = new UserController();
 
+// Configure storage for avatars
+const storage = multer.diskStorage({
+  destination: (_req, _file, cb) => {
+    cb(null, "uploads/avatars");
+  },
+  filename: (_req, file, cb) => {
+    const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
+    cb(null, `avatar-${uniqueSuffix}${path.extname(file.originalname)}`);
+  },
+});
+
+const upload = multer({
+  storage,
+  limits: { fileSize: 2 * 1024 * 1024 }, // 2MB
+  fileFilter: (_req, file, cb) => {
+    const allowed = ["image/jpeg", "image/jpg", "image/png", "image/webp"];
+    if (allowed.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error("Invalid file type. Only JPEG, PNG, and WebP are allowed."));
+    }
+  },
+});
+
 router.use(authenticateToken);
 
 // Base profile
@@ -22,4 +48,14 @@ router.patch("/employer-profile", userController.updateEmployerProfile);
 // Subscription status
 router.get("/subscription", userController.getSubscription);
 
+// Security
+router.post("/change-password", userController.changePassword);
+
+// Avatar
+router.post(
+  "/upload-avatar",
+  upload.single("avatar"),
+  userController.uploadAvatar,
+);
+
 export default router;
diff --git a/apps/api/src/server.ts b/apps/api/src/server.ts
index 157b477..3c868d2 100644
--- a/apps/api/src/server.ts
+++ b/apps/api/src/server.ts
@@ -2,6 +2,9 @@ import express from "express";
 import cors from "cors";
 import helmet from "helmet";
 import rateLimit from "express-rate-limit";
+import { tokenBucketRateLimiter } from "./middleware/token-bucket-rate-limit.js";
+import { pool } from "@postly/database";
+import { logger } from "@postly/logger";
 import { API_PORT, WEB_URL, NODE_ENV } from "./config/secrets.js";
 import { errorHandler } from "./middleware/error-handler.js";
 import { notFoundHandler } from "./middleware/not-found.js";
@@ -10,12 +13,20 @@ import userRoutes from "./routes/user.routes.js";
 import jobRoutes from "./routes/job.routes.js";
 import resumeRoutes from "./routes/resume.routes.js";
 import chatRoutes from "./routes/chat.routes.js";
-import discordRoutes from "./routes/discord.routes.js";
+import botRoutes from "./routes/bot.routes.js";
 import dodoRoutes from "./routes/dodo.routes.js";
 import applicationRoutes from "./routes/application.routes.js";
 import { queueService } from "./services/queue.service.js";
 
 const app = express();
+app.set("trust proxy", 1);
+
+import { redis as healthRedis } from "./lib/redis.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 // Security middleware
 app.use(
@@ -58,49 +69,103 @@ app.use(
   }),
 );
 
-const globalLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 100,
+const aiRateLimiter = tokenBucketRateLimiter({
+  maxTokens: 50,
+  refillRateSec: 5, // 5 tokens per second refill
+  keyPrefix: "rl:ai",
+});
+
+const apiRateLimiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 100, // limit each IP to 100 requests per windowMs
   standardHeaders: true,
   legacyHeaders: false,
   message: {
     success: false,
-    error: { message: "Too many requests, please try again later" },
+    error: { message: "Too many requests, please try again later." },
   },
 });
 
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 50,
+const healthRateLimiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 30, // limit each IP to 30 requests per minute
   standardHeaders: true,
   legacyHeaders: false,
   message: {
     success: false,
-    error: {
-      message: "Too many authentication attempts, please try again later",
-    },
+    error: { message: "Health check rate limit exceeded." },
   },
 });
 
-app.use(globalLimiter);
+// Health check — rate limited to prevent DB/Redis connection exhaustion
+app.get("/health", healthRateLimiter, async (_req, res) => {
+  const checks: Record<string, string> = {};
+
+  // Check Postgres
+  try {
+    await pool.query("SELECT 1");
+    checks.db = "ok";
+  } catch {
+    checks.db = "failed";
+  }
+
+  // Check Redis
+  try {
+    await healthRedis.ping();
+    checks.redis = "ok";
+  } catch {
+    checks.redis = "failed";
+  }
+
+  const allHealthy = checks.db === "ok" && checks.redis === "ok";
+  res.status(allHealthy ? 200 : 503).json({
+    status: allHealthy ? "ok" : "degraded",
+    checks,
+    uptime: process.uptime(),
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// Apply global API rate limit (Standard Window)
+app.use(apiRateLimiter);
 
 app.use(express.json({ limit: "10mb" }));
 app.use(express.urlencoded({ extended: true, limit: "10mb" }));
 
-app.get("/health", (_req, res) => {
-  res.json({ status: "ok", timestamp: new Date().toISOString() });
+// Request logging middleware (structured for production log aggregation)
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    // Only log in production or for slow requests
+    if (NODE_ENV === "production" || duration > 1000) {
+      logger.info("request", {
+        method: req.method,
+        url: req.url,
+        status: res.statusCode,
+        duration_ms: duration,
+        user_id:
+          (req as unknown as Request & { user?: { id: string } }).user?.id ||
+          null,
+      });
+    }
+  });
+  next();
 });
 
 // API routes
-app.use("/api/v1/auth", authLimiter, authRoutes);
+app.use("/api/v1/auth", authRoutes);
 app.use("/api/v1/users", userRoutes);
 app.use("/api/v1/jobs", jobRoutes);
-app.use("/api/v1/resumes", resumeRoutes);
-app.use("/api/v1/chat", chatRoutes);
-app.use("/api/v1/discord", discordRoutes);
+app.use("/api/v1/resumes", aiRateLimiter, resumeRoutes);
+app.use("/api/v1/chat", aiRateLimiter, chatRoutes);
+app.use("/api/v1/bots", botRoutes);
 app.use("/api/v1/payments", dodoRoutes);
 app.use("/api/v1/applications", applicationRoutes);
 
+// Static files
+app.use("/uploads", express.static(path.join(__dirname, "../uploads")));
+
 // Error handling
 app.use(notFoundHandler);
 app.use(errorHandler);
@@ -110,37 +175,23 @@ app.listen(API_PORT, "0.0.0.0", async () => {
   console.log(`🚀 API server running on http://0.0.0.0:${API_PORT}`);
   console.log(`📝 Environment: ${NODE_ENV}`);
 
-  // Initialize Discord Job Queue
+  // Initialize Bot Job Queue
   try {
     await queueService.initDailyCron();
-    // Schedule daily dispatch at 9:00 AM UTC
-    const now = new Date();
-    const target = new Date(now);
-    target.setUTCHours(9, 0, 0, 0);
-    if (target <= now) target.setDate(target.getDate() + 1);
-    const msUntilFirst = target.getTime() - now.getTime();
-    const DAY_MS = 24 * 60 * 60 * 1000;
-
-    setTimeout(() => {
-      queueService.dispatchAll();
-      setInterval(() => queueService.dispatchAll(), DAY_MS);
-    }, msUntilFirst);
-
-    console.log(`📅 Discord daily job dispatch cron initialized (9:00 AM)`);
   } catch (err) {
-    console.error("Failed to initialize Discord Queue:", err);
+    console.error("Failed to initialize Bot Queue:", err);
   }
 });
 
-// Graceful shutdown
-process.on("SIGTERM", () => {
-  console.log("SIGTERM received, shutting down gracefully...");
+// Graceful shutdown — close all connections before exiting
+const shutdown = async (signal: string) => {
+  logger.info(`${signal} received, shutting down gracefully...`);
+  healthRedis.disconnect();
+  await pool.end();
   process.exit(0);
-});
+};
 
-process.on("SIGINT", () => {
-  console.log("SIGINT received, shutting down gracefully...");
-  process.exit(0);
-});
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
 
 export default app;
diff --git a/apps/api/src/services/cache.service.ts b/apps/api/src/services/cache.service.ts
new file mode 100644
index 0000000..ac052fa
--- /dev/null
+++ b/apps/api/src/services/cache.service.ts
@@ -0,0 +1,116 @@
+import { redis } from "../lib/redis.js";
+
+/**
+ * Standardized Cache Service
+ * Provides generic cache-aside wrapping with graceful degradation.
+ */
+export class CacheService {
+  private static readonly APP_NAME = "postly";
+  private static readonly VERSION = "v1";
+
+  /**
+   * Generates a namespaced, standardized key to prevent collisions.
+   * Format: app_name:version:entity:id
+   *
+   * @example
+   * CacheService.generateKey('user', '123') // => "postly:v1:user:123"
+   */
+  public static generateKey(entity: string, id: string | number): string {
+    return `${this.APP_NAME}:${this.VERSION}:${entity}:${id}`;
+  }
+
+  /**
+   * Generic Cache-Aside Wrapper (Fail-Open)
+   *
+   * Attempts to fetch data from the KV store. On miss or redis error,
+   * falls back to the provided `fetchFunction`, caches the result,
+   * and returns the data.
+   *
+   * @param key Fully qualified cache key (use `generateKey` for consistency).
+   * @param ttlSeconds Time-to-live in seconds.
+   * @param fetchFunction Async function to execute on cache miss (e.g. DB query).
+   * @returns The cached or freshly fetched data.
+   */
+  public static async getOrSet<T>(
+    key: string,
+    ttlSeconds: number,
+    fetchFunction: () => Promise<T>,
+  ): Promise<T> {
+    try {
+      // 1. Check Redis for existing data
+      const cachedData = await redis.get(key);
+      if (cachedData) {
+        return JSON.parse(cachedData) as T;
+      }
+    } catch (error) {
+      // Log warning but DO NOT crash (Graceful Degradation)
+      console.warn(`[CacheService] Redis GET failed for key "${key}":`, error);
+    }
+
+    // 2. On miss (or Redis failure), execute the source DB query
+    const freshData = await fetchFunction();
+
+    // 3. Attempt to save the fresh data to the cache
+    try {
+      // Only cache non-null/non-undefined results
+      if (freshData !== undefined && freshData !== null) {
+        // Run SET asynchronously to not block returning the response
+        redis.setex(key, ttlSeconds, JSON.stringify(freshData)).catch((err) => {
+          console.warn(
+            `[CacheService] Background Redis SETEX failed for key "${key}":`,
+            err,
+          );
+        });
+      }
+    } catch (error) {
+      console.warn(
+        `[CacheService] Redis SETEX synchronous error for key "${key}":`,
+        error,
+      );
+    }
+
+    // 4. Return data immediately
+    return freshData;
+  }
+
+  /**
+   * Invalidates a specific key.
+   */
+  public static async invalidate(key: string): Promise<void> {
+    try {
+      await redis.del(key);
+    } catch (error) {
+      console.warn(`[CacheService] Redis DEL failed for key "${key}":`, error);
+    }
+  }
+
+  /**
+   * Invalidates all keys matching a pattern using a non-blocking SCAN operation.
+   *
+   * @example CacheService.invalidatePattern('postly:v1:user:*')
+   */
+  public static async invalidatePattern(pattern: string): Promise<void> {
+    try {
+      let cursor = "0";
+      do {
+        // Scan in chunks of 100 to avoid blocking the Redis event loop
+        const [nextCursor, matchingKeys] = await redis.scan(
+          cursor,
+          "MATCH",
+          pattern,
+          "COUNT",
+          "100",
+        );
+        cursor = nextCursor;
+        if (matchingKeys.length > 0) {
+          await redis.del(...matchingKeys);
+        }
+      } while (cursor !== "0");
+    } catch (error) {
+      console.warn(
+        `[CacheService] Redis pattern invalidation failed for "${pattern}":`,
+        error,
+      );
+    }
+  }
+}
diff --git a/apps/api/src/services/chat.service.ts b/apps/api/src/services/chat.service.ts
index a05bf1b..d72f0bb 100644
--- a/apps/api/src/services/chat.service.ts
+++ b/apps/api/src/services/chat.service.ts
@@ -3,6 +3,7 @@ import {
   conversationQueries,
   resumeQueries,
   jobQueries,
+  userQueries,
 } from "@postly/database";
 import { matchingService } from "./matching.service.js";
 import type {
@@ -18,6 +19,80 @@ interface MatchedJob extends Job {
   ai_explanation?: string;
 }
 
+interface JobIntent {
+  isRelated: boolean;
+  isSpecific: boolean;
+  techKeywords: string[];
+  allKeywords: string[];
+}
+
+/**
+ * More precise intent detection for job-related queries
+ */
+function getJobIntent(message: string): JobIntent {
+  const lowercaseMsg = message.toLowerCase();
+
+  // Universal job related terms (not just tech)
+  const jobKeywords = [
+    "job",
+    "career",
+    "hiring",
+    "opportunity",
+    "opening",
+    "position",
+    "vacancy",
+    "work",
+    "hire",
+    "recruiting",
+    "talent",
+    "apply",
+    "application",
+    "resume",
+    "cv",
+    "salary",
+    "role",
+    "looking for",
+    "hunting",
+    "find",
+    "search",
+    "offer",
+    "interview",
+    "employer",
+    "company",
+    "staff",
+    "manager",
+    "engineer",
+    "designer",
+    "architect",
+    "developer",
+    "sales",
+    "marketing",
+    "doctor",
+    "nurse",
+    "teacher",
+    "driver",
+    "chef",
+    "accounting",
+    "legal",
+    "retail",
+    "remote",
+    "hybrid",
+    "fullstack",
+    "frontend",
+    "backend",
+  ];
+
+  const foundKeywords = jobKeywords.filter((kw) => lowercaseMsg.includes(kw));
+
+  return {
+    isRelated: foundKeywords.length > 0 || message.length > 50,
+    isSpecific: foundKeywords.length > 2, // A heuristic for specific queries
+    techKeywords: [], // Deprecated: keep for type compatibility
+    allKeywords: foundKeywords,
+  };
+}
+// ... (omitting helper for brevity in diff)
+
 // Helper to transform raw job data to UI-ready format
 function toOptimizedJobMatch(job: MatchedJob): OptimizedJobMatch {
   const formatSalary = (min?: number, max?: number): string | undefined => {
@@ -69,15 +144,17 @@ export class ChatService {
         userMessage,
       );
 
-      // 2. Get conversation context
-      const conversation = await conversationQueries.findById(
-        conversationId,
-        userId,
-      );
+      // 2. Get conversation context and user context
+      const [conversation, user] = await Promise.all([
+        conversationQueries.findById(conversationId, userId),
+        userQueries.findById(userId),
+      ]);
       if (!conversation) {
         throw new Error("Conversation not found");
       }
 
+      const userRole = user?.roles[0] || "job_seeker";
+
       const messages = await conversationQueries.getMessages(conversationId);
 
       // 3. Determine which resume to use (parameter takes priority)
@@ -86,21 +163,28 @@ export class ChatService {
       // 4. Load resume context and job matches if available
       let resumeContext = "";
       let jobMatches: MatchedJob[] = [];
+      const intent = getJobIntent(userMessage);
 
       if (effectiveResumeId) {
         const resume = await resumeQueries.findById(effectiveResumeId);
         if (resume?.parsed_text) {
           resumeContext = `\n\nUser's Resume Summary:\n- Skills: ${resume.skills?.join(", ") || "Not specified"}\n- Experience: ${resume.experience_years || 0} years\n- Summary: ${resume.parsed_text.substring(0, 1000)}`;
 
-          // Find matching jobs based on resume
-          try {
-            jobMatches = await matchingService.findMatchingJobs(
-              effectiveResumeId,
-              userId,
-              5, // Limit to top 5
-            );
-          } catch (err) {
-            console.error("Failed to fetch job matches:", err);
+          // Find matching jobs based on resume ONLY if not employer AND intent is related
+          if (
+            userRole !== "employer" &&
+            userRole !== "admin" &&
+            intent.isRelated
+          ) {
+            try {
+              jobMatches = await matchingService.findMatchingJobs(
+                effectiveResumeId,
+                userId,
+                5, // Limit to top 5
+              );
+            } catch (err) {
+              console.error("Failed to fetch job matches:", err);
+            }
           }
         }
 
@@ -111,7 +195,13 @@ export class ChatService {
       }
 
       // 4b. FALLBACK: If no resume or no matches, fetch recent active jobs
-      if (jobMatches.length === 0) {
+      // Only do this if the user is not an employer AND intent is related
+      if (
+        jobMatches.length === 0 &&
+        userRole !== "employer" &&
+        userRole !== "admin" &&
+        intent.isRelated
+      ) {
         try {
           const recentJobs = await jobQueries.findActive(undefined, 5, 0);
           jobMatches = recentJobs.map((job: Job) => ({
@@ -123,6 +213,30 @@ export class ChatService {
         }
       }
 
+      // 4c. FILTER: If intent is specific, ensure matches are actually relevant.
+      // If user specified tech keywords, at least one must match.
+      // Otherwise, at least one level/general keyword must match.
+      if (intent.isSpecific && jobMatches.length > 0) {
+        jobMatches = jobMatches.filter((job) => {
+          const searchSpace = (
+            (job.title || "") +
+            " " +
+            (job.description || "") +
+            " " +
+            (job.skills_required?.join(" ") || "")
+          ).toLowerCase();
+
+          if (intent.techKeywords.length > 0) {
+            return intent.techKeywords.some((kw: string) =>
+              searchSpace.includes(kw),
+            );
+          }
+          return intent.allKeywords.some((kw: string) =>
+            searchSpace.includes(kw),
+          );
+        });
+      }
+
       // 5. Build system prompt with job context
       let jobContext = "";
       if (jobMatches.length > 0) {
@@ -135,21 +249,33 @@ export class ChatService {
           .join("\n")}`;
       }
 
-      const systemPrompt = `You are an AI career assistant helping with resume analysis and job search.
+      let roleSpecificInstructions = "";
+      if (userRole === "employer") {
+        roleSpecificInstructions =
+          "You are an AI assistant helping an employer looking to hire candidates. Your ONLY function is to help with hiring, evaluating candidates, and posting jobs.";
+      } else {
+        roleSpecificInstructions =
+          "You are an AI career assistant helping with resume analysis and job search.";
+      }
 
+      const systemPrompt = `${roleSpecificInstructions}
+${
+  userRole !== "employer"
+    ? `
 Your capabilities:
 - Analyze resumes and provide constructive feedback
 - Suggest relevant job opportunities from our database
 - Offer career advice and interview tips
 - Help with job applications
-
+`
+    : ""
+}
 IMPORTANT INSTRUCTIONS:
-1. When the user asks for jobs, ALWAYS reference the jobs listed below if any are available. These are REAL jobs from our database.
-2. Summarize the available jobs briefly and let the user know they can see the full details in the job cards.
-3. DO NOT invent or hallucinate job listings. Only mention jobs that are explicitly listed in "Available job opportunities" or "Matching job opportunities" section below.
-4. If no jobs are listed below, inform the user that no jobs are currently available in our database.
+1. ${userRole === "employer" ? "Focus STRICTLY on helping the employer with hiring. UNDER NO CIRCUMSTANCES should you suggest, mention, or offer job listings, career advice, or job search help to an employer. If asked for jobs, politely clarify your role." : "When the user explicitly asks for jobs or career opportunities, reference the jobs listed below. If they just say 'hi' or make small talk, respond conversationally without bringing up jobs."}
+2. DO NOT invent or hallucinate facts.
+${userRole !== "employer" ? "3. DO NOT hallucinate job listings. Only mention jobs explicitly listed in the context below.\n4. If the user asks for jobs and none are listed, inform the user that no jobs are currently available." : ""}
 
-Be professional, encouraging, and concise.${resumeContext}${jobContext}`;
+Be professional, encouraging, and concise.${resumeContext}${userRole !== "employer" ? jobContext : ""}`;
 
       // 6. Prepare conversation history
       const conversationHistory = messages
@@ -187,7 +313,8 @@ Be professional, encouraging, and concise.${resumeContext}${jobContext}`;
         conversationId,
         "assistant",
         fullResponse,
-        metadata as Record<string, unknown>,
+        metadata.usage?.total_tokens,
+        metadata,
       );
 
       // 9. Auto-generate conversation title if this is the first message
diff --git a/apps/api/src/services/queue.service.ts b/apps/api/src/services/queue.service.ts
index afdc1eb..6b0cd66 100644
--- a/apps/api/src/services/queue.service.ts
+++ b/apps/api/src/services/queue.service.ts
@@ -1,14 +1,14 @@
 import { Queue } from "bullmq";
 import { REDIS_URL } from "../config/secrets.js";
-import { db, discord_configs, eq } from "@postly/database";
+import { db, bot_configs, eq } from "@postly/database";
 
-const DISCORD_QUEUE_NAME = "discord_notifications";
+const BOT_QUEUE_NAME = "bot_notifications";
 
 export class QueueService {
-  private discordQueue: Queue;
+  private botQueue: Queue;
 
   constructor() {
-    this.discordQueue = new Queue(DISCORD_QUEUE_NAME, {
+    this.botQueue = new Queue(BOT_QUEUE_NAME, {
       connection: {
         url: REDIS_URL || "redis://localhost:6379",
       },
@@ -16,17 +16,12 @@ export class QueueService {
   }
 
   /**
-   * Initializes the daily cron that dispatches job alerts to all active Discord servers.
+   * Initializes the daily cron that dispatches job alerts to all active bot integrations.
    * Runs every day at 9:00 AM UTC.
-   *
-   * Instead of using an intermediate "daily_job_dispatch" job that requires
-   * a Node.js Worker to process, this directly queries active configs and
-   * enqueues one `send_discord_message` job per server — which the Python
-   * bot worker picks up via Redis.
    */
   initDailyCron = async () => {
     // Use a repeatable job that fires at 9 AM daily
-    await this.discordQueue.add(
+    await this.botQueue.add(
       "daily_job_dispatch",
       { trigger: "cron" },
       {
@@ -37,41 +32,66 @@ export class QueueService {
         removeOnFail: 5,
       },
     );
-    console.log("📅 Discord daily job dispatch cron initialized (9:00 AM)");
+    console.log("📅 Bot daily job dispatch cron initialized (9:00 AM)");
   };
 
   /**
-   * Dispatch job alerts for all active guilds.
+   * Dispatch job alerts for all active bot configurations.
    * Called by the cron handler or manually.
    */
   dispatchAll = async () => {
     const activeConfigs = await db
       .select()
-      .from(discord_configs)
-      .where(eq(discord_configs.is_active, true));
+      .from(bot_configs)
+      .where(eq(bot_configs.is_active, true));
 
     let queued = 0;
     for (const config of activeConfigs) {
-      if (config.channel_id) {
-        await this.dispatchForGuild(config.guild_id, config.channel_id);
-        queued++;
-      }
+      await this.dispatchForPlatform(config.id);
+      queued++;
     }
     console.log(
-      `✅ Queued job alerts for ${queued}/${activeConfigs.length} servers.`,
+      `✅ Queued job alerts for ${queued}/${activeConfigs.length} bot integrations.`,
     );
     return queued;
   };
 
   /**
-   * Manually trigger a dispatch for a single server (e.g. for testing).
+   * Manually trigger a dispatch for a single bot config (e.g. for testing).
    */
+  dispatchForPlatform = async (configId: string) => {
+    const [config] = await db
+      .select()
+      .from(bot_configs)
+      .where(eq(bot_configs.id, configId))
+      .limit(1);
+
+    if (!config) return;
+
+    await this.botQueue.add(
+      "send_bot_message",
+      {
+        config_id: config.id,
+        platform: config.platform,
+        target_id: config.target_id,
+        webhook_url: config.webhook_url,
+        timestamp: new Date().toISOString(),
+      },
+      {
+        removeOnComplete: true,
+        removeOnFail: 3,
+      },
+    );
+    console.log(`✅ Job dispatched for ${config.platform} config: ${configId}`);
+  };
+
   dispatchForGuild = async (guildId: string, channelId: string) => {
-    await this.discordQueue.add(
+    await this.botQueue.add(
       "send_discord_message",
       {
         guild_id: guildId,
         channel_id: channelId,
+        type: "test",
         timestamp: new Date().toISOString(),
       },
       {
@@ -79,7 +99,6 @@ export class QueueService {
         removeOnFail: 3,
       },
     );
-    console.log(`✅ Job dispatched for guild: ${guildId}`);
   };
 }
 
diff --git a/apps/api/src/services/resume.service.ts b/apps/api/src/services/resume.service.ts
index e767e75..b950241 100644
--- a/apps/api/src/services/resume.service.ts
+++ b/apps/api/src/services/resume.service.ts
@@ -5,9 +5,7 @@ import type {
   ResumeAnalysis,
   EducationEntry,
 } from "@postly/shared-types";
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-const pdfParse = require("pdf-parse");
+import { PDFParse } from "pdf-parse";
 import mammoth from "mammoth";
 
 export class ResumeService {
@@ -40,8 +38,10 @@ export class ResumeService {
    * Parse PDF file
    */
   private async parsePDF(buffer: Buffer): Promise<string> {
-    const data = await pdfParse(buffer);
-    return data.text.trim();
+    // Use the class-based API for pdf-parse v2
+    const parser = new PDFParse({ data: buffer });
+    const result = await parser.getText();
+    return result.text.trim();
   }
 
   /**
diff --git a/apps/scraper/execute_smoke.py b/apps/scraper/execute_smoke.py
new file mode 100644
index 0000000..0e6ba66
--- /dev/null
+++ b/apps/scraper/execute_smoke.py
@@ -0,0 +1,16 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+async def _smoke_test_browser():
+    try:
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=False, channel="chrome")
+            page = await browser.new_page()
+            await page.goto("https://example.com", wait_until="domcontentloaded")
+            await browser.close()
+            print("SMOKE TEST PASSED: Bare Chromium works fine")
+    except Exception as e:
+        print(f"SMOKE TEST FAILED: {e}")
+
+if __name__ == '__main__':
+    asyncio.run(_smoke_test_browser())
diff --git a/apps/scraper/requirements.txt b/apps/scraper/requirements.txt
index 78ebfa3..0274f7a 100644
--- a/apps/scraper/requirements.txt
+++ b/apps/scraper/requirements.txt
@@ -22,3 +22,4 @@ colorlog==6.8.2
 pytest==8.0.2
 pytest-asyncio==0.23.5
 playwright==1.41.0
+playwright-stealth==2.0.2
diff --git a/apps/scraper/src/__init__.py b/apps/scraper/src/__init__.py
index 2e74e79..33ff99a 100644
--- a/apps/scraper/src/__init__.py
+++ b/apps/scraper/src/__init__.py
@@ -2,11 +2,12 @@
 """
 Postly Job Scraper Package
 
-Production-grade job aggregator for hiring.cafe:
+Production-grade multi-source job aggregator:
+- Sources: Remotive, Arbeitnow, Greenhouse ATS, hiring.cafe
 - Voyage AI embeddings (768-dim, matches Drizzle schema)
-- Source-URL-based deduplication
-- aiohttp async spiders
+- Source-URL-based deduplication across all sources
+- aiohttp async spiders (API-first) + Playwright (hiring.cafe fallback)
 - Structured JSON logging
 """
 
-__version__ = "2.1.0"
+__version__ = "3.0.0"
diff --git a/apps/scraper/src/database.py b/apps/scraper/src/database.py
index 2f7aab9..c80e58d 100644
--- a/apps/scraper/src/database.py
+++ b/apps/scraper/src/database.py
@@ -3,15 +3,21 @@
 database.py
 Database layer writing to the Drizzle-managed `jobs` table.
 
-Schema is managed by Drizzle migrations — this module does NOT create tables.
-It only performs INSERT/UPDATE/SELECT/DELETE operations on the existing schema.
+CHANGELOG:
+- Added format_vector from utils to safely format pgvector strings
+- Added index creation for source_url on startup
+- Replaced str() embedding conversions with format_vector()
+- Added get_existing_urls() for fast, targeted duplicate filtering
+- Fixed remove_duplicates() to delete the older record using created_at 
 """
 
 import logging
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Set
 import asyncpg
 from datetime import datetime, timezone
 
+from utils import format_vector
+
 logger = logging.getLogger(__name__)
 
 
@@ -42,7 +48,7 @@ async def connect(self):
             )
             logger.info("Database connection pool created")
 
-            # Verify the jobs table exists
+            # Verify the jobs table exists and set up index
             async with self.pool.acquire() as conn:
                 exists = await conn.fetchval("""
                     SELECT EXISTS(
@@ -54,7 +60,13 @@ async def connect(self):
                     raise RuntimeError(
                         "Table 'jobs' does not exist — run Drizzle migrations first"
                     )
-                logger.info("Verified jobs table exists")
+                
+                # Add index on source_url for O(1) existence checks during batch dedup
+                await conn.execute("""
+                    CREATE INDEX IF NOT EXISTS idx_jobs_source_url ON jobs(source_url);
+                """)
+                
+                logger.info("Verified jobs table exists and source_url index is ready")
 
         except Exception as e:
             logger.error(f"Failed to connect to database: {e}")
@@ -107,7 +119,7 @@ async def insert_job(self, job_data: Dict[str, Any]) -> bool:
                     job_data.get("posted_at"),
                     job_data.get("expires_at"),
                     job_data.get("is_active", True),
-                    str(job_data.get("embedding")) if job_data.get("embedding") else None,
+                    format_vector(job_data.get("embedding")),
                 )
                 return True
         except asyncpg.exceptions.UniqueViolationError:
@@ -158,7 +170,7 @@ async def insert_jobs_batch(self, jobs: List[Dict[str, Any]]) -> int:
                             job.get("posted_at"),
                             job.get("expires_at"),
                             job.get("is_active", True),
-                            str(job.get("embedding")) if job.get("embedding") else None,
+                            format_vector(job.get("embedding")),
                         )
                         inserted += 1
                     except Exception as e:
@@ -188,7 +200,7 @@ async def update_embedding(self, job_id: str, embedding: List[float]):
                 UPDATE jobs
                 SET embedding = $1::vector, updated_at = NOW()
                 WHERE id = $2
-            """, embedding, job_id)
+            """, format_vector(embedding), job_id)
 
     async def update_embeddings_batch(self, updates: List[tuple]):
         """Batch update embeddings. Each tuple is (job_id, embedding_list)."""
@@ -200,12 +212,7 @@ async def update_embeddings_batch(self, updates: List[tuple]):
             async with conn.transaction():
                 for job_id, emb in updates:
                     try:
-                        # Convert Python list to pgvector string format: '[0.01,0.02,...]'
-                        if isinstance(emb, list):
-                            vec_str = '[' + ','.join(str(v) for v in emb) + ']'
-                        else:
-                            vec_str = str(emb)
-
+                        vec_str = format_vector(emb)
                         await conn.execute("""
                             UPDATE jobs
                             SET embedding = $2::vector, updated_at = NOW()
@@ -294,6 +301,45 @@ async def get_existing_source_urls(self, source: str = "hiring_cafe") -> set:
             """, source)
             return {row["source_url"] for row in rows if row["source_url"]}
 
+    async def get_existing_urls(self, urls: List[str]) -> Set[str]:
+        """Check which of the provided URLs already exist in the database."""
+        if not urls:
+            return set()
+            
+        async with self.pool.acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT source_url FROM jobs WHERE source_url = ANY($1)
+            """, urls)
+            return {row["source_url"] for row in rows if row["source_url"]}
+
+    async def get_all_source_ids(self) -> Set[str]:
+        """Fetch all known source_urls for skipping already-scraped jobs across all sources."""
+        async with self.pool.acquire() as conn:
+            rows = await conn.fetch(
+                "SELECT source_url, source FROM jobs WHERE source_url IS NOT NULL"
+            )
+            ids = set()
+            for row in rows:
+                url = row["source_url"]
+                source = row["source"]
+                # Add the full URL for general dedup
+                ids.add(url)
+                # For hiring.cafe, also extract the requisition_id suffix
+                if source == "hiring_cafe" and "/viewjob/" in url:
+                    ids.add(url.split("/viewjob/")[-1].split("/")[0])
+                # For greenhouse, add the gh-{board}-{id} key
+                elif source == "greenhouse":
+                    # URL format: https://boards.greenhouse.io/{board}/jobs/{id}
+                    parts = url.rstrip("/").split("/")
+                    if len(parts) >= 2:
+                        try:
+                            gh_id = parts[-1]
+                            board = parts[-3] if len(parts) >= 4 else ""
+                            ids.add(f"gh-{board}-{gh_id}")
+                        except (IndexError, ValueError):
+                            pass
+        return ids
+
     # ─── CLEANUP ──────────────────────────────────────────────────
 
     async def cleanup_old_jobs(self, days: int = 30) -> int:
@@ -317,26 +363,28 @@ async def cleanup_expired_jobs(self) -> int:
             return count
 
     async def deactivate_stale_jobs(self, days: int = 14) -> int:
-        """Mark jobs as inactive if not refreshed recently."""
+        """Mark jobs as inactive if not refreshed recently (across all sources)."""
         async with self.pool.acquire() as conn:
             result = await conn.execute("""
                 UPDATE jobs
                 SET is_active = FALSE, updated_at = NOW()
                 WHERE updated_at < NOW() - MAKE_INTERVAL(days => $1)
                     AND is_active = TRUE
-                    AND source = 'hiring_cafe'
             """, days)
             count = int(result.split()[-1])
             logger.info(f"Deactivated {count} stale jobs (> {days} days)")
             return count
 
     async def remove_duplicates(self) -> int:
-        """Remove duplicate jobs based on identical description."""
+        """Remove duplicate jobs based on identical source_url."""
         async with self.pool.acquire() as conn:
             result = await conn.execute("""
+                -- Explaining decision: using created_at to preserve the new scrape data. 
+                -- We delete the OLDER record (smaller created_at) when duplicate URLs exist
+                -- because id is a UUID type which cannot be ordered reliably by comparison operator.
                 DELETE FROM jobs a USING jobs b
-                WHERE a.id > b.id
-                AND a.description = b.description
+                WHERE a.created_at < b.created_at
+                AND a.source_url = b.source_url
                 AND a.source = b.source
             """)
             count = int(result.split()[-1])
@@ -358,9 +406,11 @@ async def get_stats(self) -> Dict[str, Any]:
             stats["remote_jobs"] = await conn.fetchval(
                 "SELECT COUNT(*) FROM jobs WHERE remote = TRUE"
             )
-            stats["hiring_cafe_jobs"] = await conn.fetchval(
-                "SELECT COUNT(*) FROM jobs WHERE source = 'hiring_cafe'"
+            # Per-source breakdown
+            source_rows = await conn.fetch(
+                "SELECT source, COUNT(*) as cnt FROM jobs GROUP BY source"
             )
+            stats["by_source"] = {row["source"]: row["cnt"] for row in source_rows}
             return stats
 
     async def close(self):
diff --git a/apps/scraper/src/embedding_service.py b/apps/scraper/src/embedding_service.py
index 7abca0e..9e36562 100644
--- a/apps/scraper/src/embedding_service.py
+++ b/apps/scraper/src/embedding_service.py
@@ -103,46 +103,81 @@ async def _rate_limit(self):
     
     def _prepare_text(self, job: Dict[str, Any]) -> str:
         """
-        Prepare weighted text for embedding.
-        
-        Uses weighted field merging for better embedding quality:
-        - Job title (30%) - repeated for emphasis
-        - Skills (25%)
-        - Description (30%) - truncated
-        - Industry (10%)
-        - Company (5%)
+        Prepare comprehensive weighted text for embedding.
+        
+        Reads ALL available job fields for richer vector search:
+        - Job title (high weight — repeated 3x)
+        - Skills (high weight — repeated 2x)
+        - Description (medium weight — truncated to 3000 chars)
+        - Location, job type, remote status (medium weight)
+        - Salary range, experience (low-medium weight)
+        - Company name, industry (low weight)
+        
+        This produces embeddings that capture the full context of a job,
+        enabling more accurate vector search for queries like:
+        "remote React developer in New York $120k+"
         """
         parts = []
         
-        # Job title (high weight - repeat 3x)
-        title = job.get('job_title', '')
+        # Job title (high weight — repeat 3x for emphasis)
+        title = job.get('job_title', '') or job.get('title', '')
         if title:
-            parts.extend([title] * 3)
+            parts.extend([f"Job Title: {title}"] * 3)
         
-        # Skills (medium-high weight)
+        # Skills (high weight — repeated 2x)
         skills = job.get('skills_required', [])
         if skills:
             if isinstance(skills, list):
-                skills_text = ', '.join(skills)
+                skills_text = ', '.join(str(s) for s in skills)
             else:
                 skills_text = str(skills)
-            parts.extend([skills_text] * 2)
+            parts.extend([f"Skills: {skills_text}"] * 2)
         
-        # Description (high weight but truncate)
-        description = job.get('job_description', '')
+        # Description (medium-high weight, truncated)
+        description = job.get('job_description', '') or job.get('description', '')
         if description:
-            # Take first 3000 chars to stay within token limits
             parts.append(description[:3000])
         
+        # Location (important for geo-based search)
+        location = job.get('location', '')
+        if location:
+            parts.append(f"Location: {location}")
+        
+        # Remote status (critical for modern job search)
+        remote = job.get('remote', False)
+        if remote:
+            parts.append("Work Type: Remote, Work from home, WFH")
+        
+        # Job type (full-time, part-time, contract, etc.)
+        job_type = job.get('job_type', '')
+        if job_type:
+            parts.append(f"Employment Type: {job_type}")
+        
+        # Salary range (important for salary-based queries)
+        salary_min = job.get('salary_min')
+        salary_max = job.get('salary_max')
+        if salary_min or salary_max:
+            salary_parts = []
+            if salary_min:
+                salary_parts.append(f"${salary_min:,.0f}" if isinstance(salary_min, (int, float)) else f"${salary_min}")
+            if salary_max:
+                salary_parts.append(f"${salary_max:,.0f}" if isinstance(salary_max, (int, float)) else f"${salary_max}")
+            parts.append(f"Salary Range: {' - '.join(salary_parts)} per year")
+        
+        # Experience level
+        experience = job.get('experience_required', '')
+        if experience:
+            parts.append(f"Experience Required: {experience}")
+        
+        # Company name (low weight)
+        company = job.get('company_name', '') or job.get('company', '')
+        if company:
+            parts.append(f"Company: {company}")
+        
         # Industry (low weight)
         industry = job.get('industry', '')
         if industry:
-            parts.append(industry)
-        
-        # Company (lowest weight)
-        company = job.get('company_name', '')
-        if company:
-            parts.append(company)
+            parts.append(f"Industry: {industry}")
         
         combined = '\n'.join(parts)
         
diff --git a/apps/scraper/src/health.py b/apps/scraper/src/health.py
index 1693719..eceb340 100644
--- a/apps/scraper/src/health.py
+++ b/apps/scraper/src/health.py
@@ -29,6 +29,7 @@ def __init__(self, port: int = 8080):
             "database_connected": False,
             "last_scrape": None,
             "jobs_in_db": 0,
+            "consecutive_failures": 0,
             "errors": [],
         }
 
@@ -40,13 +41,17 @@ def __init__(self, port: int = 8080):
     async def health_check(self, request) -> web.Response:
         """Liveness probe."""
         uptime = (datetime.utcnow() - self.start_time).total_seconds()
+        consecutive_failures = self.status.get("consecutive_failures", 0)
+        is_healthy = self.status["healthy"] and consecutive_failures < 3
+        
         return web.json_response(
             {
-                "status": "healthy" if self.status["healthy"] else "unhealthy",
+                "status": "healthy" if is_healthy else "unhealthy",
                 "uptime_seconds": uptime,
+                "consecutive_failures": consecutive_failures,
                 "timestamp": datetime.utcnow().isoformat(),
             },
-            status=200 if self.status["healthy"] else 503,
+            status=200 if is_healthy else 503,
         )
 
     async def readiness_check(self, request) -> web.Response:
@@ -104,9 +109,14 @@ async def start(self):
             logger.error(f"Failed to start health server: {e}")
 
     async def stop(self):
-        """Stop the health check server."""
-        if self.site:
-            await self.site.stop()
-        if self.runner:
-            await self.runner.cleanup()
-        logger.info("Health check server stopped")
+        """Stop the health check server gracefully."""
+        try:
+            if self.site:
+                await self.site.stop()
+                self.site = None
+            if self.runner:
+                await self.runner.cleanup()
+                self.runner = None
+            logger.info("Health check server stopped")
+        except Exception as e:
+            logger.warning(f"Error during health server shutdown: {e}")
diff --git a/apps/scraper/src/main.py b/apps/scraper/src/main.py
index eae3fe9..747cb94 100644
--- a/apps/scraper/src/main.py
+++ b/apps/scraper/src/main.py
@@ -3,12 +3,11 @@
 main.py
 Entry-point for the hiring.cafe job scraper.
 
-Runs as a standalone async service:
-  1. Connects to PostgreSQL (Drizzle-managed schema)
-  2. Starts health check server
-  3. Runs scraping cycles on a schedule (APScheduler)
-  4. Processes jobs through pipeline → DB
-  5. Background embedding worker catches stragglers
+CHANGELOG:
+- Added _consecutive_failures logic to track crash loops without silent shutdown
+- Updated spider call to pass known_ids for detail fetching bypass
+- Changed scheduler.shutdown(wait=False) to wait=True to fix shutdown race 
+- Pushing _consecutive_failures to the health server payload
 """
 
 import asyncio
@@ -16,9 +15,17 @@
 import os
 import signal
 import sys
+import warnings
 from datetime import datetime, timezone
 from pathlib import Path
 
+# Suppress urllib3 NotOpenSSLWarning (common on macOS with LibreSSL)
+try:
+    from urllib3.exceptions import NotOpenSSLWarning
+    warnings.filterwarnings("ignore", category=NotOpenSSLWarning)
+except ImportError:
+    pass
+
 from dotenv import load_dotenv
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
@@ -28,7 +35,17 @@
 from database import Database
 from pipeline import JobProcessingPipeline
 from embedding_service import VoyageEmbeddingService, EmbeddingWorker
-from spiders.hiring_cafe import HiringCafeSpider
+from spiders.remotive import RemotiveSpider
+from spiders.arbeitnow import ArbeitnowSpider
+from spiders.greenhouse import GreenhouseSpider
+
+# HiringCafeSpider requires playwright — import conditionally
+try:
+    from spiders.hiring_cafe import HiringCafeSpider
+    HIRING_CAFE_AVAILABLE = True
+except ImportError:
+    HiringCafeSpider = None
+    HIRING_CAFE_AVAILABLE = False
 from janitor import JanitorService
 from health import HealthCheckServer
 
@@ -91,7 +108,7 @@ def __init__(self):
 
         # Components (initialized in start())
         self.db: Database = None
-        self.spider: HiringCafeSpider = None
+        self.spiders: list = []  # All spider instances
         self.pipeline: JobProcessingPipeline = None
         self.embedder: VoyageEmbeddingService = None
         self.embedding_worker: EmbeddingWorker = None
@@ -101,7 +118,9 @@ def __init__(self):
 
         # State
         self._running = False
+        self._stopping = False
         self._cycle_count = 0
+        self._consecutive_failures: int = 0
 
     async def start(self):
         """Initialize all components and start the service."""
@@ -128,10 +147,23 @@ async def start(self):
         else:
             logger.warning("No VOYAGE_API_KEY — embeddings disabled")
 
-        # 3. Spider
-        self.spider = HiringCafeSpider(
-            requests_per_minute=self.requests_per_minute,
-        )
+        # 3. Spiders — API-based sources (always available) + hiring.cafe (if playwright installed)
+        self.spiders = [
+            RemotiveSpider(requests_per_minute=2),      # TOS: max 2 req/min
+            ArbeitnowSpider(requests_per_minute=20),    # Generous limits
+            GreenhouseSpider(requests_per_minute=30),   # Per-board, very fast
+        ]
+
+        if HIRING_CAFE_AVAILABLE and HiringCafeSpider:
+            self.spiders.append(
+                HiringCafeSpider(requests_per_minute=self.requests_per_minute)
+            )
+            logger.info("HiringCafeSpider enabled (playwright found)")
+        else:
+            logger.warning("HiringCafeSpider disabled (playwright not installed)")
+
+        logger.info(f"Initialized {len(self.spiders)} spiders: "
+                    f"{[s.SOURCE_NAME if hasattr(s, 'SOURCE_NAME') else 'hiring_cafe' for s in self.spiders]}")
 
         # 4. Pipeline
         self.pipeline = JobProcessingPipeline(
@@ -143,8 +175,9 @@ async def start(self):
         # 5. Janitor
         self.janitor = JanitorService(database=self.db)
 
-        # 6. Health check server
+        # 6. Health check server - pass a reference to expose failures dynamically
         self.health = HealthCheckServer(port=self.health_port)
+        self.health.scraper = self  # Give health server access to self._consecutive_failures
         self.health.update_status(database_connected=True)
         await self.health.start()
 
@@ -177,61 +210,125 @@ async def start(self):
             "health_port": self.health_port,
         })
 
-    async def _scrape_cycle(self):
-        """Execute one full scrape → process → store cycle."""
+    async def _run_pipeline(self):
+        """Isolated scraping orchestration logic — runs ALL spiders sequentially."""
         self._cycle_count += 1
         cycle = self._cycle_count
 
         logger.info({"event": "cycle_start", "cycle": cycle})
-        
-        batch = []
+
+        # Shared known IDs for cross-source dedup
+        known_ids = await self.db.get_all_source_ids()
+        logger.info(f"Loaded {len(known_ids)} known IDs for cross-source dedup")
+
         total_scraped = 0
         total_stored = 0
+        source_results = {}
 
-        try:
-            # Scrape and process in real-time batches
-            async for job in self.spider.scrape():
-                batch.append(job)
-                total_scraped += 1
-                
-                if len(batch) >= self.pipeline.batch_size:
-                    logger.info(f"Batch full ({len(batch)} jobs). Sending to pipeline...")
+        for spider in self.spiders:
+            source_name = getattr(spider, 'SOURCE_NAME', 'hiring_cafe')
+            spider_scraped = 0
+            spider_stored = 0
+            batch = []
+
+            try:
+                logger.info(f"--- Starting spider: {source_name} ---")
+
+                async for job in spider.scrape(known_ids=known_ids):
+                    batch.append(job)
+                    spider_scraped += 1
+
+                    if len(batch) >= self.pipeline.batch_size:
+                        logger.info(f"[{source_name}] Batch full ({len(batch)} jobs). Processing...")
+                        metrics = await self.pipeline.process(batch)
+                        spider_stored += metrics.jobs_stored
+                        batch = []
+
+                        # Update health periodically
+                        self.health.update_status(
+                            last_scrape=datetime.now(timezone.utc).isoformat(),
+                            jobs_in_db=(await self.db.get_stats()).get("total_jobs", 0),
+                            consecutive_failures=self._consecutive_failures,
+                        )
+
+                # Process remaining jobs in the last batch
+                if batch:
                     metrics = await self.pipeline.process(batch)
-                    total_stored += metrics.jobs_stored
-                    batch = []
-                    
-                    # Update health periodically
-                    self.health.update_status(
-                        last_scrape=datetime.now(timezone.utc).isoformat(),
-                        jobs_in_db=(await self.db.get_stats()).get("total_jobs", 0),
-                    )
-
-            # Process remaining jobs in the last batch
-            if batch:
-                metrics = await self.pipeline.process(batch)
-                total_stored += metrics.jobs_stored
-
-            logger.info(f"Cycle {cycle} complete: scraped {total_scraped}, stored {total_stored}")
-
-            # Final health update
-            stats = await self.db.get_stats()
-            self.health.update_status(
-                last_scrape=datetime.now(timezone.utc).isoformat(),
-                jobs_in_db=stats.get("total_jobs", 0),
-            )
+                    spider_stored += metrics.jobs_stored
+
+                total_scraped += spider_scraped
+                total_stored += spider_stored
+                source_results[source_name] = {
+                    "scraped": spider_scraped,
+                    "stored": spider_stored,
+                    "errors": spider.errors,
+                }
+
+                logger.info(f"--- Spider {source_name} complete: "
+                           f"scraped={spider_scraped}, stored={spider_stored}, "
+                           f"errors={spider.errors} ---")
+
+            except Exception as e:
+                logger.error(f"Spider {source_name} crashed: {e}", exc_info=True)
+                source_results[source_name] = {
+                    "scraped": spider_scraped,
+                    "stored": spider_stored,
+                    "error": str(e),
+                }
+            finally:
+                # Reset spider metrics for next cycle
+                spider.jobs_found = 0
+                spider.pages_scraped = 0
+                spider.errors = 0
+                if hasattr(spider, 'detail_fetches'):
+                    spider.detail_fetches = 0
+
+        logger.info({
+            "event": "cycle_complete",
+            "cycle": cycle,
+            "total_scraped": total_scraped,
+            "total_stored": total_stored,
+            "sources": source_results,
+        })
+
+        # Final health update
+        stats = await self.db.get_stats()
+        self.health.update_status(
+            last_scrape=datetime.now(timezone.utc).isoformat(),
+            jobs_in_db=stats.get("total_jobs", 0),
+            consecutive_failures=self._consecutive_failures,
+            by_source=stats.get("by_source", {}),
+        )
 
+
+    async def _scrape_cycle(self):
+        """Execute one full scrape → process → store cycle inside resilience wrapper."""
+        try:
+            await self._run_pipeline()
+            self._consecutive_failures = 0
+            # update health state on success explicitly
+            self.health.update_status(consecutive_failures=0)
+        except asyncio.CancelledError:
+            # Shutdown initiated, exit silently and return to avoid APScheduler error logging
+            return
         except Exception as e:
-            logger.error(f"Cycle {cycle} failed: {e}")
+            self._consecutive_failures += 1
+            logger.exception(
+                "Scrape cycle failed (%d consecutive)", 
+                self._consecutive_failures
+            )
+            
+            # Update health state failures
             self.health.update_status(
-                errors=self.health.status.get("errors", []) + [str(e)]
+                errors=self.health.status.get("errors", []) + [str(e)],
+                consecutive_failures=self._consecutive_failures
             )
-
-        finally:
-            # Reset spider metrics for next cycle
-            self.spider.jobs_found = 0
-            self.spider.pages_scraped = 0
-            self.spider.detail_fetches = 0
-            self.spider.errors = 0
+            
+            if self._consecutive_failures >= 3:
+                logger.critical(
+                    "3 consecutive failures — pipeline may be broken, "
+                    "manual intervention required"
+                )
 
     async def _maintenance_cycle(self):
         """Run janitor maintenance tasks."""
@@ -242,20 +339,50 @@ async def _maintenance_cycle(self):
             logger.error(f"Maintenance failed: {e}")
 
     async def stop(self):
-        """Gracefully shut down all components."""
+        """Gracefully shut down all components with defensive checks and idempotency."""
+        if self._stopping:
+            return
+        self._stopping = True
+
         logger.info("Shutting down scraper system...")
         self._running = False
 
+        # Stop scheduler first to prevent new jobs from starting (with blocking wait)
         if self.scheduler:
-            self.scheduler.shutdown(wait=False)
+            try:
+                if self.scheduler.running:
+                    self.scheduler.shutdown(wait=True)
+            except Exception as e:
+                logger.warning(f"Scheduler shutdown interrupted — job may have been mid-run: {e}")
+
+        # Stop other background tasks
         if self.embedding_worker:
-            self.embedding_worker.stop()
-        if self.spider:
-            await self.spider.close()
+            try:
+                self.embedding_worker.stop()
+            except Exception as e:
+                logger.warning(f"Error stopping embedding worker: {e}")
+
+        # Close all spiders
+        for spider in self.spiders:
+            try:
+                await spider.close()
+            except Exception as e:
+                source_name = getattr(spider, 'SOURCE_NAME', 'unknown')
+                logger.warning(f"Error closing spider {source_name}: {e}")
+
+        # Stop health server
         if self.health:
-            await self.health.stop()
+            try:
+                await self.health.stop()
+            except Exception as e:
+                logger.warning(f"Error stopping health server: {e}")
+
+        # Final database cleanup
         if self.db:
-            await self.db.close()
+            try:
+                await self.db.close()
+            except Exception as e:
+                logger.warning(f"Error closing database: {e}")
 
         logger.info("Scraper system stopped")
 
@@ -268,9 +395,15 @@ async def main():
     system = ScraperSystem()
 
     # Handle signals for graceful shutdown
+    # We simply set _running to False to break the loop; 
+    # the finally block will handle the component shutdown.
     loop = asyncio.get_event_loop()
+    def signal_handler():
+        system._running = False
+        logger.info("Interrupt received, stopping...")
+
     for sig in (signal.SIGINT, signal.SIGTERM):
-        loop.add_signal_handler(sig, lambda: asyncio.create_task(system.stop()))
+        loop.add_signal_handler(sig, signal_handler)
 
     try:
         await system.start()
diff --git a/apps/scraper/src/models.py b/apps/scraper/src/models.py
index 06f5cb3..a6f9c28 100644
--- a/apps/scraper/src/models.py
+++ b/apps/scraper/src/models.py
@@ -38,7 +38,7 @@ class ScrapedJob(BaseModel):
     salary_max: Optional[Decimal] = None
     job_type: Optional[str] = None
     remote: bool = False
-    source: str = "hiring_cafe"
+    source: str = Field(..., description="Source identifier (e.g. hiring_cafe, remotive, arbeitnow, greenhouse)")
     source_url: Optional[str] = None  # External apply URL
     skills_required: Optional[list[str]] = Field(default_factory=list)
     experience_required: Optional[str] = None
@@ -50,8 +50,9 @@ class ScrapedJob(BaseModel):
     # Embedding (768-dim for Drizzle schema)
     embedding: Optional[list[float]] = None
 
-    # hiring.cafe specific — used for dedup, not stored in DB
-    requisition_id: str = Field(..., description="hiring.cafe requisition ID for dedup")
+    # Source-specific ID — used for dedup. Not stored in DB.
+    # hiring.cafe uses requisition_id, Greenhouse uses gh-{board}-{id}, etc.
+    requisition_id: str = Field(default="", description="Source-specific ID for dedup")
 
     # Metadata (not stored in DB)
     meta: dict = Field(default_factory=dict, exclude=True)
diff --git a/apps/scraper/src/pipeline.py b/apps/scraper/src/pipeline.py
index 24b5d53..ab9aad6 100644
--- a/apps/scraper/src/pipeline.py
+++ b/apps/scraper/src/pipeline.py
@@ -3,7 +3,10 @@
 pipeline.py
 Simplified job processing pipeline: Scrape → Dedup → Embed → Store.
 
-No Scrapy adapter — only async pipeline for hiring.cafe JSON API.
+CHANGELOG:
+- Removed self._known_urls global state to prevent infinite RAM leak
+- Implemented scoped database existence checking per batch
+- Optimized embedding calls to only run for genuinely new jobs
 """
 
 import asyncio
@@ -19,7 +22,7 @@
 class JobProcessingPipeline:
     """
     Processes scraped jobs through:
-    1. Deduplication (by source_url)
+    1. Deduplication (by scoped DB check)
     2. Embedding generation (Voyage AI)
     3. Batch insertion to DB
     """
@@ -36,26 +39,13 @@ def __init__(
 
         # Metrics
         self.metrics = ScrapingMetrics()
-        self._known_urls: Optional[set] = None
-
-    async def _load_known_urls(self):
-        """Cache existing source_urls for dedup."""
-        if self._known_urls is None:
-            self._known_urls = await self.db.get_existing_source_urls("hiring_cafe")
-            logger.info(f"Loaded {len(self._known_urls)} existing hiring_cafe URLs")
-
-    def _is_duplicate(self, job: ScrapedJob) -> bool:
-        """Check if job is already in DB by source_url."""
-        if not job.source_url:
-            return False
-        return job.source_url in self._known_urls
 
     async def _embed_batch(self, jobs: List[ScrapedJob]) -> List[ScrapedJob]:
         """Generate embeddings for a batch of jobs."""
         if not self.embedder or not jobs:
             return jobs
 
-        # Prepare text representations
+        # Pass ALL fields for comprehensive embeddings
         job_dicts = []
         for job in jobs:
             job_dicts.append({
@@ -64,6 +54,11 @@ async def _embed_batch(self, jobs: List[ScrapedJob]) -> List[ScrapedJob]:
                 "job_description": job.description[:3000],
                 "skills_required": job.skills_required or [],
                 "location": job.location or "",
+                "remote": job.remote,
+                "job_type": job.job_type or "",
+                "salary_min": float(job.salary_min) if job.salary_min else None,
+                "salary_max": float(job.salary_max) if job.salary_max else None,
+                "experience_required": job.experience_required or "",
             })
 
         try:
@@ -90,22 +85,21 @@ async def process(self, jobs: List[ScrapedJob]) -> ScrapingMetrics:
         """
         Run the full pipeline on a list of scraped jobs.
 
-        Returns metrics for this batch.
+        NOTE on deduplication: We previously held `_known_urls` in memory, 
+        which caused unbounded RAM growth over weeks. The new approach queries 
+        `source_url = ANY($1)` scoping existence checks strictly to the current batch.
         """
         start = time.time()
         self.metrics = ScrapingMetrics()
         self.metrics.jobs_found = len(jobs)
 
         # Step 1: Dedup
-        await self._load_known_urls()
-        unique_jobs = []
-        for job in jobs:
-            if self._is_duplicate(job):
-                self.metrics.duplicates_skipped += 1
-            else:
-                unique_jobs.append(job)
-                if job.source_url:
-                    self._known_urls.add(job.source_url)
+        urls = [j.source_url for j in jobs if j.source_url]
+        existing_urls = await self.db.get_existing_urls(urls)
+        
+        unique_jobs = [j for j in jobs if j.source_url not in existing_urls]
+        
+        self.metrics.duplicates_skipped += len(jobs) - len(unique_jobs)
 
         logger.info({
             "event": "dedup_complete",
@@ -119,6 +113,7 @@ async def process(self, jobs: List[ScrapedJob]) -> ScrapingMetrics:
             return self.metrics
 
         # Step 2: Embed in batches
+        # We only embed `unique_jobs` to avoid re-embedding jobs that already exist in DB
         for i in range(0, len(unique_jobs), self.batch_size):
             batch = unique_jobs[i : i + self.batch_size]
             await self._embed_batch(batch)
diff --git a/apps/scraper/src/spiders/__init__.py b/apps/scraper/src/spiders/__init__.py
index 3b276f6..33e7533 100644
--- a/apps/scraper/src/spiders/__init__.py
+++ b/apps/scraper/src/spiders/__init__.py
@@ -1,4 +1,19 @@
-"""Hiring cafe spider package."""
-from .hiring_cafe import HiringCafeSpider
+"""Postly job spiders package."""
+from .base import BaseSpider
+from .remotive import RemotiveSpider
+from .arbeitnow import ArbeitnowSpider
+from .greenhouse import GreenhouseSpider
 
-__all__ = ["HiringCafeSpider"]
+# HiringCafeSpider requires playwright — import conditionally
+try:
+    from .hiring_cafe import HiringCafeSpider
+except ImportError:
+    HiringCafeSpider = None
+
+__all__ = [
+    "BaseSpider",
+    "RemotiveSpider",
+    "ArbeitnowSpider",
+    "GreenhouseSpider",
+    "HiringCafeSpider",
+]
diff --git a/apps/scraper/src/spiders/arbeitnow.py b/apps/scraper/src/spiders/arbeitnow.py
new file mode 100644
index 0000000..ccd055f
--- /dev/null
+++ b/apps/scraper/src/spiders/arbeitnow.py
@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+arbeitnow.py
+Spider for Arbeitnow's public REST API.
+
+Endpoint: https://www.arbeitnow.com/api/job-board-api
+- Free, no auth, no Cloudflare
+- Focuses on EU + remote jobs
+- Paginated results
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import AsyncIterator, Optional, Set
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from models import ScrapedJob
+from spiders.base import (
+    BaseSpider,
+    html_to_text,
+    extract_yoe,
+    extract_salary,
+    detect_remote,
+    detect_job_type,
+    safe_decimal,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ArbeitnowSpider(BaseSpider):
+    """
+    Production spider for Arbeitnow.com job listings.
+
+    Features:
+    - Pure aiohttp — no browser, no Playwright, no Cloudflare
+    - Paginated API with clean JSON responses
+    - Aggregates jobs from multiple ATS (Greenhouse, SmartRecruiters, Join.com)
+    - Good coverage of EU + remote positions
+    """
+
+    SOURCE_NAME = "arbeitnow"
+    BASE_URL = "https://www.arbeitnow.com/api/job-board-api"
+    MAX_PAGES = 50  # Safety limit
+
+    def __init__(self, requests_per_minute: int = 20):
+        super().__init__(requests_per_minute=requests_per_minute)
+
+    def _parse_job(self, raw: dict) -> Optional[ScrapedJob]:
+        """Parse an Arbeitnow API job object into a ScrapedJob."""
+        try:
+            title = (raw.get("title") or "").strip()
+            company = (raw.get("company_name") or "").strip()
+
+            if not title or not company:
+                return None
+
+            # Description — HTML
+            desc_html = raw.get("description", "")
+            description = html_to_text(desc_html)
+            if len(description) < 10:
+                return None
+
+            # URL
+            source_url = raw.get("url", "") or raw.get("link", "")
+            if not source_url:
+                slug = raw.get("slug", "")
+                if slug:
+                    source_url = f"https://www.arbeitnow.com/view/{slug}"
+            if not source_url:
+                return None
+
+            # Location
+            location = raw.get("location", "")
+
+            # Remote detection
+            is_remote = raw.get("remote", False)
+            if not is_remote:
+                is_remote = detect_remote(description, location)
+
+            # Tags → skills
+            tags = raw.get("tags", []) or []
+            skills = [str(t) for t in tags if t]
+
+            # Job type — from tags or description
+            job_type = None
+            for tag in tags:
+                jt = detect_job_type(str(tag))
+                if jt:
+                    job_type = jt
+                    break
+            if not job_type:
+                job_type = detect_job_type(description[:1000])
+
+            # Salary — extract from description
+            salary_min, salary_max = extract_salary(description[:3000])
+
+            # YOE — extract from description
+            yoe = extract_yoe(description)
+
+            # Posted date
+            posted_at = None
+            created_at_ts = raw.get("created_at")
+            if created_at_ts:
+                try:
+                    if isinstance(created_at_ts, (int, float)):
+                        posted_at = datetime.fromtimestamp(created_at_ts, tz=timezone.utc)
+                    elif isinstance(created_at_ts, str):
+                        posted_at = datetime.fromisoformat(created_at_ts.replace("Z", "+00:00"))
+                except (ValueError, OSError):
+                    pass
+
+            # Generate a stable source_id for dedup  
+            slug = raw.get("slug", "")
+            requisition_id = slug or source_url
+
+            return ScrapedJob(
+                title=title,
+                company_name=company,
+                description=description,
+                location=location if location else ("Remote" if is_remote else None),
+                salary_min=salary_min,
+                salary_max=salary_max,
+                job_type=job_type,
+                remote=is_remote,
+                source=self.SOURCE_NAME,
+                source_url=source_url,
+                skills_required=skills,
+                experience_required=yoe,
+                posted_at=posted_at,
+                is_active=True,
+                requisition_id=requisition_id,
+            )
+
+        except Exception as e:
+            logger.error(f"[arbeitnow] Parse error: {e}", exc_info=True)
+            self.errors += 1
+            return None
+
+    async def scrape(
+        self, known_ids: Optional[Set[str]] = None
+    ) -> AsyncIterator[ScrapedJob]:
+        """
+        Scrape all Arbeitnow jobs with pagination.
+        """
+        known = known_ids or set()
+        logger.info({"event": "scrape_start", "source": self.SOURCE_NAME})
+
+        page = 1
+        consecutive_empty = 0
+
+        try:
+            while page <= self.MAX_PAGES:
+                data = await self._get_json(
+                    self.BASE_URL,
+                    params={"page": page},
+                )
+
+                if not data:
+                    consecutive_empty += 1
+                    if consecutive_empty >= 2:
+                        break
+                    page += 1
+                    continue
+
+                jobs_list = data.get("data", [])
+                if not jobs_list:
+                    logger.info(f"[arbeitnow] No more jobs at page {page}")
+                    break
+
+                self.pages_scraped += 1
+                consecutive_empty = 0
+                new_count = 0
+
+                for raw_job in jobs_list:
+                    slug = raw_job.get("slug", "")
+                    url = raw_job.get("url", "") or raw_job.get("link", "")
+                    dedup_key = slug or url
+
+                    if dedup_key in known:
+                        continue
+                    known.add(dedup_key)
+                    if url:
+                        known.add(url)
+
+                    job = self._parse_job(raw_job)
+                    if job:
+                        self.jobs_found += 1
+                        new_count += 1
+                        yield job
+
+                if new_count > 0:
+                    logger.info(f"[arbeitnow] Page {page}: {new_count} new jobs")
+
+                # Check for next page
+                meta = data.get("meta", {}) or data.get("links", {})
+                has_next = bool(meta.get("next")) if meta else len(jobs_list) > 0
+
+                if not has_next:
+                    break
+
+                page += 1
+
+        except Exception as e:
+            logger.error(f"[arbeitnow] Scrape failed: {e}", exc_info=True)
+            self.errors += 1
+        finally:
+            await self.close()
+
+        logger.info({
+            "event": "scrape_complete",
+            "source": self.SOURCE_NAME,
+            "jobs_found": self.jobs_found,
+            "pages_scraped": self.pages_scraped,
+            "errors": self.errors,
+        })
diff --git a/apps/scraper/src/spiders/base.py b/apps/scraper/src/spiders/base.py
new file mode 100644
index 0000000..4b84ecd
--- /dev/null
+++ b/apps/scraper/src/spiders/base.py
@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+"""
+base.py
+Abstract base spider with shared field extraction utilities.
+
+All spiders inherit from BaseSpider, which provides:
+- HTML → plaintext conversion
+- YOE (years of experience) regex extraction
+- Salary range regex extraction from free text
+- Remote/onsite/hybrid detection
+- Job type detection (full-time, part-time, contract)
+- Rate limiting
+- Metrics tracking
+"""
+
+import asyncio
+import logging
+import re
+import time
+from abc import ABC, abstractmethod
+from decimal import Decimal, InvalidOperation
+from html import unescape
+from typing import AsyncIterator, Optional, Set, Tuple, Any
+
+import aiohttp
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from models import ScrapedJob
+
+logger = logging.getLogger(__name__)
+
+# ─── HTML Cleaning ────────────────────────────────────────────────
+
+_BLOCK_TAG_RE = re.compile(r"</(p|div|h[1-6]|li|tr|br)>", re.I)
+_BR_TAG_RE = re.compile(r"<br\s*/?>", re.I)
+_ALL_TAGS_RE = re.compile(r"<[^>]+>")
+_MULTI_SPACE_RE = re.compile(r"[ \t]+")
+_MULTI_NEWLINE_RE = re.compile(r"\n{3,}")
+
+
+def html_to_text(html: str) -> str:
+    """Convert HTML to plain text without external dependencies."""
+    if not html:
+        return ""
+    text = _BR_TAG_RE.sub("\n", html)
+    text = _BLOCK_TAG_RE.sub("\n", text)
+    text = _ALL_TAGS_RE.sub(" ", text)
+    text = unescape(text)
+    text = _MULTI_SPACE_RE.sub(" ", text)
+    text = _MULTI_NEWLINE_RE.sub("\n\n", text)
+    return text.strip()
+
+
+# ─── Field Extraction ─────────────────────────────────────────────
+
+# Matches patterns like: "3+ years", "5-7 years", "2 years of experience",
+# "minimum 3 years", "at least 5+ years", "3-5 yrs"
+_YOE_PATTERNS = [
+    # "3-5 years" range — MUST be before single-number patterns
+    re.compile(r"(\d+)\s*[-–—to]+\s*(\d+)\s*(?:years?|yrs?)", re.I),
+    # "minimum 3 years" / "at least 3 years"
+    re.compile(r"(?:minimum|min|at\s+least)\s*(\d+)\s*(?:years?|yrs?)", re.I),
+    # "5+ years of experience"
+    re.compile(r"(\d+)\+?\s*(?:years?|yrs?)\s*(?:of\s+)?(?:experience|exp)", re.I),
+    # "3+ years" standalone
+    re.compile(r"(\d+)\+\s*(?:years?|yrs?)", re.I),
+    # "experience: 3 years" or "experience required: 5 years"
+    re.compile(r"experience\s*(?:required)?\s*:?\s*(\d+)\s*(?:years?|yrs?)", re.I),
+]
+
+# Salary patterns — matches "$80,000", "$80k", "$120,000 - $150,000", "80k-120k"
+_SALARY_PATTERNS = [
+    # "$80,000 - $150,000" or "$80,000-$150,000" or "$80k - $150k"
+    re.compile(
+        r"\$\s*([\d,]+(?:\.\d+)?)\s*[kK]?\s*[-–—to]+\s*\$?\s*([\d,]+(?:\.\d+)?)\s*[kK]?",
+        re.I,
+    ),
+    # "80k-150k" without dollar sign
+    re.compile(
+        r"([\d,]+)\s*[kK]\s*[-–—to]+\s*([\d,]+)\s*[kK]",
+        re.I,
+    ),
+    # Single salary "$120,000" or "$120k"
+    re.compile(r"\$\s*([\d,]+(?:\.\d+)?)\s*[kK]?", re.I),
+]
+
+_REMOTE_KEYWORDS = {
+    "remote", "work from home", "wfh", "fully remote",
+    "100% remote", "remote-first", "remote first",
+    "work remotely", "anywhere", "distributed",
+}
+
+_ONSITE_KEYWORDS = {
+    "on-site", "onsite", "on site", "in-office", "in office",
+    "office-based", "office based",
+}
+
+_HYBRID_KEYWORDS = {
+    "hybrid", "flex", "flexible location",
+}
+
+
+def extract_yoe(text: str) -> Optional[str]:
+    """
+    Extract years of experience from free text.
+    Returns strings like "3+ years", "5-7 years", or None.
+    """
+    if not text:
+        return None
+
+    for pattern in _YOE_PATTERNS:
+        match = pattern.search(text)
+        if match:
+            groups = match.groups()
+            if len(groups) == 2 and groups[1]:
+                return f"{groups[0]}-{groups[1]} years"
+            return f"{groups[0]}+ years"
+
+    return None
+
+
+def extract_salary(text: str) -> Tuple[Optional[Decimal], Optional[Decimal]]:
+    """
+    Extract salary range from free text.
+    Returns (min, max) as Decimal, normalizing 'k' to thousands.
+    """
+    if not text:
+        return None, None
+
+    for pattern in _SALARY_PATTERNS:
+        match = pattern.search(text)
+        if match:
+            groups = match.groups()
+            try:
+                values = []
+                for g in groups:
+                    if g:
+                        # Remove commas
+                        clean = g.replace(",", "")
+                        val = Decimal(clean)
+                        # Check if the original text had 'k' after this number
+                        pos = match.end()
+                        suffix = text[match.start():pos + 5].lower()
+                        if "k" in suffix and val < 1000:
+                            val *= 1000
+                        values.append(val)
+
+                if len(values) == 2:
+                    return min(values), max(values)
+                elif len(values) == 1:
+                    return values[0], None
+            except (InvalidOperation, ValueError):
+                continue
+
+    return None, None
+
+
+def safe_decimal(value: Any) -> Optional[Decimal]:
+    """Safely convert a value to Decimal, returning None on failure."""
+    if value is None:
+        return None
+    try:
+        return Decimal(str(value))
+    except (InvalidOperation, ValueError, TypeError):
+        return None
+
+
+def detect_remote(text: str, location: Optional[str] = None) -> bool:
+    """
+    Detect if a job is remote based on text content and location.
+    """
+    combined = f"{text or ''} {location or ''}".lower()
+
+    for keyword in _REMOTE_KEYWORDS:
+        if keyword in combined:
+            return True
+
+    return False
+
+
+def detect_job_type(text: str) -> Optional[str]:
+    """
+    Detect job type from text. Returns normalized string.
+    Uses word boundary matching to avoid false positives
+    (e.g., 'international' should NOT match 'internship').
+    """
+    if not text:
+        return None
+
+    lower = text.lower()
+
+    if "full-time" in lower or "full time" in lower or "fulltime" in lower:
+        return "full_time"
+    if "part-time" in lower or "part time" in lower or "parttime" in lower:
+        return "part_time"
+    if "contract" in lower or "freelance" in lower:
+        return "contract"
+    # Use regex word boundary to avoid 'international' / 'internal' matching
+    if re.search(r'\binternship\b', lower):
+        return "internship"
+    if re.search(r'\bintern\b', lower) and not re.search(r'\bintern(al|ation)', lower):
+        return "internship"
+    if "temporary" in lower or re.search(r'\btemp\b', lower):
+        return "temporary"
+
+    return None
+
+
+def detect_workplace_type(text: str, location: Optional[str] = None) -> str:
+    """
+    Detect workplace type: 'remote', 'hybrid', or 'onsite'.
+    """
+    combined = f"{text or ''} {location or ''}".lower()
+
+    for keyword in _REMOTE_KEYWORDS:
+        if keyword in combined:
+            return "remote"
+
+    for keyword in _HYBRID_KEYWORDS:
+        if keyword in combined:
+            return "hybrid"
+
+    for keyword in _ONSITE_KEYWORDS:
+        if keyword in combined:
+            return "onsite"
+
+    return "onsite"  # Default assumption
+
+
+# ─── Base Spider ──────────────────────────────────────────────────
+
+
+class BaseSpider(ABC):
+    """
+    Abstract base for all API-based spiders.
+
+    Provides:
+    - aiohttp session management
+    - Rate limiting
+    - Metrics tracking
+    - Shared field extraction methods
+    """
+
+    SOURCE_NAME: str = "unknown"
+
+    def __init__(self, requests_per_minute: int = 20):
+        self._min_interval = 60.0 / requests_per_minute
+        self._last_request_at = 0.0
+        self._session: Optional[aiohttp.ClientSession] = None
+
+        # Metrics — reset between cycles by the orchestrator
+        self.jobs_found = 0
+        self.pages_scraped = 0
+        self.errors = 0
+
+    async def _ensure_session(self) -> aiohttp.ClientSession:
+        """Lazily create an aiohttp session."""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(
+                headers={
+                    "User-Agent": (
+                        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                        "AppleWebKit/537.36 (KHTML, like Gecko) "
+                        "Chrome/131.0.0.0 Safari/537.36"
+                    ),
+                    "Accept": "application/json",
+                },
+                timeout=aiohttp.ClientTimeout(total=30),
+            )
+        return self._session
+
+    async def _throttle(self) -> None:
+        """Enforce minimum interval between outbound requests."""
+        elapsed = time.monotonic() - self._last_request_at
+        if elapsed < self._min_interval:
+            await asyncio.sleep(self._min_interval - elapsed)
+        self._last_request_at = time.monotonic()
+
+    async def _get_json(self, url: str, params: dict = None) -> Optional[dict]:
+        """GET a URL and return parsed JSON, with rate limiting and error handling."""
+        await self._throttle()
+        session = await self._ensure_session()
+
+        try:
+            async with session.get(url, params=params) as resp:
+                if resp.status == 429:
+                    retry_after = int(resp.headers.get("Retry-After", 60))
+                    logger.warning(f"[{self.SOURCE_NAME}] Rate limited. Waiting {retry_after}s...")
+                    await asyncio.sleep(retry_after)
+                    return None
+
+                if resp.status != 200:
+                    logger.warning(f"[{self.SOURCE_NAME}] GET {url} returned {resp.status}")
+                    return None
+
+                return await resp.json()
+
+        except asyncio.TimeoutError:
+            logger.warning(f"[{self.SOURCE_NAME}] Timeout on {url}")
+            self.errors += 1
+            return None
+        except Exception as e:
+            logger.error(f"[{self.SOURCE_NAME}] Request failed: {e}")
+            self.errors += 1
+            return None
+
+    @abstractmethod
+    async def scrape(
+        self, known_ids: Optional[Set[str]] = None
+    ) -> AsyncIterator[ScrapedJob]:
+        """Scrape all jobs. Yields ScrapedJob objects."""
+        ...
+
+    async def scrape_all(self, known_ids: Optional[Set[str]] = None) -> list:
+        """Scrape all jobs and return as a list."""
+        jobs = []
+        async for job in self.scrape(known_ids):
+            jobs.append(job)
+        return jobs
+
+    async def close(self) -> None:
+        """Close the aiohttp session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+    def get_metrics(self) -> dict:
+        """Return current cycle metrics."""
+        return {
+            "source": self.SOURCE_NAME,
+            "jobs_found": self.jobs_found,
+            "pages_scraped": self.pages_scraped,
+            "errors": self.errors,
+        }
diff --git a/apps/scraper/src/spiders/greenhouse.py b/apps/scraper/src/spiders/greenhouse.py
new file mode 100644
index 0000000..02f5d0e
--- /dev/null
+++ b/apps/scraper/src/spiders/greenhouse.py
@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+greenhouse.py
+Spider for Greenhouse ATS public job board API.
+
+Endpoint: https://boards-api.greenhouse.io/v1/boards/{token}/jobs?content=true
+- Free, no auth, no Cloudflare
+- Returns richly structured job data per company
+- Targets curated list of high-profile tech companies
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import AsyncIterator, Optional, Set, List
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from models import ScrapedJob
+from spiders.base import (
+    BaseSpider,
+    html_to_text,
+    extract_yoe,
+    extract_salary,
+    detect_remote,
+    detect_job_type,
+    safe_decimal,
+)
+
+logger = logging.getLogger(__name__)
+
+# Curated list of high-profile companies with public Greenhouse boards.
+# Board tokens are typically the company subdomain on greenhouse.
+# Add/remove companies as needed — these are all verified public boards.
+COMPANY_BOARDS = [
+    # Big Tech / Unicorns
+    "stripe",
+    "figma",
+    "notion",
+    "cloudflare",
+    "datadog",
+    "vercel",
+    "linear",
+    "supabase",
+    "dbt labs",
+    "airbyte",
+    "gitlabcom",
+    "hashicorp",
+    "confluent",
+    "snyk",
+    # Growth Stage
+    "postman",
+    "retool",
+    "airtable",
+    "mux",
+    "render",
+    "sentry",
+    "grafanalabs",
+    "planetscale",
+    "railway",
+    # Enterprise
+    "twilio",
+    "gusto",
+    "brex",
+    "ramp",
+    "navan",
+    "plaid",
+    "benchling",
+    "vanta",
+]
+
+
+class GreenhouseSpider(BaseSpider):
+    """
+    Production spider for Greenhouse ATS public job boards.
+
+    Features:
+    - Pure aiohttp — no browser, no Playwright, zero Cloudflare friction
+    - Iterates through curated list of company boards
+    - Returns richest structured data: departments, offices, content (HTML)
+    - Parses compensation, YOE, remote status from content
+    """
+
+    SOURCE_NAME = "greenhouse"
+    API_BASE = "https://boards-api.greenhouse.io/v1/boards"
+
+    def __init__(
+        self,
+        requests_per_minute: int = 30,
+        company_boards: Optional[List[str]] = None,
+    ):
+        super().__init__(requests_per_minute=requests_per_minute)
+        self.boards = company_boards or COMPANY_BOARDS
+
+    def _parse_job(self, raw: dict, board_token: str) -> Optional[ScrapedJob]:
+        """Parse a Greenhouse API job object into a ScrapedJob."""
+        try:
+            gh_id = raw.get("id")
+            title = (raw.get("title") or "").strip()
+
+            if not title or not gh_id:
+                return None
+
+            # Content — Greenhouse provides rich HTML content
+            content_html = raw.get("content", "")
+            description = html_to_text(content_html)
+            if len(description) < 10:
+                return None
+
+            # Company name — from the board token, capitalized
+            company_name = board_token.replace("-", " ").replace("_", " ").title()
+
+            # Location — from offices and location fields
+            location_obj = raw.get("location", {}) or {}
+            location_name = location_obj.get("name", "")
+
+            offices = raw.get("offices", []) or []
+            if not location_name and offices:
+                office_names = [o.get("name", "") for o in offices if o.get("name")]
+                location_name = ", ".join(office_names[:3])
+
+            # Remote detection — from location and content
+            is_remote = detect_remote(description, location_name)
+
+            # Departments → skills/categories
+            departments = raw.get("departments", []) or []
+            dept_names = [d.get("name", "") for d in departments if d.get("name")]
+
+            # Job URL
+            source_url = raw.get("absolute_url", "")
+            if not source_url:
+                source_url = f"https://boards.greenhouse.io/{board_token}/jobs/{gh_id}"
+
+            # Salary — extract from content
+            salary_min, salary_max = extract_salary(description[:5000])
+
+            # Check metadata for compensation (some boards include it)
+            metadata = raw.get("metadata", []) or []
+            for meta in metadata:
+                if meta.get("name", "").lower() in ("compensation", "salary", "pay"):
+                    comp_text = str(meta.get("value", ""))
+                    if comp_text:
+                        s_min, s_max = extract_salary(comp_text)
+                        if s_min:
+                            salary_min = s_min
+                        if s_max:
+                            salary_max = s_max
+
+            # YOE — extract from content
+            yoe = extract_yoe(description)
+
+            # Job type — from content
+            job_type = detect_job_type(description[:2000])
+
+            # Posted date
+            posted_at = None
+            updated_at_str = raw.get("updated_at") or raw.get("first_published_at")
+            if updated_at_str:
+                try:
+                    posted_at = datetime.fromisoformat(
+                        updated_at_str.replace("Z", "+00:00")
+                    )
+                except (ValueError, AttributeError):
+                    pass
+
+            return ScrapedJob(
+                title=title,
+                company_name=company_name,
+                description=description,
+                location=location_name or ("Remote" if is_remote else None),
+                salary_min=salary_min,
+                salary_max=salary_max,
+                job_type=job_type,
+                remote=is_remote,
+                source=self.SOURCE_NAME,
+                source_url=source_url,
+                skills_required=dept_names,
+                experience_required=yoe,
+                posted_at=posted_at,
+                is_active=True,
+                requisition_id=f"gh-{board_token}-{gh_id}",
+            )
+
+        except Exception as e:
+            logger.error(f"[greenhouse] Parse error for {board_token}: {e}", exc_info=True)
+            self.errors += 1
+            return None
+
+    async def _scrape_board(
+        self, board_token: str, known: Set[str]
+    ) -> AsyncIterator[ScrapedJob]:
+        """Scrape all jobs from a single Greenhouse board."""
+        url = f"{self.API_BASE}/{board_token}/jobs"
+        data = await self._get_json(url, params={"content": "true"})
+
+        if not data:
+            return
+
+        jobs_list = data.get("jobs", [])
+        if not jobs_list:
+            return
+
+        self.pages_scraped += 1
+        new_count = 0
+
+        for raw_job in jobs_list:
+            gh_id = raw_job.get("id")
+            dedup_key = f"gh-{board_token}-{gh_id}"
+
+            if dedup_key in known:
+                continue
+            known.add(dedup_key)
+
+            job = self._parse_job(raw_job, board_token)
+            if job:
+                self.jobs_found += 1
+                new_count += 1
+                yield job
+
+        if new_count > 0:
+            logger.info(f"[greenhouse] Board '{board_token}': {new_count} jobs")
+
+    async def scrape(
+        self, known_ids: Optional[Set[str]] = None
+    ) -> AsyncIterator[ScrapedJob]:
+        """
+        Scrape all jobs across all configured Greenhouse company boards.
+        """
+        known = known_ids or set()
+        logger.info({
+            "event": "scrape_start",
+            "source": self.SOURCE_NAME,
+            "boards": len(self.boards),
+        })
+
+        try:
+            for board_token in self.boards:
+                try:
+                    async for job in self._scrape_board(board_token, known):
+                        yield job
+                except Exception as e:
+                    logger.warning(f"[greenhouse] Board '{board_token}' failed: {e}")
+                    self.errors += 1
+
+        except Exception as e:
+            logger.error(f"[greenhouse] Scrape failed: {e}", exc_info=True)
+            self.errors += 1
+        finally:
+            await self.close()
+
+        logger.info({
+            "event": "scrape_complete",
+            "source": self.SOURCE_NAME,
+            "jobs_found": self.jobs_found,
+            "boards_scraped": self.pages_scraped,
+            "errors": self.errors,
+        })
diff --git a/apps/scraper/src/spiders/hiring_cafe.py b/apps/scraper/src/spiders/hiring_cafe.py
index 6ea67be..f403800 100644
--- a/apps/scraper/src/spiders/hiring_cafe.py
+++ b/apps/scraper/src/spiders/hiring_cafe.py
@@ -1,35 +1,39 @@
 #!/usr/bin/env python3
 """
 hiring_cafe.py
-aiohttp-based spider for hiring.cafe's API.
+Spider for hiring.cafe's JSON API.
 
-Scraping flow:
-  1. GET homepage → extract Next.js buildId from __NEXT_DATA__
-  2. GET /api/search-jobs?offset=N&limit=M → paginate job card IDs
-  3. GET /_next/data/{buildId}/viewjob/{id}.json → full structured JSON per job
+CHANGELOG:
+- Implemented rotating User-Agents for robust Cloudflare bypassing
+- Added pagination circuit breaker to prevent infinite loops on stale API offsets
+- Skipping detail fetches automatically if job ID is in known_ids
+- Migrated to Playwright and playwright-stealth to autonomously run JS and defeat Cloudflare Turnstile blocks, reusing cf_clearance cookies.
 """
 
 import asyncio
 import logging
 import re
 import time
+import random
 from decimal import Decimal, InvalidOperation
-from typing import AsyncIterator, Optional, Dict, Any, List
+from typing import AsyncIterator, Optional, Dict, Any, List, Set, Tuple
 from datetime import datetime, timezone
 from html import unescape
 
-import aiohttp
 import json
+import os
+import sys
+from pathlib import Path
+
 from tenacity import (
     retry,
     stop_after_attempt,
     wait_exponential,
     retry_if_exception_type,
 )
-from playwright.async_api import async_playwright, Playwright, Browser, BrowserContext, Page, Error as PlaywrightError
 
-import sys
-from pathlib import Path
+from playwright.async_api import async_playwright, Page, Error as PlaywrightError
+from playwright_stealth import Stealth
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
@@ -74,36 +78,23 @@ def _safe_decimal(value: Any) -> Optional[Decimal]:
 
 class HiringCafeSpider:
     """
-    Production spider for hiring.cafe.
-
-    Uses the site's public API to discover and fetch job data:
-    - GET /api/search-jobs for paginated search
-    - GET /api/search-jobs/get-total-count for total count
-    - GET /_next/data/{buildId}/viewjob/{id}.json for full job details
+    Production spider for hiring.cafe using Playwright.
 
     Features:
-    - Auto-discovers and refreshes Next.js build ID each cycle
+    - Autonomously bypasses Cloudflare JS Challenges using a stealth Chromium instance
+    - Reuses clearance cookies for raw headless HTTP fetches avoiding constant popups
+    - GET /api/search-jobs for paginated search (returns full job records)
+    - GET /api/search-jobs/get-total-count for total count
+    - GET /_next/data/{buildId}/viewjob/{id}.json for extra detail (optional)
     - Configurable rate limiting (RPM)
     - Exponential backoff on 429 / transient errors
-    - Requisition ID as natural dedup key
+    - requisition_id as natural dedup key
     """
 
     BASE = "https://hiring.cafe"
     SEARCH_URL = "https://hiring.cafe/api/search-jobs"
     COUNT_URL = "https://hiring.cafe/api/search-jobs/get-total-count"
 
-    _BROWSER_HEADERS: Dict[str, str] = {
-        "User-Agent": (
-            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
-            "AppleWebKit/537.36 (KHTML, like Gecko) "
-            "Chrome/122.0.0.0 Safari/537.36"
-        ),
-        "Accept": "application/json, text/plain, */*",
-        "Accept-Language": "en-US,en;q=0.9",
-        "Origin": "https://hiring.cafe",
-        "Referer": "https://hiring.cafe/",
-    }
-
     _BUILD_ID_RE = re.compile(r'"buildId"\s*:\s*"([^"]+)"')
 
     def __init__(
@@ -117,11 +108,15 @@ def __init__(
         self._max_pages = max_pages
         self._last_request_at = 0.0
 
-        self._playwright: Optional[Playwright] = None
-        self._browser: Optional[Browser] = None
-        self._context: Optional[BrowserContext] = None
-        self._page: Optional[Page] = None
         self._build_id: Optional[str] = None
+        
+        # Session path
+        self._abs_root = Path("/Users/apple/Desktop/Postly/apps/scraper")
+        self._session_path = self._abs_root / ".sessions/hiring_cafe"
+        self._cookies_file = self._session_path / "cookies.json"
+        
+        # Injected runtime via scrape() execution loop
+        self._page: Optional[Page] = None
 
         # Metrics — reset between cycles by the orchestrator
         self.jobs_found = 0
@@ -129,70 +124,279 @@ def __init__(
         self.detail_fetches = 0
         self.errors = 0
 
-    # ─── Session ──────────────────────────────────────────────────
+    async def close(self) -> None:
+        """Compatibility signature."""
+        pass
+
+    # ─── Cloudflare Clearance & Session ───────────────────────────
+
+    def _get_chromium_args(self) -> List[str]:
+        """Return platform-specific Chromium arguments to avoid native segfaults."""
+        if sys.platform == "darwin":  # macOS
+            return [
+                "--disable-blink-features=AutomationControlled",
+                "--disable-dev-shm-usage",
+                "--disable-infobars",
+                "--window-size=1920,1080",
+                "--start-maximized",
+                "--lang=en-US",
+                "--exclude-switches=enable-automation",
+                "--disable-extensions-except=",
+                "--disable-gpu-sandbox",
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--disable-features=IsolateOrigins,site-per-process",
+            ]
+
+    async def _simulate_human_behavior(self, page: Page):
+        """Simulate realistic human interaction during the CF challenge window."""
+        try:
+            # Move mouse to a random spot
+            await page.mouse.move(random.randint(100, 700), random.randint(100, 500), steps=10)
+            
+            # Natural scroll (shorter, less blocking)
+            if random.random() > 0.5:
+                scroll = random.randint(100, 400)
+                await page.evaluate(f"window.scrollBy({{top: {scroll}, behavior: 'smooth'}});")
+                await asyncio.sleep(0.5)
+                await page.evaluate(f"window.scrollBy({{top: -{random.randint(50, 100)}, behavior: 'smooth'}});")
+            
+            await asyncio.sleep(random.uniform(0.1, 0.5))
+        except Exception as e:
+            logger.debug(f"Behavior simulation partial failure: {e}")
 
-    async def _get_page(self) -> Page:
-        if not self._page:
-            try:
-                if not self._playwright:
-                    self._playwright = await async_playwright().start()
-                if not self._browser:
-                    self._browser = await self._playwright.chromium.launch(
-                        headless=True,
-                        args=[
-                            "--disable-blink-features=AutomationControlled",
-                            "--no-sandbox",
-                            "--disable-setuid-sandbox",
-                            "--disable-dev-shm-usage",
-                        ],
-                    )
-                if not self._context:
-                    self._context = await self._browser.new_context(
-                        user_agent=self._BROWSER_HEADERS["User-Agent"],
-                        viewport={"width": 1280, "height": 800}
-                    )
-                if not self._page:
-                    self._page = await self._context.new_page()
-            except Exception as e:
-                # Need to clean up state so we truly retry from scratch
-                logger.error(f"Playwright initialization failed: {e}")
-                if self._playwright:
-                    await self._playwright.stop()
-                    self._playwright = None
-                self._browser = None
-                self._context = None
-                self._page = None
-                raise e
-        return self._page
+    async def _save_session(self, context) -> None:
+        """Save cookies to the session file."""
+        try:
+            self._session_path.mkdir(parents=True, exist_ok=True)
+            cookies = await context.cookies()
+            with open(self._cookies_file, "w") as f:
+                json.dump(cookies, f, indent=2)
+            logger.info(f"💾 Saved {len(cookies)} cookies to {self._cookies_file}")
+        except Exception as e:
+            logger.warning(f"Failed to save session: {e}")
 
-    async def close(self) -> None:
-        if self._context:
-            await self._context.close()
-        if self._browser:
-            await self._browser.close()
-        if self._playwright:
-            await self._playwright.stop()
-            logger.info("Spider Playwright session closed")
-
-    async def _reset_browser(self) -> None:
-        """Reset browser state after a crash."""
-        if self._page:
-            try:
-                await self._page.close()
-            except:
-                pass
-        if self._context:
+    async def _load_session(self, context) -> bool:
+        """Load cookies from the session file. Returns True if restored."""
+        try:
+            if self._cookies_file.exists():
+                with open(self._cookies_file, "r") as f:
+                    cookies = json.load(f)
+                await context.add_cookies(cookies)
+                logger.info(f"♻️ Restored {len(cookies)} cookies from session.")
+                return True
+        except Exception as e:
+            logger.warning(f"Failed to load session: {e}")
+        return False
+
+    async def _wait_for_clearance(self, page: Page, timeout_ms: int = 60000) -> bool:
+        """
+        Handles BOTH Managed (invisible) and Interactive (iframe) CF challenges.
+        Returns True if clearance was obtained.
+        """
+        start_time = asyncio.get_event_loop().time()
+        timeout_sec = timeout_ms / 1000.0
+        
+        TURNSTILE_SELECTORS = [
+            "#AOzYg6", # Primary Turnstile container found by investigation
+            "iframe[src*='challenges.cloudflare.com']",
+            "iframe[src*='challenge-platform']",
+            "iframe[title*='Cloudflare']",
+            "iframe[id*='cf-chl-widget']",
+            "#cf-turnstile",
+            ".cf-turnstile",
+        ]
+
+        logger.info(f"Executing behavioral simulation and waiting for challenge to settle ({timeout_sec}s)...")
+
+        while (asyncio.get_event_loop().time() - start_time) < timeout_sec:
+            # 1. Behavioral simulation loop (partial)
+            await self._simulate_human_behavior(page)
+            
+            # 2. Check: Cookie set (Managed Challenge solved silently or cookie restored)
+            cookies = await page.context.cookies()
+            if any(c["name"] == "cf_clearance" for c in cookies):
+                logger.info("✅ cf_clearance cookie captured.")
+                return True
+
+            # 3. Check: Page title cleared
             try:
-                await self._context.close()
-            except:
+                title = await page.title()
+                if "just a moment" not in title.lower() and "attention required" not in title.lower():
+                    logger.info(f"✅ Challenge passed based on title: {title}")
+                    return True
+            except Exception:
                 pass
-        self._page = None
-        self._context = None
+
+            # 4. Check: Turnstile Challenge (Advanced Frame Search)
+            solved_this_loop = False
+            for selector in TURNSTILE_SELECTORS:
+                try:
+                    locator = page.locator(selector).first
+                    if await locator.count() > 0:
+                        # Fallback 1: Try to find the checkbox in ANY frame on the page
+                        for frame in page.frames:
+                            try:
+                                checkbox = frame.locator("input[type='checkbox']").first
+                                if await checkbox.count() > 0 and await checkbox.is_visible():
+                                    logger.info(f"🔲 Turnstile checkbox found in frame '{frame.name or 'unnamed'}'. Clicking...")
+                                    await checkbox.click(timeout=3000)
+                                    solved_this_loop = True
+                                    break
+                            except Exception:
+                                continue
+                        
+                        if solved_this_loop:
+                            break
+
+                        # Fallback 2: Pixel click the LEFT-CENTER of the container (where the box actually is)
+                        logger.info(f"🔲 Turnstile container '{selector}' visible. Attempting left-side pixel click...")
+                        box = await locator.bounding_box()
+                        if box:
+                            # The checkbox in Cloudflare Turnstile is typically on the left side.
+                            # We click ~30px from the left and center vertically.
+                            target_x = box["x"] + 30 
+                            target_y = box["y"] + box["height"] / 2
+                            await page.mouse.click(target_x, target_y)
+                            solved_this_loop = True
+                            break
+                        
+                        logger.info(f"🔲 Turnstile element '{selector}' detected. Waiting for settlement...")
+                        break
+                except Exception:
+                    continue
+
+            await asyncio.sleep(1)
+
+        # Failure Diagnostics
+        try:
+            diag_path = self._abs_root / "debug_clearance.png"
+            await page.screenshot(path=str(diag_path))
+            logger.warning(f"❌ Clearance timed out. Screenshot saved to {diag_path}")
+        except Exception as e:
+            logger.debug(f"Failed to capture diagnostic screenshot: {e}")
+            
+        return False
+
+    async def _get_clearance(self, playwright) -> Tuple[Any, Any, Page, str]:
+        """
+        Launch a real browser, solve the CF challenge, return browser, context, page, UA.
+        """
+        is_headless = os.getenv("HEADLESS", "True").lower() in ("true", "1", "t")
+        logger.info(f"Initializing {'Headless' if is_headless else 'Headed'} Chromium/Chrome for Cloudflare Clearance...")
+        
+        launch_args = self._get_chromium_args()
+        
+        # Ensure no-sandbox for execution environment compatibility
+        if "--no-sandbox" not in launch_args:
+            launch_args.append("--no-sandbox")
+        
+        user_data_dir = self._session_path / "browser_data"
+        user_data_dir.mkdir(parents=True, exist_ok=True)
+
+        async def launch_with_retry():
+            # Attempt 1: Real Chrome (Best TLS)
+            # Attempt 2: Bundled Chromium (Fallback)
+            channels = ["chrome", None] if sys.platform == "darwin" else [None]
+            
+            last_err = None
+            for channel in channels:
+                try:
+                    logger.info(f"Targeting channel: {channel or 'bundled chromium'}...")
+                    return await playwright.chromium.launch_persistent_context(
+                        user_data_dir=str(user_data_dir.absolute()),
+                        headless=is_headless,
+                        args=launch_args,
+                        channel=channel,
+                        ignore_default_args=["--enable-automation"],
+                        user_agent=(
+                            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                            "AppleWebKit/537.36 (KHTML, like Gecko) "
+                            "Chrome/131.0.0.0 Safari/537.36"
+                        ),
+                        viewport={"width": 1440, "height": 900},
+                        device_scale_factor=2,
+                        locale="en-US",
+                    )
+                except Exception as e:
+                    last_err = e
+                    if "SingletonSocket" in str(e) or "ProcessSingleton" in str(e):
+                        logger.warning(f"Browser isolation error on {channel}: {e}. Retrying with different engine...")
+                        continue
+                    raise e
+            raise last_err
+
+        # Using 1440x900 Retina display scale for better fingerprint
+        context = await launch_with_retry()
+
+        # Patching detection vectors aggressively
+        await context.add_init_script("""
+            // 1. Remove webdriver
+            Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+            
+            // 2. Mock chrome runtime
+            window.chrome = {
+                runtime: {},
+                loadTimes: function() {},
+                csi: function() {},
+                app: {}
+            };
+            
+            // 3. Mock permissions
+            try {
+                const originalQuery = window.navigator.permissions.query;
+                window.navigator.permissions.query = (parameters) => (
+                    parameters.name === 'notifications' ?
+                    Promise.resolve({ state: Notification.permission }) :
+                    originalQuery(parameters)
+                );
+            } catch(e) {}
+            
+            // 4. Mock CPU cores (MacBook typically 8+)
+            Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8 });
+
+            // 5. Languages
+            Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+        """)
+
+        page = context.pages[0] if context.pages else await context.new_page()
+        
+        # High-fidelity Stealth CDP Injection
+        stealth = Stealth(
+            navigator_plugins=True,
+            navigator_permissions=True,
+        )
+        try:
+            await stealth.apply_stealth_async(page)
+            logger.info("playwright-stealth patches applied successfully")
+        except Exception as e:
+            logger.warning(f"playwright-stealth partial failure (continuing): {e}")
+
+        # Try restoring existing session cookies
+        await self._load_session(context)
+
+        # Navigate
+        logger.info(f"Navigating to {self.BASE} to verify session or clear challenges...")
+        try:
+            await page.goto(self.BASE, wait_until="domcontentloaded", timeout=30000)
+        except Exception as e:
+            logger.warning(f"Navigation error: {e}")
+
+        # Wait for clearance
+        success = await self._wait_for_clearance(page)
+        
+        if success:
+            await self._save_session(context)
+        else:
+            logger.warning("Proceeding without confirmed clearance (may fail with 403)")
+
+        ua = await page.evaluate("navigator.userAgent")
+        return None, context, page, ua
 
     # ─── Rate Limiting ────────────────────────────────────────────
 
     async def _throttle(self) -> None:
-        """Enforce minimum interval between outbound requests."""
+        """Enforce minimum interval between outbound API requests."""
         elapsed = time.monotonic() - self._last_request_at
         if elapsed < self._min_interval:
             await asyncio.sleep(self._min_interval - elapsed)
@@ -208,42 +412,40 @@ async def _throttle(self) -> None:
     async def _discover_build_id(self) -> str:
         """Fetch the homepage and extract the Next.js buildId."""
         await self._throttle()
-        page = await self._get_page()
+        logger.info(f"Fetching homepage for buildId using authorized session...")
 
-        try:
-            response = await page.goto(self.BASE, wait_until="domcontentloaded")
-        except Exception as e:
-            if "crashed" in str(e).lower() or "closed" in str(e).lower() or "timeout" in str(e).lower():
-                await self._reset_browser()
-            raise e
+        resp = await self._page.request.get(self.BASE)
+        status = resp.status
+        logger.info(f"Homepage response: {status}")
 
-        if not response or not response.ok:
-            raise PlaywrightError(f"Homepage returned {response.status if response else 'None'}")
-        
-        html = await page.content()
+        if status == 403:
+            logger.warning("Homepage 403 — Cloudflare block persists after clearance")
+            await asyncio.sleep(30)
+            raise PlaywrightError("Homepage 403 — Cloudflare block")
+
+        if status != 200:
+            raise PlaywrightError(f"Homepage returned {status}")
+
+        body_bytes = await resp.body()
+        html = body_bytes.decode('utf-8', errors='ignore')
 
         match = self._BUILD_ID_RE.search(html)
         if not match:
-            raise ValueError("Could not find buildId in __NEXT_DATA__")
+            logger.warning("Could not find buildId in homepage HTML.")
+            raise PlaywrightError("buildId not found in homepage")
 
         build_id = match.group(1)
         logger.info({"event": "build_id_discovered", "build_id": build_id})
         return build_id
 
     async def _ensure_build_id(self) -> None:
+        """Try to get buildId, but don't fail the whole scrape if it doesn't work."""
         if not self._build_id:
-            self._build_id = await self._discover_build_id()
-
-    async def _refresh_build_id(self) -> None:
-        """Force-refresh the build ID (e.g. after a 404 on detail fetch)."""
-        old = self._build_id
-        self._build_id = await self._discover_build_id()
-        if self._build_id != old:
-            logger.info({
-                "event": "build_id_rotated",
-                "old": old,
-                "new": self._build_id,
-            })
+            try:
+                self._build_id = await self._discover_build_id()
+            except Exception as e:
+                logger.warning(f"BuildId discovery failed: {e}. Skipping detail fetches.")
+                self._build_id = None
 
     # ─── Search API ───────────────────────────────────────────────
 
@@ -253,46 +455,50 @@ async def _refresh_build_id(self) -> None:
         retry=retry_if_exception_type((PlaywrightError, asyncio.TimeoutError)),
     )
     async def _search_page(self, offset: int) -> Dict[str, Any]:
-        """GET /api/search-jobs with query params for a page of results."""
+        """GET /api/search-jobs — returns JSON directly."""
         await self._throttle()
-        page = await self._get_page()
 
         url = f"{self.SEARCH_URL}?offset={offset}&limit={self._page_size}"
-        
-        try:
-            response = await page.goto(url, wait_until="domcontentloaded")
-        except Exception as e:
-            if "crashed" in str(e).lower() or "closed" in str(e).lower() or "timeout" in str(e).lower():
-                await self._reset_browser()
-            raise e
+        logger.debug(f"Searching offset {offset}...")
+
+        resp = await self._page.request.get(url)
+        status = resp.status
 
-        if response.status == 429:
+        if status == 429:
             retry_after = 60
+            if "Retry-After" in resp.headers:
+                retry_after = int(resp.headers["Retry-After"])
             logger.warning({"event": "rate_limited", "retry_after": retry_after})
             await asyncio.sleep(retry_after)
             raise PlaywrightError("Rate limited on search")
 
-        if not response.ok:
-            logger.error({"event": "search_error", "status": response.status})
-            raise PlaywrightError(f"Search returned {response.status}")
+        if status == 403:
+            logger.warning("Search 403 — Cloudflare challenge expired or failed.")
+            await asyncio.sleep(30)
+            raise PlaywrightError("Search returned 403")
+
+        if status != 200:
+            logger.error({"event": "search_error", "status": status})
+            raise PlaywrightError(f"Search returned {status}")
 
-        text = await page.evaluate("document.body.innerText")
         try:
-            return json.loads(text)
-        except json.JSONDecodeError:
-            raise PlaywrightError("Failed to parse search JSON")
+            data = await resp.json()
+        except Exception as e:
+            body_bytes = await resp.body()
+            text = body_bytes.decode('utf-8', errors='ignore')
+            logger.error(f"Failed to parse search JSON. Body preview: {text[:300]}")
+            raise PlaywrightError(f"Invalid JSON from search API: {e}")
+
+        return data
 
     async def _get_total_count(self) -> int:
         """GET /api/search-jobs/get-total-count → total available jobs."""
         await self._throttle()
-        page = await self._get_page()
 
         try:
-            response = await page.goto(self.COUNT_URL, wait_until="domcontentloaded")
-            if response and response.ok:
-                text = await page.evaluate("document.body.innerText")
-                data = json.loads(text)
-                # Response shape: { "total": 114789, "collapsedTotal": 4047 }
+            resp = await self._page.request.get(self.COUNT_URL)
+            if resp.status == 200:
+                data = await resp.json()
                 if isinstance(data, int):
                     total = data
                 elif isinstance(data, dict):
@@ -301,13 +507,13 @@ async def _get_total_count(self) -> int:
                     total = 0
                 logger.info({"event": "total_count", "total": total})
                 return total
+            else:
+                logger.warning(f"Count API returned {resp.status}")
         except Exception as exc:
             logger.warning(f"Could not get total count: {exc}")
-            if "crashed" in str(exc).lower() or "closed" in str(exc).lower() or "timeout" in str(exc).lower():
-                await self._reset_browser()
         return 0
 
-    # ─── Job Detail ───────────────────────────────────────────────
+    # ─── Job Detail (optional — needs buildId) ────────────────────
 
     @retry(
         stop=stop_after_attempt(3),
@@ -316,39 +522,41 @@ async def _get_total_count(self) -> int:
     )
     async def _fetch_job_detail(self, requisition_id: str) -> Optional[Dict[str, Any]]:
         """
-        GET /viewjob/{id} and extract __NEXT_DATA__
+        GET /_next/data/{buildId}/viewjob/{id}.json for full structured data.
+        Returns None if buildId is not available.
         """
-        await self._ensure_build_id()
-        await self._throttle()
-        page = await self._get_page()
+        if not self._build_id:
+            return None
 
-        url = f"{self.BASE}/viewjob/{requisition_id}"
+        await self._throttle()
 
-        try:
-            response = await page.goto(url, wait_until="domcontentloaded", timeout=30000)
-        except Exception as e:
-            logger.warning(f"Timeout or error fetching detail for {requisition_id}. Will retry... Error: {e}")
-            if "crashed" in str(e).lower() or "closed" in str(e).lower() or "timeout" in str(e).lower():
-                await self._reset_browser()
-            raise e
+        url = f"{self.BASE}/_next/data/{self._build_id}/viewjob/{requisition_id}.json"
 
-        if response and response.ok:
+        resp = await self._page.request.get(url)
+        status = resp.status
+        
+        if status == 200:
             self.detail_fetches += 1
-            html = await page.content()
-            match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>', html, re.DOTALL)
-            if match:
-                try:
-                    data = json.loads(match.group(1))
-                    return data.get("props", {})
-                except json.JSONDecodeError:
-                    return None
+            try:
+                data = await resp.json()
+                return data.get("pageProps", data)
+            except Exception:
+                return None
+
+        if status == 404:
+            logger.debug(f"Detail 404 for {requisition_id} — buildId may be stale")
             return None
 
-        if response and response.status == 429:
+        if status == 429:
             await asyncio.sleep(30)
             raise PlaywrightError("Rate limited on detail")
 
-        logger.debug(f"Detail {response.status if response else 'None'} for {requisition_id}")
+        if status == 403:
+            logger.warning("Detail 403 — blocked on individual fetch")
+            await asyncio.sleep(30)
+            raise PlaywrightError("Rate limited / blocked on detail")
+
+        logger.debug(f"Detail {status} for {requisition_id}")
         return None
 
     # ─── Parsing ──────────────────────────────────────────────────
@@ -359,20 +567,19 @@ def _extract_requisition_id(card: Dict[str, Any]) -> Optional[str]:
         return card.get("requisition_id") or card.get("objectID")
 
     def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
-        """Parse raw job detail JSON into ScrapedJob."""
+        """
+        Parse raw job data into ScrapedJob.
+        Handles both search result cards and detail page JSON.
+        """
         try:
             if not raw:
                 return None
-            
-            # Start with the main props
-            data = raw.get("pageProps", raw)
-            
-            # Merge nested job info if present, but keep parent fields
+
+            data = raw.get("pageProps", raw) if "pageProps" in raw else raw
+
             for key in ["job", "job_information"]:
                 nested = data.get(key)
                 if isinstance(nested, dict):
-                    # Shallow merge: nested fields overwrite parent but we keep what's unique
-                    # This ensures we get 'requisition_id' from parent and 'title' from child
                     merged = data.copy()
                     merged.update(nested)
                     data = merged
@@ -395,7 +602,6 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
                 logger.debug(f"Parsing failed: missing title or id. keys: {list(data.keys())}")
                 return None
 
-            # Company
             company_data = (
                 data.get("enriched_company_data")
                 or data.get("company_data")
@@ -408,7 +614,6 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
                 or "Unknown"
             )
 
-            # Description: HTML → plain text
             description_html = (
                 data.get("description")
                 or data.get("job_description_html")
@@ -416,22 +621,18 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
             )
             description = _html_to_text(description_html)
 
-            # Fall back to alternate field
             if len(description) < 10:
                 description = data.get("description_clean") or data.get("job_description_text") or description
-            
+
             if len(description) < 10:
                 logger.debug(f"Description too short for {requisition_id}. Content: {description[:50]}")
                 return None
 
-            # Processed data
             v5 = data.get("v5_processed_job_data") or data.get("processed_data") or {}
 
-            # Salary
             salary_min = _safe_decimal(v5.get("yearly_min_compensation") or data.get("yearly_min_compensation"))
             salary_max = _safe_decimal(v5.get("yearly_max_compensation") or data.get("yearly_max_compensation"))
 
-            # Location & remote
             workplace_type = (v5.get("workplace_type") or "").lower()
             is_remote = workplace_type == "remote"
             location = (
@@ -440,18 +641,14 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
                 or ("Remote" if is_remote else None)
             )
 
-            # Skills
             raw_tools = v5.get("technical_tools") or data.get("skills_required") or []
             skills = [str(t) for t in raw_tools if t] if isinstance(raw_tools, list) else []
 
-            # Experience
             min_yoe = v5.get("min_industry_and_role_yoe")
             experience = f"{min_yoe}+ years" if min_yoe else None
 
-            # Job type
             job_type = data.get("employment_type") or v5.get("employment_type")
 
-            # Apply URL
             apply_url = (
                 data.get("apply_url")
                 or f"{self.BASE}/viewjob/{requisition_id}"
@@ -479,7 +676,6 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
                     "nb_employees": company_data.get("nb_employees"),
                 },
             )
-            logger.debug(f"Parsed job successfully: {job.title} | {job.company_name}")
             return job
 
         except Exception as exc:
@@ -491,29 +687,58 @@ def _parse_job(self, raw: Dict[str, Any]) -> Optional[ScrapedJob]:
 
     async def scrape(
         self,
-        known_ids: Optional[set] = None,
+        known_ids: Optional[Set[str]] = None,
     ) -> AsyncIterator[ScrapedJob]:
         """
-        Full scrape cycle: discover IDs via search → fetch details → yield jobs.
+        Full scrape cycle using Playwright to bypass protections.
 
-        Args:
-            known_ids: Set of requisition_ids already in DB (skip these).
+        IMPORTANT: This is a best-effort spider. If Cloudflare blocks us,
+        we log a warning and yield nothing — we never crash the pipeline.
+        The other API-based spiders (Remotive, Arbeitnow, Greenhouse) will
+        still provide jobs even if hiring.cafe is fully blocked.
         """
         known = known_ids or set()
-
-        logger.info({"event": "scrape_start", "source": "hiring_cafe"})
         start_time = datetime.now(timezone.utc)
+        logger.info({"event": "scrape_start", "source": "hiring_cafe"})
 
-        # Step 1: Discover build ID
-        await self._ensure_build_id()
+        try:
+            async with async_playwright() as pw:
+                try:
+                    browser_obj, context, self._page, ua = await self._get_clearance(pw)
+                except Exception as e:
+                    logger.warning(
+                        f"[hiring_cafe] Cloudflare clearance failed — skipping this source. "
+                        f"Other sources will still run. Error: {e}"
+                    )
+                    self.errors += 1
+                    return
+
+                try:
+                    async for job in self._run_scrape_loop(known, start_time, total=None):
+                        yield job
+                finally:
+                    if browser_obj:
+                        await browser_obj.close()
+                    elif context:
+                        await context.close()
+                    self._page = None
+        except Exception as e:
+            logger.warning(
+                f"[hiring_cafe] Spider crashed — skipping this source. Error: {e}"
+            )
+            self.errors += 1
 
-        # Step 2: Get total count for progress logging
+    async def _run_scrape_loop(self, known: Set[str], start_time: datetime, total: Optional[int]) -> AsyncIterator[ScrapedJob]:
+        """Isolates the central loop iteration."""
+        
+        await self._ensure_build_id()
         total = await self._get_total_count()
 
-        # Step 3: Paginate search results to collect requisition IDs
         offset = 0
         page_num = 0
-        all_req_ids: List[str] = []
+
+        seen_ids: Set[str] = set()
+        duplicate_streak: int = 0
 
         while page_num < self._max_pages:
             try:
@@ -532,36 +757,53 @@ async def scrape(
             if not hits:
                 logger.info({"event": "pagination_complete", "pages": page_num})
                 break
+            
+            page_ids = {self._extract_requisition_id(c) for c in hits if self._extract_requisition_id(c)}
+            
+            if page_ids and page_ids.issubset(seen_ids):
+                duplicate_streak += 1
+                if duplicate_streak >= 2:
+                    logger.warning(f"Pagination loop detected, stopping early at offset {offset}")
+                    break
+            else:
+                duplicate_streak = 0
+            
+            seen_ids.update(page_ids)
 
-            page_req_ids = []
+            new_on_page = 0
             for card in hits:
                 req_id = self._extract_requisition_id(card)
-                if req_id and req_id not in known:
-                    page_req_ids.append(req_id)
-                    all_req_ids.append(req_id) # keep for final metrics
-
-            # Immediately fetch details for this page's new IDs
-            if page_req_ids:
-                logger.info(f"Discovered {len(page_req_ids)} new jobs on page {page_num + 1}. Fetching details...")
-                for rid in page_req_ids:
+                if not req_id or req_id in known:
+                    continue
+
+                known.add(req_id)
+
+                job = self._parse_job(card)
+
+                if not job and self._build_id:
                     try:
-                        result = await self._fetch_job_detail(rid)
-                        if result:
-                            job = self._parse_job(result)
-                            if job:
-                                self.jobs_found += 1
-                                yield job
+                        detail = await self._fetch_job_detail(req_id)
+                        if detail:
+                            job = self._parse_job(detail)
                     except Exception as exc:
-                        logger.error(f"Detail fetch failed for {rid}: {exc}")
+                        logger.debug(f"Detail fetch failed for {req_id}: {exc}")
                         self.errors += 1
 
+                if job:
+                    self.jobs_found += 1
+                    new_on_page += 1
+                    yield job
+
+            if new_on_page > 0:
+                logger.info(f"Page {page_num + 1}: found {new_on_page} new jobs")
+
             self.pages_scraped += 1
             page_num += 1
             offset += self._page_size
-            
+
             if page_num % 5 == 0:
-                logger.info(f"Progress: {page_num}/{self._max_pages} search pages processed. Total found: {self.jobs_found}")
-                
+                logger.info(f"Progress: {page_num}/{self._max_pages} pages. Total found: {self.jobs_found}")
+
             if total and offset >= total:
                 logger.info(f"Reached total {total} jobs")
                 break
@@ -579,7 +821,7 @@ async def scrape(
 
     async def scrape_all(
         self,
-        known_ids: Optional[set] = None,
+        known_ids: Optional[Set[str]] = None,
     ) -> List[ScrapedJob]:
         """Scrape all jobs and return as a list."""
         jobs: List[ScrapedJob] = []
diff --git a/apps/scraper/src/spiders/remotive.py b/apps/scraper/src/spiders/remotive.py
new file mode 100644
index 0000000..ec9552a
--- /dev/null
+++ b/apps/scraper/src/spiders/remotive.py
@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+remotive.py
+Spider for Remotive's public REST API.
+
+Endpoint: https://remotive.com/api/remote-jobs
+- Free, no auth, no Cloudflare
+- Returns remote-only jobs with salary, category, tags
+- Rate limit: max 2 requests/minute (TOS)
+"""
+
+import logging
+import re
+from datetime import datetime, timezone
+from typing import AsyncIterator, Optional, Set
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from models import ScrapedJob
+from spiders.base import (
+    BaseSpider,
+    html_to_text,
+    extract_yoe,
+    extract_salary,
+    detect_job_type,
+    safe_decimal,
+)
+
+logger = logging.getLogger(__name__)
+
+# Categories to scrape — covers tech, design, data, devops, marketing
+CATEGORIES = [
+    "software-dev",
+    "design",
+    "data",
+    "devops-sysadmin",
+    "product",
+    "customer-support",
+    "marketing",
+    "qa",
+    "writing",
+    "hr",
+    "finance-legal",
+    "business",
+    "all-others",
+]
+
+
+class RemotiveSpider(BaseSpider):
+    """
+    Production spider for Remotive.com remote job listings.
+
+    Features:
+    - Pure aiohttp — no browser, no Playwright, no Cloudflare issues
+    - Category-based iteration for broad coverage
+    - Rich field extraction: salary, YOE, job_type
+    - All results are remote by definition
+    """
+
+    SOURCE_NAME = "remotive"
+    BASE_URL = "https://remotive.com/api/remote-jobs"
+
+    def __init__(self, requests_per_minute: int = 2):
+        # Remotive TOS: max 2 req/min, max 4 fetches/day
+        super().__init__(requests_per_minute=requests_per_minute)
+
+    def _parse_job(self, raw: dict) -> Optional[ScrapedJob]:
+        """Parse a Remotive API job object into a ScrapedJob."""
+        try:
+            job_id = raw.get("id")
+            title = raw.get("title", "").strip()
+            company = raw.get("company_name", "").strip()
+            
+            if not title or not company:
+                return None
+
+            # Description
+            desc_html = raw.get("description", "")
+            description = html_to_text(desc_html)
+            if len(description) < 10:
+                return None
+
+            # URL
+            source_url = raw.get("url", "")
+            if not source_url:
+                return None
+
+            # Location — Remotive provides candidate_required_location
+            location = raw.get("candidate_required_location", "Worldwide")
+
+            # Salary — Remotive provides salary field as text
+            salary_text = raw.get("salary", "")
+            salary_min, salary_max = None, None
+            if salary_text:
+                salary_min, salary_max = extract_salary(salary_text)
+
+            # Also try extracting from description if no salary found
+            if not salary_min and not salary_max:
+                salary_min, salary_max = extract_salary(description[:2000])
+
+            # Job type
+            raw_job_type = raw.get("job_type", "")
+            job_type = self._normalize_job_type(raw_job_type)
+            if not job_type:
+                job_type = detect_job_type(description[:1000])
+
+            # YOE — extract from description
+            yoe = extract_yoe(description)
+
+            # Category/tags as skills
+            category = raw.get("category", "")
+            tags = raw.get("tags", []) or []
+            skills = [t for t in tags if t] if isinstance(tags, list) else []
+            if category and category not in skills:
+                skills.insert(0, category)
+
+            # Posted date
+            posted_at = None
+            pub_date = raw.get("publication_date")
+            if pub_date:
+                try:
+                    posted_at = datetime.fromisoformat(pub_date.replace("Z", "+00:00"))
+                except (ValueError, AttributeError):
+                    pass
+
+            return ScrapedJob(
+                title=title,
+                company_name=company,
+                description=description,
+                location=location,
+                salary_min=salary_min,
+                salary_max=salary_max,
+                job_type=job_type,
+                remote=True,  # All Remotive jobs are remote
+                source=self.SOURCE_NAME,
+                source_url=source_url,
+                skills_required=skills,
+                experience_required=yoe,
+                posted_at=posted_at,
+                is_active=True,
+                requisition_id=str(job_id) if job_id else source_url,
+            )
+
+        except Exception as e:
+            logger.error(f"[remotive] Parse error: {e}", exc_info=True)
+            self.errors += 1
+            return None
+
+    @staticmethod
+    def _normalize_job_type(raw: str) -> Optional[str]:
+        """Normalize Remotive job_type strings."""
+        if not raw:
+            return None
+        lower = raw.lower().replace("_", " ").replace("-", " ")
+        if "full" in lower:
+            return "full_time"
+        if "part" in lower:
+            return "part_time"
+        if "contract" in lower or "freelance" in lower:
+            return "contract"
+        if "intern" in lower:
+            return "internship"
+        return raw.lower().replace(" ", "_")
+
+    async def scrape(
+        self, known_ids: Optional[Set[str]] = None
+    ) -> AsyncIterator[ScrapedJob]:
+        """
+        Scrape all Remotive jobs across categories.
+        """
+        known = known_ids or set()
+        logger.info({"event": "scrape_start", "source": self.SOURCE_NAME})
+
+        try:
+            for category in CATEGORIES:
+                data = await self._get_json(
+                    self.BASE_URL,
+                    params={"category": category, "limit": 100},
+                )
+
+                if not data:
+                    continue
+
+                jobs_list = data.get("jobs", [])
+                if not jobs_list:
+                    logger.debug(f"[remotive] No jobs in category: {category}")
+                    continue
+
+                self.pages_scraped += 1
+                new_count = 0
+
+                for raw_job in jobs_list:
+                    job_id = str(raw_job.get("id", ""))
+                    url = raw_job.get("url", "")
+
+                    # Dedup: check by source URL or job ID
+                    if url in known or job_id in known:
+                        continue
+
+                    known.add(url)
+                    known.add(job_id)
+
+                    job = self._parse_job(raw_job)
+                    if job:
+                        self.jobs_found += 1
+                        new_count += 1
+                        yield job
+
+                if new_count > 0:
+                    logger.info(f"[remotive] Category '{category}': {new_count} new jobs")
+
+        except Exception as e:
+            logger.error(f"[remotive] Scrape failed: {e}", exc_info=True)
+            self.errors += 1
+        finally:
+            await self.close()
+
+        logger.info({
+            "event": "scrape_complete",
+            "source": self.SOURCE_NAME,
+            "jobs_found": self.jobs_found,
+            "pages_scraped": self.pages_scraped,
+            "errors": self.errors,
+        })
diff --git a/apps/scraper/src/test_hiring.py b/apps/scraper/src/test_hiring.py
new file mode 100644
index 0000000..f17b828
--- /dev/null
+++ b/apps/scraper/src/test_hiring.py
@@ -0,0 +1,22 @@
+import asyncio
+import logging
+from spiders.hiring_cafe import HiringCafeSpider
+from playwright.async_api import async_playwright
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
+)
+
+async def test_clearance():
+    spider = HiringCafeSpider()
+    async with async_playwright() as pw:
+        try:
+            cookies, ua = await spider._get_clearance(pw)
+            has_clearance = any(c['name'] == 'cf_clearance' for c in cookies)
+            print(f">>> TEST RESULT: cf_clearance obtained: {has_clearance}")
+        except Exception as e:
+            print(f">>> TEST ERROR: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_clearance())
diff --git a/apps/scraper/src/utils.py b/apps/scraper/src/utils.py
new file mode 100644
index 0000000..e71cdd6
--- /dev/null
+++ b/apps/scraper/src/utils.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+utils.py
+Shared utilities for the scraper application.
+"""
+from typing import List, Optional
+
+def format_vector(embedding: Optional[List[float]]) -> Optional[str]:
+    """
+    Safely formats a float list into pgvector-compatible string.
+    Use this everywhere — never use str(embedding) directly.
+    """
+    if not embedding:
+        return None
+    return '[' + ','.join(str(v) for v in embedding) + ']'
\ No newline at end of file
diff --git a/apps/scraper/test_args.py b/apps/scraper/test_args.py
new file mode 100644
index 0000000..8029cfe
--- /dev/null
+++ b/apps/scraper/test_args.py
@@ -0,0 +1,52 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+async def test_args(args_list, tag):
+    try:
+        async with async_playwright() as pw:
+            browser = await pw.chromium.launch(
+                headless=True,
+                args=args_list
+            )
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                viewport={"width": 1280, "height": 800},
+                locale="en-US",
+            )
+            page = await context.new_page()
+            await page.add_init_script("""
+                Object.defineProperty(navigator, 'plugins', { get: () => Object.freeze([{name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format', length: 1}]) });
+                window.chrome = { runtime: {} };
+            """)
+            print(f"[{tag}] going to hiring.cafe...")
+            await page.goto("https://hiring.cafe", wait_until="domcontentloaded", timeout=15000)
+            await page.wait_for_timeout(3000)
+            print(f"[{tag}] SUCCESS")
+            await browser.close()
+    except Exception as e:
+        print(f"[{tag}] CRASH:", e)
+
+async def main():
+    print("Testing config 1: default + swiftshader")
+    await test_args([
+        "--disable-blink-features=AutomationControlled",
+        "--disable-dev-shm-usage",
+        "--use-gl=swiftshader"
+    ], "swiftshader")
+    
+    print("Testing config 2: default WITHOUT swiftshader (no disable-gpu)")
+    await test_args([
+        "--disable-blink-features=AutomationControlled",
+        "--disable-dev-shm-usage"
+    ], "no-gpu-flags")
+
+    print("Testing config 3: angle swiftshader")
+    await test_args([
+        "--disable-blink-features=AutomationControlled",
+        "--disable-dev-shm-usage",
+        "--use-gl=angle",
+        "--use-angle=swiftshader"
+    ], "angle-swiftshader")
+
+if __name__ == '__main__':
+    asyncio.run(main())
diff --git a/apps/scraper/test_no_sandbox.py b/apps/scraper/test_no_sandbox.py
new file mode 100644
index 0000000..a8d8f9c
--- /dev/null
+++ b/apps/scraper/test_no_sandbox.py
@@ -0,0 +1,42 @@
+import asyncio
+import os
+from playwright.async_api import async_playwright
+
+async def test_no_sandbox(with_js_inject, tag):
+    try:
+        async with async_playwright() as pw:
+            # specifically ensuring --no-sandbox is absent!
+            browser = await pw.chromium.launch(
+                headless=True,
+                args=["--disable-blink-features=AutomationControlled"]
+            )
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                viewport={"width": 1280, "height": 800},
+            )
+            page = await context.new_page()
+            
+            if with_js_inject:
+                await page.add_init_script("""
+                    Object.defineProperty(navigator, 'plugins', { get: () => Object.freeze([{name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format', length: 1}]) });
+                    window.chrome = { runtime: {} };
+                """)
+
+            print(f"[{tag}] going to hiring.cafe...")
+            await page.goto("https://hiring.cafe", wait_until="domcontentloaded", timeout=15000)
+            await page.wait_for_timeout(3000)
+            html = await page.evaluate("() => document.title")
+            print(f"[{tag}] SUCCESS, title: {html}")
+            await browser.close()
+    except Exception as e:
+        print(f"[{tag}] CRASH:", e)
+
+async def main():
+    print("Testing 1: NO NO-SANDBOX, WITH JS")
+    await test_no_sandbox(True, "with_js")
+    
+    print("Testing 2: NO NO-SANDBOX, NO JS")
+    await test_no_sandbox(False, "no_js")
+
+if __name__ == '__main__':
+    asyncio.run(main())
diff --git a/apps/scraper/test_plugins.py b/apps/scraper/test_plugins.py
new file mode 100644
index 0000000..db7712b
--- /dev/null
+++ b/apps/scraper/test_plugins.py
@@ -0,0 +1,41 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+async def test_plugins(with_plugins_hack_enabled, tag):
+    try:
+        async with async_playwright() as pw:
+            browser = await pw.chromium.launch(
+                headless=True,
+                args=[
+                    "--no-sandbox",
+                    "--disable-blink-features=AutomationControlled",
+                ]
+            )
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            )
+            page = await context.new_page()
+            
+            if with_plugins_hack_enabled:
+                await page.add_init_script("""
+                    Object.defineProperty(navigator, 'plugins', { get: () => Object.freeze([{name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format', length: 1}]) });
+                """)
+
+            print(f"[{tag}] going to hiring.cafe...")
+            await page.goto("https://hiring.cafe", wait_until="domcontentloaded", timeout=15000)
+            await page.wait_for_timeout(3000)
+            title = await page.title()
+            print(f"[{tag}] SUCCESS, title: {title}")
+            await browser.close()
+    except Exception as e:
+        print(f"[{tag}] CRASH:", e)
+
+async def main():
+    print("Testing 1: WITH JS inject")
+    await test_plugins(True, "with_js")
+    
+    print("Testing 2: WITHOUT JS inject")
+    await test_plugins(False, "no_js")
+
+if __name__ == '__main__':
+    asyncio.run(main())
diff --git a/apps/scraper/test_single_process.py b/apps/scraper/test_single_process.py
new file mode 100644
index 0000000..15c2a03
--- /dev/null
+++ b/apps/scraper/test_single_process.py
@@ -0,0 +1,39 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+async def test_single_process():
+    try:
+        async with async_playwright() as pw:
+            print("launching single process chromium...")
+            browser = await pw.chromium.launch(
+                headless=True,
+                args=[
+                    "--disable-blink-features=AutomationControlled",
+                    "--disable-dev-shm-usage",
+                    "--single-process",  # Stops subprocess spawning (avoids mach_port failures)
+                ]
+            )
+            print("context...")
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                viewport={"width": 1280, "height": 800},
+            )
+            print("page...")
+            page = await context.new_page()
+            
+            await page.add_init_script("""
+                Object.defineProperty(navigator, 'plugins', { get: () => Object.freeze([{name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format', length: 1}]) });
+                window.chrome = { runtime: {} };
+            """)
+
+            print("going to hiring.cafe...")
+            await page.goto("https://hiring.cafe", wait_until="domcontentloaded", timeout=15000)
+            await page.wait_for_timeout(3000)
+            html = await page.evaluate("() => document.title")
+            print(f"SUCCESS, title: {html}")
+            await browser.close()
+    except Exception as e:
+        print("CRASH:", e)
+
+if __name__ == '__main__':
+    asyncio.run(test_single_process())
diff --git a/apps/web/index.html b/apps/web/index.html
index e49b108..eb78b71 100644
--- a/apps/web/index.html
+++ b/apps/web/index.html
@@ -5,9 +5,17 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="description" content="AI-powered job matching platform" />
-    <title>Postly - AI Job Matching</title>
+    <title>Postly - Search Jobs</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link rel="preconnect" href="https://postly-api.learnest.asia" />
+    <!-- Cloudflare Web Analytics -->
+    <script
+      defer
+      src="https://static.cloudflareinsights.com/beacon.min.js"
+      data-cf-beacon='{"token": "392845b5debd47d7a792a1f85a4909a4"}'
+    ></script>
+    <!-- End Cloudflare Web Analytics -->
     <link
       href="https://fonts.googleapis.com/css2?family=Outfit:wght@100..900&display=swap"
       rel="stylesheet"
diff --git a/apps/web/src/App.tsx b/apps/web/src/App.tsx
index 719b05a..d7f37d9 100644
--- a/apps/web/src/App.tsx
+++ b/apps/web/src/App.tsx
@@ -3,11 +3,16 @@ import { BrowserRouter, Routes, Route } from "react-router-dom";
 import { ProtectedRoute } from "./components/ProtectedRoute";
 import { PageLoader } from "./components/ui/PageLoader";
 import { ToastContainer } from "./components/ui/Toast";
+import "./styles/transmission.css";
 
-// ─── Lazy-loaded Transmission pages ─────────────────────────────────
-const TransmissionLanding = lazy(() =>
-  import("@pages/TransmissionLanding").then((m) => ({
-    default: m.TransmissionLanding,
+const TransmissionHome = lazy(() =>
+  import("@pages/TransmissionHome").then((m) => ({
+    default: m.TransmissionHome,
+  })),
+);
+const TransmissionRoleSelector = lazy(() =>
+  import("@pages/TransmissionRoleSelector").then((m) => ({
+    default: m.TransmissionRoleSelector,
   })),
 );
 const TransmissionLogin = lazy(() =>
@@ -20,6 +25,12 @@ const TransmissionRegister = lazy(() =>
     default: m.TransmissionRegister,
   })),
 );
+const VerifyOtpPage = lazy(() =>
+  import("./pages/VerifyOtpPage").then((m) => ({
+    default: m.VerifyOtpPage,
+  })),
+);
+
 const TransmissionPricing = lazy(() =>
   import("@pages/TransmissionPricing").then((m) => ({
     default: m.TransmissionPricing,
@@ -35,13 +46,17 @@ const TransmissionIntegrations = lazy(() =>
     default: m.TransmissionIntegrations,
   })),
 );
+const TransmissionSettings = lazy(() =>
+  import("@pages/TransmissionSettings").then((m) => ({
+    default: m.TransmissionSettings,
+  })),
+);
 const TransmissionNotFound = lazy(() =>
   import("@pages/TransmissionNotFound").then((m) => ({
     default: m.TransmissionNotFound,
   })),
 );
 
-// ─── Auth utilities ─────────────────────────────────────────────────
 const ForgotPasswordPage = lazy(() =>
   import("./pages/ForgotPasswordPage").then((m) => ({
     default: m.ForgotPasswordPage,
@@ -59,9 +74,12 @@ function App() {
       <Suspense fallback={<PageLoader />}>
         <Routes>
           {/* ─── Public ──────────────────────────────────── */}
-          <Route path="/" element={<TransmissionLanding />} />
+          <Route path="/" element={<TransmissionHome />} />
+          <Route path="join" element={<TransmissionRoleSelector />} />
           <Route path="login" element={<TransmissionLogin />} />
           <Route path="register" element={<TransmissionRegister />} />
+          <Route path="verify-otp" element={<VerifyOtpPage />} />
+
           <Route path="pricing" element={<TransmissionPricing />} />
           <Route path="forgot-password" element={<ForgotPasswordPage />} />
           <Route path="login/callback" element={<AuthCallbackPage />} />
@@ -91,6 +109,14 @@ function App() {
               </ProtectedRoute>
             }
           />
+          <Route
+            path="settings"
+            element={
+              <ProtectedRoute>
+                <TransmissionSettings />
+              </ProtectedRoute>
+            }
+          />
 
           {/* ─── 404 ─────────────────────────────────────── */}
           <Route path="*" element={<TransmissionNotFound />} />
diff --git a/apps/web/src/components/chat/JobCarousel.tsx b/apps/web/src/components/chat/JobCarousel.tsx
index 65d1478..88699c6 100644
--- a/apps/web/src/components/chat/JobCarousel.tsx
+++ b/apps/web/src/components/chat/JobCarousel.tsx
@@ -15,13 +15,44 @@ export function JobCarousel({
   onApply,
 }: JobCarouselProps) {
   return (
-    <div className="w-full space-y-4">
-      {message && <p className="text-zinc-100">{message}</p>}
+    <div
+      style={{
+        width: "100%",
+        display: "flex",
+        flexDirection: "column",
+        gap: "16px",
+      }}
+    >
+      {message && (
+        <p
+          style={{
+            fontFamily: "var(--tx-font-mono)",
+            fontSize: "13px",
+            color: "var(--tx-ink)",
+          }}
+        >
+          {message}
+        </p>
+      )}
 
       {/* Scroll Container */}
-      <div className="flex gap-4 overflow-x-auto pb-4 -mx-4 px-4 scrollbar-thin scrollbar-thumb-zinc-700 scrollbar-track-transparent snap-x">
+      <div
+        className="tx-scrollbar"
+        style={{
+          display: "flex",
+          gap: "16px",
+          overflowX: "auto",
+          paddingBottom: "16px",
+          scrollSnapType: "x mandatory",
+          margin: "0 -20px",
+          padding: "0 20px 16px 20px",
+        }}
+      >
         {data.map((job) => (
-          <div key={job.id} className="snap-center">
+          <div
+            key={job.id}
+            style={{ scrollSnapAlign: "center", flexShrink: 0 }}
+          >
             <JobCard job={job} onApply={onApply} variant="chat" />
           </div>
         ))}
@@ -29,14 +60,39 @@ export function JobCarousel({
 
       {/* Actions */}
       {suggested_actions && suggested_actions.length > 0 && (
-        <div className="flex flex-wrap gap-2">
+        <div style={{ display: "flex", flexWrap: "wrap", gap: "8px" }}>
           {suggested_actions.map((action, i) => (
             <button
               key={i}
-              className="px-3 py-1.5 rounded-full border border-white/10 bg-white/5 hover:bg-white/10 text-sm text-zinc-300 transition-colors flex items-center gap-1.5 group"
+              style={{
+                fontFamily: "var(--tx-font-mono)",
+                fontSize: "11px",
+                fontWeight: 600,
+                color: "var(--tx-ink)",
+                background: "transparent",
+                border: "2px solid var(--tx-border)",
+                borderRadius: "var(--tx-radius)",
+                padding: "6px 12px",
+                cursor: "pointer",
+                letterSpacing: "1px",
+                textTransform: "uppercase",
+                display: "flex",
+                alignItems: "center",
+                gap: "6px",
+                transition:
+                  "background-color 150ms var(--tx-ease-sharp), color 150ms var(--tx-ease-sharp)",
+              }}
+              onMouseEnter={(e) => {
+                e.currentTarget.style.backgroundColor = "var(--tx-ink)";
+                e.currentTarget.style.color = "var(--tx-surface)";
+              }}
+              onMouseLeave={(e) => {
+                e.currentTarget.style.backgroundColor = "transparent";
+                e.currentTarget.style.color = "var(--tx-ink)";
+              }}
             >
               {action}
-              <ChevronRight className="w-3 h-3 text-zinc-500 group-hover:text-zinc-300 transition-colors" />
+              <ChevronRight className="w-3 h-3" />
             </button>
           ))}
         </div>
diff --git a/apps/web/src/components/chat/TransmissionSidebar.tsx b/apps/web/src/components/chat/TransmissionSidebar.tsx
index b2c76df..e6b9c87 100644
--- a/apps/web/src/components/chat/TransmissionSidebar.tsx
+++ b/apps/web/src/components/chat/TransmissionSidebar.tsx
@@ -58,7 +58,9 @@ export function TransmissionSidebar({
   const [deleteId, setDeleteId] = useState<string | null>(null);
   const [isDeleting, setIsDeleting] = useState(false);
   const [isCreating, setIsCreating] = useState(false);
+  const [isProfileOpen, setIsProfileOpen] = useState(false);
   const sidebarRef = useRef<HTMLDivElement>(null);
+  const profileRef = useRef<HTMLDivElement>(null);
 
   // Fetch conversations
   const { data: fetchedConversations } = useQuery({
@@ -72,6 +74,24 @@ export function TransmissionSidebar({
     }
   }, [fetchedConversations, setConversations]);
 
+  // Click outside profile menu handler
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (
+        profileRef.current &&
+        !profileRef.current.contains(event.target as Node)
+      ) {
+        setIsProfileOpen(false);
+      }
+    };
+    if (isProfileOpen) {
+      document.addEventListener("mousedown", handleClickOutside);
+    }
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [isProfileOpen]);
+
   const handleNewChat = async () => {
     if (isCreating) return;
     setIsCreating(true);
@@ -324,83 +344,166 @@ export function TransmissionSidebar({
 
         {/* User profile */}
         <div
+          ref={profileRef}
           style={{
             padding: "12px",
             borderTop: "2px solid var(--tx-border)",
             flexShrink: 0,
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "space-between",
+            position: "relative",
           }}
         >
+          {/* Dropdown Menu */}
+          {isProfileOpen && (
+            <div
+              style={{
+                position: "absolute",
+                bottom: "calc(100% + 8px)",
+                left: "12px",
+                right: "12px",
+                background: "var(--tx-surface)",
+                border: "2px solid var(--tx-border)",
+                boxShadow: "4px 4px 0px var(--tx-border)",
+                zIndex: 100,
+                display: "flex",
+                flexDirection: "column",
+                overflow: "hidden",
+              }}
+            >
+              {[
+                // { label: "Pricing", path: "/pricing" },
+                { label: "Account Settings", path: "/settings" },
+                { label: "Integration", path: "/integrations" },
+                { label: "Logout", action: logout, danger: true },
+              ].map((item) => (
+                <button
+                  key={item.label}
+                  onClick={() => {
+                    if (item.path) navigate(item.path);
+                    if (item.action) item.action();
+                    setIsProfileOpen(false);
+                  }}
+                  style={{
+                    padding: "12px 16px",
+                    fontFamily: "var(--tx-font-mono)",
+                    fontSize: "11px",
+                    fontWeight: 600,
+                    textAlign: "left",
+                    color: item.danger ? "var(--tx-seeker)" : "var(--tx-ink)",
+                    background: "transparent",
+                    border: "none",
+                    borderBottom: "1px solid var(--tx-border)",
+                    cursor: "pointer",
+                    textTransform: "uppercase",
+                    letterSpacing: "1px",
+                    transition: "all 150ms var(--tx-ease-sharp)",
+                  }}
+                  className="tx-menu-item"
+                  onMouseEnter={(e) => {
+                    e.currentTarget.style.background = "var(--tx-bg)";
+                  }}
+                  onMouseLeave={(e) => {
+                    e.currentTarget.style.background = "transparent";
+                  }}
+                >
+                  {item.label}
+                </button>
+              ))}
+            </div>
+          )}
+
           <div
+            onClick={() => setIsProfileOpen(!isProfileOpen)}
+            role="button"
+            tabIndex={0}
             style={{
+              padding: "8px",
               display: "flex",
               alignItems: "center",
-              gap: "8px",
-              minWidth: 0,
+              justifyContent: "space-between",
+              cursor: "pointer",
+              background: isProfileOpen ? "var(--tx-bg)" : "transparent",
+              transition: "background-color 150ms var(--tx-ease-sharp)",
+            }}
+            onMouseEnter={(e) => {
+              if (!isProfileOpen)
+                e.currentTarget.style.backgroundColor = "var(--tx-bg)";
+            }}
+            onMouseLeave={(e) => {
+              if (!isProfileOpen)
+                e.currentTarget.style.backgroundColor = "transparent";
             }}
           >
             <div
               style={{
-                width: "28px",
-                height: "28px",
-                border: "2px solid var(--tx-border)",
-                borderRadius: "var(--tx-radius)",
                 display: "flex",
                 alignItems: "center",
-                justifyContent: "center",
-                fontFamily: "var(--tx-font-mono)",
-                fontSize: "11px",
-                fontWeight: 700,
-                color: "var(--tx-ink)",
-                flexShrink: 0,
+                gap: "10px",
+                minWidth: 0,
               }}
             >
-              {user?.full_name?.[0]?.toUpperCase() || "U"}
+              <div
+                style={{
+                  width: "32px",
+                  height: "32px",
+                  border: "2px solid var(--tx-border)",
+                  borderRadius: "var(--tx-radius)",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  fontFamily: "var(--tx-font-mono)",
+                  fontSize: "12px",
+                  fontWeight: 700,
+                  color: "var(--tx-ink)",
+                  background: "var(--tx-surface)",
+                  flexShrink: 0,
+                }}
+              >
+                {user?.full_name?.[0]?.toUpperCase() || "U"}
+              </div>
+              <div
+                style={{
+                  display: "flex",
+                  flexDirection: "column",
+                  minWidth: 0,
+                }}
+              >
+                <span
+                  style={{
+                    fontFamily: "var(--tx-font-mono)",
+                    fontSize: "11px",
+                    fontWeight: 700,
+                    color: "var(--tx-ink)",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap",
+                  }}
+                >
+                  {user?.full_name || "User"}
+                </span>
+                <span
+                  style={{
+                    fontFamily: "var(--tx-font-mono)",
+                    fontSize: "9px",
+                    color: "var(--tx-ink-muted)",
+                    textTransform: "uppercase",
+                  }}
+                >
+                  {role}
+                </span>
+              </div>
             </div>
-            <span
+
+            <div
               style={{
-                fontFamily: "var(--tx-font-mono)",
-                fontSize: "11px",
-                color: "var(--tx-ink)",
-                overflow: "hidden",
-                textOverflow: "ellipsis",
-                whiteSpace: "nowrap",
+                fontSize: "10px",
+                color: "var(--tx-ink-muted)",
+                transform: isProfileOpen ? "rotate(180deg)" : "rotate(0deg)",
+                transition: "transform 200ms var(--tx-ease-sharp)",
               }}
             >
-              {user?.full_name || "User"}
-            </span>
+              ▲
+            </div>
           </div>
-
-          <button
-            onClick={() => logout()}
-            style={{
-              fontFamily: "var(--tx-font-mono)",
-              fontSize: "10px",
-              fontWeight: 600,
-              color: "var(--tx-ink-muted)",
-              background: "transparent",
-              border: "1px solid var(--tx-ink-muted)",
-              borderRadius: "var(--tx-radius)",
-              padding: "4px 8px",
-              cursor: "pointer",
-              letterSpacing: "1px",
-              textTransform: "uppercase",
-              transition:
-                "color 150ms var(--tx-ease-sharp), border-color 150ms var(--tx-ease-sharp)",
-            }}
-            onMouseEnter={(e) => {
-              e.currentTarget.style.color = "var(--tx-seeker)";
-              e.currentTarget.style.borderColor = "var(--tx-seeker)";
-            }}
-            onMouseLeave={(e) => {
-              e.currentTarget.style.color = "var(--tx-ink-muted)";
-              e.currentTarget.style.borderColor = "var(--tx-ink-muted)";
-            }}
-          >
-            EXIT
-          </button>
         </div>
       </aside>
 
diff --git a/apps/web/src/components/jobs/JobCard.tsx b/apps/web/src/components/jobs/JobCard.tsx
index e733958..68725a9 100644
--- a/apps/web/src/components/jobs/JobCard.tsx
+++ b/apps/web/src/components/jobs/JobCard.tsx
@@ -57,26 +57,275 @@ export function JobCard({
   const { display_info, matching_data, meta } = job;
   const isChat = variant === "chat";
 
+  if (isChat) {
+    return (
+      <div
+        onClick={onClick}
+        style={{
+          width: "280px",
+          minWidth: "280px",
+          display: "flex",
+          flexDirection: "column",
+          background: "var(--tx-bg)",
+          border: "2px solid var(--tx-border)",
+          borderRadius: "var(--tx-radius)",
+          cursor: "pointer",
+          position: "relative",
+          transition:
+            "transform 150ms var(--tx-ease-sharp), box-shadow 150ms var(--tx-ease-sharp)",
+          boxShadow: "4px 4px 0 var(--tx-border)",
+        }}
+        onMouseEnter={(e) => {
+          e.currentTarget.style.transform = "translate(-2px, -2px)";
+          e.currentTarget.style.boxShadow = "6px 6px 0 var(--tx-border)";
+        }}
+        onMouseLeave={(e) => {
+          e.currentTarget.style.transform = "translate(0, 0)";
+          e.currentTarget.style.boxShadow = "4px 4px 0 var(--tx-border)";
+        }}
+      >
+        {/* Match Score */}
+        {matching_data.match_score > 0 && (
+          <div
+            style={{
+              position: "absolute",
+              top: "-2px",
+              right: "-2px",
+              zIndex: 10,
+            }}
+          >
+            <div
+              style={{
+                background: "var(--tx-seeker)",
+                color: "white",
+                border: "2px solid var(--tx-border)",
+                padding: "4px 8px",
+                fontFamily: "var(--tx-font-mono)",
+                fontSize: "11px",
+                fontWeight: 700,
+                letterSpacing: "1px",
+              }}
+            >
+              {matching_data.match_score}% MATCH
+            </div>
+          </div>
+        )}
+
+        {/* Content */}
+        <div
+          style={{
+            padding: "16px",
+            display: "flex",
+            flexDirection: "column",
+            flex: 1,
+          }}
+        >
+          <h3
+            style={{
+              fontFamily: "var(--tx-font-display)",
+              fontWeight: 700,
+              fontSize: "18px",
+              color: "var(--tx-ink)",
+              marginBottom: "6px",
+              lineHeight: 1.2,
+              paddingRight: "80px", // give space for match score
+              display: "-webkit-box",
+              WebkitLineClamp: 2,
+              WebkitBoxOrient: "vertical",
+              overflow: "hidden",
+            }}
+          >
+            {display_info.title}
+          </h3>
+
+          <div
+            style={{
+              display: "flex",
+              alignItems: "center",
+              gap: "6px",
+              fontFamily: "var(--tx-font-mono)",
+              fontSize: "12px",
+              color: "var(--tx-ink-muted)",
+              marginBottom: "16px",
+            }}
+          >
+            <Building2 style={{ width: "14px", height: "14px" }} />
+            <span
+              style={{
+                fontWeight: 600,
+                textTransform: "uppercase",
+                whiteSpace: "nowrap",
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+              }}
+            >
+              {display_info.company}
+            </span>
+          </div>
+
+          <div
+            style={{
+              display: "flex",
+              flexWrap: "wrap",
+              gap: "8px",
+              fontFamily: "var(--tx-font-mono)",
+              fontSize: "11px",
+              color: "var(--tx-ink)",
+              marginBottom: "16px",
+            }}
+          >
+            {display_info.location && (
+              <span
+                style={{
+                  display: "flex",
+                  alignItems: "center",
+                  gap: "4px",
+                  border: "1px solid var(--tx-border)",
+                  padding: "2px 8px",
+                  background: "var(--tx-surface)",
+                }}
+              >
+                <MapPin style={{ width: "12px", height: "12px" }} />
+                <span
+                  style={{
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    maxWidth: "120px",
+                    fontWeight: 500,
+                  }}
+                >
+                  {display_info.location}
+                </span>
+              </span>
+            )}
+            {meta.salary_range && (
+              <span
+                style={{
+                  display: "flex",
+                  alignItems: "center",
+                  gap: "4px",
+                  border: "1px solid var(--tx-border)",
+                  background: "var(--tx-surface)",
+                  padding: "2px 8px",
+                  fontWeight: 600,
+                }}
+              >
+                {meta.salary_range}
+              </span>
+            )}
+          </div>
+
+          <div
+            style={{
+              display: "flex",
+              flexWrap: "wrap",
+              gap: "6px",
+              marginTop: "auto",
+              marginBottom: "4px",
+            }}
+          >
+            {matching_data.key_skills?.slice(0, 3).map((skill) => (
+              <span
+                key={skill}
+                style={{
+                  background: "var(--tx-ink)",
+                  color: "var(--tx-surface)",
+                  padding: "2px 8px",
+                  fontFamily: "var(--tx-font-mono)",
+                  fontSize: "10px",
+                  fontWeight: 600,
+                  textTransform: "uppercase",
+                  letterSpacing: "0.5px",
+                }}
+              >
+                {skill}
+              </span>
+            ))}
+            {matching_data.key_skills &&
+              matching_data.key_skills.length > 3 && (
+                <span
+                  style={{
+                    border: "1px solid var(--tx-ink)",
+                    color: "var(--tx-ink)",
+                    padding: "2px 8px",
+                    fontFamily: "var(--tx-font-mono)",
+                    fontSize: "10px",
+                    fontWeight: 600,
+                  }}
+                >
+                  +{matching_data.key_skills.length - 3}
+                </span>
+              )}
+          </div>
+        </div>
+
+        {/* Footer actions */}
+        <div
+          style={{
+            borderTop: "2px solid var(--tx-border)",
+            padding: "12px",
+            background: "var(--tx-surface)",
+          }}
+        >
+          <button
+            onClick={(e: React.MouseEvent) => {
+              e.stopPropagation();
+              if (onApply) onApply(job.id);
+              else if (meta.apply_url)
+                window.open(meta.apply_url, "_blank", "noopener,noreferrer");
+            }}
+            style={{
+              width: "100%",
+              fontFamily: "var(--tx-font-mono)",
+              fontSize: "11px",
+              fontWeight: 700,
+              color: "var(--tx-surface)",
+              background: "var(--tx-ink)",
+              border: "2px solid var(--tx-border)",
+              padding: "10px",
+              cursor: "pointer",
+              letterSpacing: "1px",
+              textTransform: "uppercase",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              gap: "8px",
+              transition:
+                "transform 100ms var(--tx-ease-sharp), background-color 150ms var(--tx-ease-sharp)",
+            }}
+            onMouseEnter={(e) =>
+              (e.currentTarget.style.backgroundColor = "var(--tx-seeker)")
+            }
+            onMouseLeave={(e) => {
+              e.currentTarget.style.backgroundColor = "var(--tx-ink)";
+              e.currentTarget.style.transform = "scaleX(1)";
+            }}
+            onMouseDown={(e) =>
+              (e.currentTarget.style.transform = "scaleX(0.96)")
+            }
+            onMouseUp={(e) => (e.currentTarget.style.transform = "scaleX(1)")}
+          >
+            VIEW & APPLY
+            <ExternalLink style={{ width: "14px", height: "14px" }} />
+          </button>
+        </div>
+      </div>
+    );
+  }
+
   return (
     <div
       onClick={onClick}
       className={cn(
-        "group bg-card border border-border rounded-xl transition-all duration-200 cursor-pointer overflow-hidden flex flex-col",
-        isChat
-          ? "w-[280px] min-w-[280px] bg-zinc-900/50 border-white/10 hover:border-white/20"
-          : "p-4 hover:shadow-md hover:border-primary/30",
+        "group bg-card border border-border rounded-xl transition-all duration-200 cursor-pointer overflow-hidden flex flex-col p-4 hover:shadow-md hover:border-primary/30",
         isSelected && "ring-2 ring-primary border-primary",
       )}
     >
-      <div className={cn("flex gap-4", isChat && "flex-col gap-0 h-full")}>
+      <div className="flex gap-4">
         {/* Match Score */}
         {matching_data.match_score > 0 && (
-          <div
-            className={cn(
-              "flex-shrink-0",
-              isChat && "absolute top-3 right-3 z-10",
-            )}
-          >
+          <div className="shrink-0">
             <MatchScore
               score={matching_data.match_score}
               size="sm"
@@ -86,20 +335,10 @@ export function JobCard({
         )}
 
         {/* Job Info */}
-        <div className={cn("flex-1 min-w-0", isChat && "flex flex-col h-full")}>
-          <div
-            className={cn(
-              "flex items-start justify-between gap-2",
-              isChat && "p-4 pb-0 block",
-            )}
-          >
+        <div className="flex-1 min-w-0">
+          <div className="flex items-start justify-between gap-2">
             <div>
-              <h3
-                className={cn(
-                  "font-semibold text-foreground line-clamp-1",
-                  isChat && "text-white",
-                )}
-              >
+              <h3 className="font-semibold text-foreground line-clamp-1">
                 {display_info.title}
               </h3>
               <div className="flex items-center gap-2 text-sm text-muted-foreground mt-1">
@@ -109,34 +348,27 @@ export function JobCard({
             </div>
 
             {/* Save button */}
-            {!isChat && (
-              <button
-                onClick={handleSave}
-                disabled={saving}
-                className={cn(
-                  "p-2 rounded-lg transition-colors",
-                  isSaved
-                    ? "text-primary hover:bg-primary/10"
-                    : "text-muted-foreground hover:text-foreground hover:bg-muted",
-                )}
-                title={isSaved ? "Unsave job" : "Save job"}
-              >
-                {isSaved ? (
-                  <BookmarkCheck className="w-5 h-5" />
-                ) : (
-                  <Bookmark className="w-5 h-5" />
-                )}
-              </button>
-            )}
+            <button
+              onClick={handleSave}
+              disabled={saving}
+              className={cn(
+                "p-2 rounded-lg transition-colors",
+                isSaved
+                  ? "text-primary hover:bg-primary/10"
+                  : "text-muted-foreground hover:text-foreground hover:bg-muted",
+              )}
+              title={isSaved ? "Unsave job" : "Save job"}
+            >
+              {isSaved ? (
+                <BookmarkCheck className="w-5 h-5" />
+              ) : (
+                <Bookmark className="w-5 h-5" />
+              )}
+            </button>
           </div>
 
           {/* Location & Job Type */}
-          <div
-            className={cn(
-              "flex flex-wrap items-center gap-3 mt-3 text-sm text-muted-foreground",
-              isChat && "px-4 mt-2 mb-2",
-            )}
-          >
+          <div className="flex flex-wrap items-center gap-3 mt-3 text-sm text-muted-foreground">
             {display_info.location && (
               <span className="flex items-center gap-1">
                 <MapPin className="w-3.5 h-3.5" />
@@ -145,7 +377,7 @@ export function JobCard({
                 </span>
               </span>
             )}
-            {!isChat && meta.remote && (
+            {meta.remote && (
               <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
                 <Wifi className="w-4 h-4" />
                 Remote
@@ -160,99 +392,50 @@ export function JobCard({
 
           {/* Skills */}
           {matching_data.key_skills && matching_data.key_skills.length > 0 && (
-            <div
-              className={cn(
-                "flex flex-wrap gap-1.5 mt-3",
-                isChat && "px-4 mt-auto mb-3 min-h-[24px]",
-              )}
-            >
-              {matching_data.key_skills
-                .slice(0, isChat ? 3 : 4)
-                .map((skill) => (
-                  <span
-                    key={skill}
-                    className={cn(
-                      "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold",
-                      isChat
-                        ? "bg-white/5 text-zinc-400 border-white/5 px-1.5 py-0"
-                        : "bg-secondary text-secondary-foreground border-transparent",
-                    )}
-                  >
-                    {skill}
-                  </span>
-                ))}
-              {matching_data.key_skills.length > (isChat ? 3 : 4) && (
+            <div className="flex flex-wrap gap-1.5 mt-3">
+              {matching_data.key_skills.slice(0, 4).map((skill) => (
                 <span
-                  className={cn(
-                    "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold",
-                    isChat
-                      ? "bg-white/5 text-zinc-500 border-white/5 px-1.5 py-0"
-                      : "bg-transparent text-muted-foreground border-border",
-                  )}
+                  key={skill}
+                  className="inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold bg-secondary text-secondary-foreground border-transparent"
                 >
-                  +{matching_data.key_skills.length - (isChat ? 3 : 4)}
+                  {skill}
+                </span>
+              ))}
+              {matching_data.key_skills.length > 4 && (
+                <span className="inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold bg-transparent text-muted-foreground border-border">
+                  +{matching_data.key_skills.length - 4}
                 </span>
               )}
             </div>
           )}
 
           {/* AI Explanation */}
-          {!isChat && matching_data.ai_explanation && (
+          {matching_data.ai_explanation && (
             <p className="mt-3 text-sm text-muted-foreground bg-muted/50 rounded-lg p-3 line-clamp-2">
               {matching_data.ai_explanation}
             </p>
           )}
 
           {/* Actions */}
-          <div
-            className={cn(
-              "flex items-center gap-2 mt-4",
-              isChat && "mt-3 p-4 border-t border-white/5 bg-white/5",
-            )}
-          >
-            {isChat ? (
+          <div className="flex items-center gap-2 mt-4">
+            {meta.apply_url && (
               <button
                 onClick={(e: React.MouseEvent) => {
                   e.stopPropagation();
-                  if (onApply) onApply(job.id);
-                  else if (meta.apply_url)
-                    window.open(
-                      meta.apply_url,
-                      "_blank",
-                      "noopener,noreferrer",
-                    );
+                  window.open(meta.apply_url, "_blank", "noopener,noreferrer");
                 }}
-                className="w-full py-1.5 bg-white text-black font-medium rounded-lg hover:bg-zinc-200 transition-colors flex items-center justify-center gap-2 text-xs"
+                className="inline-flex items-center justify-center gap-1.5 rounded-md border border-input bg-background px-3 py-1.5 text-sm font-medium hover:bg-accent hover:text-accent-foreground transition-colors"
               >
-                View & Apply
-                <ExternalLink className="w-3 h-3" />
+                <ExternalLink className="w-4 h-4" />
+                Apply
               </button>
-            ) : (
-              <>
-                {meta.apply_url && (
-                  <button
-                    onClick={(e: React.MouseEvent) => {
-                      e.stopPropagation();
-                      window.open(
-                        meta.apply_url,
-                        "_blank",
-                        "noopener,noreferrer",
-                      );
-                    }}
-                    className="inline-flex items-center justify-center gap-1.5 rounded-md border border-input bg-background px-3 py-1.5 text-sm font-medium hover:bg-accent hover:text-accent-foreground transition-colors"
-                  >
-                    <ExternalLink className="w-4 h-4" />
-                    Apply
-                  </button>
-                )}
-                <span className="text-xs text-muted-foreground flex items-center gap-1">
-                  <Clock className="w-3 h-3" />
-                  {meta.posted_at
-                    ? new Date(meta.posted_at).toLocaleDateString()
-                    : "Recently posted"}
-                </span>
-              </>
             )}
+            <span className="text-xs text-muted-foreground flex items-center gap-1">
+              <Clock className="w-3 h-3" />
+              {meta.posted_at
+                ? new Date(meta.posted_at).toLocaleDateString()
+                : "Recently posted"}
+            </span>
           </div>
         </div>
       </div>
diff --git a/apps/web/src/components/ui/PageLoader.tsx b/apps/web/src/components/ui/PageLoader.tsx
index 788e885..321e196 100644
--- a/apps/web/src/components/ui/PageLoader.tsx
+++ b/apps/web/src/components/ui/PageLoader.tsx
@@ -1,15 +1,185 @@
 import React from "react";
+import "../../styles/transmission.css";
 
 export const PageLoader: React.FC = () => {
   return (
-    <div className="min-h-[60vh] w-full flex flex-col items-center justify-center gap-4 animate-in fade-in duration-500">
-      <div className="relative w-12 h-12">
-        <div className="absolute inset-0 border-2 border-primary/20 rounded-full" />
-        <div className="absolute inset-0 border-2 border-primary border-t-transparent rounded-full animate-spin" />
+    <div
+      style={{
+        position: "fixed",
+        inset: 0,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "var(--tx-bg)",
+        color: "var(--tx-ink)",
+        fontFamily: "var(--tx-font-mono)",
+        gap: "32px",
+        zIndex: 1000,
+      }}
+    >
+      <style>
+        {`
+          @keyframes runner-bob {
+            0%, 100% { transform: translateY(0); }
+            50% { transform: translateY(-10px); }
+          }
+          @keyframes leg-left {
+            0%, 100% { transform: rotate(-20deg); }
+            50% { transform: rotate(40deg); }
+          }
+          @keyframes leg-right {
+            0%, 100% { transform: rotate(40deg); }
+            50% { transform: rotate(-20deg); }
+          }
+          @keyframes speed-line {
+            0% { transform: translateX(100px); opacity: 0; }
+            20% { opacity: 1; }
+            80% { opacity: 1; }
+            100% { transform: translateX(-100px); opacity: 0; }
+          }
+        `}
+      </style>
+
+      {/* ─── Animated Runner SVG ────────────────────────────────────── */}
+      <div style={{ position: "relative", width: "120px", height: "120px" }}>
+        {/* Speed Lines */}
+        <div
+          style={{
+            position: "absolute",
+            top: "40%",
+            left: "0",
+            width: "40px",
+            height: "3px",
+            background: "var(--tx-ink)",
+            animation: "speed-line 0.6s linear infinite",
+          }}
+        />
+        <div
+          style={{
+            position: "absolute",
+            top: "60%",
+            left: "-20px",
+            width: "60px",
+            height: "3px",
+            background: "var(--tx-ink)",
+            animation: "speed-line 0.6s linear infinite 0.2s",
+          }}
+        />
+
+        <svg
+          viewBox="0 0 100 100"
+          style={{
+            width: "100%",
+            height: "100%",
+            animation: "runner-bob 0.4s ease-in-out infinite",
+          }}
+        >
+          {/* Head */}
+          <circle
+            cx="65"
+            cy="25"
+            r="12"
+            fill="var(--tx-bg)"
+            stroke="var(--tx-ink)"
+            strokeWidth="4"
+          />
+          {/* Body */}
+          <path
+            d="M55 35 L40 70 L65 70 Z"
+            fill="var(--tx-seeker)"
+            stroke="var(--tx-ink)"
+            strokeWidth="4"
+            strokeLinejoin="round"
+          />
+          {/* Arms */}
+          <path
+            d="M50 45 L30 55"
+            fill="none"
+            stroke="var(--tx-ink)"
+            strokeWidth="4"
+            strokeLinecap="round"
+          />
+          <path
+            d="M50 45 L75 50"
+            fill="none"
+            stroke="var(--tx-ink)"
+            strokeWidth="4"
+            strokeLinecap="round"
+          />
+          {/* Legs */}
+          <g
+            style={{
+              animation: "leg-left 0.4s infinite",
+              transformOrigin: "45px 70px",
+            }}
+          >
+            <path
+              d="M45 70 L35 90 L50 90"
+              fill="none"
+              stroke="var(--tx-ink)"
+              strokeWidth="4"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+          </g>
+          <g
+            style={{
+              animation: "leg-right 0.4s infinite",
+              transformOrigin: "55px 70px",
+            }}
+          >
+            <path
+              d="M55 70 L65 90 L80 90"
+              fill="none"
+              stroke="var(--tx-ink)"
+              strokeWidth="4"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+          </g>
+        </svg>
+      </div>
+
+      <div
+        style={{
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          gap: "8px",
+        }}
+      >
+        <p
+          style={{
+            fontSize: "12px",
+            fontWeight: 700,
+            letterSpacing: "4px",
+            textTransform: "uppercase",
+            margin: 0,
+          }}
+        >
+          TRANSMITTING SIGNAL
+        </p>
+        <div
+          className="tx-carrier-wave"
+          style={{
+            width: "140px",
+            height: "2px",
+            background: "var(--tx-ink)",
+          }}
+        />
+        <p
+          style={{
+            fontSize: "10px",
+            color: "var(--tx-ink-muted)",
+            letterSpacing: "1px",
+            textTransform: "uppercase",
+            margin: 0,
+          }}
+        >
+          Running to your destination...
+        </p>
       </div>
-      <p className="text-neutral-500 text-sm font-medium animate-pulse">
-        Loading your experience...
-      </p>
     </div>
   );
 };
diff --git a/apps/web/src/components/ui/Toast.tsx b/apps/web/src/components/ui/Toast.tsx
index 674d048..ef5b775 100644
--- a/apps/web/src/components/ui/Toast.tsx
+++ b/apps/web/src/components/ui/Toast.tsx
@@ -1,7 +1,8 @@
 import { useEffect, useState } from "react";
 import { useToastStore } from "../../stores/toast.store";
-import { X, CheckCircle, AlertCircle, Info, AlertTriangle } from "lucide-react";
+import { X } from "lucide-react";
 import { createPortal } from "react-dom";
+import "../../styles/transmission.css";
 
 export function ToastContainer() {
   const { toasts, removeToast } = useToastStore();
@@ -15,38 +16,99 @@ export function ToastContainer() {
   if (!mounted) return null;
 
   return createPortal(
-    <div className="fixed top-4 right-4 z-50 flex flex-col gap-2 pointer-events-none">
+    <div
+      style={{
+        position: "fixed",
+        top: "24px",
+        right: "24px",
+        zIndex: 9999,
+        display: "flex",
+        flexDirection: "column",
+        gap: "16px",
+        pointerEvents: "none",
+      }}
+    >
       {toasts.map((toast) => (
         <div
           key={toast.id}
-          className={`pointer-events-auto flex items-center gap-3 min-w-[300px] max-w-md px-4 py-3 rounded-lg shadow-lg border border-white/10 animate-in slide-in-from-right-full duration-300 ${
-            toast.type === "success"
-              ? "bg-zinc-900 text-green-400"
-              : toast.type === "error"
-                ? "bg-red-950/50 text-red-400 border-red-900/50"
-                : toast.type === "warning"
-                  ? "bg-yellow-950/50 text-yellow-400 border-yellow-900/50"
-                  : "bg-zinc-900 text-zinc-100"
-          }`}
+          style={{
+            pointerEvents: "auto",
+            display: "flex",
+            alignItems: "center",
+            gap: "12px",
+            minWidth: "320px",
+            maxWidth: "420px",
+            padding: "16px 20px",
+            background: "var(--tx-surface)",
+            border: "2px solid var(--tx-border)",
+            boxShadow: "6px 6px 0px var(--tx-ink)",
+            fontFamily: "var(--tx-font-mono)",
+            color: "var(--tx-ink)",
+            animation: "panel-slide 300ms var(--tx-ease-mechanical) forwards",
+          }}
         >
-          {toast.type === "success" && (
-            <CheckCircle className="w-5 h-5 shrink-0" />
-          )}
-          {toast.type === "error" && (
-            <AlertCircle className="w-5 h-5 shrink-0" />
-          )}
-          {toast.type === "warning" && (
-            <AlertTriangle className="w-5 h-5 shrink-0" />
-          )}
-          {toast.type === "info" && <Info className="w-5 h-5 shrink-0" />}
+          <div
+            style={{
+              width: "4px",
+              height: "24px",
+              background:
+                toast.type === "success"
+                  ? "#00c853"
+                  : toast.type === "error"
+                    ? "var(--tx-seeker)"
+                    : toast.type === "warning"
+                      ? "#ffd600"
+                      : "var(--tx-recruiter)",
+              flexShrink: 0,
+            }}
+          />
 
-          <p className="text-sm font-medium flex-1">{toast.message}</p>
+          <div style={{ flex: 1 }}>
+            <span
+              style={{
+                display: "block",
+                fontSize: "9px",
+                fontWeight: 800,
+                letterSpacing: "2px",
+                textTransform: "uppercase",
+                marginBottom: "2px",
+                color: "var(--tx-ink-muted)",
+              }}
+            >
+              {toast.type || "SIGNAL"}
+            </span>
+            <p
+              style={{
+                fontSize: "13px",
+                margin: 0,
+                lineHeight: "1.4",
+              }}
+            >
+              {toast.message}
+            </p>
+          </div>
 
           <button
             onClick={() => removeToast(toast.id)}
-            className="p-1 hover:bg-white/10 rounded transition-colors"
+            style={{
+              background: "none",
+              border: "none",
+              cursor: "pointer",
+              padding: "4px",
+              color: "var(--tx-ink-muted)",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              transition: "color 150ms var(--tx-ease-sharp)",
+            }}
+            onMouseEnter={(e) =>
+              (e.currentTarget.style.color = "var(--tx-ink)")
+            }
+            onMouseLeave={(e) =>
+              (e.currentTarget.style.color = "var(--tx-ink-muted)")
+            }
           >
-            <X className="w-4 h-4" />
+            <X size={16} strokeWidth={3} />
           </button>
         </div>
       ))}
diff --git a/apps/web/src/hooks/useSSEChat.ts b/apps/web/src/hooks/useSSEChat.ts
index 9ccb6e8..74031f5 100644
--- a/apps/web/src/hooks/useSSEChat.ts
+++ b/apps/web/src/hooks/useSSEChat.ts
@@ -63,10 +63,7 @@ export function useSSEChat() {
         // 1. Create conversation if needed
         if (!currentConversationId) {
           try {
-            const newConv = await chatService.createConversation(
-              undefined,
-              message,
-            );
+            const newConv = await chatService.createConversation(undefined);
             currentConversationId = newConv.id;
             addConversation(newConv);
             setActiveConversation(newConv.id);
diff --git a/apps/web/src/lib/api-client.ts b/apps/web/src/lib/api-client.ts
index 3ca1326..2a911b3 100644
--- a/apps/web/src/lib/api-client.ts
+++ b/apps/web/src/lib/api-client.ts
@@ -24,9 +24,8 @@ apiClient.interceptors.response.use(
   (response) => response,
   async (error) => {
     if (error.response?.status === 401) {
-      // Token expired, try to refresh
       localStorage.removeItem("access_token");
-      // window.location.href = "/login"; // Temporarily disabled for debugging
+      window.location.href = "/login";
       console.warn("401 Unauthorized - Token removed");
     }
     return Promise.reject(error);
diff --git a/apps/web/src/pages/TransmissionChat.tsx b/apps/web/src/pages/TransmissionChat.tsx
index 9951fb9..a68e000 100644
--- a/apps/web/src/pages/TransmissionChat.tsx
+++ b/apps/web/src/pages/TransmissionChat.tsx
@@ -42,6 +42,21 @@ export function TransmissionChat() {
   const { id: conversationIdParam } = useParams<{ id: string }>();
   const navigate = useNavigate();
   const role = (searchParams.get("role") as Role) || "seeker";
+  const { addToast } = useToastStore();
+
+  // Redirect if role is recruiter (Hiring feature is Coming Soon)
+  useEffect(() => {
+    if (role === "recruiter") {
+      addToast({
+        type: "error",
+        message: "Hiring feature is coming soon. Redirecting...",
+      });
+      const newParams = new URLSearchParams(searchParams);
+      newParams.set("role", "seeker");
+      navigate({ search: newParams.toString() }, { replace: true });
+    }
+  }, [role, searchParams, navigate, addToast]);
+
   const accentColor =
     role === "seeker" ? "var(--tx-seeker)" : "var(--tx-recruiter)";
   const accentHex = role === "seeker" ? "#FF3D00" : "#0038FF";
@@ -56,7 +71,6 @@ export function TransmissionChat() {
   const setLoading = useChatStore((s) => s.setLoading);
   const setActiveResumeId = useChatStore((s) => s.setActiveResumeId);
   const { sendMessage, stopGeneration } = useSSEChat();
-  const { addToast } = useToastStore();
 
   /* ─── Local State ────────────────────────────────────────────────── */
   const [input, setInput] = useState("");
diff --git a/apps/web/src/pages/TransmissionHome.tsx b/apps/web/src/pages/TransmissionHome.tsx
new file mode 100644
index 0000000..afba53d
--- /dev/null
+++ b/apps/web/src/pages/TransmissionHome.tsx
@@ -0,0 +1,177 @@
+import { Link } from "react-router-dom";
+import { useAuthStore } from "../stores/auth.store";
+import "../styles/transmission.css";
+
+/**
+ * TransmissionHome
+ * ────────────────
+ * Professional, neo-brutalist landing page for Postly.
+ * High contrast, bold typography, and clear calls to action.
+ */
+export function TransmissionHome() {
+  const { isAuthenticated } = useAuthStore();
+
+  return (
+    <div
+      style={{
+        minHeight: "100vh",
+        background: "var(--tx-bg)",
+        color: "var(--tx-ink)",
+        fontFamily: "var(--tx-font-display)",
+        display: "flex",
+        flexDirection: "column",
+      }}
+    >
+      {/* ─── Navigation ──────────────────────────────────────────────── */}
+      <nav
+        style={{
+          padding: "24px 40px",
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          borderBottom: "2px solid var(--tx-border)",
+          background: "var(--tx-surface)",
+        }}
+      >
+        <div
+          style={{
+            fontSize: "18px",
+            fontWeight: 800,
+            letterSpacing: "6px",
+            textTransform: "uppercase",
+          }}
+        >
+          POSTLY
+        </div>
+        <div style={{ display: "flex", gap: "24px", alignItems: "center" }}>
+          {!isAuthenticated ? (
+            <>
+              <Link
+                to="/login"
+                style={{
+                  fontFamily: "var(--tx-font-mono)",
+                  fontSize: "12px",
+                  fontWeight: 600,
+                  color: "var(--tx-ink)",
+                  textDecoration: "none",
+                  letterSpacing: "1px",
+                }}
+              >
+                SIGN IN
+              </Link>
+              <Link
+                to="/join"
+                className="tx-btn"
+                style={{
+                  background: "var(--tx-ink)",
+                  color: "white",
+                  padding: "8px 20px",
+                  fontSize: "12px",
+                  textDecoration: "none",
+                }}
+              >
+                JOIN SIGNAL
+              </Link>
+            </>
+          ) : (
+            <Link
+              target="_blank"
+              to="/chat"
+              className="tx-btn"
+              style={{
+                background: "var(--tx-ink)",
+                color: "white",
+                padding: "8px 20px",
+                fontSize: "12px",
+                textDecoration: "none",
+              }}
+            >
+              DASHBOARD →
+            </Link>
+          )}
+        </div>
+      </nav>
+
+      {/* ─── Hero Section ────────────────────────────────────────────── */}
+      <header
+        style={{
+          padding: "120px 40px",
+          textAlign: "center",
+          flex: 1,
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          borderBottom: "2px solid var(--tx-border)",
+        }}
+      >
+        <h1
+          style={{
+            fontSize: "clamp(48px, 10vw, 120px)",
+            fontWeight: 900,
+            lineHeight: 0.9,
+            letterSpacing: "-4px",
+            margin: "0 0 32px 0",
+            maxWidth: "1000px",
+            textTransform: "uppercase",
+          }}
+        >
+          The Future of Work is{" "}
+          <span style={{ color: "var(--tx-seeker)" }}>Broadcast</span>.
+        </h1>
+        <p
+          style={{
+            fontFamily: "var(--tx-font-mono)",
+            fontSize: "clamp(16px, 1.5vw, 20px)",
+            color: "var(--tx-ink-muted)",
+            maxWidth: "600px",
+            lineHeight: 1.5,
+            marginBottom: "48px",
+          }}
+        >
+          Postly is a high-frequency talent terminal. Stop searching. Start
+          transmitting. AI-driven matching for the next generation of builders.
+        </p>
+        <Link
+          to={isAuthenticated ? "/chat" : "/join"}
+          className="tx-btn"
+          style={{
+            padding: "20px 48px",
+            fontSize: "18px",
+            fontWeight: 700,
+            background: "var(--tx-ink)",
+            color: "white",
+            textDecoration: "none",
+            boxShadow: "8px 8px 0px var(--tx-seeker)",
+            transition: "all 0.1s var(--tx-ease-sharp)",
+          }}
+          onMouseEnter={(e) => {
+            e.currentTarget.style.transform = "translate(-2px, -2px)";
+            e.currentTarget.style.boxShadow = "10px 10px 0px var(--tx-seeker)";
+          }}
+          onMouseLeave={(e) => {
+            e.currentTarget.style.transform = "translate(0, 0)";
+            e.currentTarget.style.boxShadow = "8px 8px 0px var(--tx-seeker)";
+          }}
+        >
+          {isAuthenticated ? "CONTINUE TO SIGNAL →" : "GET STARTED"}
+        </Link>
+      </header>
+
+      {/* ─── Footer ──────────────────────────────────────────────────── */}
+      <footer
+        style={{
+          padding: "48px 40px",
+          background: "var(--tx-ink)",
+          color: "var(--tx-bg)",
+          textAlign: "center",
+          fontFamily: "var(--tx-font-mono)",
+          fontSize: "12px",
+          letterSpacing: "1px",
+        }}
+      >
+        © {new Date().getFullYear()} POSTLY
+      </footer>
+    </div>
+  );
+}
diff --git a/apps/web/src/pages/TransmissionLogin.tsx b/apps/web/src/pages/TransmissionLogin.tsx
index 89e23fa..29ea7fe 100644
--- a/apps/web/src/pages/TransmissionLogin.tsx
+++ b/apps/web/src/pages/TransmissionLogin.tsx
@@ -20,9 +20,14 @@ export function TransmissionLogin() {
     e.preventDefault();
     try {
       await login({ email, password });
-      navigate("/");
-    } catch {
-      // Error handled by store
+      navigate("/chat?role=seeker");
+    } catch (err: unknown) {
+      const error = err as {
+        response?: { data?: { error?: { code?: string } } };
+      };
+      if (error?.response?.data?.error?.code === "EMAIL_NOT_VERIFIED") {
+        navigate(`/verify-otp?email=${encodeURIComponent(email)}`);
+      }
     }
   };
 
diff --git a/apps/web/src/pages/TransmissionRegister.tsx b/apps/web/src/pages/TransmissionRegister.tsx
index cea91af..4056b33 100644
--- a/apps/web/src/pages/TransmissionRegister.tsx
+++ b/apps/web/src/pages/TransmissionRegister.tsx
@@ -21,8 +21,8 @@ export function TransmissionRegister() {
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
     try {
-      await register({ full_name: name, email, password, role: userType });
-      navigate("/");
+      await register({ full_name: name, email, password, roles: [userType] });
+      navigate(`/verify-otp?email=${encodeURIComponent(email)}`);
     } catch {
       // Error surfaced via store
     }
diff --git a/apps/web/src/pages/TransmissionLanding.tsx b/apps/web/src/pages/TransmissionRoleSelector.tsx
similarity index 95%
rename from apps/web/src/pages/TransmissionLanding.tsx
rename to apps/web/src/pages/TransmissionRoleSelector.tsx
index e29f605..7cb3e26 100644
--- a/apps/web/src/pages/TransmissionLanding.tsx
+++ b/apps/web/src/pages/TransmissionRoleSelector.tsx
@@ -6,8 +6,8 @@ import {
 import "../styles/transmission.css";
 
 /**
- * TransmissionLanding
- * ───────────────────
+ * TransmissionRoleSelector
+ * ────────────────────────
  * Full-viewport split-screen role selection.
  * Left = SEEKING (orange-red) | Right = HIRING (blue)
  *
@@ -20,7 +20,7 @@ import "../styles/transmission.css";
  * - clip-path circle transition on click
  */
 
-export function TransmissionLanding() {
+export function TransmissionRoleSelector() {
   const [mounted, setMounted] = useState(false);
   const { state: transState, trigger } = useTransmissionTransition();
   const seekerRef = useRef<HTMLDivElement>(null);
@@ -183,8 +183,7 @@ export function TransmissionLanding() {
         {/* ─── RIGHT PANEL: HIRING ───────────────────────────────────── */}
         <div
           ref={recruiterRef}
-          className={`tx-panel tx-panel-recruiter tx-cursor-recruiter ${mounted ? "tx-split-right" : ""}`}
-          onClick={(e) => handleRoleClick("recruiter", e)}
+          className={`tx-panel tx-panel-recruiter tx-panel-disabled ${mounted ? "tx-split-right" : ""}`}
           style={{
             flex: 1,
             display: "flex",
@@ -194,8 +193,12 @@ export function TransmissionLanding() {
             background: "#0D0D0D",
             position: "relative",
             opacity: mounted ? undefined : 0,
+            cursor: "not-allowed",
           }}
         >
+          {/* Coming Soon Badge */}
+          <div className="tx-badge-coming-soon">COMING SOON</div>
+
           {/* SVG border trace overlay */}
           <svg
             style={{
@@ -274,7 +277,7 @@ export function TransmissionLanding() {
               textTransform: "uppercase",
             }}
           >
-            ← Click to enter
+            🚧 Feature Offline
           </div>
         </div>
 
diff --git a/apps/web/src/pages/TransmissionSettings.tsx b/apps/web/src/pages/TransmissionSettings.tsx
new file mode 100644
index 0000000..cdba2bd
--- /dev/null
+++ b/apps/web/src/pages/TransmissionSettings.tsx
@@ -0,0 +1,967 @@
+import { useState, useEffect } from "react";
+import { useAuthStore } from "../stores/auth.store";
+import { Link } from "react-router-dom";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { userService } from "../services/user.service";
+import { useToastStore } from "../stores/toast.store";
+import "../styles/transmission.css";
+
+/**
+ * TransmissionSettings
+ * ────────────────────
+ * Brutalist settings page. Tabbed layout (General, Professional, Security).
+ * Dynamically adapts to Seeker or Recruiter roles.
+ */
+
+const TIMEZONES = [
+  "UTC",
+  "America/New_York",
+  "America/Chicago",
+  "America/Denver",
+  "America/Los_Angeles",
+  "Europe/London",
+  "Europe/Paris",
+  "Europe/Berlin",
+  "Asia/Tokyo",
+  "Asia/Singapore",
+  "Asia/Kolkata",
+  "Australia/Sydney",
+];
+
+const LOCALES = [
+  { label: "English (US)", value: "en-US" },
+  { label: "English (UK)", value: "en-GB" },
+  { label: "French", value: "fr-FR" },
+  { label: "German", value: "de-DE" },
+  { label: "Japanese", value: "ja-JP" },
+  { label: "Hindi", value: "hi-IN" },
+];
+
+export function TransmissionSettings() {
+  const { user } = useAuthStore();
+  const { addToast } = useToastStore();
+  const queryClient = useQueryClient();
+  const [activeTab, setActiveTab] = useState<
+    "general" | "professional" | "security"
+  >("general");
+  const [isUploading, setIsUploading] = useState(false);
+
+  const role = user?.roles?.[0] || "seeker";
+  const accentColor =
+    role === "seeker" ? "var(--tx-seeker)" : "var(--tx-recruiter)";
+
+  // Form state
+  const [formData, setFormData] = useState<Record<string, any>>({
+    full_name: user?.full_name || "",
+    avatar_url: user?.avatar_url || "",
+    timezone: user?.timezone || "UTC",
+    locale: user?.locale || "en-US",
+  });
+
+  const [passwordData, setPasswordData] = useState({
+    current_password: "",
+    new_password: "",
+    confirm_password: "",
+  });
+
+  // Fetch role-specific profile
+  const { data: profileData, isLoading: isProfileLoading } = useQuery({
+    queryKey: ["profile", role],
+    queryFn: () =>
+      role === "seeker"
+        ? userService.getSeekerProfile()
+        : userService.getEmployerProfile(),
+    enabled: !!user,
+  });
+
+  // Sync form data once profile is loaded
+  useEffect(() => {
+    if (profileData) {
+      setFormData((prev) => ({
+        ...prev,
+        ...profileData,
+        skills: profileData.skills?.join(", ") || "",
+        desired_job_titles: profileData.desired_job_titles?.join(", ") || "",
+        desired_locations: profileData.desired_locations?.join(", ") || "",
+      }));
+    }
+  }, [profileData]);
+
+  // Mutations
+  const updateBaseProfile = useMutation({
+    mutationFn: (data: Parameters<typeof userService.updateProfile>[0]) =>
+      userService.updateProfile(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["auth-me"] });
+      addToast({
+        type: "success",
+        message: "General broadcast identity updated.",
+      });
+    },
+    onError: (error: Error) => {
+      addToast({
+        type: "error",
+        message: error.message || "Failed to update profile.",
+      });
+    },
+  });
+
+  const updateRoleProfile = useMutation({
+    mutationFn: (data: any) =>
+      role === "seeker"
+        ? userService.updateSeekerProfile(data)
+        : userService.updateEmployerProfile(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["profile", role] });
+      addToast({
+        type: "success",
+        message: "Professional broadcast profile updated.",
+      });
+    },
+    onError: (error: Error) => {
+      addToast({
+        type: "error",
+        message: error.message || "Failed to update profile.",
+      });
+    },
+  });
+
+  const changePassword = useMutation({
+    mutationFn: (data: Parameters<typeof userService.changePassword>[0]) =>
+      userService.changePassword(data),
+    onSuccess: () => {
+      addToast({
+        type: "success",
+        message: "Cipher sequence updated (Password changed).",
+      });
+      setPasswordData({
+        current_password: "",
+        new_password: "",
+        confirm_password: "",
+      });
+    },
+    onError: (error: Error) => {
+      addToast({
+        type: "error",
+        message: error.message || "Failed to change password.",
+      });
+    },
+  });
+
+  const handleSaveGeneral = async (e: React.FormEvent) => {
+    e.preventDefault();
+    updateBaseProfile.mutate({
+      full_name: formData.full_name,
+      avatar_url: formData.avatar_url,
+      timezone: formData.timezone,
+      locale: formData.locale,
+    });
+  };
+
+  const handleSaveProfessional = async (e: React.FormEvent) => {
+    e.preventDefault();
+    const roleData = { ...formData };
+    delete roleData.full_name;
+    delete roleData.avatar_url;
+    delete roleData.timezone;
+    delete roleData.locale;
+    delete roleData.email;
+
+    if (role === "seeker") {
+      roleData.skills =
+        roleData.skills
+          ?.split(",")
+          .map((s: string) => s.trim())
+          .filter(Boolean) || [];
+      roleData.desired_job_titles =
+        roleData.desired_job_titles
+          ?.split(",")
+          .map((s: string) => s.trim())
+          .filter(Boolean) || [];
+      roleData.desired_locations =
+        roleData.desired_locations
+          ?.split(",")
+          .map((s: string) => s.trim())
+          .filter(Boolean) || [];
+      roleData.experience_years = parseInt(roleData.experience_years) || 0;
+    }
+
+    updateRoleProfile.mutate(roleData);
+  };
+
+  const handleChangePassword = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (passwordData.new_password !== passwordData.confirm_password) {
+      addToast({ type: "error", message: "Passphrase mismatch." });
+      return;
+    }
+    changePassword.mutate({
+      current_password: passwordData.current_password,
+      new_password: passwordData.new_password,
+    });
+  };
+
+  const handleInputChange = (
+    e: React.ChangeEvent<
+      HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement
+    >,
+  ) => {
+    const { name, value, type } = e.target;
+    const val =
+      type === "checkbox" ? (e.target as HTMLInputElement).checked : value;
+    setFormData((prev) => ({ ...prev, [name]: val }));
+  };
+
+  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+
+    // Validate size (2MB)
+    if (file.size > 2 * 1024 * 1024) {
+      addToast({
+        type: "error",
+        message: "File sequence too heavy (Max 2MB).",
+      });
+      return;
+    }
+
+    try {
+      setIsUploading(true);
+      const url = await userService.uploadAvatar(file);
+      setFormData((prev) => ({ ...prev, avatar_url: url }));
+      addToast({
+        type: "success",
+        message: "Cipher image uploaded to broadcast node.",
+      });
+    } catch (error: any) {
+      addToast({
+        type: "error",
+        message: error.message || "Failed to upload image.",
+      });
+    } finally {
+      setIsUploading(false);
+    }
+  };
+
+  const handlePasswordChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const { name, value } = e.target;
+    setPasswordData((prev) => ({ ...prev, [name]: value }));
+  };
+
+  if (isProfileLoading) {
+    return (
+      <div
+        style={{
+          minHeight: "100vh",
+          background: "var(--tx-bg)",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+        }}
+      >
+        <p
+          style={{
+            fontFamily: "var(--tx-font-mono)",
+            fontSize: "14px",
+            letterSpacing: "2px",
+          }}
+        >
+          LINKING TO BROADCAST NODE...
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      style={{
+        minHeight: "100vh",
+        background: "var(--tx-bg)",
+        fontFamily: "var(--tx-font-mono)",
+        padding: "60px 20px 80px",
+      }}
+    >
+      <div style={{ maxWidth: "900px", margin: "0 auto" }}>
+        {/* Header */}
+        <div style={{ textAlign: "center", marginBottom: "48px" }}>
+          <Link
+            to="/chat"
+            style={{
+              fontFamily: "var(--tx-font-display)",
+              fontSize: "12px",
+              fontWeight: 800,
+              letterSpacing: "6px",
+              color: "var(--tx-ink)",
+              textDecoration: "none",
+              textTransform: "uppercase",
+            }}
+          >
+            ← RETURN TO COMMUNICATIONS
+          </Link>
+          <h1
+            style={{
+              fontFamily: "var(--tx-font-display)",
+              fontSize: "clamp(36px, 6vw, 56px)",
+              fontWeight: 800,
+              color: "var(--tx-ink)",
+              margin: "20px 0 8px",
+              lineHeight: 1,
+              letterSpacing: "-1px",
+            }}
+          >
+            SETTINGS
+          </h1>
+          <p
+            style={{
+              fontSize: "12px",
+              color: "var(--tx-ink-muted)",
+              letterSpacing: "1px",
+              textTransform: "uppercase",
+            }}
+          >
+            Node ID: {user?.id?.split("-")[0]}...
+          </p>
+        </div>
+
+        {/* Main Layout */}
+        <div
+          style={{
+            display: "grid",
+            gridTemplateColumns: "220px 1fr",
+            gap: "40px",
+            alignItems: "start",
+          }}
+        >
+          {/* Side Tabs */}
+          <nav
+            style={{ display: "flex", flexDirection: "column", gap: "10px" }}
+          >
+            <TabButton
+              active={activeTab === "general"}
+              onClick={() => setActiveTab("general")}
+              accent={accentColor}
+              label="GENERAL"
+            />
+            <TabButton
+              active={activeTab === "professional"}
+              onClick={() => setActiveTab("professional")}
+              accent={accentColor}
+              label="PROFESSIONAL"
+            />
+            <TabButton
+              active={activeTab === "security"}
+              onClick={() => setActiveTab("security")}
+              accent={accentColor}
+              label="SECURITY"
+            />
+          </nav>
+
+          {/* Content Pane */}
+          <div
+            style={{
+              background: "var(--tx-surface)",
+              border: "2px solid var(--tx-border)",
+              borderRadius: "var(--tx-radius)",
+              padding: "40px",
+              boxShadow: "8px 8px 0px var(--tx-border)",
+              minHeight: "500px",
+            }}
+          >
+            {/* ─── GENERAL TAB ─── */}
+            {activeTab === "general" && (
+              <form
+                onSubmit={handleSaveGeneral}
+                style={{
+                  display: "flex",
+                  flexDirection: "column",
+                  gap: "32px",
+                }}
+              >
+                <SectionHeader title="Base Identity" />
+
+                <div
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "24px",
+                    marginBottom: "8px",
+                  }}
+                >
+                  <div
+                    style={{
+                      width: "80px",
+                      height: "80px",
+                      border: "2px solid var(--tx-border)",
+                      borderRadius: "var(--tx-radius)",
+                      background: "var(--tx-bg)",
+                      overflow: "hidden",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                    }}
+                  >
+                    {formData.avatar_url ? (
+                      <img
+                        src={formData.avatar_url}
+                        alt="Avatar"
+                        style={{
+                          width: "100%",
+                          height: "100%",
+                          objectFit: "cover",
+                        }}
+                      />
+                    ) : (
+                      <div style={{ fontSize: "24px", fontWeight: 800 }}>?</div>
+                    )}
+                  </div>
+                  <div style={{ flex: 1 }}>
+                    <Field label="Avatar URL">
+                      <div style={{ display: "flex", gap: "12px" }}>
+                        <Input
+                          name="avatar_url"
+                          value={formData.avatar_url}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                          placeholder="https://api.dicebear.com/..."
+                        />
+                        <button
+                          type="button"
+                          onClick={() =>
+                            document.getElementById("avatar-upload")?.click()
+                          }
+                          disabled={isUploading}
+                          style={{
+                            padding: "0 16px",
+                            fontFamily: "var(--tx-font-mono)",
+                            fontSize: "10px",
+                            fontWeight: 800,
+                            background: "var(--tx-bg)",
+                            border: "2px solid var(--tx-border)",
+                            borderRadius: "var(--tx-radius)",
+                            cursor: "pointer",
+                            whiteSpace: "nowrap",
+                          }}
+                        >
+                          {isUploading ? "UPLOADING..." : "UPLOAD IMAGE"}
+                        </button>
+                        <input
+                          id="avatar-upload"
+                          type="file"
+                          accept="image/*"
+                          onChange={handleFileChange}
+                          style={{ display: "none" }}
+                        />
+                      </div>
+                    </Field>
+                  </div>
+                </div>
+
+                <div
+                  style={{
+                    display: "grid",
+                    gridTemplateColumns: "1fr 1fr",
+                    gap: "24px",
+                  }}
+                >
+                  <Field label="Full Name">
+                    <Input
+                      name="full_name"
+                      value={formData.full_name}
+                      onChange={handleInputChange}
+                      accent={accentColor}
+                    />
+                  </Field>
+                  <Field label="Email (Linked)">
+                    <Input
+                      name="email"
+                      value={user?.email || ""}
+                      disabled
+                      accent={accentColor}
+                    />
+                  </Field>
+                </div>
+
+                <div
+                  style={{
+                    display: "grid",
+                    gridTemplateColumns: "1fr 1fr",
+                    gap: "24px",
+                  }}
+                >
+                  <Field label="Timezone">
+                    <Select
+                      name="timezone"
+                      value={formData.timezone}
+                      onChange={handleInputChange}
+                      accent={accentColor}
+                    >
+                      {TIMEZONES.map((tz) => (
+                        <option key={tz} value={tz}>
+                          {tz}
+                        </option>
+                      ))}
+                    </Select>
+                  </Field>
+                  <Field label="Locale">
+                    <Select
+                      name="locale"
+                      value={formData.locale}
+                      onChange={handleInputChange}
+                      accent={accentColor}
+                    >
+                      {LOCALES.map((loc) => (
+                        <option key={loc.value} value={loc.value}>
+                          {loc.label}
+                        </option>
+                      ))}
+                    </Select>
+                  </Field>
+                </div>
+
+                <SubmitButton
+                  label="UPDATE GENERAL"
+                  loading={updateBaseProfile.isPending}
+                  accent={accentColor}
+                />
+              </form>
+            )}
+
+            {/* ─── PROFESSIONAL TAB ─── */}
+            {activeTab === "professional" && (
+              <form
+                onSubmit={handleSaveProfessional}
+                style={{
+                  display: "flex",
+                  flexDirection: "column",
+                  gap: "32px",
+                }}
+              >
+                {role === "seeker" ? (
+                  <>
+                    <SectionHeader title="Broadcaster Profile" />
+                    <Field label="Headline">
+                      <Input
+                        name="headline"
+                        value={formData.headline}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                        placeholder="Senior Signal Processor"
+                      />
+                    </Field>
+                    <Field label="Summary">
+                      <TextArea
+                        name="summary"
+                        value={formData.summary}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                      />
+                    </Field>
+                    <Field label="Skills">
+                      <Input
+                        name="skills"
+                        value={formData.skills}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                        placeholder="React, Drizzle, Postgres..."
+                      />
+                    </Field>
+                    <div
+                      style={{
+                        display: "grid",
+                        gridTemplateColumns: "1fr 1fr",
+                        gap: "24px",
+                      }}
+                    >
+                      <Field label="Experience (Years)">
+                        <Input
+                          name="experience_years"
+                          type="number"
+                          value={formData.experience_years}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                        />
+                      </Field>
+                      <Field label="Level">
+                        <Select
+                          name="experience_level"
+                          value={formData.experience_level}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                        >
+                          <option value="entry">Entry</option>
+                          <option value="mid">Mid</option>
+                          <option value="senior">Senior</option>
+                          <option value="lead">Lead</option>
+                          <option value="executive">Executive</option>
+                        </Select>
+                      </Field>
+                    </div>
+                    <SectionHeader title="Transmission Preferences" />
+                    <div
+                      style={{
+                        display: "grid",
+                        gridTemplateColumns: "1fr 1fr",
+                        gap: "24px",
+                      }}
+                    >
+                      <Field label="Job Type">
+                        <Select
+                          name="desired_job_type"
+                          value={formData.desired_job_type}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                        >
+                          <option value="full_time">Full Time</option>
+                          <option value="part_time">Part Time</option>
+                          <option value="contract">Contract</option>
+                          <option value="freelance">Freelance</option>
+                        </Select>
+                      </Field>
+                      <div
+                        style={{
+                          display: "flex",
+                          alignItems: "center",
+                          gap: "12px",
+                          paddingTop: "28px",
+                        }}
+                      >
+                        <input
+                          type="checkbox"
+                          name="open_to_remote"
+                          checked={formData.open_to_remote}
+                          onChange={handleInputChange}
+                          id="remote-check"
+                          style={{ width: "20px", height: "20px", accentColor }}
+                        />
+                        <label
+                          htmlFor="remote-check"
+                          style={{
+                            fontSize: "11px",
+                            fontWeight: 700,
+                            cursor: "pointer",
+                          }}
+                        >
+                          OPEN TO REMOTE
+                        </label>
+                      </div>
+                    </div>
+                  </>
+                ) : (
+                  <>
+                    <SectionHeader title="Company Broadcaster" />
+                    <Field label="Company Name">
+                      <Input
+                        name="company_name"
+                        value={formData.company_name}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                      />
+                    </Field>
+                    <Field label="Website">
+                      <Input
+                        name="company_website"
+                        type="url"
+                        value={formData.company_website}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                      />
+                    </Field>
+                    <Field label="Description">
+                      <TextArea
+                        name="company_description"
+                        value={formData.company_description}
+                        onChange={handleInputChange}
+                        accent={accentColor}
+                      />
+                    </Field>
+                    <div
+                      style={{
+                        display: "grid",
+                        gridTemplateColumns: "1fr 1fr",
+                        gap: "24px",
+                      }}
+                    >
+                      <Field label="Industry">
+                        <Input
+                          name="industry"
+                          value={formData.industry}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                        />
+                      </Field>
+                      <Field label="Size">
+                        <Input
+                          name="company_size"
+                          value={formData.company_size}
+                          onChange={handleInputChange}
+                          accent={accentColor}
+                        />
+                      </Field>
+                    </div>
+                  </>
+                )}
+                <SubmitButton
+                  label="UPDATE PROFESSIONAL"
+                  loading={updateRoleProfile.isPending}
+                  accent={accentColor}
+                />
+              </form>
+            )}
+
+            {/* ─── SECURITY TAB ─── */}
+            {activeTab === "security" && (
+              <form
+                onSubmit={handleChangePassword}
+                style={{
+                  display: "flex",
+                  flexDirection: "column",
+                  gap: "32px",
+                }}
+              >
+                <SectionHeader title="Cipher Sequence Update" />
+                <p
+                  style={{
+                    fontSize: "12px",
+                    color: "var(--tx-ink-muted)",
+                    lineHeight: 1.5,
+                  }}
+                >
+                  Update your security passphrase. This will terminate all
+                  active broadcast sessions.
+                </p>
+                <div
+                  style={{
+                    display: "flex",
+                    flexDirection: "column",
+                    gap: "24px",
+                  }}
+                >
+                  <Field label="Current Passphrase">
+                    <Input
+                      name="current_password"
+                      type="password"
+                      value={passwordData.current_password}
+                      onChange={handlePasswordChange}
+                      accent={accentColor}
+                    />
+                  </Field>
+                  <Field label="New Passphrase">
+                    <Input
+                      name="new_password"
+                      type="password"
+                      value={passwordData.new_password}
+                      onChange={handlePasswordChange}
+                      accent={accentColor}
+                    />
+                  </Field>
+                  <Field label="Confirm Passphrase">
+                    <Input
+                      name="confirm_password"
+                      type="password"
+                      value={passwordData.confirm_password}
+                      onChange={handlePasswordChange}
+                      accent={accentColor}
+                    />
+                  </Field>
+                </div>
+                <SubmitButton
+                  label="UPDATE CIPHER"
+                  loading={changePassword.isPending}
+                  accent={accentColor}
+                />
+              </form>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/* ─── UI COMPONENTS ─────────────────────────────────────────────────────── */
+
+function TabButton({
+  active,
+  label,
+  onClick,
+  accent,
+}: {
+  active: boolean;
+  label: string;
+  onClick: () => void;
+  accent: string;
+}) {
+  return (
+    <button
+      onClick={onClick}
+      style={{
+        padding: "16px 20px",
+        fontFamily: "var(--tx-font-mono)",
+        fontSize: "13px",
+        fontWeight: 800,
+        textAlign: "left",
+        letterSpacing: "2px",
+        background: active ? accent : "transparent",
+        color: active ? "white" : "var(--tx-ink)",
+        border: active ? `2px solid var(--tx-border)` : "2px solid transparent",
+        borderRadius: "var(--tx-radius)",
+        cursor: "pointer",
+        transition: "all 150ms var(--tx-ease-sharp)",
+        boxShadow: active ? "4px 4px 0px var(--tx-border)" : "none",
+        transform: active ? "translate(-2px, -2px)" : "none",
+      }}
+    >
+      {label}
+    </button>
+  );
+}
+
+function SectionHeader({ title }: { title: string }) {
+  return (
+    <h2
+      style={{
+        fontSize: "16px",
+        fontWeight: 800,
+        letterSpacing: "2px",
+        borderBottom: "2px solid var(--tx-border)",
+        paddingBottom: "12px",
+        marginBottom: "8px",
+      }}
+    >
+      {title}
+    </h2>
+  );
+}
+
+function Field({
+  label,
+  children,
+}: {
+  label: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <div style={{ display: "flex", flexDirection: "column", gap: "8px" }}>
+      <label
+        style={{
+          fontSize: "10px",
+          fontWeight: 800,
+          color: "var(--tx-ink-muted)",
+          letterSpacing: "1px",
+        }}
+      >
+        {label}
+      </label>
+      {children}
+    </div>
+  );
+}
+
+function Input({ accent, ...props }: any) {
+  return (
+    <input
+      {...props}
+      style={{
+        width: "100%",
+        padding: "12px 14px",
+        fontFamily: "var(--tx-font-mono)",
+        fontSize: "13px",
+        background: "var(--tx-bg)",
+        border: "2px solid var(--tx-border)",
+        borderRadius: "var(--tx-radius)",
+        outline: "none",
+        ...props.style,
+      }}
+      onFocus={(e) => (e.currentTarget.style.borderColor = accent)}
+      onBlur={(e) => (e.currentTarget.style.borderColor = "var(--tx-border)")}
+    />
+  );
+}
+
+function TextArea({ accent, ...props }: any) {
+  return (
+    <textarea
+      {...props}
+      rows={4}
+      style={{
+        width: "100%",
+        padding: "12px 14px",
+        fontFamily: "var(--tx-font-mono)",
+        fontSize: "13px",
+        background: "var(--tx-bg)",
+        border: "2px solid var(--tx-border)",
+        borderRadius: "var(--tx-radius)",
+        outline: "none",
+        resize: "vertical",
+        ...props.style,
+      }}
+      onFocus={(e) => (e.currentTarget.style.borderColor = accent)}
+      onBlur={(e) => (e.currentTarget.style.borderColor = "var(--tx-border)")}
+    />
+  );
+}
+
+function Select({ accent, children, ...props }: any) {
+  return (
+    <select
+      {...props}
+      style={{
+        width: "100%",
+        padding: "12px 14px",
+        fontFamily: "var(--tx-font-mono)",
+        fontSize: "13px",
+        background: "var(--tx-bg)",
+        border: "2px solid var(--tx-border)",
+        borderRadius: "var(--tx-radius)",
+        outline: "none",
+        cursor: "pointer",
+        ...props.style,
+      }}
+      onFocus={(e) => (e.currentTarget.style.borderColor = accent)}
+      onBlur={(e) => (e.currentTarget.style.borderColor = "var(--tx-border)")}
+    >
+      {children}
+    </select>
+  );
+}
+
+function SubmitButton({
+  label,
+  loading,
+  accent,
+}: {
+  label: string;
+  loading: boolean;
+  accent: string;
+}) {
+  return (
+    <button
+      type="submit"
+      disabled={loading}
+      style={{
+        padding: "14px 28px",
+        fontFamily: "var(--tx-font-mono)",
+        fontSize: "13px",
+        fontWeight: 800,
+        letterSpacing: "2px",
+        color: "white",
+        background: accent,
+        border: `2px solid var(--tx-border)`,
+        borderRadius: "var(--tx-radius)",
+        cursor: loading ? "not-allowed" : "pointer",
+        transition: "all 150ms var(--tx-ease-sharp)",
+        boxShadow: "4px 4px 0px var(--tx-border)",
+        alignSelf: "flex-end",
+        marginTop: "16px",
+      }}
+      onMouseEnter={(e) => {
+        if (!loading) e.currentTarget.style.transform = "translate(-2px, -2px)";
+      }}
+      onMouseLeave={(e) => {
+        if (!loading) e.currentTarget.style.transform = "translate(0, 0)";
+      }}
+    >
+      {loading ? "PROCESSING..." : label}
+    </button>
+  );
+}
diff --git a/apps/web/src/pages/VerifyOtpPage.tsx b/apps/web/src/pages/VerifyOtpPage.tsx
new file mode 100644
index 0000000..8c633b0
--- /dev/null
+++ b/apps/web/src/pages/VerifyOtpPage.tsx
@@ -0,0 +1,276 @@
+import { useState, useEffect } from "react";
+import { Link, useNavigate, useSearchParams } from "react-router-dom";
+import { useAuthStore } from "../stores/auth.store";
+import "../styles/transmission.css";
+
+/**
+ * VerifyOtpPage
+ * ─────────────
+ * Neo-brutalist verification page for 6-digit email OTP.
+ */
+export function VerifyOtpPage() {
+  const [code, setCode] = useState("");
+  const [searchParams] = useSearchParams();
+  const navigate = useNavigate();
+  const { verifyOtp, resendOtp, isLoading, error } = useAuthStore();
+  const email = searchParams.get("email") || "";
+  const [resendTimer, setResendTimer] = useState(0);
+
+  useEffect(() => {
+    if (!email) {
+      navigate("/register");
+    }
+  }, [email, navigate]);
+
+  useEffect(() => {
+    if (resendTimer > 0) {
+      const timer = setTimeout(() => setResendTimer(resendTimer - 1), 1000);
+      return () => clearTimeout(timer);
+    }
+    return undefined;
+  }, [resendTimer]);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (code.length !== 6) return;
+    try {
+      await verifyOtp({ email, code });
+      navigate("/chat?role=seeker");
+    } catch {
+      // Error handled by store
+    }
+  };
+
+  const handleResend = async () => {
+    if (resendTimer > 0) return;
+    try {
+      await resendOtp(email);
+      setResendTimer(60);
+    } catch {
+      // Error handled by store
+    }
+  };
+
+  return (
+    <div
+      style={{
+        minHeight: "100vh",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "var(--tx-bg)",
+        fontFamily: "var(--tx-font-mono)",
+        padding: "20px",
+      }}
+    >
+      <div style={{ width: "100%", maxWidth: "420px" }}>
+        {/* Header */}
+        <div style={{ marginBottom: "40px", textAlign: "center" }}>
+          <Link
+            to="/"
+            style={{
+              fontFamily: "var(--tx-font-display)",
+              fontSize: "14px",
+              fontWeight: 800,
+              letterSpacing: "6px",
+              textTransform: "uppercase",
+              color: "var(--tx-ink)",
+              textDecoration: "none",
+            }}
+          >
+            POSTLY
+          </Link>
+          <h1
+            style={{
+              fontFamily: "var(--tx-font-display)",
+              fontSize: "clamp(36px, 6vw, 48px)",
+              fontWeight: 800,
+              color: "var(--tx-ink)",
+              margin: "16px 0 8px",
+              lineHeight: 1,
+              letterSpacing: "-1px",
+            }}
+          >
+            VERIFY EMAIL
+          </h1>
+          <p
+            style={{
+              fontSize: "12px",
+              color: "var(--tx-ink-muted)",
+              letterSpacing: "0.5px",
+            }}
+          >
+            SENT TO:{" "}
+            <span style={{ color: "var(--tx-ink)", fontWeight: 700 }}>
+              {email}
+            </span>
+          </p>
+        </div>
+
+        {/* Form card */}
+        <div
+          style={{
+            background: "var(--tx-surface)",
+            border: "2px solid var(--tx-border)",
+            borderRadius: "var(--tx-radius)",
+            padding: "32px 28px",
+          }}
+        >
+          {/* Error */}
+          {error && (
+            <div
+              style={{
+                padding: "10px 14px",
+                border: "2px solid var(--tx-seeker)",
+                background: "rgba(255,61,0,0.06)",
+                color: "var(--tx-seeker)",
+                fontSize: "12px",
+                marginBottom: "20px",
+                letterSpacing: "0.5px",
+              }}
+            >
+              {error.toUpperCase()}
+            </div>
+          )}
+
+          <form onSubmit={handleSubmit}>
+            {/* OTP Code */}
+            <div style={{ marginBottom: "20px" }}>
+              <label
+                style={{
+                  display: "block",
+                  fontSize: "10px",
+                  fontWeight: 700,
+                  letterSpacing: "2px",
+                  textTransform: "uppercase",
+                  color: "var(--tx-ink-muted)",
+                  marginBottom: "8px",
+                }}
+              >
+                6-DIGIT CODE
+              </label>
+              <input
+                type="text"
+                value={code}
+                onChange={(e) =>
+                  setCode(e.target.value.replace(/\D/g, "").slice(0, 6))
+                }
+                required
+                maxLength={6}
+                placeholder="000000"
+                style={{
+                  width: "100%",
+                  padding: "16px",
+                  background: "var(--tx-bg)",
+                  border: "2px solid var(--tx-border)",
+                  borderRadius: "var(--tx-radius)",
+                  fontFamily: "var(--tx-font-mono)",
+                  fontSize: "32px",
+                  fontWeight: 800,
+                  letterSpacing: "12px",
+                  color: "var(--tx-ink)",
+                  textAlign: "center",
+                  outline: "none",
+                  transition: "border-color 150ms var(--tx-ease-sharp)",
+                  boxSizing: "border-box",
+                }}
+                onFocus={(e) =>
+                  (e.currentTarget.style.borderColor = "var(--tx-ink)")
+                }
+                onBlur={(e) =>
+                  (e.currentTarget.style.borderColor = "var(--tx-border)")
+                }
+              />
+            </div>
+
+            {/* Submit */}
+            <button
+              type="submit"
+              disabled={isLoading || code.length !== 6}
+              style={{
+                width: "100%",
+                padding: "14px",
+                marginTop: "12px",
+                fontFamily: "var(--tx-font-mono)",
+                fontSize: "13px",
+                fontWeight: 700,
+                letterSpacing: "2px",
+                textTransform: "uppercase",
+                color: "var(--tx-surface)",
+                background: "var(--tx-ink)",
+                border: "2px solid var(--tx-ink)",
+                borderRadius: "var(--tx-radius)",
+                cursor:
+                  isLoading || code.length !== 6 ? "not-allowed" : "pointer",
+                opacity: isLoading || code.length !== 6 ? 0.6 : 1,
+                transition:
+                  "opacity 150ms var(--tx-ease-sharp), transform 100ms var(--tx-ease-sharp)",
+              }}
+              onMouseDown={(e) => {
+                if (!isLoading && code.length === 6)
+                  e.currentTarget.style.transform = "scaleX(0.98)";
+              }}
+              onMouseUp={(e) => {
+                e.currentTarget.style.transform = "scaleX(1)";
+              }}
+            >
+              {isLoading ? "···" : "VERIFY CODE →"}
+            </button>
+          </form>
+
+          {/* Resend */}
+          <div style={{ marginTop: "24px", textAlign: "center" }}>
+            <button
+              onClick={handleResend}
+              disabled={isLoading || resendTimer > 0}
+              style={{
+                background: "none",
+                border: "none",
+                color:
+                  isLoading || resendTimer > 0
+                    ? "var(--tx-ink-muted)"
+                    : "var(--tx-ink)",
+                fontSize: "11px",
+                fontWeight: 700,
+                letterSpacing: "1px",
+                textTransform: "uppercase",
+                cursor:
+                  isLoading || resendTimer > 0 ? "not-allowed" : "pointer",
+                padding: "4px 8px",
+                borderBottom:
+                  resendTimer === 0 ? "2px solid var(--tx-ink)" : "none",
+                transition: "opacity 150ms var(--tx-ease-sharp)",
+              }}
+            >
+              {resendTimer > 0 ? `RESEND IN ${resendTimer}S` : "RESEND CODE"}
+            </button>
+          </div>
+        </div>
+
+        {/* Footer */}
+        <p
+          style={{
+            textAlign: "center",
+            fontSize: "11px",
+            color: "var(--tx-ink-muted)",
+            marginTop: "24px",
+            letterSpacing: "0.5px",
+          }}
+        >
+          WANT TO START OVER?{" "}
+          <Link
+            to="/register"
+            style={{
+              color: "var(--tx-ink)",
+              fontWeight: 700,
+              textDecoration: "none",
+              borderBottom: "2px solid var(--tx-ink)",
+            }}
+          >
+            JOIN AGAIN
+          </Link>
+        </p>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/web/src/services/auth.service.ts b/apps/web/src/services/auth.service.ts
index 3d0a0a7..d63e942 100644
--- a/apps/web/src/services/auth.service.ts
+++ b/apps/web/src/services/auth.service.ts
@@ -30,7 +30,7 @@ export const authService = {
       email: data.email,
       password: data.password,
       full_name: data.full_name,
-      role: data.role,
+      roles: data.roles,
     };
 
     const response = await apiClient.post<ApiResponse<AuthResponse>>(
@@ -60,6 +60,29 @@ export const authService = {
     });
   },
 
+  async verifyOtp(data: {
+    email: string;
+    code: string;
+  }): Promise<AuthResponse> {
+    const response = await apiClient.post<ApiResponse<AuthResponse>>(
+      "/auth/verify-otp",
+      data,
+    );
+    const authData = response.data.data;
+
+    if (!authData) throw new Error("No data received");
+
+    if (authData.access_token) {
+      localStorage.setItem("access_token", authData.access_token);
+    }
+
+    return authData;
+  },
+
+  async resendOtp(email: string): Promise<void> {
+    await apiClient.post("/auth/resend-otp", { email });
+  },
+
   logout(): void {
     localStorage.removeItem("access_token");
   },
diff --git a/apps/web/src/services/user.service.ts b/apps/web/src/services/user.service.ts
new file mode 100644
index 0000000..78cb1a0
--- /dev/null
+++ b/apps/web/src/services/user.service.ts
@@ -0,0 +1,127 @@
+import { apiClient } from "../lib/api-client";
+import {
+  User,
+  SeekerProfile,
+  EmployerProfile,
+  ApiResponse,
+} from "@postly/shared-types";
+
+export const userService = {
+  // Base Profile
+  async getProfile(): Promise<User> {
+    const response = await apiClient.get<ApiResponse<User>>("/users/profile");
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to fetch profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  async updateProfile(data: {
+    full_name?: string;
+    avatar_url?: string;
+    timezone?: string;
+    locale?: string;
+  }): Promise<User> {
+    const response = await apiClient.patch<ApiResponse<User>>(
+      "/users/profile",
+      data,
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to update profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  // Seeker Profile
+  async getSeekerProfile(): Promise<SeekerProfile> {
+    const response = await apiClient.get<ApiResponse<SeekerProfile>>(
+      "/users/seeker-profile",
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to fetch seeker profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  async updateSeekerProfile(
+    data: Partial<SeekerProfile>,
+  ): Promise<SeekerProfile> {
+    const response = await apiClient.patch<ApiResponse<SeekerProfile>>(
+      "/users/seeker-profile",
+      data,
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to update seeker profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  // Employer Profile
+  async getEmployerProfile(): Promise<EmployerProfile> {
+    const response = await apiClient.get<ApiResponse<EmployerProfile>>(
+      "/users/employer-profile",
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to fetch employer profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  async updateEmployerProfile(
+    data: Partial<EmployerProfile>,
+  ): Promise<EmployerProfile> {
+    const response = await apiClient.patch<ApiResponse<EmployerProfile>>(
+      "/users/employer-profile",
+      data,
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to update employer profile",
+      );
+    }
+    return response.data.data;
+  },
+
+  // Security
+  async changePassword(data: Record<string, string>): Promise<void> {
+    const response = await apiClient.post<ApiResponse<unknown>>(
+      "/users/change-password",
+      data,
+    );
+    if (!response.data.success) {
+      throw new Error(
+        response.data.error?.message || "Failed to update password",
+      );
+    }
+  },
+
+  async uploadAvatar(file: File): Promise<string> {
+    const formData = new FormData();
+    formData.append("avatar", file);
+    const response = await apiClient.post<ApiResponse<{ url: string }>>(
+      "/users/upload-avatar",
+      formData,
+      {
+        headers: {
+          "Content-Type": "multipart/form-data",
+        },
+      },
+    );
+    if (!response.data.success || !response.data.data) {
+      throw new Error(
+        response.data.error?.message || "Failed to upload avatar",
+      );
+    }
+    return response.data.data.url;
+  },
+};
diff --git a/apps/web/src/stores/auth.store.ts b/apps/web/src/stores/auth.store.ts
index ea7465f..aeb8453 100644
--- a/apps/web/src/stores/auth.store.ts
+++ b/apps/web/src/stores/auth.store.ts
@@ -10,6 +10,8 @@ interface AuthState {
   error: string | null;
   login: (data: LoginRequest) => Promise<void>;
   register: (data: RegisterRequest) => Promise<void>;
+  verifyOtp: (data: { email: string; code: string }) => Promise<void>;
+  resendOtp: (email: string) => Promise<void>;
   logout: () => void;
   checkAuth: () => Promise<void>;
   setAuth: (user: User, token: string) => void;
@@ -44,7 +46,25 @@ export const useAuthStore = create<AuthState>()(
       register: async (data: RegisterRequest) => {
         set({ isLoading: true, error: null });
         try {
-          const response = await authService.register(data);
+          await authService.register(data);
+          // Don't set user/isAuthenticated yet, wait for OTP
+          set({
+            isLoading: false,
+          });
+        } catch (error) {
+          set({
+            error:
+              error instanceof Error ? error.message : "Registration failed",
+            isLoading: false,
+          });
+          throw error;
+        }
+      },
+
+      verifyOtp: async (data: { email: string; code: string }) => {
+        set({ isLoading: true, error: null });
+        try {
+          const response = await authService.verifyOtp(data);
           set({
             user: response.user,
             isAuthenticated: true,
@@ -53,7 +73,22 @@ export const useAuthStore = create<AuthState>()(
         } catch (error) {
           set({
             error:
-              error instanceof Error ? error.message : "Registration failed",
+              error instanceof Error ? error.message : "Verification failed",
+            isLoading: false,
+          });
+          throw error;
+        }
+      },
+
+      resendOtp: async (email: string) => {
+        set({ isLoading: true, error: null });
+        try {
+          await authService.resendOtp(email);
+          set({ isLoading: false });
+        } catch (error) {
+          set({
+            error:
+              error instanceof Error ? error.message : "Failed to resend code",
             isLoading: false,
           });
           throw error;
diff --git a/apps/web/src/styles/transmission.css b/apps/web/src/styles/transmission.css
index 25683cb..240aed0 100644
--- a/apps/web/src/styles/transmission.css
+++ b/apps/web/src/styles/transmission.css
@@ -372,6 +372,38 @@
   background: #002ccc;
 }
 
+/* ─── Coming Soon Badge ───────────────────────────────────────────────── */
+.tx-badge-coming-soon {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%) rotate(-5deg);
+  background: var(--tx-bg);
+  color: var(--tx-ink);
+  border: 2px solid var(--tx-ink);
+  padding: 8px 16px;
+  font-family: var(--tx-font-mono);
+  font-size: 14px;
+  font-weight: 700;
+  letter-spacing: 2px;
+  text-transform: uppercase;
+  z-index: 30;
+  box-shadow: 6px 6px 0px var(--tx-ink);
+  pointer-events: none;
+  user-select: none;
+  white-space: nowrap;
+}
+
+.tx-panel-disabled {
+  opacity: 0.6;
+  filter: grayscale(0.8);
+  pointer-events: none;
+}
+
+.tx-panel-disabled:hover {
+  background-color: #0D0D0D !important;
+}
+
 /* ─── Scrollbar styling ───────────────────────────────────────────────── */
 .tx-scrollbar::-webkit-scrollbar {
   width: 6px;
diff --git a/apps/web/src/types/auth.ts b/apps/web/src/types/auth.ts
index f784fbf..597217c 100644
--- a/apps/web/src/types/auth.ts
+++ b/apps/web/src/types/auth.ts
@@ -29,3 +29,12 @@ export interface ResetPasswordRequest {
   password: string;
   confirmPassword?: string;
 }
+
+export interface VerifyOtpRequest {
+  email: string;
+  code: string;
+}
+
+export interface ResendOtpRequest {
+  email: string;
+}
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index b461035..1e0c3a4 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -1,5 +1,6 @@
 services:
-  # PostgreSQL
+
+  # ─── PostgreSQL with pgvector ──────────────────────────────
   postgres:
     image: pgvector/pgvector:pg16
     container_name: postly-postgres
@@ -8,69 +9,77 @@ services:
       POSTGRES_USER: ${DB_USER:-postly}
       POSTGRES_PASSWORD: ${DB_PASSWORD:?Database password required}
       POSTGRES_DB: ${DB_NAME:-postly}
-      DATABASE_URL: postgresql://${DB_USER:-postly}:${DB_PASSWORD}@postgres:5432/${DB_NAME:-postly}
-    ports:
-      - "5432:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
       - ./packages/database/migrations:/docker-entrypoint-initdb.d:ro
     command: >
       postgres
-      -c shared_buffers=64MB
-      -c effective_cache_size=128MB
-      -c work_mem=4MB
-      -c maintenance_work_mem=32MB
+      -c shared_buffers=256MB
+      -c effective_cache_size=512MB
+      -c work_mem=16MB
+      -c maintenance_work_mem=64MB
       -c max_connections=30
       -c random_page_cost=1.1
+      -c wal_compression=on
     deploy:
       resources:
         limits:
-          cpus: '0.25'
-          memory: 180M
+          cpus: '0.5'
+          memory: 512M
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-postly}"]
       interval: 10s
       timeout: 5s
       retries: 5
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
     networks:
       - postly-network
 
-  # Redis
+  # ─── Redis (Job Queue & Caching) ──────────────────────────
   redis:
     image: redis:7-alpine
     container_name: postly-redis
     restart: unless-stopped
     command: >
       redis-server
-      --maxmemory 40mb
-      --maxmemory-policy noeviction
+      --maxmemory 64mb
+      --maxmemory-policy allkeys-lru
       --appendonly yes
       --save 60 1
+      --loglevel warning
     volumes:
       - redis_data:/data
     deploy:
       resources:
         limits:
           cpus: '0.1'
-          memory: 50M
+          memory: 80M
     healthcheck:
       test: ["CMD", "redis-cli", "ping"]
       interval: 10s
       timeout: 3s
       retries: 5
-    ports:
-      - "6379:6379"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "5m"
+        max-file: "2"
     networks:
       - postly-network
+    # NOTE: No ports exposed — only accessible via internal Docker network
 
-  # API Server
+  # ─── API Server ────────────────────────────────────────────
   api:
-    image: utsavjoshi/postly-api:latest
+    image: ${API_IMAGE:-utsavjoshi/postly-api:latest}
     container_name: postly-api
     restart: unless-stopped
     environment:
       NODE_ENV: production
-      NODE_OPTIONS: "--max-old-space-size=200"
+      NODE_OPTIONS: "--max-old-space-size=384"
       DB_HOST: postgres
       DB_PORT: 5432
       DB_NAME: ${DB_NAME:-postly}
@@ -96,26 +105,28 @@ services:
     deploy:
       resources:
         limits:
-          cpus: '0.3'
-          memory: 220M
+          cpus: '0.5'
+          memory: 512M
     healthcheck:
       test: ["CMD", "node", "-e", "require('http').get('http://127.0.0.1:3000/health', (res) => { if (res.statusCode !== 200) process.exit(1); }).on('error', () => process.exit(1));"]
       interval: 30s
       timeout: 10s
       retries: 3
+      start_period: 15s
     logging:
       driver: "json-file"
       options:
         max-size: "10m"
         max-file: "3"
-    ports:
-      - "3000:3000"
     networks:
       - postly-network
+    ports:
+      - "3000:3000"
+    # NOTE: No ports exposed — traffic flows through Nginx only
 
-  # Scraper
+  # ─── Scraper (Python + Playwright) ────────────────────────
   scraper:
-    image: utsavjoshi/postly-scraper:latest
+    image: ${SCRAPER_IMAGE:-utsavjoshi/postly-scraper:latest}
     container_name: postly-scraper
     restart: unless-stopped
     environment:
@@ -131,13 +142,11 @@ services:
     depends_on:
       postgres:
         condition: service_healthy
-    ports:
-      - "8080:8080"  
-    shm_size: '512mb'  
+    shm_size: '512mb'
     deploy:
       resources:
         limits:
-          cpus: '0.3'
+          cpus: '0.5'
           memory: 400M
     healthcheck:
       test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health')"]
@@ -153,9 +162,9 @@ services:
     networks:
       - postly-network
 
-  # Discord Bot
+  # ─── Discord Bot ───────────────────────────────────────────
   bot:
-    image: utsavjoshi/postly-bot:latest
+    image: ${BOT_IMAGE:-utsavjoshi/postly-bot:latest}
     container_name: postly-bot
     restart: unless-stopped
     environment:
@@ -179,7 +188,7 @@ services:
       resources:
         limits:
           cpus: '0.2'
-          memory: 150M
+          memory: 200M
     logging:
       driver: "json-file"
       options:
@@ -188,7 +197,6 @@ services:
     networks:
       - postly-network
 
-
 volumes:
   postgres_data:
   redis_data:
diff --git a/package-lock.json b/package-lock.json
index 869788c..37bcd8d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,8 +28,9 @@
         "@dodopayments/express": "^0.2.6",
         "@postly/config": "*",
         "@postly/database": "*",
+        "@postly/logger": "*",
         "@postly/shared-types": "*",
-        "bcryptjs": "^2.4.3",
+        "bcrypt": "^5.1.1",
         "bullmq": "^5.31.3",
         "cors": "^2.8.6",
         "dotenv": "^16.4.7",
@@ -41,12 +42,13 @@
         "mammoth": "^1.11.0",
         "multer": "^2.0.2",
         "pdf-parse": "^2.4.5",
+        "resend": "^6.9.4",
         "zod": "^3.24.1"
       },
       "devDependencies": {
         "@postly/eslint-config": "*",
         "@postly/typescript-config": "*",
-        "@types/bcryptjs": "^2.4.6",
+        "@types/bcrypt": "^5.0.2",
         "@types/cors": "^2.8.17",
         "@types/express": "^5.0.0",
         "@types/jsonwebtoken": "^9.0.7",
@@ -2695,6 +2697,26 @@
         "@langchain/core": "^1.0.0"
       }
     },
+    "node_modules/@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "node-pre-gyp": "bin/node-pre-gyp"
+      }
+    },
     "node_modules/@msgpackr-extract/msgpackr-extract-darwin-arm64": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-darwin-arm64/-/msgpackr-extract-darwin-arm64-3.0.3.tgz",
@@ -4565,12 +4587,15 @@
         "@babel/types": "^7.28.2"
       }
     },
-    "node_modules/@types/bcryptjs": {
-      "version": "2.4.6",
-      "resolved": "https://registry.npmjs.org/@types/bcryptjs/-/bcryptjs-2.4.6.tgz",
-      "integrity": "sha512-9xlo6R2qDs5uixm0bcIqCeMCE6HiQsIyel9KQySStiyqNl2tnj2mP3DX1Nf56MD6KMenNNlBBsy3LJ7gUEQPXQ==",
+    "node_modules/@types/bcrypt": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/@types/bcrypt/-/bcrypt-5.0.2.tgz",
+      "integrity": "sha512-6atioO8Y75fNcbmj0G7UjI9lXN2pQ/IGJ2FWT4a/btd0Lk9lQalHLKhkgKVZ3r+spnmWUKfbMi1GEe9wyHQfNQ==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
     },
     "node_modules/@types/body-parser": {
       "version": "1.19.6",
@@ -5377,6 +5402,12 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "license": "ISC"
+    },
     "node_modules/accepts": {
       "version": "1.3.8",
       "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
@@ -5411,6 +5442,18 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
     "node_modules/ajv": {
       "version": "6.14.0",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
@@ -5458,6 +5501,40 @@
       "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
       "license": "MIT"
     },
+    "node_modules/aproba": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
+      "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==",
+      "license": "ISC"
+    },
+    "node_modules/are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/are-we-there-yet/node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
@@ -5762,11 +5839,19 @@
         "baseline-browser-mapping": "dist/cli.js"
       }
     },
-    "node_modules/bcryptjs": {
-      "version": "2.4.3",
-      "resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-2.4.3.tgz",
-      "integrity": "sha512-V/Hy/X9Vt7f3BbPJEi8BdVFMByHi+jNXrYkW3huaybV/kQ0KJg0Y6PkEMbn+zeT+i+SiKZ/HMqJGIIt4LZDqNQ==",
-      "license": "MIT"
+    "node_modules/bcrypt": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",
+      "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "node-addon-api": "^5.0.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
     },
     "node_modules/bluebird": {
       "version": "3.4.7",
@@ -6153,6 +6238,15 @@
         "node": ">= 16"
       }
     },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/class-variance-authority": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
@@ -6216,28 +6310,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/cliui/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cliui/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/cliui/node_modules/wrap-ansi": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
@@ -6320,6 +6392,15 @@
         "node": ">=18"
       }
     },
+    "node_modules/color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "license": "ISC",
+      "bin": {
+        "color-support": "bin.js"
+      }
+    },
     "node_modules/combined-stream": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
@@ -6377,6 +6458,12 @@
         "node": ">= 6"
       }
     },
+    "node_modules/console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+      "license": "ISC"
+    },
     "node_modules/console-table-printer": {
       "version": "2.15.0",
       "resolved": "https://registry.npmjs.org/console-table-printer/-/console-table-printer-2.15.0.tgz",
@@ -6643,6 +6730,12 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+      "license": "MIT"
+    },
     "node_modules/denque": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
@@ -6684,7 +6777,6 @@
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
       "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
-      "devOptional": true,
       "license": "Apache-2.0",
       "engines": {
         "node": ">=8"
@@ -7421,6 +7513,12 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
     "node_modules/enabled": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
@@ -8395,6 +8493,36 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    },
     "node_modules/fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
@@ -8454,6 +8582,27 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/generator-function": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
@@ -8754,6 +8903,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+      "license": "ISC"
+    },
     "node_modules/hasown": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
@@ -8862,6 +9017,19 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/husky": {
       "version": "9.1.7",
       "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz",
@@ -9239,7 +9407,6 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -10227,6 +10394,30 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
     "node_modules/mammoth": {
       "version": "1.11.0",
       "resolved": "https://registry.npmjs.org/mammoth/-/mammoth-1.11.0.tgz",
@@ -11208,6 +11399,46 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib/node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    },
     "node_modules/mkdirp": {
       "version": "0.5.6",
       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
@@ -11324,6 +11555,12 @@
       "integrity": "sha512-AGK2yQKIjRuqnc6VkX2Xj5d+QW8xZ87pa1UK6yA6ouUyuxfHuMP6umE5QK7UmTeOAymo+Zx1Fxiuw9rVx8taHQ==",
       "license": "MIT"
     },
+    "node_modules/node-addon-api": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==",
+      "license": "MIT"
+    },
     "node_modules/node-exports-info": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.0.tgz",
@@ -11351,6 +11588,26 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/node-gyp-build-optional-packages": {
       "version": "5.2.2",
       "resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz",
@@ -11373,6 +11630,34 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -11931,6 +12216,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/postal-mime": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmjs.org/postal-mime/-/postal-mime-2.7.3.tgz",
+      "integrity": "sha512-MjhXadAJaWgYzevi46+3kLak8y6gbg0ku14O1gO/LNOuay8dO+1PtcSGvAdgDR0DoIsSaiIA8y/Ddw6MnrO0Tw==",
+      "license": "MIT-0"
+    },
     "node_modules/postcss": {
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
@@ -12526,6 +12817,27 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/resend": {
+      "version": "6.9.4",
+      "resolved": "https://registry.npmjs.org/resend/-/resend-6.9.4.tgz",
+      "integrity": "sha512-/M3dsJzu5OgozqVsA4Psd/1L7EdePgOIIxClas453GOQYFG3VHc2ZyCHZFlvqsc9aZCCd2BJRRqZgWC8D9c7/g==",
+      "license": "MIT",
+      "dependencies": {
+        "postal-mime": "2.7.3",
+        "svix": "1.86.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "@react-email/render": "*"
+      },
+      "peerDependenciesMeta": {
+        "@react-email/render": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/resolve": {
       "version": "2.0.0-next.6",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.6.tgz",
@@ -12893,6 +13205,12 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
     "node_modules/set-cookie-parser": {
       "version": "2.7.2",
       "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
@@ -13057,6 +13375,12 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
     "node_modules/simple-wcswidth": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/simple-wcswidth/-/simple-wcswidth-1.1.2.tgz",
@@ -13213,6 +13537,20 @@
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "license": "MIT"
     },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/string.prototype.matchall": {
       "version": "4.0.12",
       "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz",
@@ -13406,6 +13744,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/svix": {
+      "version": "1.86.0",
+      "resolved": "https://registry.npmjs.org/svix/-/svix-1.86.0.tgz",
+      "integrity": "sha512-/HTvXwjLJe1l/MsLXAO1ddCYxElJk4eNR4DzOjDOEmGrPN/3BtBE8perGwMAaJ2sT5T172VkBYzmHcjUfM1JRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "standardwebhooks": "1.0.0",
+        "uuid": "^10.0.0"
+      }
+    },
     "node_modules/tailwind-merge": {
       "version": "3.4.0",
       "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.4.0.tgz",
@@ -13437,6 +13785,42 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar/node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar/node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    },
     "node_modules/text-hex": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz",
@@ -13528,6 +13912,12 @@
         "node": ">=0.6"
       }
     },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
@@ -14789,6 +15179,22 @@
       "resolved": "apps/web",
       "link": true
     },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -14912,6 +15318,15 @@
         "node": ">=8"
       }
     },
+    "node_modules/wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
     "node_modules/winston": {
       "version": "3.19.0",
       "resolved": "https://registry.npmjs.org/winston/-/winston-3.19.0.tgz",
@@ -15078,28 +15493,6 @@
         "node": ">=12"
       }
     },
-    "node_modules/yargs/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/yargs/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
diff --git a/packages/config/app-config/src/index.ts b/packages/config/app-config/src/index.ts
index 98fd34d..5ca2a6a 100644
--- a/packages/config/app-config/src/index.ts
+++ b/packages/config/app-config/src/index.ts
@@ -80,6 +80,12 @@ export const DODO_PAYMENTS_ENVIRONMENT =
 export const DODO_PAYMENTS_RETURN_URL =
   process.env.DODO_PAYMENTS_RETURN_URL || "";
 
+// ─── Email (Resend) ──────────────────────────────────────────────────────────
+
+export const RESEND_API_KEY = process.env.RESEND_API_KEY || "";
+export const RESEND_FROM_EMAIL =
+  process.env.RESEND_FROM_EMAIL || "Postly <onboarding@resend.dev>";
+
 // ─── MinIO / S3 Storage (Optional) ──────────────────────────────────────────
 
 export const MINIO_ENDPOINT = process.env.MINIO_ENDPOINT || "localhost";
diff --git a/packages/database/migrations/0004_loose_madame_web.sql b/packages/database/migrations/0004_loose_madame_web.sql
new file mode 100644
index 0000000..30b2180
--- /dev/null
+++ b/packages/database/migrations/0004_loose_madame_web.sql
@@ -0,0 +1,253 @@
+CREATE TYPE "public"."bot_platform" AS ENUM('discord', 'reddit', 'twitter', 'slack');--> statement-breakpoint
+CREATE TYPE "public"."scrape_source_status" AS ENUM('active', 'paused', 'broken', 'rate_limited');--> statement-breakpoint
+ALTER TYPE "public"."subscription_plan" ADD VALUE 'discord_owner' BEFORE 'enterprise';--> statement-breakpoint
+ALTER TYPE "public"."user_role" ADD VALUE 'discord_owner';--> statement-breakpoint
+CREATE TABLE "application_status_history" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"application_id" uuid NOT NULL,
+	"from_status" "application_status",
+	"to_status" "application_status" NOT NULL,
+	"changed_by" uuid,
+	"note" text,
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+CREATE TABLE "audit_log" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"actor_id" uuid,
+	"action" varchar(100) NOT NULL,
+	"entity_type" varchar(100),
+	"entity_id" uuid,
+	"diff" jsonb,
+	"ip_address" varchar(45),
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+CREATE TABLE "bot_configs" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"platform" "bot_platform" NOT NULL,
+	"platform_config" jsonb NOT NULL,
+	"credentials" jsonb,
+	"token_expires_at" timestamp with time zone,
+	"job_filters" jsonb,
+	"post_format" varchar(50) DEFAULT 'default',
+	"max_posts_per_day" integer DEFAULT 10,
+	"post_schedule" jsonb,
+	"is_active" boolean DEFAULT true,
+	"last_post_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now(),
+	"updated_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "bot_configs_user_id_platform_unique" UNIQUE("user_id","platform")
+);
+--> statement-breakpoint
+CREATE TABLE "bot_posts" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"bot_config_id" uuid NOT NULL,
+	"job_id" uuid,
+	"platform" "bot_platform" NOT NULL,
+	"external_post_id" varchar(255),
+	"content_snapshot" text,
+	"status" varchar(30) DEFAULT 'sent',
+	"error_message" text,
+	"posted_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "bot_posts_bot_config_id_job_id_unique" UNIQUE("bot_config_id","job_id")
+);
+--> statement-breakpoint
+CREATE TABLE "discord_posted_jobs" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"discord_config_id" uuid NOT NULL,
+	"job_id" uuid NOT NULL,
+	"message_id" varchar(255),
+	"posted_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "discord_posted_jobs_discord_config_id_job_id_unique" UNIQUE("discord_config_id","job_id")
+);
+--> statement-breakpoint
+CREATE TABLE "job_fingerprints" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"job_id" uuid NOT NULL,
+	"source_id" uuid,
+	"fingerprint" varchar(64) NOT NULL,
+	"source_url" text,
+	"first_seen_at" timestamp with time zone DEFAULT now(),
+	"last_seen_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "job_fingerprints_fingerprint_unique" UNIQUE("fingerprint")
+);
+--> statement-breakpoint
+CREATE TABLE "plan_quotas" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"plan" "subscription_plan" NOT NULL,
+	"ai_tokens_per_day" integer,
+	"ai_tokens_per_month" integer,
+	"job_matches_per_day" integer,
+	"job_searches_per_day" integer,
+	"api_calls_per_minute" integer,
+	"api_calls_per_day" integer,
+	"resume_parses_per_month" integer,
+	"bot_posts_per_day" integer,
+	"is_unlimited" boolean DEFAULT false,
+	"created_at" timestamp with time zone DEFAULT now(),
+	"updated_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "plan_quotas_plan_unique" UNIQUE("plan")
+);
+--> statement-breakpoint
+CREATE TABLE "promo_codes" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"code" varchar(100) NOT NULL,
+	"discount_type" varchar(20) NOT NULL,
+	"discount_value" numeric(10, 2) NOT NULL,
+	"applies_to_plan" "subscription_plan",
+	"max_uses" integer,
+	"uses_count" integer DEFAULT 0,
+	"expires_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "promo_codes_code_unique" UNIQUE("code")
+);
+--> statement-breakpoint
+CREATE TABLE "rate_limit_overrides" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"override_type" varchar(50) NOT NULL,
+	"override_value" integer,
+	"granted_by" uuid,
+	"expires_at" timestamp with time zone,
+	"reason" text,
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+CREATE TABLE "scrape_runs" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"source_id" uuid NOT NULL,
+	"started_at" timestamp with time zone DEFAULT now(),
+	"completed_at" timestamp with time zone,
+	"status" varchar(30) DEFAULT 'running',
+	"jobs_found" integer DEFAULT 0,
+	"jobs_new" integer DEFAULT 0,
+	"jobs_updated" integer DEFAULT 0,
+	"jobs_deduped" integer DEFAULT 0,
+	"error_log" jsonb
+);
+--> statement-breakpoint
+CREATE TABLE "scrape_sources" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"name" varchar(255) NOT NULL,
+	"base_url" text NOT NULL,
+	"scraper_type" varchar(50) NOT NULL,
+	"config" jsonb NOT NULL,
+	"status" "scrape_source_status" DEFAULT 'active',
+	"requests_per_minute" integer DEFAULT 10,
+	"retry_after_seconds" integer DEFAULT 60,
+	"crawl_interval_minutes" integer DEFAULT 60,
+	"last_crawled_at" timestamp with time zone,
+	"next_crawl_at" timestamp with time zone,
+	"consecutive_failures" integer DEFAULT 0,
+	"last_error" text,
+	"total_jobs_scraped" integer DEFAULT 0,
+	"created_at" timestamp with time zone DEFAULT now(),
+	"updated_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+CREATE TABLE "sessions" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"token_hash" varchar(255) NOT NULL,
+	"ip_address" varchar(45),
+	"user_agent" text,
+	"last_active_at" timestamp with time zone DEFAULT now(),
+	"expires_at" timestamp with time zone NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "sessions_token_hash_unique" UNIQUE("token_hash")
+);
+--> statement-breakpoint
+CREATE TABLE "system_prompts" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"version" integer NOT NULL,
+	"slug" varchar(100) NOT NULL,
+	"content" text NOT NULL,
+	"is_active" boolean DEFAULT false,
+	"created_by" uuid,
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+CREATE TABLE "token_usage" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"window_type" varchar(20) NOT NULL,
+	"window_start" timestamp with time zone NOT NULL,
+	"tokens_used" integer DEFAULT 0 NOT NULL,
+	"api_calls" integer DEFAULT 0 NOT NULL,
+	"job_matches" integer DEFAULT 0 NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now(),
+	"updated_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "token_usage_user_id_window_type_window_start_unique" UNIQUE("user_id","window_type","window_start")
+);
+--> statement-breakpoint
+DROP INDEX "idx_users_role";--> statement-breakpoint
+ALTER TABLE "applications" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "system_prompt_version" integer DEFAULT 1;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "total_tokens_used" integer DEFAULT 0;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "context_window_used" integer;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "guild_name" varchar(255);--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "channel_name" varchar(255);--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "bot_webhook_url" text;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "job_filters" jsonb;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "post_format" varchar(50) DEFAULT 'embed';--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "ping_role_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "ping_everyone" boolean DEFAULT false;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "max_posts_per_day" integer DEFAULT 10;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "last_post_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "posts_today" integer DEFAULT 0;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD COLUMN "posts_today_reset_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "email_notifications" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "employer_profiles" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "job_matches" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "jobs" ADD COLUMN "scrape_source_id" uuid;--> statement-breakpoint
+ALTER TABLE "jobs" ADD COLUMN "external_job_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "jobs" ADD COLUMN "fingerprint" varchar(64);--> statement-breakpoint
+ALTER TABLE "jobs" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "tokens_used" integer;--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "model_used" varchar(100);--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "latency_ms" integer;--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "finish_reason" varchar(50);--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "cost_usd" numeric(10, 6);--> statement-breakpoint
+ALTER TABLE "messages" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "notification_templates" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "idempotency_key" varchar(255);--> statement-breakpoint
+ALTER TABLE "resumes" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "seeker_profiles" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD COLUMN "promo_code_id" uuid;--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "roles" "user_role"[] DEFAULT '{"job_seeker"}' NOT NULL;--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "timezone" varchar(50);--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "locale" varchar(20);--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "deleted_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "application_status_history" ADD CONSTRAINT "application_status_history_application_id_applications_id_fk" FOREIGN KEY ("application_id") REFERENCES "public"."applications"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "application_status_history" ADD CONSTRAINT "application_status_history_changed_by_users_id_fk" FOREIGN KEY ("changed_by") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "audit_log" ADD CONSTRAINT "audit_log_actor_id_users_id_fk" FOREIGN KEY ("actor_id") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD CONSTRAINT "bot_configs_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "bot_posts" ADD CONSTRAINT "bot_posts_bot_config_id_bot_configs_id_fk" FOREIGN KEY ("bot_config_id") REFERENCES "public"."bot_configs"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "bot_posts" ADD CONSTRAINT "bot_posts_job_id_jobs_id_fk" FOREIGN KEY ("job_id") REFERENCES "public"."jobs"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "discord_posted_jobs" ADD CONSTRAINT "discord_posted_jobs_discord_config_id_discord_configs_id_fk" FOREIGN KEY ("discord_config_id") REFERENCES "public"."discord_configs"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "discord_posted_jobs" ADD CONSTRAINT "discord_posted_jobs_job_id_jobs_id_fk" FOREIGN KEY ("job_id") REFERENCES "public"."jobs"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "job_fingerprints" ADD CONSTRAINT "job_fingerprints_job_id_jobs_id_fk" FOREIGN KEY ("job_id") REFERENCES "public"."jobs"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "job_fingerprints" ADD CONSTRAINT "job_fingerprints_source_id_scrape_sources_id_fk" FOREIGN KEY ("source_id") REFERENCES "public"."scrape_sources"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "rate_limit_overrides" ADD CONSTRAINT "rate_limit_overrides_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "rate_limit_overrides" ADD CONSTRAINT "rate_limit_overrides_granted_by_users_id_fk" FOREIGN KEY ("granted_by") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "scrape_runs" ADD CONSTRAINT "scrape_runs_source_id_scrape_sources_id_fk" FOREIGN KEY ("source_id") REFERENCES "public"."scrape_sources"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "sessions" ADD CONSTRAINT "sessions_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "system_prompts" ADD CONSTRAINT "system_prompts_created_by_users_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "token_usage" ADD CONSTRAINT "token_usage_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_bot_configs_active" ON "bot_configs" USING btree ("is_active","platform");--> statement-breakpoint
+CREATE INDEX "idx_bot_posts_config" ON "bot_posts" USING btree ("bot_config_id","posted_at");--> statement-breakpoint
+CREATE INDEX "idx_discord_posted_config" ON "discord_posted_jobs" USING btree ("discord_config_id");--> statement-breakpoint
+CREATE INDEX "idx_scrape_runs_source" ON "scrape_runs" USING btree ("source_id","started_at");--> statement-breakpoint
+CREATE INDEX "idx_scrape_sources_queue" ON "scrape_sources" USING btree ("status","next_crawl_at");--> statement-breakpoint
+CREATE INDEX "idx_system_prompts_active" ON "system_prompts" USING btree ("slug","is_active");--> statement-breakpoint
+CREATE INDEX "idx_token_usage_user_window" ON "token_usage" USING btree ("user_id","window_type","window_start");--> statement-breakpoint
+ALTER TABLE "jobs" ADD CONSTRAINT "jobs_scrape_source_id_scrape_sources_id_fk" FOREIGN KEY ("scrape_source_id") REFERENCES "public"."scrape_sources"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD CONSTRAINT "subscriptions_promo_code_id_promo_codes_id_fk" FOREIGN KEY ("promo_code_id") REFERENCES "public"."promo_codes"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_jobs_active" ON "jobs" USING btree ("is_active");--> statement-breakpoint
+CREATE INDEX "idx_users_role" ON "users" USING btree ("roles");--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "status_history";--> statement-breakpoint
+ALTER TABLE "users" DROP COLUMN "role";--> statement-breakpoint
+ALTER TABLE "payments" ADD CONSTRAINT "payments_idempotency_key_unique" UNIQUE("idempotency_key");
\ No newline at end of file
diff --git a/packages/database/migrations/0005_brown_viper.sql b/packages/database/migrations/0005_brown_viper.sql
new file mode 100644
index 0000000..2f3e612
--- /dev/null
+++ b/packages/database/migrations/0005_brown_viper.sql
@@ -0,0 +1,12 @@
+CREATE TABLE "otp_codes" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"code_hash" varchar(255) NOT NULL,
+	"expires_at" timestamp with time zone NOT NULL,
+	"attempts" integer DEFAULT 0 NOT NULL,
+	"last_attempt_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+ALTER TABLE "otp_codes" ADD CONSTRAINT "otp_codes_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_otp_user" ON "otp_codes" USING btree ("user_id");
\ No newline at end of file
diff --git a/packages/database/migrations/0006_loving_forge.sql b/packages/database/migrations/0006_loving_forge.sql
new file mode 100644
index 0000000..1dceeef
--- /dev/null
+++ b/packages/database/migrations/0006_loving_forge.sql
@@ -0,0 +1,151 @@
+CREATE TABLE "notifications" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"type" varchar(100),
+	"subject" varchar(500) NOT NULL,
+	"content" text NOT NULL,
+	"to_email" varchar(255) NOT NULL,
+	"status" "notification_status" DEFAULT 'pending' NOT NULL,
+	"sent_at" timestamp with time zone,
+	"error_message" text,
+	"created_at" timestamp with time zone DEFAULT now()
+);
+--> statement-breakpoint
+ALTER TABLE "career_site_integrations" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "discord_configs" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "discord_posted_jobs" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "email_notifications" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "job_fingerprints" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "message_attachments" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "notification_templates" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "plan_quotas" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "promo_codes" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "rate_limit_overrides" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "scrape_runs" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "scrape_sources" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+DROP TABLE "career_site_integrations" CASCADE;--> statement-breakpoint
+DROP TABLE "discord_configs" CASCADE;--> statement-breakpoint
+DROP TABLE "discord_posted_jobs" CASCADE;--> statement-breakpoint
+DROP TABLE "email_notifications" CASCADE;--> statement-breakpoint
+DROP TABLE "job_fingerprints" CASCADE;--> statement-breakpoint
+DROP TABLE "message_attachments" CASCADE;--> statement-breakpoint
+DROP TABLE "notification_templates" CASCADE;--> statement-breakpoint
+DROP TABLE "plan_quotas" CASCADE;--> statement-breakpoint
+DROP TABLE "promo_codes" CASCADE;--> statement-breakpoint
+DROP TABLE "rate_limit_overrides" CASCADE;--> statement-breakpoint
+DROP TABLE "scrape_runs" CASCADE;--> statement-breakpoint
+DROP TABLE "scrape_sources" CASCADE;--> statement-breakpoint
+ALTER TABLE "bot_posts" DROP CONSTRAINT "bot_posts_bot_config_id_job_id_unique";--> statement-breakpoint
+ALTER TABLE "payments" DROP CONSTRAINT "payments_dodo_payment_id_unique";--> statement-breakpoint
+ALTER TABLE "payments" DROP CONSTRAINT "payments_idempotency_key_unique";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP CONSTRAINT "token_usage_user_id_window_type_window_start_unique";--> statement-breakpoint
+ALTER TABLE "jobs" DROP CONSTRAINT "jobs_scrape_source_id_scrape_sources_id_fk";
+--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP CONSTRAINT "subscriptions_promo_code_id_promo_codes_id_fk";
+--> statement-breakpoint
+ALTER TABLE "system_prompts" DROP CONSTRAINT "system_prompts_created_by_users_id_fk";
+--> statement-breakpoint
+ALTER TABLE "bot_configs" ALTER COLUMN "platform" SET DATA TYPE text;--> statement-breakpoint
+DROP TYPE "public"."bot_platform";--> statement-breakpoint
+CREATE TYPE "public"."bot_platform" AS ENUM('discord', 'reddit', 'twitter');--> statement-breakpoint
+ALTER TABLE "bot_configs" ALTER COLUMN "platform" SET DATA TYPE "public"."bot_platform" USING "platform"::"public"."bot_platform";--> statement-breakpoint
+ALTER TABLE "subscriptions" ALTER COLUMN "plan" SET DATA TYPE text;--> statement-breakpoint
+DROP TYPE "public"."subscription_plan";--> statement-breakpoint
+CREATE TYPE "public"."subscription_plan" AS ENUM('seeker', 'employer', 'discord_owner');--> statement-breakpoint
+ALTER TABLE "subscriptions" ALTER COLUMN "plan" SET DATA TYPE "public"."subscription_plan" USING "plan"::"public"."subscription_plan";--> statement-breakpoint
+DROP INDEX "idx_applications_seeker_status";--> statement-breakpoint
+DROP INDEX "idx_applications_job_pipeline";--> statement-breakpoint
+DROP INDEX "idx_bot_configs_active";--> statement-breakpoint
+DROP INDEX "idx_bot_posts_config";--> statement-breakpoint
+DROP INDEX "idx_conversations_user";--> statement-breakpoint
+DROP INDEX "idx_conversations_archived";--> statement-breakpoint
+DROP INDEX "idx_employer_profiles_company";--> statement-breakpoint
+DROP INDEX "idx_employer_profiles_industry";--> statement-breakpoint
+DROP INDEX "idx_job_matches_user";--> statement-breakpoint
+DROP INDEX "idx_job_matches_job";--> statement-breakpoint
+DROP INDEX "idx_jobs_location";--> statement-breakpoint
+DROP INDEX "idx_jobs_remote";--> statement-breakpoint
+DROP INDEX "idx_jobs_type";--> statement-breakpoint
+DROP INDEX "idx_messages_conversation";--> statement-breakpoint
+DROP INDEX "idx_messages_parent";--> statement-breakpoint
+DROP INDEX "idx_messages_active";--> statement-breakpoint
+DROP INDEX "idx_payments_user";--> statement-breakpoint
+DROP INDEX "idx_payments_dodo_payment";--> statement-breakpoint
+DROP INDEX "idx_payments_status";--> statement-breakpoint
+DROP INDEX "idx_seeker_profiles_level";--> statement-breakpoint
+DROP INDEX "idx_seeker_profiles_job_type";--> statement-breakpoint
+DROP INDEX "idx_subscriptions_user";--> statement-breakpoint
+DROP INDEX "idx_subscriptions_status";--> statement-breakpoint
+DROP INDEX "idx_subscriptions_dodo_sub";--> statement-breakpoint
+DROP INDEX "idx_subscriptions_period_end";--> statement-breakpoint
+DROP INDEX "idx_system_prompts_active";--> statement-breakpoint
+DROP INDEX "idx_token_usage_user_window";--> statement-breakpoint
+DROP INDEX "idx_users_reset_token";--> statement-breakpoint
+ALTER TABLE "subscriptions" ALTER COLUMN "plan" DROP DEFAULT;--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "target_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "target_name" varchar(255);--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "webhook_url" text;--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "filter_keywords" varchar(500);--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "filter_locations" varchar(500);--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "filter_min_salary" numeric(10, 2);--> statement-breakpoint
+ALTER TABLE "bot_configs" ADD COLUMN "filter_job_types" varchar(255)[];--> statement-breakpoint
+ALTER TABLE "notifications" ADD CONSTRAINT "notifications_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "notes";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "external_url";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "contact_info";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "next_interview_at";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "offer_details";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "match_score";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "ai_explanation";--> statement-breakpoint
+ALTER TABLE "applications" DROP COLUMN "deleted_at";--> statement-breakpoint
+ALTER TABLE "audit_log" DROP COLUMN "diff";--> statement-breakpoint
+ALTER TABLE "audit_log" DROP COLUMN "ip_address";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "platform_config";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "token_expires_at";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "job_filters";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "post_format";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "max_posts_per_day";--> statement-breakpoint
+ALTER TABLE "bot_configs" DROP COLUMN "post_schedule";--> statement-breakpoint
+ALTER TABLE "bot_posts" DROP COLUMN "platform";--> statement-breakpoint
+ALTER TABLE "bot_posts" DROP COLUMN "content_snapshot";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "model";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "is_archived";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "system_prompt_version";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "total_tokens_used";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "context_window_used";--> statement-breakpoint
+ALTER TABLE "conversations" DROP COLUMN "deleted_at";--> statement-breakpoint
+ALTER TABLE "jobs" DROP COLUMN "scrape_source_id";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "metadata";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "parent_message_id";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "version";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "is_active";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "status";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "model_used";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "latency_ms";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "finish_reason";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "cost_usd";--> statement-breakpoint
+ALTER TABLE "messages" DROP COLUMN "deleted_at";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "dodo_payment_id";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "dodo_customer_id";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "event_type";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "idempotency_key";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "raw_payload";--> statement-breakpoint
+ALTER TABLE "payments" DROP COLUMN "paid_at";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "dodo_customer_id";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "dodo_product_id";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "current_period_start";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "trial_ends_at";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "cancelled_at";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "access_until";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "promo_code_id";--> statement-breakpoint
+ALTER TABLE "subscriptions" DROP COLUMN "raw_data";--> statement-breakpoint
+ALTER TABLE "system_prompts" DROP COLUMN "created_by";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP COLUMN "window_type";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP COLUMN "api_calls";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP COLUMN "job_matches";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP COLUMN "created_at";--> statement-breakpoint
+ALTER TABLE "token_usage" DROP COLUMN "updated_at";--> statement-breakpoint
+ALTER TABLE "otp_codes" ADD CONSTRAINT "otp_codes_user_id_unique" UNIQUE("user_id");--> statement-breakpoint
+ALTER TABLE "token_usage" ADD CONSTRAINT "token_usage_user_id_window_start_unique" UNIQUE("user_id","window_start");--> statement-breakpoint
+DROP TYPE "public"."integration_provider";--> statement-breakpoint
+DROP TYPE "public"."scrape_source_status";
\ No newline at end of file
diff --git a/packages/database/migrations/0007_tan_the_order.sql b/packages/database/migrations/0007_tan_the_order.sql
new file mode 100644
index 0000000..19af4c4
--- /dev/null
+++ b/packages/database/migrations/0007_tan_the_order.sql
@@ -0,0 +1,9 @@
+ALTER TABLE "messages" ADD COLUMN "metadata" jsonb;--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "dodo_payment_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "dodo_customer_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "event_type" varchar(100);--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "paid_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "raw_payload" jsonb;--> statement-breakpoint
+ALTER TABLE "payments" ADD COLUMN "idempotency_key" varchar(255);--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD COLUMN "dodo_customer_id" varchar(255);--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD COLUMN "raw_data" jsonb;
\ No newline at end of file
diff --git a/packages/database/migrations/0008_bumpy_mac_gargan.sql b/packages/database/migrations/0008_bumpy_mac_gargan.sql
new file mode 100644
index 0000000..aa81c76
--- /dev/null
+++ b/packages/database/migrations/0008_bumpy_mac_gargan.sql
@@ -0,0 +1,18 @@
+CREATE TABLE "discord_configs" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"guild_id" varchar(255) NOT NULL,
+	"channel_id" varchar(255),
+	"user_id" uuid NOT NULL,
+	"is_active" boolean DEFAULT true,
+	"created_at" timestamp with time zone DEFAULT now(),
+	"updated_at" timestamp with time zone DEFAULT now(),
+	CONSTRAINT "discord_configs_guild_id_unique" UNIQUE("guild_id")
+);
+--> statement-breakpoint
+ALTER TABLE "applications" ADD COLUMN "notes" text;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "model" varchar(100);--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "is_archived" boolean DEFAULT false;--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD COLUMN "current_period_start" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "subscriptions" ADD COLUMN "cancelled_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "discord_configs" ADD CONSTRAINT "discord_configs_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "idx_discord_guild" ON "discord_configs" USING btree ("guild_id");
\ No newline at end of file
diff --git a/packages/database/migrations/meta/0004_snapshot.json b/packages/database/migrations/meta/0004_snapshot.json
new file mode 100644
index 0000000..944d376
--- /dev/null
+++ b/packages/database/migrations/meta/0004_snapshot.json
@@ -0,0 +1,4184 @@
+{
+  "id": "72e40b57-7e98-4f26-8ebe-fafdc27f46e5",
+  "prevId": "337c03ff-dba8-4f69-9f03-cffddb477fed",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.application_status_history": {
+      "name": "application_status_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_status": {
+          "name": "from_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_status": {
+          "name": "to_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "changed_by": {
+          "name": "changed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_status_history_application_id_applications_id_fk": {
+          "name": "application_status_history_application_id_applications_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "applications",
+          "columnsFrom": ["application_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_status_history_changed_by_users_id_fk": {
+          "name": "application_status_history_changed_by_users_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "users",
+          "columnsFrom": ["changed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.applications": {
+      "name": "applications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "seeker_id": {
+          "name": "seeker_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'applied'"
+        },
+        "cover_letter": {
+          "name": "cover_letter",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_url": {
+          "name": "external_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "contact_info": {
+          "name": "contact_info",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_interview_at": {
+          "name": "next_interview_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "offer_details": {
+          "name": "offer_details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_applications_seeker_status": {
+          "name": "idx_applications_seeker_status",
+          "columns": [
+            {
+              "expression": "seeker_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_applications_job_pipeline": {
+          "name": "idx_applications_job_pipeline",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "applications_seeker_id_users_id_fk": {
+          "name": "applications_seeker_id_users_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "users",
+          "columnsFrom": ["seeker_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_resume_id_resumes_id_fk": {
+          "name": "applications_resume_id_resumes_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "applications_seeker_id_job_id_unique": {
+          "name": "applications_seeker_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["seeker_id", "job_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": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "diff": {
+          "name": "diff",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_configs": {
+      "name": "bot_configs",
+      "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
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "platform_config": {
+          "name": "platform_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credentials": {
+          "name": "credentials",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_expires_at": {
+          "name": "token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_filters": {
+          "name": "job_filters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "post_format": {
+          "name": "post_format",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'default'"
+        },
+        "max_posts_per_day": {
+          "name": "max_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "post_schedule": {
+          "name": "post_schedule",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_bot_configs_active": {
+          "name": "idx_bot_configs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "platform",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bot_configs_user_id_users_id_fk": {
+          "name": "bot_configs_user_id_users_id_fk",
+          "tableFrom": "bot_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_configs_user_id_platform_unique": {
+          "name": "bot_configs_user_id_platform_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "platform"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_posts": {
+      "name": "bot_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "bot_config_id": {
+          "name": "bot_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_post_id": {
+          "name": "external_post_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_snapshot": {
+          "name": "content_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'sent'"
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_bot_posts_config": {
+          "name": "idx_bot_posts_config",
+          "columns": [
+            {
+              "expression": "bot_config_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "posted_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bot_posts_bot_config_id_bot_configs_id_fk": {
+          "name": "bot_posts_bot_config_id_bot_configs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "bot_configs",
+          "columnsFrom": ["bot_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bot_posts_job_id_jobs_id_fk": {
+          "name": "bot_posts_job_id_jobs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_posts_bot_config_id_job_id_unique": {
+          "name": "bot_posts_bot_config_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["bot_config_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.career_site_integrations": {
+      "name": "career_site_integrations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "integration_provider",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_expires_at": {
+          "name": "token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_config": {
+          "name": "provider_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "sync_interval_minutes": {
+          "name": "sync_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_sync_at": {
+          "name": "next_sync_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_sync_job_count": {
+          "name": "last_sync_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "last_sync_error": {
+          "name": "last_sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_integrations_employer": {
+          "name": "idx_integrations_employer",
+          "columns": [
+            {
+              "expression": "employer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_integrations_sync_queue": {
+          "name": "idx_integrations_sync_queue",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_sync_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "career_site_integrations_employer_id_users_id_fk": {
+          "name": "career_site_integrations_employer_id_users_id_fk",
+          "tableFrom": "career_site_integrations",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "career_site_integrations_employer_id_provider_unique": {
+          "name": "career_site_integrations_employer_id_provider_unique",
+          "nullsNotDistinct": false,
+          "columns": ["employer_id", "provider"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "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
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "model": {
+          "name": "model",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_archived": {
+          "name": "is_archived",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "system_prompt_version": {
+          "name": "system_prompt_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1
+        },
+        "total_tokens_used": {
+          "name": "total_tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "context_window_used": {
+          "name": "context_window_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_conversations_user": {
+          "name": "idx_conversations_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_conversations_archived": {
+          "name": "idx_conversations_archived",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_archived",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversations_user_id_users_id_fk": {
+          "name": "conversations_user_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversations_resume_id_resumes_id_fk": {
+          "name": "conversations_resume_id_resumes_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord_configs": {
+      "name": "discord_configs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "guild_id": {
+          "name": "guild_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_id": {
+          "name": "channel_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "guild_name": {
+          "name": "guild_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "channel_name": {
+          "name": "channel_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bot_webhook_url": {
+          "name": "bot_webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_filters": {
+          "name": "job_filters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "post_format": {
+          "name": "post_format",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'embed'"
+        },
+        "ping_role_id": {
+          "name": "ping_role_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ping_everyone": {
+          "name": "ping_everyone",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "max_posts_per_day": {
+          "name": "max_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posts_today": {
+          "name": "posts_today",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "posts_today_reset_at": {
+          "name": "posts_today_reset_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_discord_guild": {
+          "name": "idx_discord_guild",
+          "columns": [
+            {
+              "expression": "guild_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_discord_user": {
+          "name": "idx_discord_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "discord_configs_user_id_users_id_fk": {
+          "name": "discord_configs_user_id_users_id_fk",
+          "tableFrom": "discord_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "discord_configs_guild_id_unique": {
+          "name": "discord_configs_guild_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["guild_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord_posted_jobs": {
+      "name": "discord_posted_jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "discord_config_id": {
+          "name": "discord_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_discord_posted_config": {
+          "name": "idx_discord_posted_config",
+          "columns": [
+            {
+              "expression": "discord_config_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "discord_posted_jobs_discord_config_id_discord_configs_id_fk": {
+          "name": "discord_posted_jobs_discord_config_id_discord_configs_id_fk",
+          "tableFrom": "discord_posted_jobs",
+          "tableTo": "discord_configs",
+          "columnsFrom": ["discord_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "discord_posted_jobs_job_id_jobs_id_fk": {
+          "name": "discord_posted_jobs_job_id_jobs_id_fk",
+          "tableFrom": "discord_posted_jobs",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "discord_posted_jobs_discord_config_id_job_id_unique": {
+          "name": "discord_posted_jobs_discord_config_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["discord_config_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_notifications": {
+      "name": "email_notifications",
+      "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
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "notification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "template_variables": {
+          "name": "template_variables",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_ids": {
+          "name": "job_ids",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_message_id": {
+          "name": "provider_message_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "retry_count": {
+          "name": "retry_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "scheduled_at": {
+          "name": "scheduled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "opened_at": {
+          "name": "opened_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_email_notif_pending": {
+          "name": "idx_email_notif_pending",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scheduled_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_email_notif_user": {
+          "name": "idx_email_notif_user",
+          "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": {}
+        },
+        "idx_email_notif_template": {
+          "name": "idx_email_notif_template",
+          "columns": [
+            {
+              "expression": "template_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_notifications_user_id_users_id_fk": {
+          "name": "email_notifications_user_id_users_id_fk",
+          "tableFrom": "email_notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_notifications_template_id_notification_templates_id_fk": {
+          "name": "email_notifications_template_id_notification_templates_id_fk",
+          "tableFrom": "email_notifications",
+          "tableTo": "notification_templates",
+          "columnsFrom": ["template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.employer_profiles": {
+      "name": "employer_profiles",
+      "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
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_website": {
+          "name": "company_website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_logo_url": {
+          "name": "company_logo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_description": {
+          "name": "company_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_size": {
+          "name": "company_size",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "industry": {
+          "name": "industry",
+          "type": "varchar(150)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "headquarters_location": {
+          "name": "headquarters_location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "social_links": {
+          "name": "social_links",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_job_count": {
+          "name": "active_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_employer_profiles_user": {
+          "name": "idx_employer_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_employer_profiles_company": {
+          "name": "idx_employer_profiles_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_employer_profiles_industry": {
+          "name": "idx_employer_profiles_industry",
+          "columns": [
+            {
+              "expression": "industry",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "employer_profiles_user_id_users_id_fk": {
+          "name": "employer_profiles_user_id_users_id_fk",
+          "tableFrom": "employer_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "employer_profiles_user_id_unique": {
+          "name": "employer_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_fingerprints": {
+      "name": "job_fingerprints",
+      "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
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_fingerprints_job_id_jobs_id_fk": {
+          "name": "job_fingerprints_job_id_jobs_id_fk",
+          "tableFrom": "job_fingerprints",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_fingerprints_source_id_scrape_sources_id_fk": {
+          "name": "job_fingerprints_source_id_scrape_sources_id_fk",
+          "tableFrom": "job_fingerprints",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_fingerprints_fingerprint_unique": {
+          "name": "job_fingerprints_fingerprint_unique",
+          "nullsNotDistinct": false,
+          "columns": ["fingerprint"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_matches": {
+      "name": "job_matches",
+      "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
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_saved": {
+          "name": "is_saved",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "applied": {
+          "name": "applied",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_job_matches_user": {
+          "name": "idx_job_matches_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "match_score",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_job_matches_job": {
+          "name": "idx_job_matches_job",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_matches_user_id_users_id_fk": {
+          "name": "job_matches_user_id_users_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_resume_id_resumes_id_fk": {
+          "name": "job_matches_resume_id_resumes_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_job_id_jobs_id_fk": {
+          "name": "job_matches_job_id_jobs_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_matches_user_id_job_id_unique": {
+          "name": "job_matches_user_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_min": {
+          "name": "salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_max": {
+          "name": "salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_type": {
+          "name": "job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote": {
+          "name": "remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills_required": {
+          "name": "skills_required",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_required": {
+          "name": "experience_required",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scrape_source_id": {
+          "name": "scrape_source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_job_id": {
+          "name": "external_job_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_jobs_company": {
+          "name": "idx_jobs_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_location": {
+          "name": "idx_jobs_location",
+          "columns": [
+            {
+              "expression": "location",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_remote": {
+          "name": "idx_jobs_remote",
+          "columns": [
+            {
+              "expression": "remote",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_type": {
+          "name": "idx_jobs_type",
+          "columns": [
+            {
+              "expression": "job_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_active": {
+          "name": "idx_jobs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_employer_id_users_id_fk": {
+          "name": "jobs_employer_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "jobs_scrape_source_id_scrape_sources_id_fk": {
+          "name": "jobs_scrape_source_id_scrape_sources_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["scrape_source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.message_attachments": {
+      "name": "message_attachments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_type": {
+          "name": "file_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_attachments_message": {
+          "name": "idx_attachments_message",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_attachments_message_id_messages_id_fk": {
+          "name": "message_attachments_message_id_messages_id_fk",
+          "tableFrom": "message_attachments",
+          "tableTo": "messages",
+          "columnsFrom": ["message_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_message_id": {
+          "name": "parent_message_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'completed'"
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "model_used": {
+          "name": "model_used",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "latency_ms": {
+          "name": "latency_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "finish_reason": {
+          "name": "finish_reason",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cost_usd": {
+          "name": "cost_usd",
+          "type": "numeric(10, 6)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_messages_conversation": {
+          "name": "idx_messages_conversation",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_messages_parent": {
+          "name": "idx_messages_parent",
+          "columns": [
+            {
+              "expression": "parent_message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_messages_active": {
+          "name": "idx_messages_active",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_templates": {
+      "name": "notification_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "html_body": {
+          "name": "html_body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "text_body": {
+          "name": "text_body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_notif_templates_slug": {
+          "name": "idx_notif_templates_slug",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "notification_templates_slug_unique": {
+          "name": "notification_templates_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": ["slug"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.payments": {
+      "name": "payments",
+      "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
+        },
+        "subscription_id": {
+          "name": "subscription_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_payment_id": {
+          "name": "dodo_payment_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_payload": {
+          "name": "raw_payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paid_at": {
+          "name": "paid_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_payments_user": {
+          "name": "idx_payments_user",
+          "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": {}
+        },
+        "idx_payments_dodo_payment": {
+          "name": "idx_payments_dodo_payment",
+          "columns": [
+            {
+              "expression": "dodo_payment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_payments_status": {
+          "name": "idx_payments_status",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "payments_user_id_users_id_fk": {
+          "name": "payments_user_id_users_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "payments_subscription_id_subscriptions_id_fk": {
+          "name": "payments_subscription_id_subscriptions_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "subscriptions",
+          "columnsFrom": ["subscription_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "payments_dodo_payment_id_unique": {
+          "name": "payments_dodo_payment_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_payment_id"]
+        },
+        "payments_idempotency_key_unique": {
+          "name": "payments_idempotency_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["idempotency_key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.plan_quotas": {
+      "name": "plan_quotas",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_tokens_per_day": {
+          "name": "ai_tokens_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ai_tokens_per_month": {
+          "name": "ai_tokens_per_month",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_matches_per_day": {
+          "name": "job_matches_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_searches_per_day": {
+          "name": "job_searches_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_calls_per_minute": {
+          "name": "api_calls_per_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_calls_per_day": {
+          "name": "api_calls_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_parses_per_month": {
+          "name": "resume_parses_per_month",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bot_posts_per_day": {
+          "name": "bot_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_unlimited": {
+          "name": "is_unlimited",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "plan_quotas_plan_unique": {
+          "name": "plan_quotas_plan_unique",
+          "nullsNotDistinct": false,
+          "columns": ["plan"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.promo_codes": {
+      "name": "promo_codes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "code": {
+          "name": "code",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "discount_type": {
+          "name": "discount_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "discount_value": {
+          "name": "discount_value",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applies_to_plan": {
+          "name": "applies_to_plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "max_uses": {
+          "name": "max_uses",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uses_count": {
+          "name": "uses_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "promo_codes_code_unique": {
+          "name": "promo_codes_code_unique",
+          "nullsNotDistinct": false,
+          "columns": ["code"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rate_limit_overrides": {
+      "name": "rate_limit_overrides",
+      "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
+        },
+        "override_type": {
+          "name": "override_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "override_value": {
+          "name": "override_value",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "granted_by": {
+          "name": "granted_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rate_limit_overrides_user_id_users_id_fk": {
+          "name": "rate_limit_overrides_user_id_users_id_fk",
+          "tableFrom": "rate_limit_overrides",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rate_limit_overrides_granted_by_users_id_fk": {
+          "name": "rate_limit_overrides_granted_by_users_id_fk",
+          "tableFrom": "rate_limit_overrides",
+          "tableTo": "users",
+          "columnsFrom": ["granted_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resumes": {
+      "name": "resumes",
+      "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
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parsed_text": {
+          "name": "parsed_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_resumes_user": {
+          "name": "idx_resumes_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "resumes_user_id_users_id_fk": {
+          "name": "resumes_user_id_users_id_fk",
+          "tableFrom": "resumes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scrape_runs": {
+      "name": "scrape_runs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'running'"
+        },
+        "jobs_found": {
+          "name": "jobs_found",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_new": {
+          "name": "jobs_new",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_updated": {
+          "name": "jobs_updated",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_deduped": {
+          "name": "jobs_deduped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "error_log": {
+          "name": "error_log",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_scrape_runs_source": {
+          "name": "idx_scrape_runs_source",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "scrape_runs_source_id_scrape_sources_id_fk": {
+          "name": "scrape_runs_source_id_scrape_sources_id_fk",
+          "tableFrom": "scrape_runs",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scrape_sources": {
+      "name": "scrape_sources",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scraper_type": {
+          "name": "scraper_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "scrape_source_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'active'"
+        },
+        "requests_per_minute": {
+          "name": "requests_per_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "retry_after_seconds": {
+          "name": "retry_after_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "crawl_interval_minutes": {
+          "name": "crawl_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "last_crawled_at": {
+          "name": "last_crawled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_crawl_at": {
+          "name": "next_crawl_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_jobs_scraped": {
+          "name": "total_jobs_scraped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_scrape_sources_queue": {
+          "name": "idx_scrape_sources_queue",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_crawl_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seeker_profiles": {
+      "name": "seeker_profiles",
+      "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
+        },
+        "headline": {
+          "name": "headline",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_level": {
+          "name": "experience_level",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certifications": {
+          "name": "certifications",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "languages": {
+          "name": "languages",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "work_history": {
+          "name": "work_history",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_titles": {
+          "name": "desired_job_titles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_locations": {
+          "name": "desired_locations",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_min": {
+          "name": "desired_salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_max": {
+          "name": "desired_salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_type": {
+          "name": "desired_job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_to_remote": {
+          "name": "open_to_remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "open_to_relocation": {
+          "name": "open_to_relocation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prompt_history_summary": {
+          "name": "prompt_history_summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_parsed_at": {
+          "name": "last_parsed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_seeker_profiles_user": {
+          "name": "idx_seeker_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_seeker_profiles_level": {
+          "name": "idx_seeker_profiles_level",
+          "columns": [
+            {
+              "expression": "experience_level",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_seeker_profiles_job_type": {
+          "name": "idx_seeker_profiles_job_type",
+          "columns": [
+            {
+              "expression": "desired_job_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "seeker_profiles_user_id_users_id_fk": {
+          "name": "seeker_profiles_user_id_users_id_fk",
+          "tableFrom": "seeker_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seeker_profiles_user_id_unique": {
+          "name": "seeker_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "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
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "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": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_hash_unique": {
+          "name": "sessions_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.subscriptions": {
+      "name": "subscriptions",
+      "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
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'free'"
+        },
+        "status": {
+          "name": "status",
+          "type": "subscription_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_subscription_id": {
+          "name": "dodo_subscription_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_product_id": {
+          "name": "dodo_product_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_start": {
+          "name": "current_period_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_end": {
+          "name": "current_period_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "trial_ends_at": {
+          "name": "trial_ends_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_until": {
+          "name": "access_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "promo_code_id": {
+          "name": "promo_code_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_data": {
+          "name": "raw_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_subscriptions_user": {
+          "name": "idx_subscriptions_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_status": {
+          "name": "idx_subscriptions_status",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_dodo_sub": {
+          "name": "idx_subscriptions_dodo_sub",
+          "columns": [
+            {
+              "expression": "dodo_subscription_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_period_end": {
+          "name": "idx_subscriptions_period_end",
+          "columns": [
+            {
+              "expression": "current_period_end",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "subscriptions_user_id_users_id_fk": {
+          "name": "subscriptions_user_id_users_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "subscriptions_promo_code_id_promo_codes_id_fk": {
+          "name": "subscriptions_promo_code_id_promo_codes_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "promo_codes",
+          "columnsFrom": ["promo_code_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "subscriptions_user_id_unique": {
+          "name": "subscriptions_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        },
+        "subscriptions_dodo_subscription_id_unique": {
+          "name": "subscriptions_dodo_subscription_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_subscription_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_prompts": {
+      "name": "system_prompts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_system_prompts_active": {
+          "name": "idx_system_prompts_active",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "system_prompts_created_by_users_id_fk": {
+          "name": "system_prompts_created_by_users_id_fk",
+          "tableFrom": "system_prompts",
+          "tableTo": "users",
+          "columnsFrom": ["created_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.token_usage": {
+      "name": "token_usage",
+      "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
+        },
+        "window_type": {
+          "name": "window_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "window_start": {
+          "name": "window_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "api_calls": {
+          "name": "api_calls",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "job_matches": {
+          "name": "job_matches",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_token_usage_user_window": {
+          "name": "idx_token_usage_user_window",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "window_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "window_start",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "token_usage_user_id_users_id_fk": {
+          "name": "token_usage_user_id_users_id_fk",
+          "tableFrom": "token_usage",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "token_usage_user_id_window_type_window_start_unique": {
+          "name": "token_usage_user_id_window_type_window_start_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "window_type", "window_start"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "full_name": {
+          "name": "full_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "roles": {
+          "name": "roles",
+          "type": "user_role[]",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"job_seeker\"}'"
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_token": {
+          "name": "password_reset_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_expires_at": {
+          "name": "password_reset_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_users_email": {
+          "name": "idx_users_email",
+          "columns": [
+            {
+              "expression": "email",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_role": {
+          "name": "idx_users_role",
+          "columns": [
+            {
+              "expression": "roles",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_reset_token": {
+          "name": "idx_users_reset_token",
+          "columns": [
+            {
+              "expression": "password_reset_token",
+              "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"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.application_status": {
+      "name": "application_status",
+      "schema": "public",
+      "values": [
+        "applied",
+        "under_review",
+        "phone_screen",
+        "interviewed",
+        "offer_extended",
+        "accepted",
+        "rejected",
+        "withdrawn"
+      ]
+    },
+    "public.bot_platform": {
+      "name": "bot_platform",
+      "schema": "public",
+      "values": ["discord", "reddit", "twitter", "slack"]
+    },
+    "public.integration_provider": {
+      "name": "integration_provider",
+      "schema": "public",
+      "values": [
+        "greenhouse",
+        "lever",
+        "workday",
+        "bamboohr",
+        "linkedin",
+        "indeed",
+        "custom"
+      ]
+    },
+    "public.notification_status": {
+      "name": "notification_status",
+      "schema": "public",
+      "values": ["pending", "sent", "failed", "bounced", "opened"]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": ["pending", "succeeded", "failed", "refunded", "disputed"]
+    },
+    "public.scrape_source_status": {
+      "name": "scrape_source_status",
+      "schema": "public",
+      "values": ["active", "paused", "broken", "rate_limited"]
+    },
+    "public.subscription_plan": {
+      "name": "subscription_plan",
+      "schema": "public",
+      "values": ["free", "seeker", "employer", "discord_owner", "enterprise"]
+    },
+    "public.subscription_status": {
+      "name": "subscription_status",
+      "schema": "public",
+      "values": [
+        "active",
+        "cancelled",
+        "past_due",
+        "trialing",
+        "paused",
+        "expired"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": ["job_seeker", "employer", "admin", "discord_owner"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/database/migrations/meta/0005_snapshot.json b/packages/database/migrations/meta/0005_snapshot.json
new file mode 100644
index 0000000..4a9df8e
--- /dev/null
+++ b/packages/database/migrations/meta/0005_snapshot.json
@@ -0,0 +1,4268 @@
+{
+  "id": "d1e6f70c-0f27-40e6-9966-f3a471418b1c",
+  "prevId": "72e40b57-7e98-4f26-8ebe-fafdc27f46e5",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.application_status_history": {
+      "name": "application_status_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_status": {
+          "name": "from_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_status": {
+          "name": "to_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "changed_by": {
+          "name": "changed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_status_history_application_id_applications_id_fk": {
+          "name": "application_status_history_application_id_applications_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "applications",
+          "columnsFrom": ["application_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_status_history_changed_by_users_id_fk": {
+          "name": "application_status_history_changed_by_users_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "users",
+          "columnsFrom": ["changed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.applications": {
+      "name": "applications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "seeker_id": {
+          "name": "seeker_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'applied'"
+        },
+        "cover_letter": {
+          "name": "cover_letter",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_url": {
+          "name": "external_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "contact_info": {
+          "name": "contact_info",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_interview_at": {
+          "name": "next_interview_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "offer_details": {
+          "name": "offer_details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_applications_seeker_status": {
+          "name": "idx_applications_seeker_status",
+          "columns": [
+            {
+              "expression": "seeker_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_applications_job_pipeline": {
+          "name": "idx_applications_job_pipeline",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "applications_seeker_id_users_id_fk": {
+          "name": "applications_seeker_id_users_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "users",
+          "columnsFrom": ["seeker_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_resume_id_resumes_id_fk": {
+          "name": "applications_resume_id_resumes_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "applications_seeker_id_job_id_unique": {
+          "name": "applications_seeker_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["seeker_id", "job_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": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "diff": {
+          "name": "diff",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_configs": {
+      "name": "bot_configs",
+      "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
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "platform_config": {
+          "name": "platform_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credentials": {
+          "name": "credentials",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_expires_at": {
+          "name": "token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_filters": {
+          "name": "job_filters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "post_format": {
+          "name": "post_format",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'default'"
+        },
+        "max_posts_per_day": {
+          "name": "max_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "post_schedule": {
+          "name": "post_schedule",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_bot_configs_active": {
+          "name": "idx_bot_configs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "platform",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bot_configs_user_id_users_id_fk": {
+          "name": "bot_configs_user_id_users_id_fk",
+          "tableFrom": "bot_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_configs_user_id_platform_unique": {
+          "name": "bot_configs_user_id_platform_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "platform"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_posts": {
+      "name": "bot_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "bot_config_id": {
+          "name": "bot_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_post_id": {
+          "name": "external_post_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_snapshot": {
+          "name": "content_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'sent'"
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_bot_posts_config": {
+          "name": "idx_bot_posts_config",
+          "columns": [
+            {
+              "expression": "bot_config_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "posted_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bot_posts_bot_config_id_bot_configs_id_fk": {
+          "name": "bot_posts_bot_config_id_bot_configs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "bot_configs",
+          "columnsFrom": ["bot_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bot_posts_job_id_jobs_id_fk": {
+          "name": "bot_posts_job_id_jobs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_posts_bot_config_id_job_id_unique": {
+          "name": "bot_posts_bot_config_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["bot_config_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.career_site_integrations": {
+      "name": "career_site_integrations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "integration_provider",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_expires_at": {
+          "name": "token_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_config": {
+          "name": "provider_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "sync_interval_minutes": {
+          "name": "sync_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_sync_at": {
+          "name": "next_sync_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_sync_job_count": {
+          "name": "last_sync_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "last_sync_error": {
+          "name": "last_sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_integrations_employer": {
+          "name": "idx_integrations_employer",
+          "columns": [
+            {
+              "expression": "employer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_integrations_sync_queue": {
+          "name": "idx_integrations_sync_queue",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_sync_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "career_site_integrations_employer_id_users_id_fk": {
+          "name": "career_site_integrations_employer_id_users_id_fk",
+          "tableFrom": "career_site_integrations",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "career_site_integrations_employer_id_provider_unique": {
+          "name": "career_site_integrations_employer_id_provider_unique",
+          "nullsNotDistinct": false,
+          "columns": ["employer_id", "provider"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "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
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "model": {
+          "name": "model",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_archived": {
+          "name": "is_archived",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "system_prompt_version": {
+          "name": "system_prompt_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1
+        },
+        "total_tokens_used": {
+          "name": "total_tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "context_window_used": {
+          "name": "context_window_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_conversations_user": {
+          "name": "idx_conversations_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_conversations_archived": {
+          "name": "idx_conversations_archived",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_archived",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversations_user_id_users_id_fk": {
+          "name": "conversations_user_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversations_resume_id_resumes_id_fk": {
+          "name": "conversations_resume_id_resumes_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord_configs": {
+      "name": "discord_configs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "guild_id": {
+          "name": "guild_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_id": {
+          "name": "channel_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "guild_name": {
+          "name": "guild_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "channel_name": {
+          "name": "channel_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bot_webhook_url": {
+          "name": "bot_webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_filters": {
+          "name": "job_filters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "post_format": {
+          "name": "post_format",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'embed'"
+        },
+        "ping_role_id": {
+          "name": "ping_role_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ping_everyone": {
+          "name": "ping_everyone",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "max_posts_per_day": {
+          "name": "max_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posts_today": {
+          "name": "posts_today",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "posts_today_reset_at": {
+          "name": "posts_today_reset_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_discord_guild": {
+          "name": "idx_discord_guild",
+          "columns": [
+            {
+              "expression": "guild_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_discord_user": {
+          "name": "idx_discord_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "discord_configs_user_id_users_id_fk": {
+          "name": "discord_configs_user_id_users_id_fk",
+          "tableFrom": "discord_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "discord_configs_guild_id_unique": {
+          "name": "discord_configs_guild_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["guild_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord_posted_jobs": {
+      "name": "discord_posted_jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "discord_config_id": {
+          "name": "discord_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_discord_posted_config": {
+          "name": "idx_discord_posted_config",
+          "columns": [
+            {
+              "expression": "discord_config_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "discord_posted_jobs_discord_config_id_discord_configs_id_fk": {
+          "name": "discord_posted_jobs_discord_config_id_discord_configs_id_fk",
+          "tableFrom": "discord_posted_jobs",
+          "tableTo": "discord_configs",
+          "columnsFrom": ["discord_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "discord_posted_jobs_job_id_jobs_id_fk": {
+          "name": "discord_posted_jobs_job_id_jobs_id_fk",
+          "tableFrom": "discord_posted_jobs",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "discord_posted_jobs_discord_config_id_job_id_unique": {
+          "name": "discord_posted_jobs_discord_config_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["discord_config_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_notifications": {
+      "name": "email_notifications",
+      "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
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "notification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "template_variables": {
+          "name": "template_variables",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_ids": {
+          "name": "job_ids",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_message_id": {
+          "name": "provider_message_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "retry_count": {
+          "name": "retry_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "scheduled_at": {
+          "name": "scheduled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "opened_at": {
+          "name": "opened_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_email_notif_pending": {
+          "name": "idx_email_notif_pending",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scheduled_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_email_notif_user": {
+          "name": "idx_email_notif_user",
+          "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": {}
+        },
+        "idx_email_notif_template": {
+          "name": "idx_email_notif_template",
+          "columns": [
+            {
+              "expression": "template_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_notifications_user_id_users_id_fk": {
+          "name": "email_notifications_user_id_users_id_fk",
+          "tableFrom": "email_notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_notifications_template_id_notification_templates_id_fk": {
+          "name": "email_notifications_template_id_notification_templates_id_fk",
+          "tableFrom": "email_notifications",
+          "tableTo": "notification_templates",
+          "columnsFrom": ["template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.employer_profiles": {
+      "name": "employer_profiles",
+      "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
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_website": {
+          "name": "company_website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_logo_url": {
+          "name": "company_logo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_description": {
+          "name": "company_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_size": {
+          "name": "company_size",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "industry": {
+          "name": "industry",
+          "type": "varchar(150)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "headquarters_location": {
+          "name": "headquarters_location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "social_links": {
+          "name": "social_links",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_job_count": {
+          "name": "active_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_employer_profiles_user": {
+          "name": "idx_employer_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_employer_profiles_company": {
+          "name": "idx_employer_profiles_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_employer_profiles_industry": {
+          "name": "idx_employer_profiles_industry",
+          "columns": [
+            {
+              "expression": "industry",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "employer_profiles_user_id_users_id_fk": {
+          "name": "employer_profiles_user_id_users_id_fk",
+          "tableFrom": "employer_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "employer_profiles_user_id_unique": {
+          "name": "employer_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_fingerprints": {
+      "name": "job_fingerprints",
+      "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
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_fingerprints_job_id_jobs_id_fk": {
+          "name": "job_fingerprints_job_id_jobs_id_fk",
+          "tableFrom": "job_fingerprints",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_fingerprints_source_id_scrape_sources_id_fk": {
+          "name": "job_fingerprints_source_id_scrape_sources_id_fk",
+          "tableFrom": "job_fingerprints",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_fingerprints_fingerprint_unique": {
+          "name": "job_fingerprints_fingerprint_unique",
+          "nullsNotDistinct": false,
+          "columns": ["fingerprint"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_matches": {
+      "name": "job_matches",
+      "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
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_saved": {
+          "name": "is_saved",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "applied": {
+          "name": "applied",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_job_matches_user": {
+          "name": "idx_job_matches_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "match_score",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_job_matches_job": {
+          "name": "idx_job_matches_job",
+          "columns": [
+            {
+              "expression": "job_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "job_matches_user_id_users_id_fk": {
+          "name": "job_matches_user_id_users_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_resume_id_resumes_id_fk": {
+          "name": "job_matches_resume_id_resumes_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_job_id_jobs_id_fk": {
+          "name": "job_matches_job_id_jobs_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_matches_user_id_job_id_unique": {
+          "name": "job_matches_user_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_min": {
+          "name": "salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_max": {
+          "name": "salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_type": {
+          "name": "job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote": {
+          "name": "remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills_required": {
+          "name": "skills_required",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_required": {
+          "name": "experience_required",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scrape_source_id": {
+          "name": "scrape_source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_job_id": {
+          "name": "external_job_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_jobs_company": {
+          "name": "idx_jobs_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_location": {
+          "name": "idx_jobs_location",
+          "columns": [
+            {
+              "expression": "location",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_remote": {
+          "name": "idx_jobs_remote",
+          "columns": [
+            {
+              "expression": "remote",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_type": {
+          "name": "idx_jobs_type",
+          "columns": [
+            {
+              "expression": "job_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_active": {
+          "name": "idx_jobs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_employer_id_users_id_fk": {
+          "name": "jobs_employer_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "jobs_scrape_source_id_scrape_sources_id_fk": {
+          "name": "jobs_scrape_source_id_scrape_sources_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["scrape_source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.message_attachments": {
+      "name": "message_attachments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_type": {
+          "name": "file_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_attachments_message": {
+          "name": "idx_attachments_message",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_attachments_message_id_messages_id_fk": {
+          "name": "message_attachments_message_id_messages_id_fk",
+          "tableFrom": "message_attachments",
+          "tableTo": "messages",
+          "columnsFrom": ["message_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_message_id": {
+          "name": "parent_message_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'completed'"
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "model_used": {
+          "name": "model_used",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "latency_ms": {
+          "name": "latency_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "finish_reason": {
+          "name": "finish_reason",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cost_usd": {
+          "name": "cost_usd",
+          "type": "numeric(10, 6)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_messages_conversation": {
+          "name": "idx_messages_conversation",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_messages_parent": {
+          "name": "idx_messages_parent",
+          "columns": [
+            {
+              "expression": "parent_message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_messages_active": {
+          "name": "idx_messages_active",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_templates": {
+      "name": "notification_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "html_body": {
+          "name": "html_body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "text_body": {
+          "name": "text_body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_notif_templates_slug": {
+          "name": "idx_notif_templates_slug",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "notification_templates_slug_unique": {
+          "name": "notification_templates_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": ["slug"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.otp_codes": {
+      "name": "otp_codes",
+      "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
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_otp_user": {
+          "name": "idx_otp_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "otp_codes_user_id_users_id_fk": {
+          "name": "otp_codes_user_id_users_id_fk",
+          "tableFrom": "otp_codes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "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()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subscription_id": {
+          "name": "subscription_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_payment_id": {
+          "name": "dodo_payment_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_payload": {
+          "name": "raw_payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paid_at": {
+          "name": "paid_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_payments_user": {
+          "name": "idx_payments_user",
+          "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": {}
+        },
+        "idx_payments_dodo_payment": {
+          "name": "idx_payments_dodo_payment",
+          "columns": [
+            {
+              "expression": "dodo_payment_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_payments_status": {
+          "name": "idx_payments_status",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "payments_user_id_users_id_fk": {
+          "name": "payments_user_id_users_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "payments_subscription_id_subscriptions_id_fk": {
+          "name": "payments_subscription_id_subscriptions_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "subscriptions",
+          "columnsFrom": ["subscription_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "payments_dodo_payment_id_unique": {
+          "name": "payments_dodo_payment_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_payment_id"]
+        },
+        "payments_idempotency_key_unique": {
+          "name": "payments_idempotency_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["idempotency_key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.plan_quotas": {
+      "name": "plan_quotas",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_tokens_per_day": {
+          "name": "ai_tokens_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ai_tokens_per_month": {
+          "name": "ai_tokens_per_month",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_matches_per_day": {
+          "name": "job_matches_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_searches_per_day": {
+          "name": "job_searches_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_calls_per_minute": {
+          "name": "api_calls_per_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_calls_per_day": {
+          "name": "api_calls_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_parses_per_month": {
+          "name": "resume_parses_per_month",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bot_posts_per_day": {
+          "name": "bot_posts_per_day",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_unlimited": {
+          "name": "is_unlimited",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "plan_quotas_plan_unique": {
+          "name": "plan_quotas_plan_unique",
+          "nullsNotDistinct": false,
+          "columns": ["plan"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.promo_codes": {
+      "name": "promo_codes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "code": {
+          "name": "code",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "discount_type": {
+          "name": "discount_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "discount_value": {
+          "name": "discount_value",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "applies_to_plan": {
+          "name": "applies_to_plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "max_uses": {
+          "name": "max_uses",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uses_count": {
+          "name": "uses_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "promo_codes_code_unique": {
+          "name": "promo_codes_code_unique",
+          "nullsNotDistinct": false,
+          "columns": ["code"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.rate_limit_overrides": {
+      "name": "rate_limit_overrides",
+      "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
+        },
+        "override_type": {
+          "name": "override_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "override_value": {
+          "name": "override_value",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "granted_by": {
+          "name": "granted_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rate_limit_overrides_user_id_users_id_fk": {
+          "name": "rate_limit_overrides_user_id_users_id_fk",
+          "tableFrom": "rate_limit_overrides",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rate_limit_overrides_granted_by_users_id_fk": {
+          "name": "rate_limit_overrides_granted_by_users_id_fk",
+          "tableFrom": "rate_limit_overrides",
+          "tableTo": "users",
+          "columnsFrom": ["granted_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resumes": {
+      "name": "resumes",
+      "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
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parsed_text": {
+          "name": "parsed_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_resumes_user": {
+          "name": "idx_resumes_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "resumes_user_id_users_id_fk": {
+          "name": "resumes_user_id_users_id_fk",
+          "tableFrom": "resumes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scrape_runs": {
+      "name": "scrape_runs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'running'"
+        },
+        "jobs_found": {
+          "name": "jobs_found",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_new": {
+          "name": "jobs_new",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_updated": {
+          "name": "jobs_updated",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "jobs_deduped": {
+          "name": "jobs_deduped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "error_log": {
+          "name": "error_log",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_scrape_runs_source": {
+          "name": "idx_scrape_runs_source",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "scrape_runs_source_id_scrape_sources_id_fk": {
+          "name": "scrape_runs_source_id_scrape_sources_id_fk",
+          "tableFrom": "scrape_runs",
+          "tableTo": "scrape_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scrape_sources": {
+      "name": "scrape_sources",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scraper_type": {
+          "name": "scraper_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "scrape_source_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'active'"
+        },
+        "requests_per_minute": {
+          "name": "requests_per_minute",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 10
+        },
+        "retry_after_seconds": {
+          "name": "retry_after_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "crawl_interval_minutes": {
+          "name": "crawl_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 60
+        },
+        "last_crawled_at": {
+          "name": "last_crawled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "next_crawl_at": {
+          "name": "next_crawl_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_jobs_scraped": {
+          "name": "total_jobs_scraped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_scrape_sources_queue": {
+          "name": "idx_scrape_sources_queue",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_crawl_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seeker_profiles": {
+      "name": "seeker_profiles",
+      "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
+        },
+        "headline": {
+          "name": "headline",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_level": {
+          "name": "experience_level",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certifications": {
+          "name": "certifications",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "languages": {
+          "name": "languages",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "work_history": {
+          "name": "work_history",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_titles": {
+          "name": "desired_job_titles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_locations": {
+          "name": "desired_locations",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_min": {
+          "name": "desired_salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_max": {
+          "name": "desired_salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_type": {
+          "name": "desired_job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_to_remote": {
+          "name": "open_to_remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "open_to_relocation": {
+          "name": "open_to_relocation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prompt_history_summary": {
+          "name": "prompt_history_summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_parsed_at": {
+          "name": "last_parsed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_seeker_profiles_user": {
+          "name": "idx_seeker_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_seeker_profiles_level": {
+          "name": "idx_seeker_profiles_level",
+          "columns": [
+            {
+              "expression": "experience_level",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_seeker_profiles_job_type": {
+          "name": "idx_seeker_profiles_job_type",
+          "columns": [
+            {
+              "expression": "desired_job_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "seeker_profiles_user_id_users_id_fk": {
+          "name": "seeker_profiles_user_id_users_id_fk",
+          "tableFrom": "seeker_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seeker_profiles_user_id_unique": {
+          "name": "seeker_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "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
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "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": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_hash_unique": {
+          "name": "sessions_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.subscriptions": {
+      "name": "subscriptions",
+      "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
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'free'"
+        },
+        "status": {
+          "name": "status",
+          "type": "subscription_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_subscription_id": {
+          "name": "dodo_subscription_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_product_id": {
+          "name": "dodo_product_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_start": {
+          "name": "current_period_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_end": {
+          "name": "current_period_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "trial_ends_at": {
+          "name": "trial_ends_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_until": {
+          "name": "access_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "promo_code_id": {
+          "name": "promo_code_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_data": {
+          "name": "raw_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_subscriptions_user": {
+          "name": "idx_subscriptions_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_status": {
+          "name": "idx_subscriptions_status",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_dodo_sub": {
+          "name": "idx_subscriptions_dodo_sub",
+          "columns": [
+            {
+              "expression": "dodo_subscription_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_subscriptions_period_end": {
+          "name": "idx_subscriptions_period_end",
+          "columns": [
+            {
+              "expression": "current_period_end",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "subscriptions_user_id_users_id_fk": {
+          "name": "subscriptions_user_id_users_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "subscriptions_promo_code_id_promo_codes_id_fk": {
+          "name": "subscriptions_promo_code_id_promo_codes_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "promo_codes",
+          "columnsFrom": ["promo_code_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "subscriptions_user_id_unique": {
+          "name": "subscriptions_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        },
+        "subscriptions_dodo_subscription_id_unique": {
+          "name": "subscriptions_dodo_subscription_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_subscription_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_prompts": {
+      "name": "system_prompts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_system_prompts_active": {
+          "name": "idx_system_prompts_active",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "system_prompts_created_by_users_id_fk": {
+          "name": "system_prompts_created_by_users_id_fk",
+          "tableFrom": "system_prompts",
+          "tableTo": "users",
+          "columnsFrom": ["created_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.token_usage": {
+      "name": "token_usage",
+      "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
+        },
+        "window_type": {
+          "name": "window_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "window_start": {
+          "name": "window_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "api_calls": {
+          "name": "api_calls",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "job_matches": {
+          "name": "job_matches",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_token_usage_user_window": {
+          "name": "idx_token_usage_user_window",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "window_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "window_start",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "token_usage_user_id_users_id_fk": {
+          "name": "token_usage_user_id_users_id_fk",
+          "tableFrom": "token_usage",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "token_usage_user_id_window_type_window_start_unique": {
+          "name": "token_usage_user_id_window_type_window_start_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "window_type", "window_start"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "full_name": {
+          "name": "full_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "roles": {
+          "name": "roles",
+          "type": "user_role[]",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"job_seeker\"}'"
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_token": {
+          "name": "password_reset_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_expires_at": {
+          "name": "password_reset_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_users_email": {
+          "name": "idx_users_email",
+          "columns": [
+            {
+              "expression": "email",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_role": {
+          "name": "idx_users_role",
+          "columns": [
+            {
+              "expression": "roles",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_reset_token": {
+          "name": "idx_users_reset_token",
+          "columns": [
+            {
+              "expression": "password_reset_token",
+              "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"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.application_status": {
+      "name": "application_status",
+      "schema": "public",
+      "values": [
+        "applied",
+        "under_review",
+        "phone_screen",
+        "interviewed",
+        "offer_extended",
+        "accepted",
+        "rejected",
+        "withdrawn"
+      ]
+    },
+    "public.bot_platform": {
+      "name": "bot_platform",
+      "schema": "public",
+      "values": ["discord", "reddit", "twitter", "slack"]
+    },
+    "public.integration_provider": {
+      "name": "integration_provider",
+      "schema": "public",
+      "values": [
+        "greenhouse",
+        "lever",
+        "workday",
+        "bamboohr",
+        "linkedin",
+        "indeed",
+        "custom"
+      ]
+    },
+    "public.notification_status": {
+      "name": "notification_status",
+      "schema": "public",
+      "values": ["pending", "sent", "failed", "bounced", "opened"]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": ["pending", "succeeded", "failed", "refunded", "disputed"]
+    },
+    "public.scrape_source_status": {
+      "name": "scrape_source_status",
+      "schema": "public",
+      "values": ["active", "paused", "broken", "rate_limited"]
+    },
+    "public.subscription_plan": {
+      "name": "subscription_plan",
+      "schema": "public",
+      "values": ["free", "seeker", "employer", "discord_owner", "enterprise"]
+    },
+    "public.subscription_status": {
+      "name": "subscription_status",
+      "schema": "public",
+      "values": [
+        "active",
+        "cancelled",
+        "past_due",
+        "trialing",
+        "paused",
+        "expired"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": ["job_seeker", "employer", "admin", "discord_owner"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/database/migrations/meta/0006_snapshot.json b/packages/database/migrations/meta/0006_snapshot.json
new file mode 100644
index 0000000..f77ecec
--- /dev/null
+++ b/packages/database/migrations/meta/0006_snapshot.json
@@ -0,0 +1,2075 @@
+{
+  "id": "cdd04111-fd50-40fc-a796-70fcc5572658",
+  "prevId": "d1e6f70c-0f27-40e6-9966-f3a471418b1c",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.application_status_history": {
+      "name": "application_status_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_status": {
+          "name": "from_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_status": {
+          "name": "to_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "changed_by": {
+          "name": "changed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_status_history_application_id_applications_id_fk": {
+          "name": "application_status_history_application_id_applications_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "applications",
+          "columnsFrom": ["application_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_status_history_changed_by_users_id_fk": {
+          "name": "application_status_history_changed_by_users_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "users",
+          "columnsFrom": ["changed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.applications": {
+      "name": "applications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "seeker_id": {
+          "name": "seeker_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'applied'"
+        },
+        "cover_letter": {
+          "name": "cover_letter",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_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": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "applications_seeker_id_users_id_fk": {
+          "name": "applications_seeker_id_users_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "users",
+          "columnsFrom": ["seeker_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_resume_id_resumes_id_fk": {
+          "name": "applications_resume_id_resumes_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "applications_seeker_id_job_id_unique": {
+          "name": "applications_seeker_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["seeker_id", "job_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": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_configs": {
+      "name": "bot_configs",
+      "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
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "credentials": {
+          "name": "credentials",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_name": {
+          "name": "target_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "webhook_url": {
+          "name": "webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_keywords": {
+          "name": "filter_keywords",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_locations": {
+          "name": "filter_locations",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_min_salary": {
+          "name": "filter_min_salary",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_job_types": {
+          "name": "filter_job_types",
+          "type": "varchar(255)[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_configs_user_id_users_id_fk": {
+          "name": "bot_configs_user_id_users_id_fk",
+          "tableFrom": "bot_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_configs_user_id_platform_unique": {
+          "name": "bot_configs_user_id_platform_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "platform"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_posts": {
+      "name": "bot_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "bot_config_id": {
+          "name": "bot_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_post_id": {
+          "name": "external_post_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'sent'"
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_posts_bot_config_id_bot_configs_id_fk": {
+          "name": "bot_posts_bot_config_id_bot_configs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "bot_configs",
+          "columnsFrom": ["bot_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bot_posts_job_id_jobs_id_fk": {
+          "name": "bot_posts_job_id_jobs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "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
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "conversations_user_id_users_id_fk": {
+          "name": "conversations_user_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversations_resume_id_resumes_id_fk": {
+          "name": "conversations_resume_id_resumes_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.employer_profiles": {
+      "name": "employer_profiles",
+      "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
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_website": {
+          "name": "company_website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_logo_url": {
+          "name": "company_logo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_description": {
+          "name": "company_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_size": {
+          "name": "company_size",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "industry": {
+          "name": "industry",
+          "type": "varchar(150)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "headquarters_location": {
+          "name": "headquarters_location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "social_links": {
+          "name": "social_links",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_job_count": {
+          "name": "active_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_employer_profiles_user": {
+          "name": "idx_employer_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "employer_profiles_user_id_users_id_fk": {
+          "name": "employer_profiles_user_id_users_id_fk",
+          "tableFrom": "employer_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "employer_profiles_user_id_unique": {
+          "name": "employer_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_matches": {
+      "name": "job_matches",
+      "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
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_saved": {
+          "name": "is_saved",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "applied": {
+          "name": "applied",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_matches_user_id_users_id_fk": {
+          "name": "job_matches_user_id_users_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_resume_id_resumes_id_fk": {
+          "name": "job_matches_resume_id_resumes_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_job_id_jobs_id_fk": {
+          "name": "job_matches_job_id_jobs_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_matches_user_id_job_id_unique": {
+          "name": "job_matches_user_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_min": {
+          "name": "salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_max": {
+          "name": "salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_type": {
+          "name": "job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote": {
+          "name": "remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills_required": {
+          "name": "skills_required",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_required": {
+          "name": "experience_required",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_job_id": {
+          "name": "external_job_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_jobs_company": {
+          "name": "idx_jobs_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_active": {
+          "name": "idx_jobs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_employer_id_users_id_fk": {
+          "name": "jobs_employer_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "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
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "notification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.otp_codes": {
+      "name": "otp_codes",
+      "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
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_otp_user": {
+          "name": "idx_otp_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "otp_codes_user_id_users_id_fk": {
+          "name": "otp_codes_user_id_users_id_fk",
+          "tableFrom": "otp_codes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "otp_codes_user_id_unique": {
+          "name": "otp_codes_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.payments": {
+      "name": "payments",
+      "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
+        },
+        "subscription_id": {
+          "name": "subscription_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "payments_user_id_users_id_fk": {
+          "name": "payments_user_id_users_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "payments_subscription_id_subscriptions_id_fk": {
+          "name": "payments_subscription_id_subscriptions_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "subscriptions",
+          "columnsFrom": ["subscription_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resumes": {
+      "name": "resumes",
+      "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
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parsed_text": {
+          "name": "parsed_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_resumes_user": {
+          "name": "idx_resumes_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "resumes_user_id_users_id_fk": {
+          "name": "resumes_user_id_users_id_fk",
+          "tableFrom": "resumes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seeker_profiles": {
+      "name": "seeker_profiles",
+      "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
+        },
+        "headline": {
+          "name": "headline",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_level": {
+          "name": "experience_level",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certifications": {
+          "name": "certifications",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "languages": {
+          "name": "languages",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "work_history": {
+          "name": "work_history",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_titles": {
+          "name": "desired_job_titles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_locations": {
+          "name": "desired_locations",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_min": {
+          "name": "desired_salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_max": {
+          "name": "desired_salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_type": {
+          "name": "desired_job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_to_remote": {
+          "name": "open_to_remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "open_to_relocation": {
+          "name": "open_to_relocation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prompt_history_summary": {
+          "name": "prompt_history_summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_parsed_at": {
+          "name": "last_parsed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_seeker_profiles_user": {
+          "name": "idx_seeker_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "seeker_profiles_user_id_users_id_fk": {
+          "name": "seeker_profiles_user_id_users_id_fk",
+          "tableFrom": "seeker_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seeker_profiles_user_id_unique": {
+          "name": "seeker_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "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
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "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": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_hash_unique": {
+          "name": "sessions_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.subscriptions": {
+      "name": "subscriptions",
+      "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
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "subscription_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "dodo_subscription_id": {
+          "name": "dodo_subscription_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_end": {
+          "name": "current_period_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "subscriptions_user_id_users_id_fk": {
+          "name": "subscriptions_user_id_users_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "subscriptions_user_id_unique": {
+          "name": "subscriptions_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        },
+        "subscriptions_dodo_subscription_id_unique": {
+          "name": "subscriptions_dodo_subscription_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_subscription_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_prompts": {
+      "name": "system_prompts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.token_usage": {
+      "name": "token_usage",
+      "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
+        },
+        "window_start": {
+          "name": "window_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "token_usage_user_id_users_id_fk": {
+          "name": "token_usage_user_id_users_id_fk",
+          "tableFrom": "token_usage",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "token_usage_user_id_window_start_unique": {
+          "name": "token_usage_user_id_window_start_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "window_start"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "full_name": {
+          "name": "full_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "roles": {
+          "name": "roles",
+          "type": "user_role[]",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"job_seeker\"}'"
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_token": {
+          "name": "password_reset_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_expires_at": {
+          "name": "password_reset_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_users_email": {
+          "name": "idx_users_email",
+          "columns": [
+            {
+              "expression": "email",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_role": {
+          "name": "idx_users_role",
+          "columns": [
+            {
+              "expression": "roles",
+              "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"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.application_status": {
+      "name": "application_status",
+      "schema": "public",
+      "values": [
+        "applied",
+        "under_review",
+        "phone_screen",
+        "interviewed",
+        "offer_extended",
+        "accepted",
+        "rejected",
+        "withdrawn"
+      ]
+    },
+    "public.bot_platform": {
+      "name": "bot_platform",
+      "schema": "public",
+      "values": ["discord", "reddit", "twitter"]
+    },
+    "public.notification_status": {
+      "name": "notification_status",
+      "schema": "public",
+      "values": ["pending", "sent", "failed", "bounced", "opened"]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": ["pending", "succeeded", "failed", "refunded", "disputed"]
+    },
+    "public.subscription_plan": {
+      "name": "subscription_plan",
+      "schema": "public",
+      "values": ["seeker", "employer", "discord_owner"]
+    },
+    "public.subscription_status": {
+      "name": "subscription_status",
+      "schema": "public",
+      "values": [
+        "active",
+        "cancelled",
+        "past_due",
+        "trialing",
+        "paused",
+        "expired"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": ["job_seeker", "employer", "admin", "discord_owner"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/database/migrations/meta/0007_snapshot.json b/packages/database/migrations/meta/0007_snapshot.json
new file mode 100644
index 0000000..5817f0f
--- /dev/null
+++ b/packages/database/migrations/meta/0007_snapshot.json
@@ -0,0 +1,2129 @@
+{
+  "id": "294ad33b-0987-400c-8f79-09b31806134d",
+  "prevId": "cdd04111-fd50-40fc-a796-70fcc5572658",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.application_status_history": {
+      "name": "application_status_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_status": {
+          "name": "from_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_status": {
+          "name": "to_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "changed_by": {
+          "name": "changed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_status_history_application_id_applications_id_fk": {
+          "name": "application_status_history_application_id_applications_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "applications",
+          "columnsFrom": ["application_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_status_history_changed_by_users_id_fk": {
+          "name": "application_status_history_changed_by_users_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "users",
+          "columnsFrom": ["changed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.applications": {
+      "name": "applications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "seeker_id": {
+          "name": "seeker_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'applied'"
+        },
+        "cover_letter": {
+          "name": "cover_letter",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_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": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "applications_seeker_id_users_id_fk": {
+          "name": "applications_seeker_id_users_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "users",
+          "columnsFrom": ["seeker_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_resume_id_resumes_id_fk": {
+          "name": "applications_resume_id_resumes_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "applications_seeker_id_job_id_unique": {
+          "name": "applications_seeker_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["seeker_id", "job_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": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_configs": {
+      "name": "bot_configs",
+      "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
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "credentials": {
+          "name": "credentials",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_name": {
+          "name": "target_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "webhook_url": {
+          "name": "webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_keywords": {
+          "name": "filter_keywords",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_locations": {
+          "name": "filter_locations",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_min_salary": {
+          "name": "filter_min_salary",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_job_types": {
+          "name": "filter_job_types",
+          "type": "varchar(255)[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_configs_user_id_users_id_fk": {
+          "name": "bot_configs_user_id_users_id_fk",
+          "tableFrom": "bot_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_configs_user_id_platform_unique": {
+          "name": "bot_configs_user_id_platform_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "platform"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_posts": {
+      "name": "bot_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "bot_config_id": {
+          "name": "bot_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_post_id": {
+          "name": "external_post_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'sent'"
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_posts_bot_config_id_bot_configs_id_fk": {
+          "name": "bot_posts_bot_config_id_bot_configs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "bot_configs",
+          "columnsFrom": ["bot_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bot_posts_job_id_jobs_id_fk": {
+          "name": "bot_posts_job_id_jobs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "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
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "conversations_user_id_users_id_fk": {
+          "name": "conversations_user_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversations_resume_id_resumes_id_fk": {
+          "name": "conversations_resume_id_resumes_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.employer_profiles": {
+      "name": "employer_profiles",
+      "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
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_website": {
+          "name": "company_website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_logo_url": {
+          "name": "company_logo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_description": {
+          "name": "company_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_size": {
+          "name": "company_size",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "industry": {
+          "name": "industry",
+          "type": "varchar(150)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "headquarters_location": {
+          "name": "headquarters_location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "social_links": {
+          "name": "social_links",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_job_count": {
+          "name": "active_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_employer_profiles_user": {
+          "name": "idx_employer_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "employer_profiles_user_id_users_id_fk": {
+          "name": "employer_profiles_user_id_users_id_fk",
+          "tableFrom": "employer_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "employer_profiles_user_id_unique": {
+          "name": "employer_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_matches": {
+      "name": "job_matches",
+      "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
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_saved": {
+          "name": "is_saved",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "applied": {
+          "name": "applied",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_matches_user_id_users_id_fk": {
+          "name": "job_matches_user_id_users_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_resume_id_resumes_id_fk": {
+          "name": "job_matches_resume_id_resumes_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_job_id_jobs_id_fk": {
+          "name": "job_matches_job_id_jobs_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_matches_user_id_job_id_unique": {
+          "name": "job_matches_user_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_min": {
+          "name": "salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_max": {
+          "name": "salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_type": {
+          "name": "job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote": {
+          "name": "remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills_required": {
+          "name": "skills_required",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_required": {
+          "name": "experience_required",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_job_id": {
+          "name": "external_job_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_jobs_company": {
+          "name": "idx_jobs_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_active": {
+          "name": "idx_jobs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_employer_id_users_id_fk": {
+          "name": "jobs_employer_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "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
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "notification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.otp_codes": {
+      "name": "otp_codes",
+      "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
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_otp_user": {
+          "name": "idx_otp_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "otp_codes_user_id_users_id_fk": {
+          "name": "otp_codes_user_id_users_id_fk",
+          "tableFrom": "otp_codes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "otp_codes_user_id_unique": {
+          "name": "otp_codes_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.payments": {
+      "name": "payments",
+      "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
+        },
+        "subscription_id": {
+          "name": "subscription_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_payment_id": {
+          "name": "dodo_payment_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "paid_at": {
+          "name": "paid_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_payload": {
+          "name": "raw_payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "payments_user_id_users_id_fk": {
+          "name": "payments_user_id_users_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "payments_subscription_id_subscriptions_id_fk": {
+          "name": "payments_subscription_id_subscriptions_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "subscriptions",
+          "columnsFrom": ["subscription_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resumes": {
+      "name": "resumes",
+      "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
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parsed_text": {
+          "name": "parsed_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_resumes_user": {
+          "name": "idx_resumes_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "resumes_user_id_users_id_fk": {
+          "name": "resumes_user_id_users_id_fk",
+          "tableFrom": "resumes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seeker_profiles": {
+      "name": "seeker_profiles",
+      "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
+        },
+        "headline": {
+          "name": "headline",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_level": {
+          "name": "experience_level",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certifications": {
+          "name": "certifications",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "languages": {
+          "name": "languages",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "work_history": {
+          "name": "work_history",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_titles": {
+          "name": "desired_job_titles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_locations": {
+          "name": "desired_locations",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_min": {
+          "name": "desired_salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_max": {
+          "name": "desired_salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_type": {
+          "name": "desired_job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_to_remote": {
+          "name": "open_to_remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "open_to_relocation": {
+          "name": "open_to_relocation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prompt_history_summary": {
+          "name": "prompt_history_summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_parsed_at": {
+          "name": "last_parsed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_seeker_profiles_user": {
+          "name": "idx_seeker_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "seeker_profiles_user_id_users_id_fk": {
+          "name": "seeker_profiles_user_id_users_id_fk",
+          "tableFrom": "seeker_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seeker_profiles_user_id_unique": {
+          "name": "seeker_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "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
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "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": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_hash_unique": {
+          "name": "sessions_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.subscriptions": {
+      "name": "subscriptions",
+      "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
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "subscription_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "dodo_subscription_id": {
+          "name": "dodo_subscription_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_end": {
+          "name": "current_period_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_data": {
+          "name": "raw_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "subscriptions_user_id_users_id_fk": {
+          "name": "subscriptions_user_id_users_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "subscriptions_user_id_unique": {
+          "name": "subscriptions_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        },
+        "subscriptions_dodo_subscription_id_unique": {
+          "name": "subscriptions_dodo_subscription_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_subscription_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_prompts": {
+      "name": "system_prompts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.token_usage": {
+      "name": "token_usage",
+      "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
+        },
+        "window_start": {
+          "name": "window_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "token_usage_user_id_users_id_fk": {
+          "name": "token_usage_user_id_users_id_fk",
+          "tableFrom": "token_usage",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "token_usage_user_id_window_start_unique": {
+          "name": "token_usage_user_id_window_start_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "window_start"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "full_name": {
+          "name": "full_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "roles": {
+          "name": "roles",
+          "type": "user_role[]",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"job_seeker\"}'"
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_token": {
+          "name": "password_reset_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_expires_at": {
+          "name": "password_reset_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_users_email": {
+          "name": "idx_users_email",
+          "columns": [
+            {
+              "expression": "email",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_role": {
+          "name": "idx_users_role",
+          "columns": [
+            {
+              "expression": "roles",
+              "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"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.application_status": {
+      "name": "application_status",
+      "schema": "public",
+      "values": [
+        "applied",
+        "under_review",
+        "phone_screen",
+        "interviewed",
+        "offer_extended",
+        "accepted",
+        "rejected",
+        "withdrawn"
+      ]
+    },
+    "public.bot_platform": {
+      "name": "bot_platform",
+      "schema": "public",
+      "values": ["discord", "reddit", "twitter"]
+    },
+    "public.notification_status": {
+      "name": "notification_status",
+      "schema": "public",
+      "values": ["pending", "sent", "failed", "bounced", "opened"]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": ["pending", "succeeded", "failed", "refunded", "disputed"]
+    },
+    "public.subscription_plan": {
+      "name": "subscription_plan",
+      "schema": "public",
+      "values": ["seeker", "employer", "discord_owner"]
+    },
+    "public.subscription_status": {
+      "name": "subscription_status",
+      "schema": "public",
+      "values": [
+        "active",
+        "cancelled",
+        "past_due",
+        "trialing",
+        "paused",
+        "expired"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": ["job_seeker", "employer", "admin", "discord_owner"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/database/migrations/meta/0008_snapshot.json b/packages/database/migrations/meta/0008_snapshot.json
new file mode 100644
index 0000000..5da40d6
--- /dev/null
+++ b/packages/database/migrations/meta/0008_snapshot.json
@@ -0,0 +1,2251 @@
+{
+  "id": "9985efb9-5bbb-4a6d-8ac5-56478be12dff",
+  "prevId": "294ad33b-0987-400c-8f79-09b31806134d",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.application_status_history": {
+      "name": "application_status_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "application_id": {
+          "name": "application_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_status": {
+          "name": "from_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_status": {
+          "name": "to_status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "changed_by": {
+          "name": "changed_by",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "application_status_history_application_id_applications_id_fk": {
+          "name": "application_status_history_application_id_applications_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "applications",
+          "columnsFrom": ["application_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "application_status_history_changed_by_users_id_fk": {
+          "name": "application_status_history_changed_by_users_id_fk",
+          "tableFrom": "application_status_history",
+          "tableTo": "users",
+          "columnsFrom": ["changed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.applications": {
+      "name": "applications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "seeker_id": {
+          "name": "seeker_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "application_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'applied'"
+        },
+        "cover_letter": {
+          "name": "cover_letter",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_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": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "applications_seeker_id_users_id_fk": {
+          "name": "applications_seeker_id_users_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "users",
+          "columnsFrom": ["seeker_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_resume_id_resumes_id_fk": {
+          "name": "applications_resume_id_resumes_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "applications_seeker_id_job_id_unique": {
+          "name": "applications_seeker_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["seeker_id", "job_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": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_configs": {
+      "name": "bot_configs",
+      "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
+        },
+        "platform": {
+          "name": "platform",
+          "type": "bot_platform",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "credentials": {
+          "name": "credentials",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_name": {
+          "name": "target_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "webhook_url": {
+          "name": "webhook_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_keywords": {
+          "name": "filter_keywords",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_locations": {
+          "name": "filter_locations",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_min_salary": {
+          "name": "filter_min_salary",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter_job_types": {
+          "name": "filter_job_types",
+          "type": "varchar(255)[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_post_at": {
+          "name": "last_post_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_configs_user_id_users_id_fk": {
+          "name": "bot_configs_user_id_users_id_fk",
+          "tableFrom": "bot_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bot_configs_user_id_platform_unique": {
+          "name": "bot_configs_user_id_platform_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "platform"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bot_posts": {
+      "name": "bot_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "bot_config_id": {
+          "name": "bot_config_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_post_id": {
+          "name": "external_post_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'sent'"
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "bot_posts_bot_config_id_bot_configs_id_fk": {
+          "name": "bot_posts_bot_config_id_bot_configs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "bot_configs",
+          "columnsFrom": ["bot_config_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bot_posts_job_id_jobs_id_fk": {
+          "name": "bot_posts_job_id_jobs_id_fk",
+          "tableFrom": "bot_posts",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "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
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "model": {
+          "name": "model",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_archived": {
+          "name": "is_archived",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "conversations_user_id_users_id_fk": {
+          "name": "conversations_user_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversations_resume_id_resumes_id_fk": {
+          "name": "conversations_resume_id_resumes_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.discord_configs": {
+      "name": "discord_configs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "guild_id": {
+          "name": "guild_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_id": {
+          "name": "channel_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_discord_guild": {
+          "name": "idx_discord_guild",
+          "columns": [
+            {
+              "expression": "guild_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "discord_configs_user_id_users_id_fk": {
+          "name": "discord_configs_user_id_users_id_fk",
+          "tableFrom": "discord_configs",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "discord_configs_guild_id_unique": {
+          "name": "discord_configs_guild_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["guild_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.employer_profiles": {
+      "name": "employer_profiles",
+      "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
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_website": {
+          "name": "company_website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_logo_url": {
+          "name": "company_logo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_description": {
+          "name": "company_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "company_size": {
+          "name": "company_size",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "industry": {
+          "name": "industry",
+          "type": "varchar(150)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "headquarters_location": {
+          "name": "headquarters_location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "social_links": {
+          "name": "social_links",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_job_count": {
+          "name": "active_job_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_employer_profiles_user": {
+          "name": "idx_employer_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "employer_profiles_user_id_users_id_fk": {
+          "name": "employer_profiles_user_id_users_id_fk",
+          "tableFrom": "employer_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "employer_profiles_user_id_unique": {
+          "name": "employer_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.job_matches": {
+      "name": "job_matches",
+      "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
+        },
+        "resume_id": {
+          "name": "resume_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "match_score": {
+          "name": "match_score",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ai_explanation": {
+          "name": "ai_explanation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_saved": {
+          "name": "is_saved",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "applied": {
+          "name": "applied",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "job_matches_user_id_users_id_fk": {
+          "name": "job_matches_user_id_users_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_resume_id_resumes_id_fk": {
+          "name": "job_matches_resume_id_resumes_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "resumes",
+          "columnsFrom": ["resume_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "job_matches_job_id_jobs_id_fk": {
+          "name": "job_matches_job_id_jobs_id_fk",
+          "tableFrom": "job_matches",
+          "tableTo": "jobs",
+          "columnsFrom": ["job_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "job_matches_user_id_job_id_unique": {
+          "name": "job_matches_user_id_job_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "job_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.jobs": {
+      "name": "jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "company_name": {
+          "name": "company_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "location": {
+          "name": "location",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_min": {
+          "name": "salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "salary_max": {
+          "name": "salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "job_type": {
+          "name": "job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote": {
+          "name": "remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills_required": {
+          "name": "skills_required",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_required": {
+          "name": "experience_required",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "posted_at": {
+          "name": "posted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "employer_id": {
+          "name": "employer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_job_id": {
+          "name": "external_job_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fingerprint": {
+          "name": "fingerprint",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_jobs_company": {
+          "name": "idx_jobs_company",
+          "columns": [
+            {
+              "expression": "company_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_jobs_active": {
+          "name": "idx_jobs_active",
+          "columns": [
+            {
+              "expression": "is_active",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "jobs_employer_id_users_id_fk": {
+          "name": "jobs_employer_id_users_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "users",
+          "columnsFrom": ["employer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "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
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "notification_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.otp_codes": {
+      "name": "otp_codes",
+      "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
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_otp_user": {
+          "name": "idx_otp_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "otp_codes_user_id_users_id_fk": {
+          "name": "otp_codes_user_id_users_id_fk",
+          "tableFrom": "otp_codes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "otp_codes_user_id_unique": {
+          "name": "otp_codes_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.payments": {
+      "name": "payments",
+      "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
+        },
+        "subscription_id": {
+          "name": "subscription_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_payment_id": {
+          "name": "dodo_payment_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "status": {
+          "name": "status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "paid_at": {
+          "name": "paid_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_payload": {
+          "name": "raw_payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "payments_user_id_users_id_fk": {
+          "name": "payments_user_id_users_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "payments_subscription_id_subscriptions_id_fk": {
+          "name": "payments_subscription_id_subscriptions_id_fk",
+          "tableFrom": "payments",
+          "tableTo": "subscriptions",
+          "columnsFrom": ["subscription_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.resumes": {
+      "name": "resumes",
+      "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
+        },
+        "file_url": {
+          "name": "file_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parsed_text": {
+          "name": "parsed_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_resumes_user": {
+          "name": "idx_resumes_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "resumes_user_id_users_id_fk": {
+          "name": "resumes_user_id_users_id_fk",
+          "tableFrom": "resumes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.seeker_profiles": {
+      "name": "seeker_profiles",
+      "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
+        },
+        "headline": {
+          "name": "headline",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_years": {
+          "name": "experience_years",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "experience_level": {
+          "name": "experience_level",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "education": {
+          "name": "education",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "certifications": {
+          "name": "certifications",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "languages": {
+          "name": "languages",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "work_history": {
+          "name": "work_history",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_titles": {
+          "name": "desired_job_titles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_locations": {
+          "name": "desired_locations",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_min": {
+          "name": "desired_salary_min",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_salary_max": {
+          "name": "desired_salary_max",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "desired_job_type": {
+          "name": "desired_job_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_to_remote": {
+          "name": "open_to_remote",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "open_to_relocation": {
+          "name": "open_to_relocation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "prompt_history_summary": {
+          "name": "prompt_history_summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_parsed_at": {
+          "name": "last_parsed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_seeker_profiles_user": {
+          "name": "idx_seeker_profiles_user",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "seeker_profiles_user_id_users_id_fk": {
+          "name": "seeker_profiles_user_id_users_id_fk",
+          "tableFrom": "seeker_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "seeker_profiles_user_id_unique": {
+          "name": "seeker_profiles_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.sessions": {
+      "name": "sessions",
+      "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
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_active_at": {
+          "name": "last_active_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "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": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "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"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "sessions_token_hash_unique": {
+          "name": "sessions_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.subscriptions": {
+      "name": "subscriptions",
+      "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
+        },
+        "plan": {
+          "name": "plan",
+          "type": "subscription_plan",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "subscription_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "dodo_subscription_id": {
+          "name": "dodo_subscription_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dodo_customer_id": {
+          "name": "dodo_customer_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_start": {
+          "name": "current_period_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_period_end": {
+          "name": "current_period_end",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "raw_data": {
+          "name": "raw_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "subscriptions_user_id_users_id_fk": {
+          "name": "subscriptions_user_id_users_id_fk",
+          "tableFrom": "subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "subscriptions_user_id_unique": {
+          "name": "subscriptions_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        },
+        "subscriptions_dodo_subscription_id_unique": {
+          "name": "subscriptions_dodo_subscription_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["dodo_subscription_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.system_prompts": {
+      "name": "system_prompts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.token_usage": {
+      "name": "token_usage",
+      "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
+        },
+        "window_start": {
+          "name": "window_start",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tokens_used": {
+          "name": "tokens_used",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "token_usage_user_id_users_id_fk": {
+          "name": "token_usage_user_id_users_id_fk",
+          "tableFrom": "token_usage",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "token_usage_user_id_window_start_unique": {
+          "name": "token_usage_user_id_window_start_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "window_start"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "full_name": {
+          "name": "full_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "roles": {
+          "name": "roles",
+          "type": "user_role[]",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"job_seeker\"}'"
+        },
+        "is_verified": {
+          "name": "is_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_token": {
+          "name": "password_reset_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_reset_expires_at": {
+          "name": "password_reset_expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_users_email": {
+          "name": "idx_users_email",
+          "columns": [
+            {
+              "expression": "email",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_users_role": {
+          "name": "idx_users_role",
+          "columns": [
+            {
+              "expression": "roles",
+              "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"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.application_status": {
+      "name": "application_status",
+      "schema": "public",
+      "values": [
+        "applied",
+        "under_review",
+        "phone_screen",
+        "interviewed",
+        "offer_extended",
+        "accepted",
+        "rejected",
+        "withdrawn"
+      ]
+    },
+    "public.bot_platform": {
+      "name": "bot_platform",
+      "schema": "public",
+      "values": ["discord", "reddit", "twitter"]
+    },
+    "public.notification_status": {
+      "name": "notification_status",
+      "schema": "public",
+      "values": ["pending", "sent", "failed", "bounced", "opened"]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": ["pending", "succeeded", "failed", "refunded", "disputed"]
+    },
+    "public.subscription_plan": {
+      "name": "subscription_plan",
+      "schema": "public",
+      "values": ["seeker", "employer", "discord_owner"]
+    },
+    "public.subscription_status": {
+      "name": "subscription_status",
+      "schema": "public",
+      "values": [
+        "active",
+        "cancelled",
+        "past_due",
+        "trialing",
+        "paused",
+        "expired"
+      ]
+    },
+    "public.user_role": {
+      "name": "user_role",
+      "schema": "public",
+      "values": ["job_seeker", "employer", "admin", "discord_owner"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/packages/database/migrations/meta/_journal.json b/packages/database/migrations/meta/_journal.json
index b4fc635..7dbcfd9 100644
--- a/packages/database/migrations/meta/_journal.json
+++ b/packages/database/migrations/meta/_journal.json
@@ -29,6 +29,41 @@
       "when": 1772210196881,
       "tag": "0003_giant_tattoo",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1774462483063,
+      "tag": "0004_loose_madame_web",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1774806193977,
+      "tag": "0005_brown_viper",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "7",
+      "when": 1777393089539,
+      "tag": "0006_loving_forge",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1777394234644,
+      "tag": "0007_tan_the_order",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1777396102324,
+      "tag": "0008_bumpy_mac_gargan",
+      "breakpoints": true
     }
   ]
 }
diff --git a/packages/database/src/queries/applications.ts b/packages/database/src/queries/applications.ts
index 276e5a0..e67a427 100644
--- a/packages/database/src/queries/applications.ts
+++ b/packages/database/src/queries/applications.ts
@@ -1,10 +1,7 @@
 import { eq, desc, and, ilike } from "drizzle-orm";
 import { db } from "../index";
-import { applications, jobs } from "../schema";
-import type {
-  ApplicationStatus,
-  StatusHistoryEntry,
-} from "@postly/shared-types";
+import { applications, jobs, application_status_history } from "../schema";
+import type { ApplicationStatus } from "@postly/shared-types";
 
 export const applicationQueries = {
   async create(
@@ -13,21 +10,26 @@ export const applicationQueries = {
     resumeId?: string,
     coverLetter?: string,
   ) {
-    const initialHistory: StatusHistoryEntry[] = [
-      { status: "applied", timestamp: new Date().toISOString() },
-    ];
-
-    const [result] = await db
-      .insert(applications)
-      .values({
-        seeker_id: seekerId,
-        job_id: jobId,
-        resume_id: resumeId,
-        cover_letter: coverLetter,
-        status: "applied",
-        status_history: initialHistory,
-      })
-      .returning();
+    const [result] = await db.transaction(async (tx) => {
+      const [app] = await tx
+        .insert(applications)
+        .values({
+          seeker_id: seekerId,
+          job_id: jobId,
+          resume_id: resumeId,
+          cover_letter: coverLetter,
+          status: "applied",
+        })
+        .returning();
+
+      await tx.insert(application_status_history).values({
+        application_id: app.id,
+        to_status: "applied",
+        changed_by: seekerId,
+      });
+
+      return [app];
+    });
 
     return result;
   },
@@ -55,7 +57,7 @@ export const applicationQueries = {
       })
       .from(applications)
       .innerJoin(jobs, eq(applications.job_id, jobs.id))
-      .where(eq(applications.seeker_id, seekerId))
+      .where(and(eq(applications.seeker_id, seekerId)))
       .orderBy(desc(applications.applied_at))
       .limit(limit)
       .offset(offset);
@@ -95,62 +97,50 @@ export const applicationQueries = {
       .offset(offset);
   },
 
-  async updateStatus(id: string, status: ApplicationStatus, note?: string) {
-    const [existing] = await db
-      .select({ status_history: applications.status_history })
-      .from(applications)
-      .where(eq(applications.id, id));
-
-    if (!existing) return null;
-
-    const history = (
-      Array.isArray(existing.status_history) ? existing.status_history : []
-    ) as StatusHistoryEntry[];
+  async updateStatus(
+    id: string,
+    status: ApplicationStatus,
+    note?: string,
+    actorId?: string,
+  ) {
+    const [result] = await db.transaction(async (tx) => {
+      const [app] = await tx
+        .update(applications)
+        .set({
+          status,
+          updated_at: new Date(),
+        })
+        .where(eq(applications.id, id))
+        .returning();
+
+      if (app) {
+        await tx.insert(application_status_history).values({
+          application_id: id,
+          to_status: status,
+          note,
+          changed_by: actorId,
+        });
+      }
+
+      return [app];
+    });
 
-    const newEntry: StatusHistoryEntry = {
-      status,
-      timestamp: new Date().toISOString(),
-      ...(note && { note }),
-    };
+    return result ?? null;
+  },
 
+  async updateNotes(id: string, actorId: string, notes: string) {
     const [result] = await db
       .update(applications)
       .set({
-        status,
-        status_history: [...history, newEntry],
+        notes,
         updated_at: new Date(),
       })
-      .where(eq(applications.id, id))
+      .where(and(eq(applications.id, id), eq(applications.seeker_id, actorId)))
       .returning();
 
     return result ?? null;
   },
 
-  async updateNotes(id: string, seekerId: string, notes: string) {
-    const [result] = await db
-      .update(applications)
-      .set({ notes, updated_at: new Date() })
-      .where(and(eq(applications.id, id), eq(applications.seeker_id, seekerId)))
-      .returning();
-
-    return result ?? null;
-  },
-
-  async updateMatchScore(
-    id: string,
-    matchScore: number,
-    aiExplanation?: string,
-  ) {
-    await db
-      .update(applications)
-      .set({
-        match_score: matchScore.toString(),
-        ai_explanation: aiExplanation,
-        updated_at: new Date(),
-      })
-      .where(eq(applications.id, id));
-  },
-
   async delete(id: string, seekerId: string) {
     const [result] = await db
       .delete(applications)
diff --git a/packages/database/src/queries/bots.ts b/packages/database/src/queries/bots.ts
new file mode 100644
index 0000000..80295e9
--- /dev/null
+++ b/packages/database/src/queries/bots.ts
@@ -0,0 +1,127 @@
+import { eq, and, desc } from "drizzle-orm";
+import { db } from "../index";
+import { bot_configs, bot_posts } from "../schema";
+import type { BotPlatform } from "@postly/shared-types";
+
+export interface CreateBotConfigInput {
+  user_id: string;
+  platform: BotPlatform;
+  target_id?: string;
+  target_name?: string;
+  webhook_url?: string;
+  credentials?: Record<string, unknown>;
+  filter_keywords?: string;
+  filter_locations?: string;
+  filter_min_salary?: string;
+  filter_job_types?: string[];
+}
+
+export const botQueries = {
+  /**
+   * Create or update bot configuration for a platform
+   */
+  async upsertConfig(input: CreateBotConfigInput) {
+    const [result] = await db
+      .insert(bot_configs)
+      .values({
+        ...input,
+        updated_at: new Date(),
+      })
+      .onConflictDoUpdate({
+        target: [bot_configs.user_id, bot_configs.platform],
+        set: {
+          ...input,
+          updated_at: new Date(),
+        },
+      })
+      .returning();
+
+    return result;
+  },
+
+  /**
+   * Find bot config for a user and platform
+   */
+  async findConfig(userId: string, platform: BotPlatform) {
+    const [result] = await db
+      .select()
+      .from(bot_configs)
+      .where(
+        and(
+          eq(bot_configs.user_id, userId),
+          eq(bot_configs.platform, platform),
+        ),
+      );
+
+    return result ?? null;
+  },
+
+  /**
+   * Get all active bot configs for a platform (for the worker)
+   */
+  async findActiveConfigsByPlatform(platform: BotPlatform) {
+    return db
+      .select()
+      .from(bot_configs)
+      .where(
+        and(
+          eq(bot_configs.platform, platform),
+          eq(bot_configs.is_active, true),
+        ),
+      );
+  },
+
+  /**
+   * Create a record of a job posted by a bot
+   */
+  async createPost(
+    botConfigId: string,
+    jobId: string,
+    externalPostId?: string,
+  ) {
+    const [result] = await db
+      .insert(bot_posts)
+      .values({
+        bot_config_id: botConfigId,
+        job_id: jobId,
+        external_post_id: externalPostId,
+        status: "sent",
+      })
+      .returning();
+
+    // Update last post timestamp
+    await db
+      .update(bot_configs)
+      .set({ last_post_at: new Date() })
+      .where(eq(bot_configs.id, botConfigId));
+
+    return result;
+  },
+
+  /**
+   * Log a failed post attempt
+   */
+  async logPostError(botConfigId: string, jobId: string, errorMessage: string) {
+    return db
+      .insert(bot_posts)
+      .values({
+        bot_config_id: botConfigId,
+        job_id: jobId,
+        status: "failed",
+        error_message: errorMessage,
+      })
+      .returning();
+  },
+
+  /**
+   * Get recent posts for a bot config
+   */
+  async findRecentPosts(botConfigId: string, limit = 50) {
+    return db
+      .select()
+      .from(bot_posts)
+      .where(eq(bot_posts.bot_config_id, botConfigId))
+      .orderBy(desc(bot_posts.posted_at))
+      .limit(limit);
+  },
+};
diff --git a/packages/database/src/queries/conversations.ts b/packages/database/src/queries/conversations.ts
index b497f48..59ceacb 100644
--- a/packages/database/src/queries/conversations.ts
+++ b/packages/database/src/queries/conversations.ts
@@ -1,11 +1,7 @@
-import { eq, asc, and } from "drizzle-orm";
+import { eq, asc, and, desc, ilike } from "drizzle-orm";
 import { db } from "../index";
 import { conversations, messages } from "../schema";
-import type {
-  Conversation,
-  Message,
-  MessageStreamStatus,
-} from "@postly/shared-types";
+import type { Conversation, Message } from "@postly/shared-types";
 
 export const conversationQueries = {
   /**
@@ -25,30 +21,30 @@ export const conversationQueries = {
   },
 
   /**
-   * Get all conversations for a user (most recent first, excludes archived by default)
+   * Get all conversations for a user
    */
   async findByUser(
     userId: string,
     limit = 50,
     includeArchived = false,
   ): Promise<Conversation[]> {
-    const conditions = [eq(conversations.user_id, userId)];
-    if (!includeArchived) {
-      conditions.push(eq(conversations.is_archived, false));
-    }
-
     const result = await db
       .select()
       .from(conversations)
-      .where(and(...conditions))
-      .orderBy(asc(conversations.updated_at))
+      .where(
+        and(
+          eq(conversations.user_id, userId),
+          includeArchived ? undefined : eq(conversations.is_archived, false),
+        ),
+      )
+      .orderBy(desc(conversations.updated_at))
       .limit(limit);
 
     return result as unknown as Conversation[];
   },
 
   /**
-   * Get a single conversation by ID (scoped to user)
+   * Get a single conversation by ID
    */
   async findById(id: string, userId: string): Promise<Conversation | null> {
     const [result] = await db
@@ -70,7 +66,7 @@ export const conversationQueries = {
   },
 
   /**
-   * Update conversation resume_id
+   * Update the resume associated with a conversation
    */
   async updateResumeId(id: string, resumeId: string): Promise<void> {
     await db
@@ -80,17 +76,7 @@ export const conversationQueries = {
   },
 
   /**
-   * Archive / unarchive a conversation
-   */
-  async setArchived(id: string, isArchived: boolean): Promise<void> {
-    await db
-      .update(conversations)
-      .set({ is_archived: isArchived, updated_at: new Date() })
-      .where(eq(conversations.id, id));
-  },
-
-  /**
-   * Delete a conversation (scoped to user)
+   * Delete a conversation
    */
   async delete(id: string, userId: string): Promise<boolean> {
     const [result] = await db
@@ -101,139 +87,86 @@ export const conversationQueries = {
     return !!result;
   },
 
-  // ─── Message Operations ──────────────────────────────────────────────────
+  async getActiveThread(conversationId: string, limit = 100) {
+    const result = await db
+      .select()
+      .from(messages)
+      .where(eq(messages.conversation_id, conversationId))
+      .orderBy(asc(messages.created_at))
+      .limit(limit);
 
-  /**
-   * Create a new message in a conversation
-   */
-  async createMessage(
-    conversationId: string,
-    role: Message["role"],
+    return result as unknown as Message[];
+  },
+
+  async setArchived(id: string, isArchived: boolean) {
+    await db
+      .update(conversations)
+      .set({ is_archived: isArchived, updated_at: new Date() })
+      .where(eq(conversations.id, id));
+  },
+
+  async editMessage(
+    messageId: string,
     content: string,
-    metadata?: Record<string, unknown>,
-    parentMessageId?: string,
-    status: MessageStreamStatus = "completed",
-  ): Promise<Message> {
+    conversationId: string,
+  ) {
     const [result] = await db
       .insert(messages)
       .values({
         conversation_id: conversationId,
-        role,
+        role: "user",
         content,
-        metadata,
-        parent_message_id: parentMessageId,
-        status,
+        metadata: { edited_from: messageId },
       })
       .returning();
 
-    // Touch conversation timestamp
-    await db
-      .update(conversations)
-      .set({ updated_at: new Date() })
-      .where(eq(conversations.id, conversationId));
-
     return result as unknown as Message;
   },
 
-  /**
-   * Get only the active-branch messages (what the user sees)
-   */
-  async getActiveThread(
-    conversationId: string,
-    limit = 100,
-  ): Promise<Message[]> {
+  async cancelMessage(messageId: string) {
+    await db
+      .update(messages)
+      .set({
+        metadata: { cancelled: true },
+      })
+      .where(eq(messages.id, messageId));
+  },
+
+  async getMessageVersions(parentMessageId: string, role: string) {
     const result = await db
       .select()
       .from(messages)
       .where(
         and(
-          eq(messages.conversation_id, conversationId),
-          eq(messages.is_active, true),
+          eq(messages.role, role),
+          // This is a simplified versioning logic
+          ilike(messages.content, `%${parentMessageId}%`),
         ),
-      )
-      .orderBy(asc(messages.created_at))
-      .limit(limit);
+      );
 
     return result as unknown as Message[];
   },
 
-  /**
-   * Get ALL messages (including inactive branches) for tree rendering
-   */
-  async getMessages(conversationId: string, limit = 100): Promise<Message[]> {
-    const result = await db
-      .select()
-      .from(messages)
-      .where(eq(messages.conversation_id, conversationId))
-      .orderBy(asc(messages.created_at))
-      .limit(limit);
-
-    return result as unknown as Message[];
-  },
+  // ─── Message Operations ──────────────────────────────────────────────────
 
   /**
-   * Edit a user message → creates a new sibling version,
-   * deactivates the old message and its entire subtree.
+   * Create a new message in a conversation
    */
-  async editMessage(
-    messageId: string,
-    newContent: string,
+  async createMessage(
     conversationId: string,
+    role: string,
+    content: string,
+    tokensUsed?: number,
+    metadata?: unknown,
   ): Promise<Message> {
-    // 1. Get the original message
-    const [original] = await db
-      .select()
-      .from(messages)
-      .where(eq(messages.id, messageId));
-
-    if (!original) throw new Error("Message not found");
-
-    // 2. Deactivate ALL active messages in this conversation
-    await db
-      .update(messages)
-      .set({ is_active: false })
-      .where(
-        and(
-          eq(messages.conversation_id, conversationId),
-          eq(messages.is_active, true),
-        ),
-      );
-
-    // 3. Re-activate ancestors of the edited message (walk the parent chain)
-    const allMessages = await db
-      .select()
-      .from(messages)
-      .where(eq(messages.conversation_id, conversationId))
-      .orderBy(asc(messages.created_at));
-
-    const messageMap = new Map(allMessages.map((m) => [m.id, m]));
-    const ancestorIds = new Set<string>();
-    let currentParentId = original.parent_message_id;
-
-    while (currentParentId) {
-      ancestorIds.add(currentParentId);
-      const parent = messageMap.get(currentParentId);
-      currentParentId = parent?.parent_message_id || null;
-    }
-
-    for (const ancestorId of ancestorIds) {
-      await db
-        .update(messages)
-        .set({ is_active: true })
-        .where(eq(messages.id, ancestorId));
-    }
-
-    // 4. Create new version as a sibling (same parent, higher version)
-    const [newMessage] = await db
+    const [result] = await db
       .insert(messages)
       .values({
         conversation_id: conversationId,
-        role: original.role,
-        content: newContent,
-        parent_message_id: original.parent_message_id,
-        version: original.version + 1,
-        is_active: true,
-        status: "completed",
+        role,
+        content,
+        tokens_used: tokensUsed,
+        metadata,
       })
       .returning();
 
@@ -243,60 +176,19 @@ export const conversationQueries = {
       .set({ updated_at: new Date() })
       .where(eq(conversations.id, conversationId));
 
-    return newMessage as unknown as Message;
-  },
-
-  /**
-   * Cancel a streaming message (user pressed "Stop generating")
-   */
-  async cancelMessage(messageId: string): Promise<void> {
-    await db
-      .update(messages)
-      .set({ status: "cancelled" })
-      .where(eq(messages.id, messageId));
-  },
-
-  /**
-   * Update message status (streaming lifecycle)
-   */
-  async updateMessageStatus(
-    messageId: string,
-    status: MessageStreamStatus,
-  ): Promise<void> {
-    await db.update(messages).set({ status }).where(eq(messages.id, messageId));
-  },
-
-  /**
-   * Update message content (for streamed content accumulation)
-   */
-  async updateMessageContent(
-    messageId: string,
-    content: string,
-    metadata?: Record<string, unknown>,
-  ): Promise<void> {
-    const updateData: Record<string, unknown> = { content };
-    if (metadata) updateData.metadata = metadata;
-
-    await db.update(messages).set(updateData).where(eq(messages.id, messageId));
+    return result as unknown as Message;
   },
 
   /**
-   * Get all edit versions for a parent (for "edited 2/3" navigation)
+   * Get messages for a conversation
    */
-  async getMessageVersions(
-    parentMessageId: string,
-    role: string,
-  ): Promise<Message[]> {
+  async getMessages(conversationId: string, limit = 100): Promise<Message[]> {
     const result = await db
       .select()
       .from(messages)
-      .where(
-        and(
-          eq(messages.parent_message_id, parentMessageId),
-          eq(messages.role, role),
-        ),
-      )
-      .orderBy(asc(messages.version));
+      .where(eq(messages.conversation_id, conversationId))
+      .orderBy(asc(messages.created_at))
+      .limit(limit);
 
     return result as unknown as Message[];
   },
diff --git a/packages/database/src/queries/employer_profiles.ts b/packages/database/src/queries/employer_profiles.ts
index fea88c0..8a543ad 100644
--- a/packages/database/src/queries/employer_profiles.ts
+++ b/packages/database/src/queries/employer_profiles.ts
@@ -1,4 +1,4 @@
-import { eq, sql } from "drizzle-orm";
+import { eq, sql, and, isNull } from "drizzle-orm";
 import { db } from "../index";
 import { employer_profiles } from "../schema";
 import type {
@@ -20,7 +20,12 @@ export const employerProfileQueries = {
     const [result] = await db
       .select()
       .from(employer_profiles)
-      .where(eq(employer_profiles.user_id, userId));
+      .where(
+        and(
+          eq(employer_profiles.user_id, userId),
+          isNull(employer_profiles.deleted_at),
+        ),
+      );
 
     return result ?? null;
   },
@@ -29,7 +34,9 @@ export const employerProfileQueries = {
     const [result] = await db
       .select()
       .from(employer_profiles)
-      .where(eq(employer_profiles.id, id));
+      .where(
+        and(eq(employer_profiles.id, id), isNull(employer_profiles.deleted_at)),
+      );
 
     return result ?? null;
   },
diff --git a/packages/database/src/queries/index.ts b/packages/database/src/queries/index.ts
index 8015092..3f2f7c2 100644
--- a/packages/database/src/queries/index.ts
+++ b/packages/database/src/queries/index.ts
@@ -9,3 +9,4 @@ export * from "./seeker_profiles";
 export * from "./subscriptions";
 export * from "./payments";
 export * from "./notifications";
+export * from "./bots";
diff --git a/packages/database/src/queries/jobs.ts b/packages/database/src/queries/jobs.ts
index 4c5787b..8217475 100644
--- a/packages/database/src/queries/jobs.ts
+++ b/packages/database/src/queries/jobs.ts
@@ -1,4 +1,4 @@
-import { eq, desc, and, sql, isNull, ilike } from "drizzle-orm";
+import { eq, desc, and, sql, isNull, ilike, isNotNull } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm";
 import { db } from "../index";
 import { jobs } from "../schema";
@@ -30,6 +30,8 @@ export const jobQueries = {
         experience_required: input.experience_required,
         expires_at: input.expires_at,
         employer_id: employerId,
+        external_job_id: input.external_job_id,
+        fingerprint: input.fingerprint,
       })
       .returning();
 
@@ -74,6 +76,8 @@ export const jobQueries = {
           updated_at: new Date(),
           expires_at: expiresAt,
           is_active: true,
+          external_job_id: input.external_job_id,
+          fingerprint: input.fingerprint,
         })
         .where(eq(jobs.source_url, input.source_url))
         .returning();
@@ -100,6 +104,8 @@ export const jobQueries = {
         embedding: input.embedding,
         expires_at: expiresAt,
         is_active: true,
+        external_job_id: input.external_job_id,
+        fingerprint: input.fingerprint,
       })
       .returning();
 
@@ -114,7 +120,7 @@ export const jobQueries = {
     limit = 50,
     offset = 0,
   ): Promise<Job[]> {
-    const conditions = [eq(jobs.is_active, true)];
+    const conditions = [eq(jobs.is_active, true), isNull(jobs.deleted_at)];
 
     if (filters?.location) {
       conditions.push(ilike(jobs.location, `%${filters.location}%`));
@@ -158,7 +164,13 @@ export const jobQueries = {
     const result = await db
       .select({ ...getTableColumns(jobs), similarity })
       .from(jobs)
-      .where(and(eq(jobs.is_active, true), sql`${jobs.embedding} IS NOT NULL`))
+      .where(
+        and(
+          eq(jobs.is_active, true),
+          isNull(jobs.deleted_at),
+          isNotNull(jobs.embedding),
+        ),
+      )
       .orderBy(sql`${jobs.embedding} <=> ${JSON.stringify(embedding)}::vector`)
       .limit(limit);
 
@@ -172,7 +184,7 @@ export const jobQueries = {
     const [result] = await db
       .select({ count: sql<number>`count(*)` })
       .from(jobs)
-      .where(eq(jobs.is_active, true));
+      .where(and(eq(jobs.is_active, true), isNull(jobs.deleted_at)));
 
     return Number(result.count);
   },
diff --git a/packages/database/src/queries/matches.ts b/packages/database/src/queries/matches.ts
index a8e8513..ef60694 100644
--- a/packages/database/src/queries/matches.ts
+++ b/packages/database/src/queries/matches.ts
@@ -1,4 +1,4 @@
-import { eq, and, desc } from "drizzle-orm";
+import { eq, and, desc, isNull } from "drizzle-orm";
 import { db } from "../index";
 import { job_matches, jobs } from "../schema";
 import type { JobMatch, Job } from "@postly/shared-types";
@@ -47,7 +47,9 @@ export const matchQueries = {
       })
       .from(job_matches)
       .innerJoin(jobs, eq(job_matches.job_id, jobs.id))
-      .where(eq(job_matches.user_id, userId))
+      .where(
+        and(eq(job_matches.user_id, userId), isNull(job_matches.deleted_at)),
+      )
       .orderBy(desc(job_matches.match_score), desc(job_matches.created_at))
       .limit(limit);
 
@@ -72,7 +74,11 @@ export const matchQueries = {
       .from(job_matches)
       .innerJoin(jobs, eq(job_matches.job_id, jobs.id))
       .where(
-        and(eq(job_matches.user_id, userId), eq(job_matches.is_saved, true)),
+        and(
+          eq(job_matches.user_id, userId),
+          eq(job_matches.is_saved, true),
+          isNull(job_matches.deleted_at),
+        ),
       )
       .orderBy(desc(job_matches.created_at))
       .limit(limit);
diff --git a/packages/database/src/queries/notifications.ts b/packages/database/src/queries/notifications.ts
index 9631780..4451714 100644
--- a/packages/database/src/queries/notifications.ts
+++ b/packages/database/src/queries/notifications.ts
@@ -1,100 +1,69 @@
-import { eq, desc, and } from "drizzle-orm";
+import { eq, desc } from "drizzle-orm";
 import { db } from "../index";
-import { email_notifications, notification_templates } from "../schema";
-import type {
-  NotificationStatus,
-  CreateNotificationTemplateInput,
-  CreateNotificationInput,
-} from "@postly/shared-types";
+import { notifications } from "../schema";
+import type { NotificationStatus } from "@postly/shared-types";
 
-export const notificationQueries = {
-  // Templates
-  async findTemplateBySlug(slug: string) {
-    const [result] = await db
-      .select()
-      .from(notification_templates)
-      .where(eq(notification_templates.slug, slug));
-
-    return result ?? null;
-  },
+export interface CreateNotificationInput {
+  user_id: string;
+  type?: string;
+  subject: string;
+  content: string;
+  to_email: string;
+  status?: NotificationStatus;
+}
 
-  async createTemplate(input: CreateNotificationTemplateInput) {
-    const [result] = await db
-      .insert(notification_templates)
-      .values(input)
-      .returning();
-
-    return result;
-  },
-
-  // Notifications
-  async createNotification(input: CreateNotificationInput) {
+export const notificationQueries = {
+  /**
+   * Create a notification record (log)
+   */
+  async create(input: CreateNotificationInput) {
     const [result] = await db
-      .insert(email_notifications)
-      .values({ ...input, status: "pending" })
+      .insert(notifications)
+      .values({ ...input, status: input.status || "pending" })
       .returning();
 
     return result;
   },
 
-  // Worker queue: fetch all pending notifications due for dispatch.
+  /**
+   * Worker queue: fetch all pending notifications.
+   */
   async findPending(limit = 100) {
     return db
-      .select({
-        notification: email_notifications,
-        template: {
-          html_body: notification_templates.html_body,
-          text_body: notification_templates.text_body,
-        },
-      })
-      .from(email_notifications)
-      .leftJoin(
-        notification_templates,
-        eq(email_notifications.template_id, notification_templates.id),
-      )
-      .where(and(eq(email_notifications.status, "pending")))
-      .orderBy(email_notifications.scheduled_at)
+      .select()
+      .from(notifications)
+      .where(eq(notifications.status, "pending"))
+      .orderBy(notifications.created_at)
       .limit(limit);
   },
 
+  /**
+   * Update notification status after sending.
+   */
   async updateStatus(
     id: string,
     status: NotificationStatus,
-    providerMessageId?: string,
     errorMessage?: string,
   ) {
     await db
-      .update(email_notifications)
+      .update(notifications)
       .set({
         status,
-        ...(providerMessageId && { provider_message_id: providerMessageId }),
         ...(errorMessage && { error_message: errorMessage }),
         ...(status === "sent" && { sent_at: new Date() }),
-        ...(status === "opened" && { opened_at: new Date() }),
       })
-      .where(eq(email_notifications.id, id));
-  },
-
-  async incrementRetryCount(id: string) {
-    const [existing] = await db
-      .select({ retry_count: email_notifications.retry_count })
-      .from(email_notifications)
-      .where(eq(email_notifications.id, id));
-
-    if (!existing) return;
-
-    await db
-      .update(email_notifications)
-      .set({ retry_count: (existing.retry_count ?? 0) + 1 })
-      .where(eq(email_notifications.id, id));
+      .where(eq(notifications.id, id));
   },
 
+  /**
+   * Fetch notification history for a user.
+   */
   async findByUser(userId: string, limit = 50) {
     return db
       .select()
-      .from(email_notifications)
-      .where(eq(email_notifications.user_id, userId))
-      .orderBy(desc(email_notifications.created_at))
+      .from(notifications)
+      .where(eq(notifications.user_id, userId))
+      .orderBy(desc(notifications.created_at))
       .limit(limit);
   },
 };
diff --git a/packages/database/src/queries/payments.ts b/packages/database/src/queries/payments.ts
index e572d88..791cdf7 100644
--- a/packages/database/src/queries/payments.ts
+++ b/packages/database/src/queries/payments.ts
@@ -27,6 +27,7 @@ export const paymentQueries = {
         subscription_id: resolvedSubId,
         ...input,
         currency: input.currency ?? "USD",
+        idempotency_key: input.idempotency_key,
       })
       .returning();
 
diff --git a/packages/database/src/queries/seeker_profiles.ts b/packages/database/src/queries/seeker_profiles.ts
index 24fa873..f876a88 100644
--- a/packages/database/src/queries/seeker_profiles.ts
+++ b/packages/database/src/queries/seeker_profiles.ts
@@ -1,4 +1,4 @@
-import { eq, sql, and } from "drizzle-orm";
+import { eq, sql, and, isNull } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm";
 import { db } from "../index";
 import { seeker_profiles } from "../schema";
@@ -38,7 +38,12 @@ export const seekerProfileQueries = {
     const [result] = await db
       .select()
       .from(seeker_profiles)
-      .where(eq(seeker_profiles.user_id, userId));
+      .where(
+        and(
+          eq(seeker_profiles.user_id, userId),
+          isNull(seeker_profiles.deleted_at),
+        ),
+      );
 
     return result ?? null;
   },
diff --git a/packages/database/src/queries/subscriptions.ts b/packages/database/src/queries/subscriptions.ts
index b636c1e..a5489c0 100644
--- a/packages/database/src/queries/subscriptions.ts
+++ b/packages/database/src/queries/subscriptions.ts
@@ -28,12 +28,22 @@ export const subscriptionQueries = {
 
   // Called by the DodoPayments webhook handler to create or update the subscription record.
   async upsertFromWebhook(userId: string, payload: DodoSubscriptionPayload) {
+    const data = {
+      user_id: userId,
+      dodo_subscription_id: payload.dodo_subscription_id,
+      dodo_customer_id: payload.dodo_customer_id,
+      plan: (payload.plan as SubscriptionPlan) || "seeker",
+      status: payload.status || "active",
+      current_period_end: payload.current_period_end,
+      updated_at: new Date(),
+    };
+
     const [result] = await db
       .insert(subscriptions)
-      .values({ user_id: userId, ...payload })
+      .values(data)
       .onConflictDoUpdate({
         target: [subscriptions.user_id],
-        set: { ...payload, updated_at: new Date() },
+        set: data,
       })
       .returning();
 
@@ -43,14 +53,13 @@ export const subscriptionQueries = {
   async updateStatus(
     userId: string,
     status: SubscriptionStatus,
-    accessUntil?: Date,
+    currentPeriodEnd?: Date,
   ) {
     const [result] = await db
       .update(subscriptions)
       .set({
         status,
-        ...(accessUntil && { access_until: accessUntil }),
-        ...(status === "cancelled" && { cancelled_at: new Date() }),
+        ...(currentPeriodEnd && { current_period_end: currentPeriodEnd }),
         updated_at: new Date(),
       })
       .where(eq(subscriptions.user_id, userId))
@@ -75,7 +84,7 @@ export const subscriptionQueries = {
     const sub = await this.findByUserId(userId);
     if (!sub) return false;
     if (sub.status !== "active" && sub.status !== "trialing") return false;
-    if (sub.access_until && new Date(sub.access_until) < new Date())
+    if (sub.current_period_end && new Date(sub.current_period_end) < new Date())
       return false;
     return true;
   },
diff --git a/packages/database/src/queries/users.ts b/packages/database/src/queries/users.ts
index fcf1144..3d1b7b3 100644
--- a/packages/database/src/queries/users.ts
+++ b/packages/database/src/queries/users.ts
@@ -1,21 +1,54 @@
-import { eq } from "drizzle-orm";
+import { eq, sql } from "drizzle-orm";
 import { db } from "../index";
-import { users } from "../schema";
-import type { User, CreateUserDbInput } from "@postly/shared-types";
+import {
+  users,
+  employer_profiles,
+  seeker_profiles,
+  otp_codes,
+} from "../schema";
+import type { User, CreateUserDbInput, UserRole } from "@postly/shared-types";
 
 export const userQueries = {
   /**
    * Create a new user
    */
   async create(input: CreateUserDbInput): Promise<User> {
-    const { email, password_hash, full_name, role = "job_seeker" } = input;
+    const { email, password_hash, full_name, roles = ["job_seeker"] } = input;
 
-    const [result] = await db
-      .insert(users)
-      .values({ email, password_hash, full_name, role })
-      .returning();
+    return db.transaction(async (tx) => {
+      // Generate DiceBear avatar URL
+      const seed = full_name || email.split("@")[0];
+      const avatar_url = `https://api.dicebear.com/9.x/dylan/svg?seed=${encodeURIComponent(seed)}`;
 
-    return result as unknown as User;
+      const [result] = await tx
+        .insert(users)
+        .values({ email, password_hash, full_name, roles, avatar_url })
+        .returning();
+
+      const user = result as unknown as User;
+
+      // Initialize profiles based on initial roles
+      if (roles.includes("employer")) {
+        await tx
+          .insert(employer_profiles)
+          .values({
+            user_id: user.id,
+            company_name: user.full_name || "My Company",
+          })
+          .onConflictDoNothing();
+      }
+
+      if (roles.includes("job_seeker")) {
+        await tx
+          .insert(seeker_profiles)
+          .values({
+            user_id: user.id,
+          })
+          .onConflictDoNothing();
+      }
+
+      return user;
+    });
   },
 
   /**
@@ -46,7 +79,9 @@ export const userQueries = {
    */
   async update(
     id: string,
-    updates: Partial<Pick<User, "full_name" | "role">>,
+    updates: Partial<
+      Pick<User, "full_name" | "roles" | "timezone" | "locale" | "avatar_url">
+    >,
   ): Promise<User | null> {
     if (Object.keys(updates).length === 0) {
       return this.findById(id);
@@ -154,4 +189,164 @@ export const userQueries = {
       .set({ last_login_at: new Date(), updated_at: new Date() })
       .where(eq(users.id, id));
   },
+  /**
+   * Fetch a user with all their role-specific profiles and configs.
+   */
+  async getDetailedProfile(id: string) {
+    return db.query.users.findFirst({
+      where: eq(users.id, id),
+      with: {
+        seeker_profile: true,
+        employer_profile: true,
+        bot_configs: true,
+        subscription: true,
+      },
+    });
+  },
+
+  /**
+   * Add a role to a user if they don't already have it.
+   */
+  async addRole(userId: string, role: string): Promise<boolean> {
+    const user = await this.findById(userId);
+    if (!user) return false;
+
+    const roles = user.roles as UserRole[];
+    if (roles.includes(role as UserRole)) return true;
+
+    const [result] = await db
+      .update(users)
+      .set({
+        roles: [...roles, role as UserRole],
+        updated_at: new Date(),
+      })
+      .where(eq(users.id, userId))
+      .returning({ id: users.id });
+
+    // Auto-create profiles if needed
+    if (role === "employer") {
+      await db
+        .insert(employer_profiles)
+        .values({
+          user_id: userId,
+          company_name: user.full_name || "My Company", // Default name
+        })
+        .onConflictDoNothing();
+    } else if (role === "job_seeker") {
+      await db
+        .insert(seeker_profiles)
+        .values({
+          user_id: userId,
+        })
+        .onConflictDoNothing();
+    }
+
+    return !!result;
+  },
+
+  /**
+   * Remove a role from a user.
+   */
+  async removeRole(userId: string, role: string): Promise<boolean> {
+    const user = await this.findById(userId);
+    if (!user) return false;
+
+    const roles = user.roles as UserRole[];
+    if (!roles.includes(role as UserRole)) return true;
+
+    const [result] = await db
+      .update(users)
+      .set({
+        roles: roles.filter((r) => r !== (role as UserRole)),
+        updated_at: new Date(),
+      })
+      .where(eq(users.id, userId))
+      .returning({ id: users.id });
+
+    return !!result;
+  },
+  /**
+   * Update user password
+   */
+  async updatePassword(id: string, passwordHash: string): Promise<boolean> {
+    const [result] = await db
+      .update(users)
+      .set({ password_hash: passwordHash, updated_at: new Date() })
+      .where(eq(users.id, id))
+      .returning({ id: users.id });
+
+    return !!result;
+  },
+};
+
+// ─── OTP Flow ──────────────────────────────────────────────────────────
+
+export const otpQueries = {
+  /**
+   * Create or update an OTP for a user.
+   */
+  async upsertOtp(
+    userId: string,
+    codeHash: string,
+    expiresAt: Date,
+  ): Promise<void> {
+    await db
+      .insert(otp_codes)
+      .values({
+        user_id: userId,
+        code_hash: codeHash,
+        expires_at: expiresAt,
+        attempts: 0,
+        last_attempt_at: null,
+      })
+      .onConflictDoUpdate({
+        target: otp_codes.user_id,
+        set: {
+          code_hash: codeHash,
+          expires_at: expiresAt,
+          attempts: 0,
+          last_attempt_at: null,
+          created_at: new Date(),
+        },
+      });
+  },
+
+  /**
+   * Find OTP for a user.
+   */
+  async findOtpByUserId(userId: string) {
+    return db.query.otp_codes.findFirst({
+      where: eq(otp_codes.user_id, userId),
+    });
+  },
+
+  /**
+   * Increment OTP attempt count.
+   */
+  async incrementOtpAttempts(otpId: string): Promise<void> {
+    await db
+      .update(otp_codes)
+      .set({
+        attempts: sql`${otp_codes.attempts} + 1`,
+        last_attempt_at: new Date(),
+      })
+      .where(eq(otp_codes.id, otpId));
+  },
+
+  /**
+   * Delete OTP after successful verification or expiry.
+   */
+  async deleteOtp(otpId: string): Promise<void> {
+    await db.delete(otp_codes).where(eq(otp_codes.id, otpId));
+  },
+
+  /**
+   * Mark user as verified.
+   */
+  async verifyUser(userId: string): Promise<void> {
+    await db
+      .update(users)
+      .set({ is_verified: true, updated_at: new Date() })
+      .where(eq(users.id, userId));
+  },
 };
diff --git a/packages/database/src/schema.ts b/packages/database/src/schema.ts
index 4ba2f67..e4483b9 100644
--- a/packages/database/src/schema.ts
+++ b/packages/database/src/schema.ts
@@ -21,6 +21,7 @@ export const userRoleEnum = pgEnum("user_role", [
   "job_seeker",
   "employer",
   "admin",
+  "discord_owner",
 ]);
 
 export const applicationStatusEnum = pgEnum("application_status", [
@@ -44,10 +45,9 @@ export const subscriptionStatusEnum = pgEnum("subscription_status", [
 ]);
 
 export const subscriptionPlanEnum = pgEnum("subscription_plan", [
-  "free",
   "seeker",
   "employer",
-  "enterprise",
+  "discord_owner",
 ]);
 
 export const paymentStatusEnum = pgEnum("payment_status", [
@@ -66,18 +66,13 @@ export const notificationStatusEnum = pgEnum("notification_status", [
   "opened",
 ]);
 
-export const integrationProviderEnum = pgEnum("integration_provider", [
-  "greenhouse",
-  "lever",
-  "workday",
-  "bamboohr",
-  "linkedin",
-  "indeed",
-  "custom",
+export const botPlatformEnum = pgEnum("bot_platform", [
+  "discord",
+  "reddit",
+  "twitter",
 ]);
 
-// ─── Users ────────────────────────────────────────────────────────────────────
-// Base auth table for all user types (job_seeker, employer, admin).
+// ─── Users & Auth ─────────────────────────────────────────────────────────────
 
 export const users = pgTable(
   "users",
@@ -87,49 +82,132 @@ export const users = pgTable(
     password_hash: varchar("password_hash", { length: 255 }),
     full_name: varchar("full_name", { length: 255 }),
     avatar_url: text("avatar_url"),
-    role: varchar("role", { length: 50 }).notNull().default("job_seeker"),
+    roles: userRoleEnum("roles").array().notNull().default(["job_seeker"]),
     is_verified: boolean("is_verified").default(false),
+    timezone: varchar("timezone", { length: 50 }),
+    locale: varchar("locale", { length: 20 }),
     password_reset_token: varchar("password_reset_token", { length: 255 }),
     password_reset_expires_at: timestamp("password_reset_expires_at", {
       withTimezone: true,
     }),
     last_login_at: timestamp("last_login_at", { withTimezone: true }),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
   },
   (table) => ({
     emailIdx: index("idx_users_email").on(table.email),
-    roleIdx: index("idx_users_role").on(table.role),
-    resetTokenIdx: index("idx_users_reset_token").on(
-      table.password_reset_token,
-    ),
+    rolesIdx: index("idx_users_role").on(table.roles),
   }),
 );
 
-// ─── Discord ──────────────────────────────────────────────────────────────────
-// Discord guild/channel configuration linked to a user.
+export const sessions = pgTable("sessions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  user_id: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  token_hash: varchar("token_hash", { length: 255 }).notNull().unique(),
+  ip_address: varchar("ip_address", { length: 45 }),
+  user_agent: text("user_agent"),
+  last_active_at: timestamp("last_active_at", {
+    withTimezone: true,
+  }).defaultNow(),
+  expires_at: timestamp("expires_at", { withTimezone: true }).notNull(),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+export const otp_codes = pgTable(
+  "otp_codes",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    user_id: uuid("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" })
+      .unique(),
+    code_hash: varchar("code_hash", { length: 255 }).notNull(),
+    expires_at: timestamp("expires_at", { withTimezone: true }).notNull(),
+    attempts: integer("attempts").default(0).notNull(),
+    last_attempt_at: timestamp("last_attempt_at", { withTimezone: true }),
+    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  },
+  (table) => ({
+    userIdIdx: index("idx_otp_user").on(table.user_id),
+  }),
+);
 
-export const discord_configs = pgTable(
-  "discord_configs",
+// ─── Profiles ─────────────────────────────────────────────────────────────────
+
+export const seeker_profiles = pgTable(
+  "seeker_profiles",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    guild_id: varchar("guild_id", { length: 255 }).notNull().unique(),
-    channel_id: varchar("channel_id", { length: 255 }),
     user_id: uuid("user_id")
       .notNull()
+      .unique()
       .references(() => users.id, { onDelete: "cascade" }),
-    is_active: boolean("is_active").default(true),
+    headline: varchar("headline", { length: 500 }),
+    summary: text("summary"),
+    skills: jsonb("skills"),
+    experience_years: integer("experience_years"),
+    experience_level: varchar("experience_level", { length: 50 }),
+    education: jsonb("education"),
+    certifications: jsonb("certifications"),
+    languages: jsonb("languages"),
+    work_history: jsonb("work_history"),
+    desired_job_titles: jsonb("desired_job_titles"),
+    desired_locations: jsonb("desired_locations"),
+    desired_salary_min: decimal("desired_salary_min", {
+      precision: 10,
+      scale: 2,
+    }),
+    desired_salary_max: decimal("desired_salary_max", {
+      precision: 10,
+      scale: 2,
+    }),
+    desired_job_type: varchar("desired_job_type", { length: 50 }),
+    open_to_remote: boolean("open_to_remote").default(true),
+    open_to_relocation: boolean("open_to_relocation").default(false),
+    embedding: vector("embedding", { dimensions: 1024 }),
+    prompt_history_summary: text("prompt_history_summary"),
+    last_parsed_at: timestamp("last_parsed_at", { withTimezone: true }),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => ({
-    guildIdx: index("idx_discord_guild").on(table.guild_id),
-    userIdIdx: index("idx_discord_user").on(table.user_id),
+    userIdIdx: index("idx_seeker_profiles_user").on(table.user_id),
   }),
 );
 
-// ─── Resumes ──────────────────────────────────────────────────────────────────
-// Raw resume files plus parsed content and vector embedding for AI search.
+export const employer_profiles = pgTable(
+  "employer_profiles",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    user_id: uuid("user_id")
+      .notNull()
+      .unique()
+      .references(() => users.id, { onDelete: "cascade" }),
+    company_name: varchar("company_name", { length: 255 }).notNull(),
+    company_website: text("company_website"),
+    company_logo_url: text("company_logo_url"),
+    company_description: text("company_description"),
+    company_size: varchar("company_size", { length: 50 }),
+    industry: varchar("industry", { length: 150 }),
+    headquarters_location: varchar("headquarters_location", { length: 255 }),
+    social_links: jsonb("social_links"),
+    embedding: vector("embedding", { dimensions: 1024 }),
+    active_job_count: integer("active_job_count").default(0),
+    is_verified: boolean("is_verified").default(false),
+    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
+  },
+  (table) => ({
+    userIdIdx: index("idx_employer_profiles_user").on(table.user_id),
+  }),
+);
+
+// ─── Resumes & Jobs ───────────────────────────────────────────────────────────
 
 export const resumes = pgTable(
   "resumes",
@@ -145,15 +223,13 @@ export const resumes = pgTable(
     experience_years: integer("experience_years"),
     education: jsonb("education"),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => ({
     userIdIdx: index("idx_resumes_user").on(table.user_id),
   }),
 );
 
-// ─── Jobs ─────────────────────────────────────────────────────────────────────
-// Job postings from employers or imported from external sources.
-
 export const jobs = pgTable(
   "jobs",
   {
@@ -166,7 +242,7 @@ export const jobs = pgTable(
     salary_max: decimal("salary_max", { precision: 10, scale: 2 }),
     job_type: varchar("job_type", { length: 50 }),
     remote: boolean("remote").default(false),
-    source: varchar("source", { length: 100 }).notNull(),
+    source: varchar("source", { length: 100 }).notNull(), // 'internal' or origin (e.g. 'indeed')
     source_url: text("source_url"),
     embedding: vector("embedding", { dimensions: 1024 }),
     skills_required: jsonb("skills_required"),
@@ -174,21 +250,19 @@ export const jobs = pgTable(
     posted_at: timestamp("posted_at", { withTimezone: true }),
     expires_at: timestamp("expires_at", { withTimezone: true }),
     is_active: boolean("is_active").default(true),
-    employer_id: uuid("employer_id").references(() => users.id),
+    employer_id: uuid("employer_id").references(() => users.id), // Nullable for scraped jobs
+    external_job_id: varchar("external_job_id", { length: 255 }),
+    fingerprint: varchar("fingerprint", { length: 64 }),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => ({
     companyIdx: index("idx_jobs_company").on(table.company_name),
-    locationIdx: index("idx_jobs_location").on(table.location),
-    remoteIdx: index("idx_jobs_remote").on(table.remote),
-    jobTypeIdx: index("idx_jobs_type").on(table.job_type),
+    activeIdx: index("idx_jobs_active").on(table.is_active),
   }),
 );
 
-// ─── Job Matches ──────────────────────────────────────────────────────────────
-// AI-generated match scores between a seeker's resume and a job posting.
-
 export const job_matches = pgTable(
   "job_matches",
   {
@@ -207,105 +281,15 @@ export const job_matches = pgTable(
     is_saved: boolean("is_saved").default(false),
     applied: boolean("applied").default(false),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => ({
-    userIdIdx: index("idx_job_matches_user").on(
-      table.user_id,
-      table.match_score,
-    ),
-    jobIdIdx: index("idx_job_matches_job").on(table.job_id),
     uniqueMatch: unique().on(table.user_id, table.job_id),
   }),
 );
 
-// ─── Employer Profiles ────────────────────────────────────────────────────────
-// Extended company details for users with role = 'employer'.
-
-export const employer_profiles = pgTable(
-  "employer_profiles",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    user_id: uuid("user_id")
-      .notNull()
-      .unique()
-      .references(() => users.id, { onDelete: "cascade" }),
-    company_name: varchar("company_name", { length: 255 }).notNull(),
-    company_website: text("company_website"),
-    company_logo_url: text("company_logo_url"),
-    company_description: text("company_description"),
-    company_size: varchar("company_size", { length: 50 }),
-    industry: varchar("industry", { length: 150 }),
-    headquarters_location: varchar("headquarters_location", { length: 255 }),
-    social_links: jsonb("social_links"),
-    embedding: vector("embedding", { dimensions: 1024 }),
-    active_job_count: integer("active_job_count").default(0),
-    is_verified: boolean("is_verified").default(false),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    userIdIdx: index("idx_employer_profiles_user").on(table.user_id),
-    companyNameIdx: index("idx_employer_profiles_company").on(
-      table.company_name,
-    ),
-    industryIdx: index("idx_employer_profiles_industry").on(table.industry),
-  }),
-);
-
-// ─── Seeker Profiles ──────────────────────────────────────────────────────────
-// Extended profile for job seekers with parsed resume data, preferences, and
-// a vector embedding for natural-language job matching and email alerts.
-
-export const seeker_profiles = pgTable(
-  "seeker_profiles",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    user_id: uuid("user_id")
-      .notNull()
-      .unique()
-      .references(() => users.id, { onDelete: "cascade" }),
-    headline: varchar("headline", { length: 500 }),
-    summary: text("summary"),
-    skills: jsonb("skills"),
-    experience_years: integer("experience_years"),
-    experience_level: varchar("experience_level", { length: 50 }),
-    education: jsonb("education"),
-    certifications: jsonb("certifications"),
-    languages: jsonb("languages"),
-    work_history: jsonb("work_history"),
-    desired_job_titles: jsonb("desired_job_titles"),
-    desired_locations: jsonb("desired_locations"),
-    desired_salary_min: decimal("desired_salary_min", {
-      precision: 10,
-      scale: 2,
-    }),
-    desired_salary_max: decimal("desired_salary_max", {
-      precision: 10,
-      scale: 2,
-    }),
-    desired_job_type: varchar("desired_job_type", { length: 50 }),
-    open_to_remote: boolean("open_to_remote").default(true),
-    open_to_relocation: boolean("open_to_relocation").default(false),
-    embedding: vector("embedding", { dimensions: 1024 }),
-    prompt_history_summary: text("prompt_history_summary"),
-    last_parsed_at: timestamp("last_parsed_at", { withTimezone: true }),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    userIdIdx: index("idx_seeker_profiles_user").on(table.user_id),
-    experienceLevelIdx: index("idx_seeker_profiles_level").on(
-      table.experience_level,
-    ),
-    jobTypeIdx: index("idx_seeker_profiles_job_type").on(
-      table.desired_job_type,
-    ),
-  }),
-);
-
 // ─── Applications ─────────────────────────────────────────────────────────────
-// Tracks every job application submitted by a seeker, including full status
-// lifecycle and a JSONB audit trail of every status change.
+// ONLY for jobs generated on our platform (where employer_id is NOT NULL)
 
 export const applications = pgTable(
   "applications",
@@ -319,288 +303,229 @@ export const applications = pgTable(
       .references(() => jobs.id, { onDelete: "cascade" }),
     resume_id: uuid("resume_id").references(() => resumes.id),
     status: applicationStatusEnum("status").notNull().default("applied"),
-    status_history: jsonb("status_history").notNull().default([]),
     cover_letter: text("cover_letter"),
     notes: text("notes"),
-    external_url: text("external_url"),
-    contact_info: jsonb("contact_info"),
-    next_interview_at: timestamp("next_interview_at", { withTimezone: true }),
-    offer_details: jsonb("offer_details"),
-    match_score: decimal("match_score", { precision: 5, scale: 2 }),
-    ai_explanation: text("ai_explanation"),
     applied_at: timestamp("applied_at", { withTimezone: true }).defaultNow(),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
   },
   (table) => ({
-    seekerStatusIdx: index("idx_applications_seeker_status").on(
-      table.seeker_id,
-      table.status,
-    ),
-    jobPipelineIdx: index("idx_applications_job_pipeline").on(
-      table.job_id,
-      table.created_at,
-    ),
     seekerJobUnique: unique().on(table.seeker_id, table.job_id),
   }),
 );
 
-// ─── Career Site Integrations ─────────────────────────────────────────────────
-// Employer-owned OAuth/API connections to external job boards for job import sync.
-
-export const career_site_integrations = pgTable(
-  "career_site_integrations",
+export const application_status_history = pgTable(
+  "application_status_history",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    employer_id: uuid("employer_id")
+    application_id: uuid("application_id")
       .notNull()
-      .references(() => users.id, { onDelete: "cascade" }),
-    provider: integrationProviderEnum("provider").notNull(),
-    label: varchar("label", { length: 255 }),
-    access_token: text("access_token"),
-    refresh_token: text("refresh_token"),
-    token_expires_at: timestamp("token_expires_at", { withTimezone: true }),
-    api_key: text("api_key"),
-    provider_config: jsonb("provider_config"),
-    is_active: boolean("is_active").default(true),
-    sync_interval_minutes: integer("sync_interval_minutes").default(60),
-    last_synced_at: timestamp("last_synced_at", { withTimezone: true }),
-    next_sync_at: timestamp("next_sync_at", { withTimezone: true }),
-    last_sync_job_count: integer("last_sync_job_count").default(0),
-    last_sync_error: text("last_sync_error"),
+      .references(() => applications.id, { onDelete: "cascade" }),
+    from_status: applicationStatusEnum("from_status"),
+    to_status: applicationStatusEnum("to_status").notNull(),
+    changed_by: uuid("changed_by").references(() => users.id),
+    note: text("note"),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
   },
-  (table) => ({
-    employerIdx: index("idx_integrations_employer").on(table.employer_id),
-    syncQueueIdx: index("idx_integrations_sync_queue").on(
-      table.is_active,
-      table.next_sync_at,
-    ),
-    employerProviderUnique: unique().on(table.employer_id, table.provider),
-  }),
 );
 
-// ─── Conversations ────────────────────────────────────────────────────────────
-// Chat sessions between a user and the AI, optionally grounded to a resume.
-
-export const conversations = pgTable(
-  "conversations",
+// ─── AI Conversations ─────────────────────────────────────────────────────────
+
+export const system_prompts = pgTable("system_prompts", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  version: integer("version").notNull(),
+  slug: varchar("slug", { length: 100 }).notNull(),
+  content: text("content").notNull(),
+  is_active: boolean("is_active").default(false),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+export const conversations = pgTable("conversations", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  user_id: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  title: varchar("title", { length: 255 }),
+  resume_id: uuid("resume_id").references(() => resumes.id),
+  model: varchar("model", { length: 100 }),
+  is_archived: boolean("is_archived").default(false),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});
+
+export const messages = pgTable("messages", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  conversation_id: uuid("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  role: varchar("role", { length: 50 }).notNull(),
+  content: text("content").notNull(),
+  tokens_used: integer("tokens_used"),
+  metadata: jsonb("metadata"),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+// ─── Bots & Social ────────────────────────────────────────────────────────────
+
+export const bot_configs = pgTable(
+  "bot_configs",
   {
     id: uuid("id").primaryKey().defaultRandom(),
     user_id: uuid("user_id")
       .notNull()
       .references(() => users.id, { onDelete: "cascade" }),
-    title: varchar("title", { length: 255 }),
-    resume_id: uuid("resume_id").references(() => resumes.id),
-    model: varchar("model", { length: 100 }),
-    is_archived: boolean("is_archived").default(false),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-    updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    userIdIdx: index("idx_conversations_user").on(
-      table.user_id,
-      table.updated_at,
-    ),
-    archivedIdx: index("idx_conversations_archived").on(
-      table.user_id,
-      table.is_archived,
-    ),
-  }),
-);
-
-// ─── Messages ─────────────────────────────────────────────────────────────────
-// Individual messages within a conversation. Supports branching via parent_message_id
-// and edit versioning; only the active branch is rendered to the user.
+    platform: botPlatformEnum("platform").notNull(),
 
-export const messages = pgTable(
-  "messages",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    conversation_id: uuid("conversation_id")
-      .notNull()
-      .references(() => conversations.id, { onDelete: "cascade" }),
-    role: varchar("role", { length: 50 }).notNull(),
-    content: text("content").notNull(),
-    metadata: jsonb("metadata"),
-    parent_message_id: uuid("parent_message_id"),
-    version: integer("version").notNull().default(1),
-    is_active: boolean("is_active").notNull().default(true),
-    status: varchar("status", { length: 20 }).notNull().default("completed"),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    conversationIdIdx: index("idx_messages_conversation").on(
-      table.conversation_id,
-      table.created_at,
-    ),
-    parentIdx: index("idx_messages_parent").on(table.parent_message_id),
-    activeIdx: index("idx_messages_active").on(
-      table.conversation_id,
-      table.is_active,
-    ),
-  }),
-);
-
-// ─── Message Attachments ──────────────────────────────────────────────────────
-// Files uploaded alongside a message (e.g. resumes, documents).
+    // Detailed Configuration
+    is_active: boolean("is_active").default(true),
 
-export const message_attachments = pgTable(
-  "message_attachments",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    message_id: uuid("message_id")
-      .notNull()
-      .references(() => messages.id, { onDelete: "cascade" }),
-    file_url: text("file_url").notNull(),
-    file_name: varchar("file_name", { length: 255 }).notNull(),
-    file_type: varchar("file_type", { length: 100 }),
-    file_size: integer("file_size"),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    messageIdIdx: index("idx_attachments_message").on(table.message_id),
-  }),
-);
+    // Platform Auth (Stored as JSON for flexibility, or encrypted)
+    credentials: jsonb("credentials"),
 
-// ─── Subscriptions ────────────────────────────────────────────────────────────
-// DodoPayments subscription record per user. Controls plan access and feature gating.
+    // Target Destination (e.g. Channel ID for Discord, Subreddit for Reddit)
+    target_id: varchar("target_id", { length: 255 }),
+    target_name: varchar("target_name", { length: 255 }),
+    webhook_url: text("webhook_url"),
 
-export const subscriptions = pgTable(
-  "subscriptions",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    user_id: uuid("user_id")
-      .notNull()
-      .unique()
-      .references(() => users.id, { onDelete: "cascade" }),
-    plan: subscriptionPlanEnum("plan").notNull().default("free"),
-    status: subscriptionStatusEnum("status").notNull().default("active"),
-    dodo_customer_id: varchar("dodo_customer_id", { length: 255 }),
-    dodo_subscription_id: varchar("dodo_subscription_id", {
-      length: 255,
-    }).unique(),
-    dodo_product_id: varchar("dodo_product_id", { length: 255 }),
-    current_period_start: timestamp("current_period_start", {
-      withTimezone: true,
+    // Filtering Details: "What type of jobs they want"
+    filter_keywords: varchar("filter_keywords", { length: 500 }), // comma separated
+    filter_locations: varchar("filter_locations", { length: 500 }),
+    filter_min_salary: decimal("filter_min_salary", {
+      precision: 10,
+      scale: 2,
     }),
-    current_period_end: timestamp("current_period_end", { withTimezone: true }),
-    trial_ends_at: timestamp("trial_ends_at", { withTimezone: true }),
-    cancelled_at: timestamp("cancelled_at", { withTimezone: true }),
-    access_until: timestamp("access_until", { withTimezone: true }),
-    raw_data: jsonb("raw_data"),
+    filter_job_types: varchar("filter_job_types", { length: 255 }).array(),
+
+    last_post_at: timestamp("last_post_at", { withTimezone: true }),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
   },
-  (table) => ({
-    userIdx: index("idx_subscriptions_user").on(table.user_id),
-    statusIdx: index("idx_subscriptions_status").on(table.status),
-    dodoSubIdx: index("idx_subscriptions_dodo_sub").on(
-      table.dodo_subscription_id,
-    ),
-    periodEndIdx: index("idx_subscriptions_period_end").on(
-      table.current_period_end,
-    ),
+  (t) => ({
+    userPlatformUnique: unique().on(t.user_id, t.platform),
   }),
 );
 
-// ─── Payments ─────────────────────────────────────────────────────────────────
-// Immutable DodoPayments event ledger. One row per webhook event, never mutated.
-
-export const payments = pgTable(
-  "payments",
+export const discord_configs = pgTable(
+  "discord_configs",
   {
     id: uuid("id").primaryKey().defaultRandom(),
+    guild_id: varchar("guild_id", { length: 255 }).notNull().unique(),
+    channel_id: varchar("channel_id", { length: 255 }),
     user_id: uuid("user_id")
       .notNull()
       .references(() => users.id, { onDelete: "cascade" }),
-    subscription_id: uuid("subscription_id").references(() => subscriptions.id),
-    dodo_payment_id: varchar("dodo_payment_id", { length: 255 }).unique(),
-    dodo_customer_id: varchar("dodo_customer_id", { length: 255 }),
-    event_type: varchar("event_type", { length: 100 }).notNull(),
-    status: paymentStatusEnum("status").notNull(),
-    amount: integer("amount").notNull(),
-    currency: varchar("currency", { length: 10 }).notNull().default("USD"),
-    raw_payload: jsonb("raw_payload"),
-    paid_at: timestamp("paid_at", { withTimezone: true }),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    userIdx: index("idx_payments_user").on(table.user_id, table.created_at),
-    dodoPaymentIdx: index("idx_payments_dodo_payment").on(
-      table.dodo_payment_id,
-    ),
-    statusIdx: index("idx_payments_status").on(table.status),
-  }),
-);
-
-// ─── Notification Templates ───────────────────────────────────────────────────
-// Reusable Handlebars-style email templates keyed by a unique slug.
-
-export const notification_templates = pgTable(
-  "notification_templates",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    slug: varchar("slug", { length: 100 }).notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
-    subject: varchar("subject", { length: 500 }).notNull(),
-    html_body: text("html_body").notNull(),
-    text_body: text("text_body"),
-    metadata: jsonb("metadata"),
     is_active: boolean("is_active").default(true),
     created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
     updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
   },
   (table) => ({
-    slugIdx: index("idx_notif_templates_slug").on(table.slug),
+    guildIdx: index("idx_discord_guild").on(table.guild_id),
   }),
 );
 
-// ─── Email Notifications ──────────────────────────────────────────────────────
-// Per-user email dispatch log for job alerts and transactional emails.
-
-export const email_notifications = pgTable(
-  "email_notifications",
+export const bot_posts = pgTable("bot_posts", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  bot_config_id: uuid("bot_config_id")
+    .notNull()
+    .references(() => bot_configs.id, { onDelete: "cascade" }),
+  job_id: uuid("job_id").references(() => jobs.id, { onDelete: "set null" }),
+  external_post_id: varchar("external_post_id", { length: 255 }),
+  status: varchar("status", { length: 30 }).default("sent"),
+  error_message: text("error_message"),
+  posted_at: timestamp("posted_at", { withTimezone: true }).defaultNow(),
+});
+
+// ─── Billing ──────────────────────────────────────────────────────────────────
+
+export const subscriptions = pgTable("subscriptions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  user_id: uuid("user_id")
+    .notNull()
+    .unique()
+    .references(() => users.id, { onDelete: "cascade" }),
+  plan: subscriptionPlanEnum("plan").notNull(),
+  status: subscriptionStatusEnum("status").notNull().default("active"),
+  dodo_subscription_id: varchar("dodo_subscription_id", {
+    length: 255,
+  }).unique(),
+  dodo_customer_id: varchar("dodo_customer_id", { length: 255 }),
+  current_period_start: timestamp("current_period_start", {
+    withTimezone: true,
+  }),
+  current_period_end: timestamp("current_period_end", { withTimezone: true }),
+  cancelled_at: timestamp("cancelled_at", { withTimezone: true }),
+  raw_data: jsonb("raw_data"),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updated_at: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});
+
+export const payments = pgTable("payments", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  user_id: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  subscription_id: uuid("subscription_id").references(() => subscriptions.id),
+  dodo_payment_id: varchar("dodo_payment_id", { length: 255 }),
+  dodo_customer_id: varchar("dodo_customer_id", { length: 255 }),
+  event_type: varchar("event_type", { length: 100 }),
+  amount: integer("amount").notNull(),
+  currency: varchar("currency", { length: 10 }).notNull().default("USD"),
+  status: paymentStatusEnum("status").notNull(),
+  paid_at: timestamp("paid_at", { withTimezone: true }),
+  raw_payload: jsonb("raw_payload"),
+  idempotency_key: varchar("idempotency_key", { length: 255 }),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+// ─── Notifications ────────────────────────────────────────────────────────────
+
+export const notifications = pgTable("notifications", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  user_id: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  type: varchar("type", { length: 100 }), // e.g. 'job_alert', 'welcome'
+  subject: varchar("subject", { length: 500 }).notNull(),
+  content: text("content").notNull(), // HTML or Text body
+  to_email: varchar("to_email", { length: 255 }).notNull(),
+  status: notificationStatusEnum("status").notNull().default("pending"),
+  sent_at: timestamp("sent_at", { withTimezone: true }),
+  error_message: text("error_message"),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+// ─── System ───────────────────────────────────────────────────────────────────
+
+export const audit_log = pgTable("audit_log", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  actor_id: uuid("actor_id").references(() => users.id),
+  action: varchar("action", { length: 100 }).notNull(),
+  entity_type: varchar("entity_type", { length: 100 }),
+  entity_id: uuid("entity_id"),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+});
+
+export const token_usage = pgTable(
+  "token_usage",
   {
     id: uuid("id").primaryKey().defaultRandom(),
     user_id: uuid("user_id")
       .notNull()
       .references(() => users.id, { onDelete: "cascade" }),
-    template_id: uuid("template_id").references(
-      () => notification_templates.id,
-    ),
-    to_email: varchar("to_email", { length: 255 }).notNull(),
-    subject: varchar("subject", { length: 500 }).notNull(),
-    status: notificationStatusEnum("status").notNull().default("pending"),
-    template_variables: jsonb("template_variables"),
-    job_ids: jsonb("job_ids"),
-    provider_message_id: varchar("provider_message_id", { length: 255 }),
-    error_message: text("error_message"),
-    retry_count: integer("retry_count").default(0),
-    scheduled_at: timestamp("scheduled_at", { withTimezone: true }),
-    sent_at: timestamp("sent_at", { withTimezone: true }),
-    opened_at: timestamp("opened_at", { withTimezone: true }),
-    created_at: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    window_start: timestamp("window_start", { withTimezone: true }).notNull(),
+    tokens_used: integer("tokens_used").notNull().default(0),
   },
   (table) => ({
-    pendingQueueIdx: index("idx_email_notif_pending").on(
-      table.status,
-      table.scheduled_at,
-    ),
-    userIdx: index("idx_email_notif_user").on(table.user_id, table.created_at),
-    templateIdx: index("idx_email_notif_template").on(table.template_id),
+    uniqueWindow: unique().on(table.user_id, table.window_start),
   }),
 );
 
 // ─── Relations ────────────────────────────────────────────────────────────────
-// Declared after all tables to avoid forward-reference errors.
 
 export const usersRelations = relations(users, ({ one, many }) => ({
   resumes: many(resumes),
   conversations: many(conversations),
   job_matches: many(job_matches),
-  discord_configs: many(discord_configs),
   employer_profile: one(employer_profiles, {
     fields: [users.id],
     references: [employer_profiles.user_id],
@@ -615,26 +540,33 @@ export const usersRelations = relations(users, ({ one, many }) => ({
     references: [subscriptions.user_id],
   }),
   payments: many(payments),
-  email_notifications: many(email_notifications),
-  career_site_integrations: many(career_site_integrations),
+  sessions: many(sessions),
+  bot_configs: many(bot_configs),
+  notifications: many(notifications),
+  audit_logs: many(audit_log),
+  token_usage: many(token_usage),
 }));
 
-export const discordConfigsRelations = relations(
-  discord_configs,
+export const seekerProfilesRelations = relations(
+  seeker_profiles,
   ({ one }) => ({
     user: one(users, {
-      fields: [discord_configs.user_id],
+      fields: [seeker_profiles.user_id],
       references: [users.id],
     }),
   }),
 );
 
-export const resumesRelations = relations(resumes, ({ one }) => ({
-  user: one(users, {
-    fields: [resumes.user_id],
-    references: [users.id],
+export const employerProfilesRelations = relations(
+  employer_profiles,
+  ({ one, many }) => ({
+    user: one(users, {
+      fields: [employer_profiles.user_id],
+      references: [users.id],
+    }),
+    jobs: many(jobs),
   }),
-}));
+);
 
 export const jobsRelations = relations(jobs, ({ one, many }) => ({
   employer: one(users, {
@@ -660,58 +592,31 @@ export const jobMatchesRelations = relations(job_matches, ({ one }) => ({
   }),
 }));
 
-export const employerProfilesRelations = relations(
-  employer_profiles,
+export const applicationsRelations = relations(
+  applications,
   ({ one, many }) => ({
-    user: one(users, {
-      fields: [employer_profiles.user_id],
+    seeker: one(users, {
+      fields: [applications.seeker_id],
       references: [users.id],
     }),
-    jobs: many(jobs),
-    career_site_integrations: many(career_site_integrations),
-  }),
-);
-
-export const seekerProfilesRelations = relations(
-  seeker_profiles,
-  ({ one, many }) => ({
-    user: one(users, {
-      fields: [seeker_profiles.user_id],
-      references: [users.id],
+    job: one(jobs, {
+      fields: [applications.job_id],
+      references: [jobs.id],
     }),
-    applications: many(applications),
+    resume: one(resumes, {
+      fields: [applications.resume_id],
+      references: [resumes.id],
+    }),
+    status_history: many(application_status_history),
   }),
 );
 
-export const applicationsRelations = relations(applications, ({ one }) => ({
-  seeker: one(users, {
-    fields: [applications.seeker_id],
-    references: [users.id],
-  }),
-  job: one(jobs, {
-    fields: [applications.job_id],
-    references: [jobs.id],
-  }),
-  resume: one(resumes, {
-    fields: [applications.resume_id],
-    references: [resumes.id],
-  }),
-  seeker_profile: one(seeker_profiles, {
-    fields: [applications.seeker_id],
-    references: [seeker_profiles.user_id],
-  }),
-}));
-
-export const careerSiteIntegrationsRelations = relations(
-  career_site_integrations,
+export const applicationStatusHistoryRelations = relations(
+  application_status_history,
   ({ one }) => ({
-    employer: one(users, {
-      fields: [career_site_integrations.employer_id],
-      references: [users.id],
-    }),
-    employer_profile: one(employer_profiles, {
-      fields: [career_site_integrations.employer_id],
-      references: [employer_profiles.user_id],
+    application: one(applications, {
+      fields: [application_status_history.application_id],
+      references: [applications.id],
     }),
   }),
 );
@@ -731,29 +636,31 @@ export const conversationsRelations = relations(
   }),
 );
 
-export const messagesRelations = relations(messages, ({ one, many }) => ({
+export const messagesRelations = relations(messages, ({ one }) => ({
   conversation: one(conversations, {
     fields: [messages.conversation_id],
     references: [conversations.id],
   }),
-  parent: one(messages, {
-    fields: [messages.parent_message_id],
-    references: [messages.id],
-    relationName: "message_parent",
+}));
+
+export const botConfigsRelations = relations(bot_configs, ({ one, many }) => ({
+  user: one(users, {
+    fields: [bot_configs.user_id],
+    references: [users.id],
   }),
-  children: many(messages, { relationName: "message_parent" }),
-  attachments: many(message_attachments),
+  posts: many(bot_posts),
 }));
 
-export const messageAttachmentsRelations = relations(
-  message_attachments,
-  ({ one }) => ({
-    message: one(messages, {
-      fields: [message_attachments.message_id],
-      references: [messages.id],
-    }),
+export const botPostsRelations = relations(bot_posts, ({ one }) => ({
+  config: one(bot_configs, {
+    fields: [bot_posts.bot_config_id],
+    references: [bot_configs.id],
   }),
-);
+  job: one(jobs, {
+    fields: [bot_posts.job_id],
+    references: [jobs.id],
+  }),
+}));
 
 export const subscriptionsRelations = relations(subscriptions, ({ one }) => ({
   user: one(users, {
@@ -773,23 +680,16 @@ export const paymentsRelations = relations(payments, ({ one }) => ({
   }),
 }));
 
-export const notificationTemplatesRelations = relations(
-  notification_templates,
-  ({ many }) => ({
-    email_notifications: many(email_notifications),
+export const notificationsRelations = relations(notifications, ({ one }) => ({
+  user: one(users, {
+    fields: [notifications.user_id],
+    references: [users.id],
   }),
-);
+}));
 
-export const emailNotificationsRelations = relations(
-  email_notifications,
-  ({ one }) => ({
-    user: one(users, {
-      fields: [email_notifications.user_id],
-      references: [users.id],
-    }),
-    template: one(notification_templates, {
-      fields: [email_notifications.template_id],
-      references: [notification_templates.id],
-    }),
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+  user: one(users, {
+    fields: [sessions.user_id],
+    references: [users.id],
   }),
-);
+}));
diff --git a/packages/logger/src/index.ts b/packages/logger/src/index.ts
index b673129..ff43402 100644
--- a/packages/logger/src/index.ts
+++ b/packages/logger/src/index.ts
@@ -2,43 +2,84 @@ import winston from "winston";
 
 const { combine, timestamp, printf, colorize, errors } = winston.format;
 
-// Custom log format
-const logFormat = printf(({ level, message, timestamp, stack }) => {
+// Custom log format for development
+const devFormat = printf(({ level, message, timestamp, stack }) => {
   return `${timestamp} [${level}]: ${stack || message}`;
 });
 
+interface LogInfo {
+  level: string;
+  message: string;
+  timestamp?: string;
+  stack?: string;
+  req?: {
+    method?: string;
+    url?: string;
+    headers?: {
+      authorization?: string;
+    };
+  };
+  body?: {
+    password?: string;
+    token?: string;
+  };
+  [key: string]: unknown;
+}
+
+// Redact sensitive fields from logs
+const redactSensitive = winston.format((info) => {
+  const data = info as unknown as LogInfo;
+  if (data.req?.headers?.authorization) {
+    data.req.headers.authorization = "[REDACTED]";
+  }
+  if (data.body?.password) {
+    data.body.password = "[REDACTED]";
+  }
+  if (data.body?.token) {
+    data.body.token = "[REDACTED]";
+  }
+  return info;
+});
+
 // Create logger instance
 export const logger = winston.createLogger({
   level: process.env.LOG_LEVEL || "info",
+  defaultMeta: {
+    service: process.env.SERVICE_NAME || "unknown-service",
+    env: process.env.NODE_ENV || "development",
+  },
   format: combine(
     errors({ stack: true }),
+    redactSensitive(),
     timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-    logFormat,
   ),
-  transports: [
-    // Console transport with colors
+  transports: [],
+});
+
+// Production: structured JSON to stdout (for Loki/Promtail to pick up)
+if (process.env.NODE_ENV === "production") {
+  logger.add(
+    new winston.transports.Console({
+      format: combine(timestamp(), winston.format.json()),
+    }),
+  );
+} else {
+  // Development: colorized human-readable output + file logs
+  logger.add(
     new winston.transports.Console({
-      format: combine(colorize(), logFormat),
+      format: combine(colorize(), devFormat),
     }),
-    // File transport for errors
+  );
+  logger.add(
     new winston.transports.File({
       filename: "logs/error.log",
       level: "error",
     }),
-    // File transport for all logs
+  );
+  logger.add(
     new winston.transports.File({
       filename: "logs/combined.log",
     }),
-  ],
-});
-
-// Production environment: disable console colors, enable JSON format
-if (process.env.NODE_ENV === "production") {
-  logger.clear();
-  logger.add(
-    new winston.transports.Console({
-      format: combine(timestamp(), winston.format.json()),
-    }),
   );
 }
 
diff --git a/packages/shared-types/src/domain.ts b/packages/shared-types/src/domain.ts
index f776162..695637b 100644
--- a/packages/shared-types/src/domain.ts
+++ b/packages/shared-types/src/domain.ts
@@ -24,13 +24,6 @@ export interface Application {
   status: ApplicationStatus;
   status_history: StatusHistoryEntry[];
   cover_letter?: string | null;
-  notes?: string | null;
-  external_url?: string | null;
-  contact_info?: unknown;
-  next_interview_at?: Date | null;
-  offer_details?: unknown;
-  match_score?: string | null;
-  ai_explanation?: string | null;
   applied_at?: Date | null;
   created_at: Date;
   updated_at: Date;
@@ -102,7 +95,7 @@ export interface SeekerProfile extends SeekerProfileData {
 
 // ─── Subscription Types ───────────────────────────────────────────────────────
 
-export type SubscriptionPlan = "free" | "seeker" | "employer" | "enterprise";
+export type SubscriptionPlan = "seeker" | "employer" | "discord_owner";
 export type SubscriptionStatus =
   | "active"
   | "cancelled"
@@ -152,6 +145,7 @@ export interface CreatePaymentInput {
   currency?: string;
   paid_at?: Date;
   raw_payload?: unknown;
+  idempotency_key?: string;
 }
 
 export interface Payment extends CreatePaymentInput {
@@ -171,40 +165,20 @@ export type NotificationStatus =
   | "bounced"
   | "opened";
 
-export interface CreateNotificationTemplateInput {
-  slug: string;
-  name: string;
-  subject: string;
-  html_body: string;
-  text_body?: string;
-  metadata?: unknown;
-}
-
 export interface CreateNotificationInput {
   user_id: string;
-  template_id?: string;
+  type?: string;
   to_email: string;
   subject: string;
-  template_variables?: unknown;
-  job_ids?: string[];
+  content: string;
   scheduled_at?: Date;
 }
 
-export interface NotificationTemplate extends CreateNotificationTemplateInput {
-  id: string;
-  is_active: boolean;
-  created_at: Date;
-  updated_at: Date;
-}
-
-export interface EmailNotification extends CreateNotificationInput {
+export interface Notification extends CreateNotificationInput {
   id: string;
   status: NotificationStatus;
-  provider_message_id?: string | null;
   error_message?: string | null;
-  retry_count: number;
   sent_at?: Date | null;
-  opened_at?: Date | null;
   created_at: Date;
 }
 
@@ -259,3 +233,13 @@ export interface VectorSearchResult {
   similarity: number;
   [key: string]: unknown;
 }
+
+export interface JobSearchFilters {
+  location?: string;
+  job_type?: string;
+  remote?: boolean;
+  salary_min?: number;
+  skills?: string[];
+}
+
+export type BotPlatform = "discord" | "reddit" | "twitter";
diff --git a/packages/shared-types/src/index.ts b/packages/shared-types/src/index.ts
index 973aa2a..89aaccf 100644
--- a/packages/shared-types/src/index.ts
+++ b/packages/shared-types/src/index.ts
@@ -1,12 +1,72 @@
+import {
+  Notification,
+  SubscriptionPlan,
+  EmbeddingInputType,
+  EmbeddingResult,
+  SingleEmbeddingResult,
+  ChatMetadata,
+  ChatResult,
+  ChatStreamResult,
+  VectorSearchResult,
+  JobSearchFilters,
+  BotPlatform,
+  SeekerProfile,
+  EmployerProfile,
+  ApplicationStatus,
+  CreateEmployerProfileInput,
+  UpdateEmployerProfileInput,
+  NotificationStatus,
+  CreatePaymentInput,
+  SeekerProfileData,
+  SubscriptionStatus,
+  DodoSubscriptionPayload,
+} from "./domain";
+
+export type {
+  Notification,
+  SubscriptionPlan,
+  EmbeddingInputType,
+  EmbeddingResult,
+  SingleEmbeddingResult,
+  ChatMetadata,
+  ChatResult,
+  ChatStreamResult,
+  VectorSearchResult,
+  JobSearchFilters,
+  BotPlatform,
+  SeekerProfile,
+  EmployerProfile,
+  ApplicationStatus,
+  CreateEmployerProfileInput,
+  UpdateEmployerProfileInput,
+  NotificationStatus,
+  CreatePaymentInput,
+  SeekerProfileData,
+  SubscriptionStatus,
+  DodoSubscriptionPayload,
+};
+
+export type ConversationState =
+  | "idle"
+  | "thinking"
+  | "streaming"
+  | "completed"
+  | "error"
+  | "interrupted";
+
 // User types
-export type UserRole = "job_seeker" | "employer" | "admin";
+export type UserRole = "job_seeker" | "employer" | "admin" | "discord_owner";
 
 export interface User {
   id: string;
   email: string;
   full_name?: string;
-  role: UserRole;
+  roles: UserRole[];
   is_verified: boolean;
+  timezone?: string | null;
+  avatar_url?: string | null;
+  locale?: string | null;
+  deleted_at?: Date | null;
   password_reset_token?: string;
   password_reset_expires_at?: Date;
   last_login_at?: Date;
@@ -18,7 +78,7 @@ export interface CreateUserInput {
   email: string;
   password: string;
   full_name?: string;
-  role?: UserRole;
+  roles?: UserRole[];
 }
 
 /** DB-level input for creating a user (password already hashed) */
@@ -26,7 +86,7 @@ export interface CreateUserDbInput {
   email: string;
   password_hash: string;
   full_name?: string;
-  role?: UserRole;
+  roles?: UserRole[];
 }
 
 export interface LoginInput {
@@ -98,6 +158,8 @@ export interface Job {
   expires_at?: Date;
   is_active: boolean;
   employer_id?: string;
+  external_job_id?: string;
+  fingerprint?: string;
   created_at: Date;
   updated_at: Date;
 }
@@ -114,6 +176,8 @@ export interface CreateJobInput {
   skills_required?: string[];
   experience_required?: string;
   expires_at?: Date;
+  external_job_id?: string;
+  fingerprint?: string;
 }
 
 /** Input from web scrapers — used by the scraper service to upsert jobs */
@@ -133,6 +197,8 @@ export interface ScrapedJobInput {
   posted_at?: Date;
   expires_at?: Date;
   embedding?: number[];
+  external_job_id?: string;
+  fingerprint?: string;
 }
 
 // Job Match types
@@ -178,44 +244,51 @@ export interface MatchJobsInput {
   limit?: number;
 }
 
-export interface JobSearchFilters {
-  location?: string;
-  job_type?: JobType;
-  remote?: boolean;
-  salary_min?: number;
-  skills?: string[];
-}
-
-// Bot Subscription types
-export type CommunityType = "discord" | "reddit";
-export type SubscriptionTier = "basic" | "premium";
-
-export interface BotSubscription {
+// Bots & Social types
+export interface BotConfig {
   id: string;
-  community_type: CommunityType;
-  community_id: string;
-  admin_user_id: string;
-  filter_criteria?: JobSearchFilters;
+  user_id: string;
+  platform: BotPlatform;
   is_active: boolean;
-  subscription_tier: SubscriptionTier;
-  expires_at?: Date;
+  target_id?: string;
+  target_name?: string;
+  webhook_url?: string;
+  credentials?: Record<string, unknown>;
+  filter_keywords?: string;
+  filter_locations?: string;
+  filter_min_salary?: string;
+  filter_job_types?: string[];
+  last_post_at?: Date;
   created_at: Date;
+  updated_at: Date;
 }
 
-// Scraping types
-export type ScrapingStatus = "pending" | "running" | "completed" | "failed";
-
-export interface ScrapingJob {
+export interface BotPost {
   id: string;
-  source: JobSource;
-  status: ScrapingStatus;
-  jobs_scraped: number;
+  bot_config_id: string;
+  job_id: string;
+  external_post_id?: string;
+  status: "sent" | "failed";
   error_message?: string;
-  started_at?: Date;
-  completed_at?: Date;
-  created_at: Date;
+  posted_at: Date;
 }
 
+export interface MessageMetadata {
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+  job_matches?: OptimizedJobMatch[];
+  [key: string]: unknown;
+}
+
+export type StreamChatResponse =
+  | { type: "chunk"; content: string }
+  | { type: "metadata"; metadata: MessageMetadata }
+  | { type: "complete"; message_id: string; metadata: MessageMetadata }
+  | { type: "error"; error: string };
+
 // AI Chat types
 export interface ChatMessage {
   role: "user" | "assistant" | "system";
@@ -249,67 +322,23 @@ export interface Conversation {
   title: string;
   resume_id: string | null;
   model?: string;
-  is_archived: boolean;
-  state?: ConversationState;
   created_at: Date;
   updated_at: Date;
 }
 
-export type ConversationState =
-  | "idle"
-  | "typing"
-  | "thinking"
-  | "streaming"
-  | "completed"
-  | "error"
-  | "interrupted";
-
 export interface Message {
   id: string;
   conversation_id: string;
-  role: "user" | "assistant" | "system" | "tool";
+  role: string;
   content: string;
-
-  /** Self-referencing — forms a message tree for branching */
-  parent_message_id?: string | null;
-  /** Edit version number (1 = original, 2+ = edits) */
-  version: number;
-  /** Only the active branch is rendered in the UI */
-  is_active: boolean;
-  /** Streaming lifecycle: sending → streaming → completed / cancelled / error */
-  status: MessageStreamStatus;
-
+  tokens_used?: number;
+  status?: "sending" | "completed" | "error";
   metadata?: MessageMetadata;
+  version?: number;
+  is_active?: boolean;
   created_at: Date;
 }
 
-/** Streaming lifecycle status stored in DB */
-export type MessageStreamStatus =
-  | "sending"
-  | "streaming"
-  | "completed"
-  | "cancelled"
-  | "error";
-
-/** @deprecated Use MessageStreamStatus instead */
-export type MessageStatus = "sending" | "sent" | "delivered" | "error";
-
-export interface MessageMetadata {
-  job_matches?: OptimizedJobMatch[];
-  resume_feedback?: ResumeFeedback;
-  error?: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-  timing?: {
-    start: number;
-    end: number;
-    duration: number;
-  };
-}
-
 export interface CreateConversationRequest {
   resume_id?: string;
   initial_message?: string;
@@ -320,14 +349,6 @@ export interface SendMessageRequest {
   conversation_id: string;
 }
 
-export interface StreamChatResponse {
-  type: "chunk" | "complete" | "error" | "metadata";
-  content?: string;
-  metadata?: MessageMetadata;
-  message_id?: string;
-  error?: string;
-}
-
 // API Response types
 export interface ApiResponse<T = unknown> {
   success: boolean;
@@ -357,4 +378,3 @@ export const AI_ERROR_CODES = {
 export type AIErrorCode = (typeof AI_ERROR_CODES)[keyof typeof AI_ERROR_CODES];
 
 export * from "./schemas.js";
-export * from "./domain.js";
diff --git a/scripts/add-hnsw-indexes.sql b/scripts/add-hnsw-indexes.sql
new file mode 100644
index 0000000..d94c7bd
--- /dev/null
+++ b/scripts/add-hnsw-indexes.sql
@@ -0,0 +1,29 @@
+-- ──────────────────────────────────────────────────────────
+-- HNSW Vector Indexes for pgvector
+-- ──────────────────────────────────────────────────────────
+-- Uses HNSW (Hierarchical Navigable Small World) instead of
+-- IVFFlat for better recall and no training step required.
+--
+-- m=16, ef_construction=64 is a good balance for <100k rows.
+-- All embedding columns are 1024 dimensions (Voyage AI).
+-- ──────────────────────────────────────────────────────────
+
+-- Resumes: used for resume-to-job matching
+CREATE INDEX CONCURRENTLY IF NOT EXISTS resumes_embedding_hnsw
+ON resumes USING hnsw (embedding vector_cosine_ops)
+WITH (m = 16, ef_construction = 64);
+
+-- Jobs: used for job-to-resume matching and job search
+CREATE INDEX CONCURRENTLY IF NOT EXISTS jobs_embedding_hnsw
+ON jobs USING hnsw (embedding vector_cosine_ops)
+WITH (m = 16, ef_construction = 64);
+
+-- Employer Profiles: used for company similarity search
+CREATE INDEX CONCURRENTLY IF NOT EXISTS employer_profiles_embedding_hnsw
+ON employer_profiles USING hnsw (embedding vector_cosine_ops)
+WITH (m = 16, ef_construction = 64);
+
+-- Seeker Profiles: used for candidate matching
+CREATE INDEX CONCURRENTLY IF NOT EXISTS seeker_profiles_embedding_hnsw
+ON seeker_profiles USING hnsw (embedding vector_cosine_ops)
+WITH (m = 16, ef_construction = 64);
diff --git a/scripts/backup.sh b/scripts/backup.sh
new file mode 100644
index 0000000..1a3b47f
--- /dev/null
+++ b/scripts/backup.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+# ──────────────────────────────────────────────────────────────
+# Postly — Daily PostgreSQL Backup
+# ──────────────────────────────────────────────────────────────
+# Cron entry:  0 2 * * * /opt/postly/scripts/backup.sh >> /var/log/postly-backup.log 2>&1
+#
+# Prerequisites:
+#   - rclone configured with a remote named "b2" (Backblaze B2)
+#   - Or comment out the rclone section to use local backups only
+# ──────────────────────────────────────────────────────────────
+set -euo pipefail
+
+DATE=$(date +%Y%m%d_%H%M%S)
+BACKUP_DIR="/opt/postly/backups/local"
+BACKUP_FILE="/tmp/postly_${DATE}.dump"
+RETENTION_DAYS=7
+
+# Optional: Discord/Slack webhook for failure alerts
+ALERT_WEBHOOK="${ALERT_WEBHOOK:-}"
+
+echo "[${DATE}] Starting Postly backup..."
+
+# Create local backup directory
+mkdir -p "${BACKUP_DIR}"
+
+# ─── Step 1: Dump PostgreSQL ──────────────────────────────────
+echo "→ Creating compressed PostgreSQL dump..."
+docker exec postly-postgres pg_dump \
+  -U "${DB_USER:-postly}" \
+  -d "${DB_NAME:-postly}" \
+  -Fc --compress=9 \
+  > "${BACKUP_FILE}"
+
+BACKUP_SIZE=$(du -sh "${BACKUP_FILE}" | cut -f1)
+echo "  Dump created: ${BACKUP_SIZE}"
+
+# ─── Step 2: Upload to remote storage (Backblaze B2) ────────
+# Uncomment the following when rclone is configured:
+#
+# echo "→ Uploading to Backblaze B2..."
+# rclone copy "${BACKUP_FILE}" b2:postly-backups/daily/
+#
+# # Verify upload
+# if rclone ls b2:postly-backups/daily/ | grep -q "postly_${DATE}"; then
+#   echo "  ✅ Upload verified"
+# else
+#   echo "  ❌ Upload verification failed!"
+#   if [ -n "${ALERT_WEBHOOK}" ]; then
+#     curl -s -X POST "${ALERT_WEBHOOK}" \
+#       -H "Content-Type: application/json" \
+#       -d "{\"content\": \"⚠️ Postly backup upload failed for ${DATE}\"}"
+#   fi
+# fi
+
+# ─── Step 3: Local rolling retention ────────────────────────
+echo "→ Copying to local backup directory..."
+cp "${BACKUP_FILE}" "${BACKUP_DIR}/"
+
+echo "→ Cleaning backups older than ${RETENTION_DAYS} days..."
+find "${BACKUP_DIR}" -name "postly_*.dump" -mtime "+${RETENTION_DAYS}" -delete
+
+# ─── Step 4: Clean up temp file ──────────────────────────────
+rm -f "${BACKUP_FILE}"
+
+# ─── Done ────────────────────────────────────────────────────
+KEPT=$(ls -1 "${BACKUP_DIR}"/postly_*.dump 2>/dev/null | wc -l)
+echo "✅ Backup complete. ${KEPT} backups retained locally."
+echo ""