Add CI/CD workflow

.gitea/workflows/ci.yml

@@ -33,8 +33,8 @@ jobs:
     steps:
       - name: Deploy to Dokploy
         run: |
-          curl -fsSL -X POST "${{ secrets.DOKPLOY_URL }}/api/compose.deploy" \
+          curl -fsSL -X POST "${{ secrets.DOKPLOY_URL }}/api/application.deploy" \
             -H "Content-Type: application/json" \
             -H "x-api-key: ${{ secrets.DOKPLOY_API_TOKEN }}" \
-            -d '{"composeId": "${{ secrets.DOKPLOY_COMPOSE_ID }}"}'
+            -d '{"applicationId": "${{ secrets.DOKPLOY_APP_ID }}"}'
           echo "Deploy triggered on Dokploy"

Dockerfile

@@ -4,7 +4,7 @@ WORKDIR /app
 # Install dependencies
 FROM base AS install
 COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile
+RUN bun install --frozen-lockfile --production
 
 # Production image
 FROM base AS release

entrypoint.sh

@@ -1,12 +1,10 @@
 #!/bin/bash
 set -e
 
-echo "Running db:push..."
+# Run seed (creates test user if not exists)
-bun run db:push || echo "db:push skipped"
+echo "Running database seed..."
-
+bun run db:seed || echo "Seed skipped or failed (may already exist)"
-# Seed disabled — was a one-time DB reset that truncates all tables
-# echo "Running database seed..."
-# bun run db:seed || echo "Seed skipped"
 
+# Start the app
 echo "Starting API..."
 exec bun run src/index.ts

package.json

@@ -17,7 +17,8 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/pg": "^8.16.0"
+    "@types/pg": "^8.16.0",
+    "drizzle-kit": "^0.31.8"
   },
   "peerDependencies": {
     "typescript": "^5"
@@ -34,7 +35,6 @@
     "pg-boss": "^12.7.0",
     "postgres": "^3.4.8",
     "resend": "^6.8.0",
-    "zod": "^4.3.6",
+    "zod": "^4.3.6"
-    "drizzle-kit": "^0.31.8"
   }
-}
+}

src/__tests__/audit.test.ts

@@ -1,208 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-describe('Audit Logging', () => {
-  describe('Audit Log Data Structure', () => {
-    test('audit log entry has required fields', () => {
-      const entry = {
-        userId: 'user-123',
-        action: 'create',
-        entityType: 'client',
-        entityId: 'client-456',
-        details: { firstName: 'John', lastName: 'Doe' },
-        ipAddress: '192.168.1.1',
-        userAgent: 'Mozilla/5.0',
-      };
-      expect(entry.userId).toBeDefined();
-      expect(entry.action).toBe('create');
-      expect(entry.entityType).toBe('client');
-    });
-
-    test('valid action types', () => {
-      const validActions = ['create', 'update', 'delete', 'view', 'send', 'login', 'logout', 'password_change'];
-      validActions.forEach(action => {
-        expect(validActions).toContain(action);
-      });
-    });
-
-    test('valid entity types', () => {
-      const validTypes = ['client', 'email', 'event', 'template', 'segment', 'user', 'auth', 'interaction', 'note', 'notification', 'invite', 'profile'];
-      expect(validTypes.length).toBeGreaterThan(0);
-      expect(validTypes).toContain('client');
-      expect(validTypes).toContain('auth');
-    });
-
-    test('details can be JSONB with diff info', () => {
-      const details = {
-        changes: {
-          firstName: { from: 'John', to: 'Jonathan' },
-          stage: { from: 'lead', to: 'active' },
-        },
-      };
-      expect(details.changes.firstName.from).toBe('John');
-      expect(details.changes.firstName.to).toBe('Jonathan');
-    });
-  });
-
-  describe('Request Metadata', () => {
-    test('IP address extracted from x-forwarded-for', () => {
-      const header = '192.168.1.1, 10.0.0.1';
-      const ip = header.split(',')[0]!.trim();
-      expect(ip).toBe('192.168.1.1');
-    });
-
-    test('User-Agent is captured', () => {
-      const ua = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)';
-      expect(ua).toContain('Mozilla');
-    });
-  });
-
-  describe('Diff Computation', () => {
-    test('detects changed fields', () => {
-      const oldVal = { firstName: 'John', lastName: 'Doe', stage: 'lead' };
-      const newVal = { firstName: 'Jonathan', lastName: 'Doe', stage: 'active' };
-      
-      const diff: Record<string, { from: unknown; to: unknown }> = {};
-      for (const key of Object.keys(newVal)) {
-        const oldV = (oldVal as any)[key];
-        const newV = (newVal as any)[key];
-        if (JSON.stringify(oldV) !== JSON.stringify(newV)) {
-          diff[key] = { from: oldV, to: newV };
-        }
-      }
-      
-      expect(Object.keys(diff)).toHaveLength(2);
-      expect(diff.firstName!.from).toBe('John');
-      expect(diff.firstName!.to).toBe('Jonathan');
-      expect(diff.stage!.from).toBe('lead');
-      expect(diff.lastName).toBeUndefined();
-    });
-
-    test('handles array differences', () => {
-      const old = { tags: ['vip'] };
-      const cur = { tags: ['vip', 'active'] };
-      const same = JSON.stringify(old.tags) === JSON.stringify(cur.tags);
-      expect(same).toBe(false);
-    });
-  });
-
-  describe('Audit Log Filters', () => {
-    test('page and limit defaults', () => {
-      const noPage: string | undefined = undefined;
-      const noLimit: string | undefined = undefined;
-      const page = parseInt(noPage || '1');
-      const limit = Math.min(parseInt(noLimit || '50'), 100);
-      expect(page).toBe(1);
-      expect(limit).toBe(50);
-    });
-
-    test('limit capped at 100', () => {
-      const limit = Math.min(parseInt('200'), 100);
-      expect(limit).toBe(100);
-    });
-
-    test('date range filtering', () => {
-      const startDate = new Date('2024-01-01');
-      const endDate = new Date('2024-12-31');
-      const logDate = new Date('2024-06-15');
-      expect(logDate >= startDate && logDate <= endDate).toBe(true);
-    });
-  });
-});
-
-describe('Meeting Prep', () => {
-  describe('Health Score Calculation', () => {
-    test('perfect score for recently contacted client', () => {
-      let healthScore = 100;
-      const daysSinceContact = 5;
-      if (daysSinceContact > 90) healthScore -= 40;
-      else if (daysSinceContact > 60) healthScore -= 25;
-      else if (daysSinceContact > 30) healthScore -= 10;
-      expect(healthScore).toBe(100);
-    });
-
-    test('score decreases with time since contact', () => {
-      let healthScore = 100;
-      const daysSinceContact = 95;
-      if (daysSinceContact > 90) healthScore -= 40;
-      else if (daysSinceContact > 60) healthScore -= 25;
-      else if (daysSinceContact > 30) healthScore -= 10;
-      expect(healthScore).toBe(60);
-    });
-
-    test('interaction frequency adds bonus', () => {
-      let healthScore = 75;
-      const interactionsLast90Days = 5;
-      if (interactionsLast90Days >= 5) healthScore = Math.min(100, healthScore + 15);
-      expect(healthScore).toBe(90);
-    });
-
-    test('score clamped to 0-100', () => {
-      let healthScore = -10;
-      healthScore = Math.max(0, Math.min(100, healthScore));
-      expect(healthScore).toBe(0);
-      
-      healthScore = 120;
-      healthScore = Math.max(0, Math.min(100, healthScore));
-      expect(healthScore).toBe(100);
-    });
-  });
-
-  describe('Important Dates', () => {
-    test('birthday within 90 days is included', () => {
-      const now = new Date();
-      const birthday = new Date(now);
-      birthday.setDate(birthday.getDate() + 30);
-      const daysUntil = Math.ceil((birthday.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-      expect(daysUntil <= 90).toBe(true);
-    });
-
-    test('birthday beyond 90 days is excluded', () => {
-      const now = new Date();
-      const birthday = new Date(now);
-      birthday.setDate(birthday.getDate() + 120);
-      const daysUntil = Math.ceil((birthday.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-      expect(daysUntil <= 90).toBe(false);
-    });
-  });
-});
-
-describe('Communication Style', () => {
-  test('style has valid tone options', () => {
-    const validTones = ['formal', 'friendly', 'casual'];
-    expect(validTones).toContain('formal');
-    expect(validTones).toContain('friendly');
-    expect(validTones).toContain('casual');
-  });
-
-  test('writing samples capped at 3', () => {
-    const samples = ['sample1', 'sample2', 'sample3', 'sample4'];
-    const capped = samples.slice(0, 3);
-    expect(capped).toHaveLength(3);
-  });
-
-  test('style object structure', () => {
-    const style = {
-      tone: 'friendly' as const,
-      greeting: 'Hi',
-      signoff: 'Best regards',
-      writingSamples: ['Sample email text'],
-      avoidWords: ['synergy', 'leverage'],
-    };
-    expect(style.tone).toBe('friendly');
-    expect(style.avoidWords).toHaveLength(2);
-    expect(style.writingSamples).toHaveLength(1);
-  });
-
-  test('default style when none set', () => {
-    const profile = { communicationStyle: null };
-    const style = profile.communicationStyle || {
-      tone: 'friendly',
-      greeting: '',
-      signoff: '',
-      writingSamples: [],
-      avoidWords: [],
-    };
-    expect(style.tone).toBe('friendly');
-    expect(style.writingSamples).toHaveLength(0);
-  });
-});

src/__tests__/clients.test.ts

@@ -3,7 +3,7 @@ import { describe, test, expect } from 'bun:test';
 describe('Client Routes', () => {
   describe('Validation', () => {
     test('clientSchema requires firstName', () => {
-      const invalidClient: Record<string, unknown> = {
+      const invalidClient = {
         lastName: 'Doe',
       };
       // Schema validation test - firstName is required
@@ -11,7 +11,7 @@ describe('Client Routes', () => {
     });
 
     test('clientSchema requires lastName', () => {
-      const invalidClient: Record<string, unknown> = {
+      const invalidClient = {
         firstName: 'John',
       };
       // Schema validation test - lastName is required
@@ -107,8 +107,8 @@ describe('Search Functionality', () => {
     
     const filtered = clients.filter(c => c.tags?.includes('vip'));
     expect(filtered).toHaveLength(2);
-    expect(filtered[0]!.firstName).toBe('John');
+    expect(filtered[0].firstName).toBe('John');
-    expect(filtered[1]!.firstName).toBe('Bob');
+    expect(filtered[1].firstName).toBe('Bob');
   });
 });
 

src/__tests__/email.test.ts

@@ -93,14 +93,11 @@ describe('Email Service', () => {
 
   describe('Default From Email', () => {
     test('falls back to default when from not provided', () => {
-      const savedEnv = process.env.DEFAULT_FROM_EMAIL;
-      delete process.env.DEFAULT_FROM_EMAIL;
       const from = undefined;
       const defaultFrom = 'onboarding@resend.dev';
       const result = from || process.env.DEFAULT_FROM_EMAIL || defaultFrom;
       
       expect(result).toBe(defaultFrom);
-      if (savedEnv) process.env.DEFAULT_FROM_EMAIL = savedEnv;
     });
 
     test('uses provided from when available', () => {

src/__tests__/engagement.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-
-// Unit tests for engagement scoring logic
-describe('Engagement Scoring', () => {
-  describe('Recency Score', () => {
-    const calculateRecencyScore = (lastContactedAt: Date | null): number => {
-      if (!lastContactedAt) return 0;
-      const daysSince = Math.floor((Date.now() - lastContactedAt.getTime()) / (1000 * 60 * 60 * 24));
-      if (daysSince <= 7) return 40;
-      if (daysSince <= 14) return 35;
-      if (daysSince <= 30) return 28;
-      if (daysSince <= 60) return 18;
-      if (daysSince <= 90) return 10;
-      if (daysSince <= 180) return 5;
-      return 0;
-    };
-
-    it('returns 40 for contact within last week', () => {
-      const recent = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(recent)).toBe(40);
-    });
-
-    it('returns 35 for contact within 2 weeks', () => {
-      const twoWeeksAgo = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(twoWeeksAgo)).toBe(35);
-    });
-
-    it('returns 28 for contact within 30 days', () => {
-      const monthAgo = new Date(Date.now() - 25 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(monthAgo)).toBe(28);
-    });
-
-    it('returns 18 for contact within 60 days', () => {
-      const twoMonthsAgo = new Date(Date.now() - 45 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(twoMonthsAgo)).toBe(18);
-    });
-
-    it('returns 10 for contact within 90 days', () => {
-      const threeMonthsAgo = new Date(Date.now() - 75 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(threeMonthsAgo)).toBe(10);
-    });
-
-    it('returns 0 for no contact', () => {
-      expect(calculateRecencyScore(null)).toBe(0);
-    });
-
-    it('returns 0 for very old contact', () => {
-      const longAgo = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000);
-      expect(calculateRecencyScore(longAgo)).toBe(0);
-    });
-  });
-
-  describe('Interaction Score', () => {
-    const calculateInteractionScore = (count: number): number => {
-      if (count >= 10) return 25;
-      if (count >= 7) return 22;
-      if (count >= 5) return 18;
-      if (count >= 3) return 14;
-      if (count >= 1) return 8;
-      return 0;
-    };
-
-    it('returns max score for 10+ interactions', () => {
-      expect(calculateInteractionScore(10)).toBe(25);
-      expect(calculateInteractionScore(20)).toBe(25);
-    });
-
-    it('returns 0 for no interactions', () => {
-      expect(calculateInteractionScore(0)).toBe(0);
-    });
-
-    it('scales appropriately', () => {
-      expect(calculateInteractionScore(1)).toBe(8);
-      expect(calculateInteractionScore(3)).toBe(14);
-      expect(calculateInteractionScore(5)).toBe(18);
-      expect(calculateInteractionScore(7)).toBe(22);
-    });
-  });
-
-  describe('Email Score', () => {
-    const calculateEmailScore = (count: number): number => {
-      if (count >= 8) return 15;
-      if (count >= 5) return 12;
-      if (count >= 3) return 9;
-      if (count >= 1) return 5;
-      return 0;
-    };
-
-    it('returns max score for 8+ emails', () => {
-      expect(calculateEmailScore(8)).toBe(15);
-    });
-
-    it('returns 0 for no emails', () => {
-      expect(calculateEmailScore(0)).toBe(0);
-    });
-  });
-
-  describe('Total Score', () => {
-    it('max possible score is 100', () => {
-      const maxRecency = 40;
-      const maxInteractions = 25;
-      const maxEmails = 15;
-      const maxEvents = 10;
-      const maxNotes = 10;
-      expect(maxRecency + maxInteractions + maxEmails + maxEvents + maxNotes).toBe(100);
-    });
-
-    it('all zeros gives score of 0', () => {
-      expect(0 + 0 + 0 + 0 + 0).toBe(0);
-    });
-  });
-
-  describe('Engagement Labels', () => {
-    const getEngagementLabel = (score: number): string => {
-      if (score >= 80) return 'highly_engaged';
-      if (score >= 60) return 'engaged';
-      if (score >= 40) return 'warm';
-      if (score >= 20) return 'cooling';
-      return 'cold';
-    };
-
-    it('classifies scores correctly', () => {
-      expect(getEngagementLabel(95)).toBe('highly_engaged');
-      expect(getEngagementLabel(80)).toBe('highly_engaged');
-      expect(getEngagementLabel(70)).toBe('engaged');
-      expect(getEngagementLabel(50)).toBe('warm');
-      expect(getEngagementLabel(25)).toBe('cooling');
-      expect(getEngagementLabel(10)).toBe('cold');
-      expect(getEngagementLabel(0)).toBe('cold');
-    });
-  });
-
-  describe('Recommendations', () => {
-    it('generates recency recommendation for old contacts', () => {
-      const breakdown = { recency: 5, interactions: 25, emails: 15, events: 10, notes: 10 };
-      const recs: string[] = [];
-      if (breakdown.recency < 18) {
-        recs.push('Reach out soon');
-      }
-      expect(recs.length).toBeGreaterThan(0);
-    });
-
-    it('generates no recency recommendation for recent contacts', () => {
-      const breakdown = { recency: 40, interactions: 25, emails: 15, events: 10, notes: 10 };
-      const recs: string[] = [];
-      if (breakdown.recency < 18) {
-        recs.push('Reach out soon');
-      }
-      expect(recs.length).toBe(0);
-    });
-  });
-});

src/db/schema.ts

@@ -1,4 +1,4 @@
-import { pgTable, text, timestamp, uuid, boolean, jsonb, integer, numeric } from 'drizzle-orm/pg-core';
+import { pgTable, text, timestamp, uuid, boolean, jsonb, integer } from 'drizzle-orm/pg-core';
 import { relations } from 'drizzle-orm';
 
 // Users table (managed by BetterAuth - uses text IDs)
@@ -44,14 +44,6 @@ export const userProfiles = pgTable('user_profiles', {
   company: text('company'), // e.g., "ABC Financial Group"
   phone: text('phone'),
   emailSignature: text('email_signature'), // Custom signature block
-  communicationStyle: jsonb('communication_style').$type<{
-    tone?: 'formal' | 'friendly' | 'casual';
-    greeting?: string;
-    signoff?: string;
-    writingSamples?: string[];
-    avoidWords?: string[];
-  }>(),
-  onboardingComplete: boolean('onboarding_complete').default(false),
   createdAt: timestamp('created_at').defaultNow().notNull(),
   updatedAt: timestamp('updated_at').defaultNow().notNull(),
 });
@@ -126,7 +118,6 @@ export const clients = pgTable('clients', {
   
   // Organization
   tags: jsonb('tags').$type<string[]>().default([]),
-  stage: text('stage').default('lead'), // 'lead' | 'prospect' | 'onboarding' | 'active' | 'inactive'
   
   // Tracking
   lastContactedAt: timestamp('last_contacted_at'),
@@ -163,172 +154,17 @@ export const communications = pgTable('communications', {
   aiModel: text('ai_model'), // Which model was used
   status: text('status').default('draft'), // 'draft' | 'approved' | 'sent'
   sentAt: timestamp('sent_at'),
-  batchId: text('batch_id'), // for grouping bulk sends
   
   createdAt: timestamp('created_at').defaultNow().notNull(),
 });
 
-// Notifications table
-export const notifications = pgTable('notifications', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  type: text('type').notNull(), // 'event_reminder' | 'interaction' | 'system'
-  title: text('title').notNull(),
-  message: text('message').notNull(),
-  read: boolean('read').default(false),
-  clientId: uuid('client_id').references(() => clients.id, { onDelete: 'set null' }),
-  eventId: uuid('event_id').references(() => events.id, { onDelete: 'set null' }),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-});
-
-// Interactions table (touchpoint logging)
-export const interactions = pgTable('interactions', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  clientId: uuid('client_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  type: text('type').notNull(), // 'call' | 'meeting' | 'email' | 'note' | 'other'
-  title: text('title').notNull(),
-  description: text('description'),
-  duration: integer('duration'), // in minutes
-  contactedAt: timestamp('contacted_at').notNull(),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-});
-
-// Client notes table
-export const clientNotes = pgTable('client_notes', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  clientId: uuid('client_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  content: text('content').notNull(),
-  pinned: boolean('pinned').default(false),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
-// Email templates table
-export const emailTemplates = pgTable('email_templates', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  name: text('name').notNull(),
-  category: text('category').notNull(), // 'follow-up' | 'birthday' | 'introduction' | 'check-in' | 'thank-you' | 'custom'
-  subject: text('subject').notNull(),
-  content: text('content').notNull(), // supports {{firstName}}, {{lastName}}, {{company}} placeholders
-  isDefault: boolean('is_default').default(false), // mark as default for category
-  usageCount: integer('usage_count').default(0),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
-// Saved client filters / segments
-export const clientSegments = pgTable('client_segments', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  name: text('name').notNull(),
-  description: text('description'),
-  filters: jsonb('filters').$type<{
-    stages?: string[];
-    tags?: string[];
-    industries?: string[];
-    cities?: string[];
-    states?: string[];
-    lastContactedBefore?: string; // ISO date
-    lastContactedAfter?: string;
-    createdBefore?: string;
-    createdAfter?: string;
-    hasEmail?: boolean;
-    hasPhone?: boolean;
-    search?: string;
-  }>().notNull(),
-  color: text('color').default('#3b82f6'), // badge color
-  pinned: boolean('pinned').default(false),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
-// Audit logs table (compliance)
-export const auditLogs = pgTable('audit_logs', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'set null' }),
-  action: text('action').notNull(), // 'create' | 'update' | 'delete' | 'view' | 'send' | 'login' | 'logout' | 'password_change'
-  entityType: text('entity_type').notNull(), // 'client' | 'email' | 'event' | 'template' | 'segment' | 'user' | 'auth' | etc
-  entityId: text('entity_id'), // ID of the affected entity
-  details: jsonb('details').$type<Record<string, unknown>>(), // what changed
-  ipAddress: text('ip_address'),
-  userAgent: text('user_agent'),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-});
-
-// Client Documents table (file attachments)
-export const clientDocuments = pgTable('client_documents', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  clientId: uuid('client_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  name: text('name').notNull(), // user-facing display name
-  filename: text('filename').notNull(), // actual filename on disk
-  mimeType: text('mime_type').notNull(),
-  size: integer('size').notNull(), // bytes
-  category: text('category').default('other').notNull(), // 'contract' | 'agreement' | 'id' | 'statement' | 'correspondence' | 'other'
-  path: text('path').notNull(), // filesystem path
-  notes: text('notes'),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-});
-
-// Client Goals / Financial Objectives table
-export const clientGoals = pgTable('client_goals', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  clientId: uuid('client_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  title: text('title').notNull(),
-  description: text('description'),
-  category: text('category').default('other').notNull(), // 'retirement' | 'investment' | 'savings' | 'insurance' | 'estate' | 'education' | 'debt' | 'other'
-  targetAmount: numeric('target_amount', { precision: 15, scale: 2 }),
-  currentAmount: numeric('current_amount', { precision: 15, scale: 2 }).default('0'),
-  targetDate: timestamp('target_date'),
-  status: text('status').default('on-track').notNull(), // 'on-track' | 'at-risk' | 'behind' | 'completed'
-  priority: text('priority').default('medium').notNull(), // 'high' | 'medium' | 'low'
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
-// Referrals table
-export const referrals = pgTable('referrals', {
-  id: uuid('id').primaryKey().defaultRandom(),
-  referrerId: uuid('referrer_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  referredId: uuid('referred_id').references(() => clients.id, { onDelete: 'cascade' }).notNull(),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-  type: text('type').default('client').notNull(), // 'client' | 'partner' | 'event'
-  notes: text('notes'),
-  status: text('status').default('pending').notNull(), // 'pending' | 'contacted' | 'converted' | 'lost'
-  value: numeric('value', { precision: 15, scale: 2 }), // estimated deal value
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
   clients: many(clients),
   events: many(events),
   communications: many(communications),
-  notifications: many(notifications),
-  interactions: many(interactions),
   sessions: many(sessions),
   accounts: many(accounts),
-  emailTemplates: many(emailTemplates),
-  clientSegments: many(clientSegments),
-}));
-
-export const emailTemplatesRelations = relations(emailTemplates, ({ one }) => ({
-  user: one(users, {
-    fields: [emailTemplates.userId],
-    references: [users.id],
-  }),
-}));
-
-export const clientSegmentsRelations = relations(clientSegments, ({ one }) => ({
-  user: one(users, {
-    fields: [clientSegments.userId],
-    references: [users.id],
-  }),
 }));
 
 export const clientsRelations = relations(clients, ({ one, many }) => ({
@@ -338,88 +174,6 @@ export const clientsRelations = relations(clients, ({ one, many }) => ({
   }),
   events: many(events),
   communications: many(communications),
-  notes: many(clientNotes),
-  interactions: many(interactions),
-  documents: many(clientDocuments),
-  goals: many(clientGoals),
-  referralsMade: many(referrals, { relationName: 'referrer' }),
-  referralsReceived: many(referrals, { relationName: 'referred' }),
-}));
-
-export const clientDocumentsRelations = relations(clientDocuments, ({ one }) => ({
-  client: one(clients, {
-    fields: [clientDocuments.clientId],
-    references: [clients.id],
-  }),
-  user: one(users, {
-    fields: [clientDocuments.userId],
-    references: [users.id],
-  }),
-}));
-
-export const clientGoalsRelations = relations(clientGoals, ({ one }) => ({
-  client: one(clients, {
-    fields: [clientGoals.clientId],
-    references: [clients.id],
-  }),
-  user: one(users, {
-    fields: [clientGoals.userId],
-    references: [users.id],
-  }),
-}));
-
-export const referralsRelations = relations(referrals, ({ one }) => ({
-  referrer: one(clients, {
-    fields: [referrals.referrerId],
-    references: [clients.id],
-    relationName: 'referrer',
-  }),
-  referred: one(clients, {
-    fields: [referrals.referredId],
-    references: [clients.id],
-    relationName: 'referred',
-  }),
-  user: one(users, {
-    fields: [referrals.userId],
-    references: [users.id],
-  }),
-}));
-
-export const notificationsRelations = relations(notifications, ({ one }) => ({
-  user: one(users, {
-    fields: [notifications.userId],
-    references: [users.id],
-  }),
-  client: one(clients, {
-    fields: [notifications.clientId],
-    references: [clients.id],
-  }),
-  event: one(events, {
-    fields: [notifications.eventId],
-    references: [events.id],
-  }),
-}));
-
-export const interactionsRelations = relations(interactions, ({ one }) => ({
-  user: one(users, {
-    fields: [interactions.userId],
-    references: [users.id],
-  }),
-  client: one(clients, {
-    fields: [interactions.clientId],
-    references: [clients.id],
-  }),
-}));
-
-export const clientNotesRelations = relations(clientNotes, ({ one }) => ({
-  client: one(clients, {
-    fields: [clientNotes.clientId],
-    references: [clients.id],
-  }),
-  user: one(users, {
-    fields: [clientNotes.userId],
-    references: [users.id],
-  }),
 }));
 
 export const eventsRelations = relations(events, ({ one }) => ({

src/db/seed.ts

@@ -1,29 +1,156 @@
 import { db } from './index';
-import { sql } from 'drizzle-orm';
+import { users, accounts, clients } from './schema';
+import { eq } from 'drizzle-orm';
+import { hashPassword } from 'better-auth/crypto';
+
+const fakeClients = [
+  {
+    firstName: 'Sarah',
+    lastName: 'Mitchell',
+    email: 'sarah.mitchell@email.com',
+    phone: '(555) 234-5678',
+    company: 'Mitchell & Associates',
+    role: 'Managing Partner',
+    city: 'Austin',
+    state: 'TX',
+    birthday: new Date('1978-06-15'),
+    anniversary: new Date('2005-09-20'),
+    interests: ['golf', 'wine collecting', 'travel'],
+    family: { spouse: 'David', children: ['Emma', 'Jack'] },
+    notes: 'Very interested in sustainable investing. Prefers morning meetings.',
+    tags: ['high-value', 'quarterly-review'],
+  },
+  {
+    firstName: 'Marcus',
+    lastName: 'Johnson',
+    email: 'marcus.j@techventures.io',
+    phone: '(555) 876-5432',
+    company: 'TechVentures Capital',
+    role: 'CEO',
+    city: 'San Francisco',
+    state: 'CA',
+    birthday: new Date('1985-03-22'),
+    interests: ['startups', 'AI', 'marathon running', 'podcasts'],
+    family: { spouse: 'Michelle' },
+    notes: 'Recently sold his startup. Looking for aggressive growth strategies.',
+    tags: ['new-client', 'tech'],
+  },
+  {
+    firstName: 'Linda',
+    lastName: 'Chen',
+    email: 'lchen@globalhealth.org',
+    phone: '(555) 345-9876',
+    company: 'Global Health Foundation',
+    role: 'Executive Director',
+    city: 'Seattle',
+    state: 'WA',
+    birthday: new Date('1972-11-08'),
+    anniversary: new Date('1998-07-12'),
+    interests: ['philanthropy', 'hiking', 'classical music', 'book clubs'],
+    family: { spouse: 'Robert', children: ['Olivia', 'Noah', 'Sophia'] },
+    notes: 'Focused on legacy planning and charitable giving. Daughter Olivia graduating medical school in May.',
+    tags: ['philanthropy', 'estate-planning'],
+  },
+  {
+    firstName: 'James',
+    lastName: 'Rodriguez',
+    email: 'james.rodriguez@email.com',
+    phone: '(555) 567-8901',
+    company: 'Rodriguez Construction',
+    role: 'Owner',
+    city: 'Phoenix',
+    state: 'AZ',
+    birthday: new Date('1968-09-30'),
+    interests: ['fishing', 'classic cars', 'football'],
+    family: { spouse: 'Maria', children: ['Carlos', 'Isabella'] },
+    notes: 'Planning to retire in 5 years. Wants to transition business to son Carlos.',
+    tags: ['retirement', 'business-succession'],
+  },
+  {
+    firstName: 'Emily',
+    lastName: 'Watson',
+    email: 'emily.watson@lawfirm.com',
+    phone: '(555) 432-1098',
+    company: 'Watson Legal Group',
+    role: 'Senior Partner',
+    city: 'Chicago',
+    state: 'IL',
+    birthday: new Date('1980-04-17'),
+    interests: ['art collecting', 'yoga', 'french cuisine'],
+    notes: 'Recently divorced. Needs portfolio restructuring. Interested in real estate investments.',
+    tags: ['life-change', 'real-estate'],
+  },
+];
 
 async function seed() {
-  console.log('Clearing all user data...');
+  const testEmail = 'test@test.com';
   
-  // Disable FK constraints
+  // Check if test user already exists
-  await db.execute(sql`SET session_replication_role = 'replica'`);
+  const [existing] = await db.select()
+    .from(users)
+    .where(eq(users.email, testEmail))
+    .limit(1);
   
-  // Get all tables and truncate them
+  let userId: string;
-  const tables = await db.execute(sql`
-    SELECT tablename FROM pg_tables WHERE schemaname = 'public'
-  `);
   
-  for (const row of tables as any) {
+  if (existing) {
-    const table = (row as any).tablename;
+    console.log('✓ Test user already exists');
-    if (table.startsWith('__drizzle') || table.startsWith('pgboss')) continue;
+    userId = existing.id;
-    console.log(`  Truncating ${table}...`);
+  } else {
-    await db.execute(sql.raw(`TRUNCATE TABLE "${table}" CASCADE`));
+    // Create test user
+    userId = crypto.randomUUID();
+    const hashedPassword = await hashPassword('test');
+    
+    await db.insert(users).values({
+      id: userId,
+      email: testEmail,
+      name: 'Test User',
+      emailVerified: true,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+    
+    // Create credential account (for email/password login)
+    await db.insert(accounts).values({
+      id: crypto.randomUUID(),
+      userId: userId,
+      accountId: userId,
+      providerId: 'credential',
+      password: hashedPassword,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+    
+    console.log('✓ Created test user: test@test.com / test');
   }
   
-  // Re-enable FK constraints  
+  // Check if fake clients already exist (check for Sarah Mitchell specifically)
-  await db.execute(sql`SET session_replication_role = 'origin'`);
+  const [existingFakeClient] = await db.select()
+    .from(clients)
+    .where(eq(clients.email, 'sarah.mitchell@email.com'))
+    .limit(1);
   
-  console.log('Database cleared! No accounts exist.');
+  if (existingFakeClient) {
-  process.exit(0);
+    console.log('✓ Test clients already exist');
+    return;
+  }
+  
+  // Add fake clients
+  for (const client of fakeClients) {
+    await db.insert(clients).values({
+      userId,
+      ...client,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+  
+  console.log(`✓ Created ${fakeClients.length} test clients`);
 }
 
-seed().catch(e => { console.error(e); process.exit(1); });
+seed()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    console.error('Seed failed:', err);
+    process.exit(1);
+  });

src/index.ts

@@ -1,6 +1,5 @@
 import { Elysia } from 'elysia';
 import { cors } from '@elysiajs/cors';
-import { rateLimitPlugin } from './middleware/rate-limit';
 import { auth } from './lib/auth';
 import { clientRoutes } from './routes/clients';
 import { emailRoutes } from './routes/emails';
@@ -14,31 +13,12 @@ import { importRoutes } from './routes/import';
 import { activityRoutes } from './routes/activity';
 import { insightsRoutes } from './routes/insights';
 import { reportsRoutes } from './routes/reports';
-import { notesRoutes } from './routes/notes';
-import { notificationRoutes } from './routes/notifications';
-import { interactionRoutes } from './routes/interactions';
-import { templateRoutes } from './routes/templates';
-import { segmentRoutes } from './routes/segments';
-import { auditLogRoutes } from './routes/audit-logs';
-import { meetingPrepRoutes } from './routes/meeting-prep';
 import { db } from './db';
 import { users } from './db/schema';
 import { eq } from 'drizzle-orm';
-import { tagRoutes } from './routes/tags';
+import type { User } from './lib/auth';
-import { engagementRoutes } from './routes/engagement';
-import { statsRoutes } from './routes/stats';
-import { searchRoutes } from './routes/search';
-import { mergeRoutes } from './routes/merge';
-import { exportRoutes } from './routes/export';
-import { documentRoutes } from './routes/documents';
-import { goalRoutes } from './routes/goals';
-import { referralRoutes } from './routes/referrals';
-import { initJobQueue } from './services/jobs';
 
 const app = new Elysia()
-  // Rate limiting (before everything else)
-  .use(rateLimitPlugin)
-  
   // CORS
   .use(cors({
     origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
@@ -64,7 +44,21 @@ const app = new Elysia()
   .use(inviteRoutes)
   .use(passwordResetRoutes)
   
-  // API routes (auth middleware is in each route plugin)
+  // Protected routes - require auth
+  .derive(async ({ request, set }): Promise<{ user: User }> => {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+    
+    if (!session?.user) {
+      set.status = 401;
+      throw new Error('Unauthorized');
+    }
+    
+    return { user: session.user as User };
+  })
+  
+  // API routes (all require auth due to derive above)
   .group('/api', app => app
     .use(clientRoutes)
     .use(importRoutes)
@@ -76,73 +70,45 @@ const app = new Elysia()
     .use(networkRoutes)
     .use(insightsRoutes)
     .use(reportsRoutes)
-    .use(notesRoutes)
-    .use(notificationRoutes)
-    .use(interactionRoutes)
-    .use(templateRoutes)
-    .use(segmentRoutes)
-    .use(auditLogRoutes)
-    .use(meetingPrepRoutes)
-    .use(tagRoutes)
-    .use(engagementRoutes)
-    .use(statsRoutes)
-    .use(mergeRoutes)
-    .use(searchRoutes)
-    .use(exportRoutes)
-    .use(documentRoutes)
-    .use(goalRoutes)
-    .use(referralRoutes)
   )
   
   // Error handler
   .onError(({ code, error, set, path }) => {
     // Always log errors with full details
-    const message = error instanceof Error ? error.message : String(error);
-    const stack = error instanceof Error ? error.stack : undefined;
-
     console.error(`[${new Date().toISOString()}] ERROR on ${path}:`, {
       code,
-      message,
+      message: error.message,
-      stack,
+      stack: error.stack,
     });
     
     if (code === 'VALIDATION') {
       set.status = 400;
-      return { error: 'Validation error', details: message };
+      return { error: 'Validation error', details: error.message };
     }
     
-    if (message === 'Unauthorized') {
+    if (error.message === 'Unauthorized') {
       set.status = 401;
       return { error: 'Unauthorized' };
     }
 
-    if (message.includes('Forbidden')) {
+    if (error.message.includes('Forbidden')) {
       set.status = 403;
-      return { error: message };
+      return { error: error.message };
     }
     
-    if (message.includes('not found')) {
+    if (error.message.includes('not found')) {
       set.status = 404;
-      return { error: message };
+      return { error: error.message };
     }
     
     set.status = 500;
-    return { error: 'Internal server error', details: message };
+    return { error: 'Internal server error', details: error.message };
   })
   
   .listen(process.env.PORT || 3000);
 
 console.log(`🚀 Network App API running at ${app.server?.hostname}:${app.server?.port}`);
 
-// Initialize pg-boss job queue
-(async () => {
-  try {
-    await initJobQueue();
-  } catch (e) {
-    console.error('pg-boss init failed (will retry on next restart):', e);
-  }
-})();
-
 // Bootstrap: ensure donovan@donovankelly.xyz is admin
 (async () => {
   try {

src/middleware/auth.ts

@@ -1,20 +0,0 @@
-import { Elysia } from 'elysia';
-import { auth, type User } from '../lib/auth';
-
-/**
- * Auth middleware plugin - adds `user` to the Elysia context.
- * Import and `.use(authMiddleware)` in route files that need authentication.
- */
-export const authMiddleware = new Elysia({ name: 'auth-middleware' })
-  .derive({ as: 'scoped' }, async ({ request, set }): Promise<{ user: User }> => {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
-
-    if (!session?.user) {
-      set.status = 401;
-      throw new Error('Unauthorized');
-    }
-
-    return { user: session.user as User };
-  });

src/middleware/rate-limit.ts

@@ -1,95 +0,0 @@
-import { Elysia } from 'elysia';
-
-interface RateLimitEntry {
-  count: number;
-  resetAt: number;
-}
-
-interface RateLimitConfig {
-  windowMs: number;
-  maxRequests: number;
-}
-
-// In-memory store keyed by "bucket:ip"
-const store = new Map<string, RateLimitEntry>();
-
-// Cleanup expired entries every 60s
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, entry] of store) {
-    if (entry.resetAt <= now) {
-      store.delete(key);
-    }
-  }
-}, 60_000);
-
-function checkRateLimit(key: string, config: RateLimitConfig): { allowed: boolean; remaining: number; retryAfterSec: number } {
-  const now = Date.now();
-  const entry = store.get(key);
-
-  if (!entry || entry.resetAt <= now) {
-    store.set(key, { count: 1, resetAt: now + config.windowMs });
-    return { allowed: true, remaining: config.maxRequests - 1, retryAfterSec: 0 };
-  }
-
-  entry.count++;
-  if (entry.count > config.maxRequests) {
-    const retryAfterSec = Math.ceil((entry.resetAt - now) / 1000);
-    return { allowed: false, remaining: 0, retryAfterSec };
-  }
-
-  return { allowed: true, remaining: config.maxRequests - entry.count, retryAfterSec: 0 };
-}
-
-function getClientIP(request: Request): string {
-  // Check common proxy headers
-  const forwarded = request.headers.get('x-forwarded-for');
-  if (forwarded) return forwarded.split(',')[0]?.trim() ?? '127.0.0.1';
-  const realIp = request.headers.get('x-real-ip');
-  if (realIp) return realIp;
-  return '127.0.0.1';
-}
-
-// Route-specific limits
-const AUTH_PATHS = ['/api/auth/sign-in', '/api/auth/sign-up', '/auth/reset-password'];
-const AI_PATHS = ['/meeting-prep', '/emails/generate', '/emails/bulk-generate', '/network/intro'];
-
-function getBucket(path: string): { bucket: string; config: RateLimitConfig } {
-  const lowerPath = path.toLowerCase();
-
-  // Auth endpoints: 5 req/min
-  if (AUTH_PATHS.some(p => lowerPath.startsWith(p))) {
-    return { bucket: 'auth', config: { windowMs: 60_000, maxRequests: 5 } };
-  }
-
-  // AI endpoints: 10 req/min
-  if (AI_PATHS.some(p => lowerPath.includes(p))) {
-    return { bucket: 'ai', config: { windowMs: 60_000, maxRequests: 10 } };
-  }
-
-  // Global: 100 req/min
-  return { bucket: 'global', config: { windowMs: 60_000, maxRequests: 100 } };
-}
-
-export const rateLimitPlugin = new Elysia({ name: 'rate-limit' })
-  .onBeforeHandle(({ request, set }) => {
-    const ip = getClientIP(request);
-    const url = new URL(request.url);
-    const { bucket, config } = getBucket(url.pathname);
-    const key = `${bucket}:${ip}`;
-
-    const result = checkRateLimit(key, config);
-
-    // Always set rate limit headers
-    set.headers['X-RateLimit-Limit'] = String(config.maxRequests);
-    set.headers['X-RateLimit-Remaining'] = String(result.remaining);
-
-    if (!result.allowed) {
-      set.status = 429;
-      set.headers['Retry-After'] = String(result.retryAfterSec);
-      return {
-        error: 'Too many requests',
-        retryAfter: result.retryAfterSec,
-      };
-    }
-  });

src/routes/activity.ts

@@ -1,13 +1,12 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
-import { clients, events, communications, interactions } from '../db/schema';
+import { clients, events, communications } from '../db/schema';
 import { eq, and, desc } from 'drizzle-orm';
 import type { User } from '../lib/auth';
 
 export interface ActivityItem {
   id: string;
-  type: 'email_sent' | 'email_drafted' | 'event_created' | 'client_contacted' | 'client_created' | 'client_updated' | 'interaction';
+  type: 'email_sent' | 'email_drafted' | 'event_created' | 'client_contacted' | 'client_created' | 'client_updated';
   title: string;
   description?: string;
   date: string;
@@ -15,7 +14,6 @@ export interface ActivityItem {
 }
 
 export const activityRoutes = new Elysia({ prefix: '/clients' })
-  .use(authMiddleware)
   // Get activity timeline for a client
   .get('/:id/activity', async ({ params, user }: { params: { id: string }; user: User }) => {
     // Verify client belongs to user
@@ -112,37 +110,6 @@ export const activityRoutes = new Elysia({ prefix: '/clients' })
       });
     }
 
-    // Interactions
-    const clientInteractions = await db.select()
-      .from(interactions)
-      .where(and(
-        eq(interactions.clientId, params.id),
-        eq(interactions.userId, user.id),
-      ))
-      .orderBy(desc(interactions.contactedAt));
-
-    for (const interaction of clientInteractions) {
-      const typeLabels: Record<string, string> = {
-        call: '📞 Phone Call',
-        meeting: '🤝 Meeting',
-        email: '✉️ Email',
-        note: '📝 Note',
-        other: '📌 Interaction',
-      };
-      activities.push({
-        id: `interaction-${interaction.id}`,
-        type: 'interaction',
-        title: `${typeLabels[interaction.type] || typeLabels.other}: ${interaction.title}`,
-        description: interaction.description || undefined,
-        date: interaction.contactedAt.toISOString(),
-        metadata: {
-          interactionId: interaction.id,
-          interactionType: interaction.type,
-          duration: interaction.duration,
-        },
-      });
-    }
-
     // Sort by date descending
     activities.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
 

src/routes/admin.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { users, invites, passwordResetTokens } from '../db/schema';
@@ -7,7 +6,6 @@ import { auth } from '../lib/auth';
 import type { User } from '../lib/auth';
 
 export const adminRoutes = new Elysia({ prefix: '/admin' })
-  .use(authMiddleware)
   // Admin guard — all routes in this group require admin role
   .onBeforeHandle(({ user, set }: { user: User; set: any }) => {
     if ((user as any).role !== 'admin') {

src/routes/audit-logs.ts

@@ -1,103 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { auditLogs, users } from '../db/schema';
-import { eq, desc, and, gte, lte, ilike, or, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const auditLogRoutes = new Elysia({ prefix: '/audit-logs' })
-  .use(authMiddleware)
-  // Admin guard
-  .onBeforeHandle(({ user, set }: { user: User; set: any }) => {
-    if ((user as any).role !== 'admin') {
-      set.status = 403;
-      throw new Error('Forbidden: admin access required');
-    }
-  })
-
-  // List audit logs with filters
-  .get('/', async ({ query }: {
-    query: {
-      entityType?: string;
-      action?: string;
-      userId?: string;
-      startDate?: string;
-      endDate?: string;
-      search?: string;
-      page?: string;
-      limit?: string;
-    };
-  }) => {
-    const page = parseInt(query.page || '1');
-    const limit = Math.min(parseInt(query.limit || '50'), 100);
-    const offset = (page - 1) * limit;
-
-    const conditions: any[] = [];
-
-    if (query.entityType) {
-      conditions.push(eq(auditLogs.entityType, query.entityType));
-    }
-    if (query.action) {
-      conditions.push(eq(auditLogs.action, query.action));
-    }
-    if (query.userId) {
-      conditions.push(eq(auditLogs.userId, query.userId));
-    }
-    if (query.startDate) {
-      conditions.push(gte(auditLogs.createdAt, new Date(query.startDate)));
-    }
-    if (query.endDate) {
-      conditions.push(lte(auditLogs.createdAt, new Date(query.endDate)));
-    }
-    if (query.search) {
-      conditions.push(
-        sql`${auditLogs.details}::text ILIKE ${'%' + query.search + '%'}`
-      );
-    }
-
-    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-
-    const [logs, countResult] = await Promise.all([
-      db.select({
-        id: auditLogs.id,
-        userId: auditLogs.userId,
-        action: auditLogs.action,
-        entityType: auditLogs.entityType,
-        entityId: auditLogs.entityId,
-        details: auditLogs.details,
-        ipAddress: auditLogs.ipAddress,
-        userAgent: auditLogs.userAgent,
-        createdAt: auditLogs.createdAt,
-        userName: users.name,
-        userEmail: users.email,
-      })
-        .from(auditLogs)
-        .leftJoin(users, eq(auditLogs.userId, users.id))
-        .where(whereClause)
-        .orderBy(desc(auditLogs.createdAt))
-        .limit(limit)
-        .offset(offset),
-      db.select({ count: sql<number>`count(*)` })
-        .from(auditLogs)
-        .where(whereClause),
-    ]);
-
-    return {
-      logs,
-      total: Number(countResult[0]?.count || 0),
-      page,
-      limit,
-      totalPages: Math.ceil(Number(countResult[0]?.count || 0) / limit),
-    };
-  }, {
-    query: t.Object({
-      entityType: t.Optional(t.String()),
-      action: t.Optional(t.String()),
-      userId: t.Optional(t.String()),
-      startDate: t.Optional(t.String()),
-      endDate: t.Optional(t.String()),
-      search: t.Optional(t.String()),
-      page: t.Optional(t.String()),
-      limit: t.Optional(t.String()),
-    }),
-  });

src/routes/clients.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { clients, events } from '../db/schema';
@@ -79,15 +78,13 @@ const clientSchema = t.Object({
   })),
   notes: t.Optional(t.String()),
   tags: t.Optional(t.Array(t.String())),
-  stage: t.Optional(t.String()),
 });
 
 const updateClientSchema = t.Partial(clientSchema);
 
 export const clientRoutes = new Elysia({ prefix: '/clients' })
-  .use(authMiddleware)
+  // List clients with optional search
-  // List clients with optional search and pagination
+  .get('/', async ({ query, user }: { query: { search?: string; tag?: string }; user: User }) => {
-  .get('/', async ({ query, user }: { query: { search?: string; tag?: string; page?: string; limit?: string }; user: User }) => {
     let baseQuery = db.select().from(clients).where(eq(clients.userId, user.id));
     
     if (query.search) {
@@ -105,34 +102,18 @@ export const clientRoutes = new Elysia({ prefix: '/clients' })
       );
     }
     
-    let results = await baseQuery.orderBy(clients.lastName, clients.firstName);
+    const results = await baseQuery.orderBy(clients.lastName, clients.firstName);
     
     // Filter by tag in-memory if needed (JSONB filtering)
     if (query.tag) {
-      results = results.filter(c => c.tags?.includes(query.tag!));
+      return results.filter(c => c.tags?.includes(query.tag!));
     }
-
+    
-    // Pagination
+    return results;
-    const page = Math.max(1, parseInt(query.page || '1', 10) || 1);
-    const limit = Math.min(200, Math.max(1, parseInt(query.limit || '0', 10) || 0));
-
-    // If no limit specified, return all (backwards compatible)
-    if (!query.limit) {
-      return results;
-    }
-
-    const total = results.length;
-    const totalPages = Math.ceil(total / limit);
-    const offset = (page - 1) * limit;
-    const data = results.slice(offset, offset + limit);
-
-    return { data, total, page, limit, totalPages };
   }, {
     query: t.Object({
       search: t.Optional(t.String()),
       tag: t.Optional(t.String()),
-      page: t.Optional(t.String()),
-      limit: t.Optional(t.String()),
     }),
   })
   
@@ -176,14 +157,11 @@ export const clientRoutes = new Elysia({ prefix: '/clients' })
         family: body.family,
         notes: body.notes,
         tags: body.tags || [],
-        stage: body.stage || 'lead',
       })
       .returning();
     
     // Auto-sync birthday/anniversary events
-    if (client) {
+    await syncClientEvents(user.id, client);
-      await syncClientEvents(user.id, client);
-    }
     
     return client;
   }, {
@@ -214,7 +192,6 @@ export const clientRoutes = new Elysia({ prefix: '/clients' })
     if (body.family !== undefined) updateData.family = body.family;
     if (body.notes !== undefined) updateData.notes = body.notes;
     if (body.tags !== undefined) updateData.tags = body.tags;
-    if (body.stage !== undefined) updateData.stage = body.stage;
     
     const [client] = await db.update(clients)
       .set(updateData)

src/routes/documents.ts

@@ -1,150 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clientDocuments, clients } from '../db/schema';
-import { eq, and, desc, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-import { mkdir, unlink } from 'fs/promises';
-import { join } from 'path';
-
-const UPLOAD_DIR = process.env.UPLOAD_DIR || './uploads/documents';
-
-async function verifyClientOwnership(clientId: string, userId: string) {
-  const [client] = await db.select({ id: clients.id })
-    .from(clients)
-    .where(and(eq(clients.id, clientId), eq(clients.userId, userId)))
-    .limit(1);
-  if (!client) throw new Error('Client not found');
-  return client;
-}
-
-export const documentRoutes = new Elysia()
-  .use(authMiddleware)
-
-  // List documents for a client
-  .get('/clients/:clientId/documents', async ({ params, query, user }: { params: { clientId: string }; query: { category?: string }; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    let q = db.select()
-      .from(clientDocuments)
-      .where(eq(clientDocuments.clientId, params.clientId))
-      .orderBy(desc(clientDocuments.createdAt));
-
-    if (query.category) {
-      q = db.select()
-        .from(clientDocuments)
-        .where(and(
-          eq(clientDocuments.clientId, params.clientId),
-          eq(clientDocuments.category, query.category),
-        ))
-        .orderBy(desc(clientDocuments.createdAt));
-    }
-
-    return q;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-    query: t.Object({ category: t.Optional(t.String()) }),
-  })
-
-  // Upload document
-  .post('/clients/:clientId/documents', async ({ params, body, user }: { params: { clientId: string }; body: { file: File; name?: string; category?: string; notes?: string }; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    const file = body.file;
-    if (!file || !(file instanceof File)) {
-      throw new Error('File is required');
-    }
-
-    // Create directory
-    const clientDir = join(UPLOAD_DIR, params.clientId);
-    await mkdir(clientDir, { recursive: true });
-
-    // Generate unique filename
-    const ext = file.name.split('.').pop() || 'bin';
-    const uniqueName = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`;
-    const filePath = join(clientDir, uniqueName);
-
-    // Write file
-    const buffer = await file.arrayBuffer();
-    await Bun.write(filePath, buffer);
-
-    const [doc] = await db.insert(clientDocuments)
-      .values({
-        clientId: params.clientId,
-        userId: user.id,
-        name: body.name || file.name,
-        filename: uniqueName,
-        mimeType: file.type || 'application/octet-stream',
-        size: file.size,
-        category: body.category || 'other',
-        path: filePath,
-        notes: body.notes || null,
-      })
-      .returning();
-
-    return doc;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      file: t.File(),
-      name: t.Optional(t.String()),
-      category: t.Optional(t.String()),
-      notes: t.Optional(t.String()),
-    }),
-  })
-
-  // Download document
-  .get('/documents/:documentId/download', async ({ params, user, set }: { params: { documentId: string }; user: User; set: any }) => {
-    const [doc] = await db.select()
-      .from(clientDocuments)
-      .where(and(
-        eq(clientDocuments.id, params.documentId),
-        eq(clientDocuments.userId, user.id),
-      ))
-      .limit(1);
-
-    if (!doc) throw new Error('Document not found');
-
-    const file = Bun.file(doc.path);
-    if (!await file.exists()) {
-      throw new Error('File not found on disk');
-    }
-
-    set.headers['content-type'] = doc.mimeType;
-    set.headers['content-disposition'] = `attachment; filename="${doc.name}"`;
-    return file;
-  }, {
-    params: t.Object({ documentId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Delete document
-  .delete('/documents/:documentId', async ({ params, user }: { params: { documentId: string }; user: User }) => {
-    const [doc] = await db.delete(clientDocuments)
-      .where(and(
-        eq(clientDocuments.id, params.documentId),
-        eq(clientDocuments.userId, user.id),
-      ))
-      .returning();
-
-    if (!doc) throw new Error('Document not found');
-
-    // Try to delete file from disk
-    try { await unlink(doc.path); } catch {}
-
-    return { success: true, id: doc.id };
-  }, {
-    params: t.Object({ documentId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Get document count for a client (used by client cards)
-  .get('/clients/:clientId/documents/count', async ({ params, user }: { params: { clientId: string }; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    const [result] = await db.select({ count: sql<number>`count(*)::int` })
-      .from(clientDocuments)
-      .where(eq(clientDocuments.clientId, params.clientId));
-
-    return { count: result?.count || 0 };
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-  });

src/routes/emails.ts

@@ -1,15 +1,12 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { clients, communications, userProfiles } from '../db/schema';
-import { eq, and, inArray } from 'drizzle-orm';
+import { eq, and } from 'drizzle-orm';
 import { generateEmail, generateSubject, generateBirthdayMessage, type AIProvider } from '../services/ai';
 import { sendEmail } from '../services/email';
 import type { User } from '../lib/auth';
-import { randomUUID } from 'crypto';
 
 export const emailRoutes = new Elysia({ prefix: '/emails' })
-  .use(authMiddleware)
   // Generate email for a client
   .post('/generate', async ({ body, user }: { 
     body: { 
@@ -61,7 +58,6 @@ export const emailRoutes = new Elysia({ prefix: '/emails' })
         notes: client.notes || '',
         purpose: body.purpose,
         provider: body.provider,
-        communicationStyle: profile?.communicationStyle as any,
       });
       console.log(`[${new Date().toISOString()}] Email content generated successfully`);
     } catch (e) {
@@ -298,147 +294,6 @@ export const emailRoutes = new Elysia({ prefix: '/emails' })
     }),
   })
   
-  // Bulk generate emails
-  .post('/bulk-generate', async ({ body, user }: {
-    body: { clientIds: string[]; purpose: string; provider?: AIProvider };
-    user: User;
-  }) => {
-    const batchId = randomUUID();
-
-    // Get user profile
-    const [profile] = await db.select()
-      .from(userProfiles)
-      .where(eq(userProfiles.userId, user.id))
-      .limit(1);
-
-    const advisorInfo = {
-      name: user.name,
-      title: profile?.title || '',
-      company: profile?.company || '',
-      phone: profile?.phone || '',
-      signature: profile?.emailSignature || '',
-    };
-
-    // Get all selected clients
-    const selectedClients = await db.select()
-      .from(clients)
-      .where(and(
-        inArray(clients.id, body.clientIds),
-        eq(clients.userId, user.id),
-      ));
-
-    if (selectedClients.length === 0) {
-      throw new Error('No valid clients found');
-    }
-
-    const results = [];
-
-    for (const client of selectedClients) {
-      try {
-        const content = await generateEmail({
-          advisorName: advisorInfo.name,
-          advisorTitle: advisorInfo.title,
-          advisorCompany: advisorInfo.company,
-          advisorPhone: advisorInfo.phone,
-          advisorSignature: advisorInfo.signature,
-          clientName: client.firstName,
-          interests: client.interests || [],
-          notes: client.notes || '',
-          purpose: body.purpose,
-          provider: body.provider,
-        });
-
-        const subject = await generateSubject(body.purpose, client.firstName, body.provider);
-
-        const [comm] = await db.insert(communications)
-          .values({
-            userId: user.id,
-            clientId: client.id,
-            type: 'email',
-            subject,
-            content,
-            aiGenerated: true,
-            aiModel: body.provider || 'anthropic',
-            status: 'draft',
-            batchId,
-          })
-          .returning();
-
-        results.push({ clientId: client.id, email: comm, success: true });
-      } catch (error: any) {
-        results.push({ clientId: client.id, error: error.message, success: false });
-      }
-    }
-
-    return { batchId, results, total: selectedClients.length, generated: results.filter(r => r.success).length };
-  }, {
-    body: t.Object({
-      clientIds: t.Array(t.String({ format: 'uuid' }), { minItems: 1 }),
-      purpose: t.String({ minLength: 1 }),
-      provider: t.Optional(t.Union([t.Literal('anthropic'), t.Literal('openai')])),
-    }),
-  })
-
-  // Bulk send all drafts in a batch
-  .post('/bulk-send', async ({ body, user }: {
-    body: { batchId: string };
-    user: User;
-  }) => {
-    // Get all drafts in this batch
-    const drafts = await db.select({
-      email: communications,
-      client: clients,
-    })
-      .from(communications)
-      .innerJoin(clients, eq(communications.clientId, clients.id))
-      .where(and(
-        eq(communications.batchId, body.batchId),
-        eq(communications.userId, user.id),
-        eq(communications.status, 'draft'),
-      ));
-
-    const results = [];
-
-    for (const { email, client } of drafts) {
-      if (!client.email) {
-        results.push({ id: email.id, success: false, error: 'Client has no email' });
-        continue;
-      }
-
-      try {
-        await sendEmail({
-          to: client.email,
-          subject: email.subject || 'Message from your advisor',
-          content: email.content,
-        });
-
-        await db.update(communications)
-          .set({ status: 'sent', sentAt: new Date() })
-          .where(eq(communications.id, email.id));
-
-        await db.update(clients)
-          .set({ lastContactedAt: new Date() })
-          .where(eq(clients.id, client.id));
-
-        results.push({ id: email.id, success: true });
-      } catch (error: any) {
-        results.push({ id: email.id, success: false, error: error.message });
-      }
-    }
-
-    return {
-      batchId: body.batchId,
-      total: drafts.length,
-      sent: results.filter(r => r.success).length,
-      failed: results.filter(r => !r.success).length,
-      results,
-    };
-  }, {
-    body: t.Object({
-      batchId: t.String({ minLength: 1 }),
-    }),
-  })
-
   // Delete draft
   .delete('/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
     const [deleted] = await db.delete(communications)

src/routes/engagement.ts

@@ -1,326 +0,0 @@
-import { Elysia } from 'elysia';
-import { db } from '../db';
-import { clients, interactions, communications, events, clientNotes } from '../db/schema';
-import { eq, and, gte, count, desc, sql } from 'drizzle-orm';
-import { authMiddleware } from '../middleware/auth';
-import type { User } from '../lib/auth';
-
-/**
- * Client Engagement Scoring
- * 
- * Scores each client 0-100 based on:
- * - Recency of last contact (40 pts)
- * - Interaction frequency in last 90 days (25 pts)
- * - Email communication activity (15 pts)
- * - Events/meetings scheduled (10 pts)
- * - Notes activity (10 pts)
- */
-
-interface EngagementScore {
-  clientId: string;
-  clientName: string;
-  score: number;
-  breakdown: {
-    recency: number;      // 0-40
-    interactions: number;  // 0-25
-    emails: number;        // 0-15
-    events: number;        // 0-10
-    notes: number;         // 0-10
-  };
-  lastContactedAt: string | null;
-  stage: string;
-  trend: 'rising' | 'stable' | 'declining';
-}
-
-function calculateRecencyScore(lastContactedAt: Date | null): number {
-  if (!lastContactedAt) return 0;
-  const daysSince = Math.floor((Date.now() - lastContactedAt.getTime()) / (1000 * 60 * 60 * 24));
-  if (daysSince <= 7) return 40;
-  if (daysSince <= 14) return 35;
-  if (daysSince <= 30) return 28;
-  if (daysSince <= 60) return 18;
-  if (daysSince <= 90) return 10;
-  if (daysSince <= 180) return 5;
-  return 0;
-}
-
-function calculateInteractionScore(count: number): number {
-  if (count >= 10) return 25;
-  if (count >= 7) return 22;
-  if (count >= 5) return 18;
-  if (count >= 3) return 14;
-  if (count >= 1) return 8;
-  return 0;
-}
-
-function calculateEmailScore(count: number): number {
-  if (count >= 8) return 15;
-  if (count >= 5) return 12;
-  if (count >= 3) return 9;
-  if (count >= 1) return 5;
-  return 0;
-}
-
-function calculateEventScore(count: number): number {
-  if (count >= 4) return 10;
-  if (count >= 2) return 7;
-  if (count >= 1) return 4;
-  return 0;
-}
-
-function calculateNoteScore(count: number): number {
-  if (count >= 5) return 10;
-  if (count >= 3) return 7;
-  if (count >= 1) return 4;
-  return 0;
-}
-
-function getEngagementLabel(score: number): string {
-  if (score >= 80) return 'highly_engaged';
-  if (score >= 60) return 'engaged';
-  if (score >= 40) return 'warm';
-  if (score >= 20) return 'cooling';
-  return 'cold';
-}
-
-export const engagementRoutes = new Elysia()
-  .use(authMiddleware)
-  // Get engagement scores for all clients
-  .get('/engagement', async ({ user }) => {
-    const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
-
-    // Get all clients
-    const allClients = await db.select().from(clients).where(eq(clients.userId, user.id));
-
-    const scores: EngagementScore[] = [];
-
-    for (const client of allClients) {
-      // Count interactions in last 90 days
-      const [interactionCount] = await db.select({ count: count() })
-        .from(interactions)
-        .where(and(
-          eq(interactions.clientId, client.id),
-          gte(interactions.contactedAt, ninetyDaysAgo),
-        ));
-
-      // Count emails in last 90 days
-      const [emailCount] = await db.select({ count: count() })
-        .from(communications)
-        .where(and(
-          eq(communications.clientId, client.id),
-          gte(communications.createdAt, ninetyDaysAgo),
-        ));
-
-      // Count events in last 90 days
-      const [eventCount] = await db.select({ count: count() })
-        .from(events)
-        .where(and(
-          eq(events.clientId, client.id),
-          gte(events.date, ninetyDaysAgo),
-        ));
-
-      // Count notes in last 90 days
-      const [noteCount] = await db.select({ count: count() })
-        .from(clientNotes)
-        .where(and(
-          eq(clientNotes.clientId, client.id),
-          gte(clientNotes.createdAt, ninetyDaysAgo),
-        ));
-
-      const breakdown = {
-        recency: calculateRecencyScore(client.lastContactedAt),
-        interactions: calculateInteractionScore(interactionCount?.count || 0),
-        emails: calculateEmailScore(emailCount?.count || 0),
-        events: calculateEventScore(eventCount?.count || 0),
-        notes: calculateNoteScore(noteCount?.count || 0),
-      };
-
-      const score = breakdown.recency + breakdown.interactions + breakdown.emails + breakdown.events + breakdown.notes;
-
-      // Simple trend: compare current 45-day vs previous 45-day interaction count
-      const fortyFiveDaysAgo = new Date(Date.now() - 45 * 24 * 60 * 60 * 1000);
-      const [recentInteractions] = await db.select({ count: count() })
-        .from(interactions)
-        .where(and(
-          eq(interactions.clientId, client.id),
-          gte(interactions.contactedAt, fortyFiveDaysAgo),
-        ));
-      const [olderInteractions] = await db.select({ count: count() })
-        .from(interactions)
-        .where(and(
-          eq(interactions.clientId, client.id),
-          gte(interactions.contactedAt, ninetyDaysAgo),
-        ));
-      const recent = recentInteractions?.count || 0;
-      const older = (olderInteractions?.count || 0) - recent;
-      const trend: 'rising' | 'stable' | 'declining' = recent > older ? 'rising' : recent < older ? 'declining' : 'stable';
-
-      scores.push({
-        clientId: client.id,
-        clientName: `${client.firstName} ${client.lastName}`,
-        score,
-        breakdown,
-        lastContactedAt: client.lastContactedAt?.toISOString() || null,
-        stage: client.stage || 'lead',
-        trend,
-      });
-    }
-
-    // Sort by score descending
-    scores.sort((a, b) => b.score - a.score);
-
-    // Summary stats
-    const distribution = {
-      highly_engaged: scores.filter(s => s.score >= 80).length,
-      engaged: scores.filter(s => s.score >= 60 && s.score < 80).length,
-      warm: scores.filter(s => s.score >= 40 && s.score < 60).length,
-      cooling: scores.filter(s => s.score >= 20 && s.score < 40).length,
-      cold: scores.filter(s => s.score < 20).length,
-    };
-
-    const avgScore = scores.length > 0
-      ? Math.round(scores.reduce((sum, s) => sum + s.score, 0) / scores.length)
-      : 0;
-
-    return {
-      scores,
-      summary: {
-        totalClients: scores.length,
-        averageScore: avgScore,
-        distribution,
-        topClients: scores.slice(0, 5).map(s => ({ name: s.clientName, score: s.score })),
-        needsAttention: scores.filter(s => s.score < 20).map(s => ({
-          name: s.clientName,
-          score: s.score,
-          lastContactedAt: s.lastContactedAt,
-        })),
-      },
-    };
-  })
-
-  // Get engagement score for a single client
-  .get('/clients/:id/engagement', async ({ user, params, set }) => {
-    const clientId = params.id;
-    const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
-
-    const [client] = await db.select().from(clients)
-      .where(and(eq(clients.id, clientId), eq(clients.userId, user.id)))
-      .limit(1);
-
-    if (!client) {
-      set.status = 404;
-      return { error: 'Client not found' };
-    }
-
-    // Get interaction counts
-    const [interactionCount] = await db.select({ count: count() })
-      .from(interactions)
-      .where(and(
-        eq(interactions.clientId, clientId),
-        gte(interactions.contactedAt, ninetyDaysAgo),
-      ));
-
-    const [emailCount] = await db.select({ count: count() })
-      .from(communications)
-      .where(and(
-        eq(communications.clientId, clientId),
-        gte(communications.createdAt, ninetyDaysAgo),
-      ));
-
-    const [eventCount] = await db.select({ count: count() })
-      .from(events)
-      .where(and(
-        eq(events.clientId, clientId),
-        gte(events.date, ninetyDaysAgo),
-      ));
-
-    const [noteCount] = await db.select({ count: count() })
-      .from(clientNotes)
-      .where(and(
-        eq(clientNotes.clientId, clientId),
-        gte(clientNotes.createdAt, ninetyDaysAgo),
-      ));
-
-    const breakdown = {
-      recency: calculateRecencyScore(client.lastContactedAt),
-      interactions: calculateInteractionScore(interactionCount?.count || 0),
-      emails: calculateEmailScore(emailCount?.count || 0),
-      events: calculateEventScore(eventCount?.count || 0),
-      notes: calculateNoteScore(noteCount?.count || 0),
-    };
-
-    const score = breakdown.recency + breakdown.interactions + breakdown.emails + breakdown.events + breakdown.notes;
-
-    // Get recent interaction history for sparkline/chart
-    const recentInteractions = await db.select({
-      contactedAt: interactions.contactedAt,
-      type: interactions.type,
-    })
-      .from(interactions)
-      .where(and(
-        eq(interactions.clientId, clientId),
-        gte(interactions.contactedAt, ninetyDaysAgo),
-      ))
-      .orderBy(desc(interactions.contactedAt))
-      .limit(20);
-
-    return {
-      clientId,
-      clientName: `${client.firstName} ${client.lastName}`,
-      score,
-      label: getEngagementLabel(score),
-      breakdown,
-      rawCounts: {
-        interactions: interactionCount?.count || 0,
-        emails: emailCount?.count || 0,
-        events: eventCount?.count || 0,
-        notes: noteCount?.count || 0,
-      },
-      recentInteractions: recentInteractions.map(i => ({
-        date: i.contactedAt?.toISOString(),
-        type: i.type,
-      })),
-      recommendations: generateRecommendations(score, breakdown, client),
-    };
-  });
-
-function generateRecommendations(
-  score: number,
-  breakdown: EngagementScore['breakdown'],
-  client: { firstName: string; lastName: string; email: string | null; lastContactedAt: Date | null }
-): string[] {
-  const recs: string[] = [];
-
-  if (breakdown.recency < 18) {
-    const daysSince = client.lastContactedAt
-      ? Math.floor((Date.now() - client.lastContactedAt.getTime()) / (1000 * 60 * 60 * 24))
-      : null;
-    recs.push(
-      daysSince
-        ? `It's been ${daysSince} days since last contact — reach out soon.`
-        : `No contact recorded yet — schedule an intro call.`
-    );
-  }
-
-  if (breakdown.interactions < 10) {
-    recs.push('Log more interactions — calls, meetings, and notes all count.');
-  }
-
-  if (breakdown.emails < 5 && client.email) {
-    recs.push('Send a personalized email to strengthen the relationship.');
-  }
-
-  if (breakdown.events < 4) {
-    recs.push('Schedule a follow-up meeting or check-in event.');
-  }
-
-  if (breakdown.notes < 4) {
-    recs.push('Add notes after each interaction to track relationship context.');
-  }
-
-  if (score >= 80) {
-    recs.push(`${client.firstName} is highly engaged — consider them for referrals or network introductions.`);
-  }
-
-  return recs;
-}

src/routes/events.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { events, clients } from '../db/schema';
@@ -6,7 +5,6 @@ import { eq, and, gte, lte, sql } from 'drizzle-orm';
 import type { User } from '../lib/auth';
 
 export const eventRoutes = new Elysia({ prefix: '/events' })
-  .use(authMiddleware)
   // List events with optional filters
   .get('/', async ({ query, user }: {
     query: { 

src/routes/export.ts

@@ -1,270 +0,0 @@
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clients, communications, events, interactions, clientNotes, emailTemplates, clientSegments } from '../db/schema';
-import { and, eq, desc } from 'drizzle-orm';
-import { logAudit, getRequestMeta } from '../services/audit';
-
-export const exportRoutes = new Elysia({ prefix: '/export' })
-  // Full data export (JSON)
-  .get('/json', async ({ headers, request }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const [
-      allClients,
-      allEmails,
-      allEvents,
-      allInteractions,
-      allNotes,
-      allTemplates,
-      allSegments,
-    ] = await Promise.all([
-      db.select().from(clients).where(eq(clients.userId, userId)).orderBy(desc(clients.createdAt)),
-      db.select().from(communications).where(eq(communications.userId, userId)).orderBy(desc(communications.createdAt)),
-      db.select().from(events).where(eq(events.userId, userId)).orderBy(desc(events.date)),
-      db.select().from(interactions).where(eq(interactions.userId, userId)).orderBy(desc(interactions.createdAt)),
-      db.select().from(clientNotes).where(eq(clientNotes.userId, userId)).orderBy(desc(clientNotes.createdAt)),
-      db.select().from(emailTemplates).where(eq(emailTemplates.userId, userId)).orderBy(desc(emailTemplates.createdAt)),
-      db.select().from(clientSegments).where(eq(clientSegments.userId, userId)).orderBy(desc(clientSegments.createdAt)),
-    ]);
-
-    const meta = getRequestMeta(request);
-    await logAudit({
-      userId,
-      action: 'view',
-      entityType: 'export' as any,
-      entityId: 'full-json',
-      details: {
-        clients: allClients.length,
-        emails: allEmails.length,
-        events: allEvents.length,
-        interactions: allInteractions.length,
-        notes: allNotes.length,
-        templates: allTemplates.length,
-        segments: allSegments.length,
-      },
-      ...meta,
-    });
-
-    const exportData = {
-      exportedAt: new Date().toISOString(),
-      version: '1.0',
-      summary: {
-        clients: allClients.length,
-        emails: allEmails.length,
-        events: allEvents.length,
-        interactions: allInteractions.length,
-        notes: allNotes.length,
-        templates: allTemplates.length,
-        segments: allSegments.length,
-      },
-      data: {
-        clients: allClients,
-        emails: allEmails,
-        events: allEvents,
-        interactions: allInteractions,
-        notes: allNotes,
-        templates: allTemplates,
-        segments: allSegments,
-      },
-    };
-
-    return new Response(JSON.stringify(exportData, null, 2), {
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Disposition': `attachment; filename="network-app-export-${new Date().toISOString().split('T')[0]}.json"`,
-      },
-    });
-  })
-
-  // CSV export for clients
-  .get('/clients/csv', async ({ headers, request }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const allClients = await db.select().from(clients).where(eq(clients.userId, userId)).orderBy(desc(clients.createdAt));
-
-    const csvHeaders = [
-      'First Name', 'Last Name', 'Email', 'Phone', 'Company', 'Role', 'Industry',
-      'Stage', 'Street', 'City', 'State', 'Zip',
-      'Birthday', 'Anniversary', 'Interests', 'Tags', 'Notes',
-      'Last Contacted', 'Created At',
-    ];
-
-    const escCsv = (v: any) => {
-      if (v == null) return '';
-      const s = String(v);
-      if (s.includes(',') || s.includes('"') || s.includes('\n')) {
-        return `"${s.replace(/"/g, '""')}"`;
-      }
-      return s;
-    };
-
-    const rows = allClients.map(c => [
-      c.firstName, c.lastName, c.email, c.phone, c.company, c.role, c.industry,
-      c.stage, c.street, c.city, c.state, c.zip,
-      c.birthday?.toISOString().split('T')[0],
-      c.anniversary?.toISOString().split('T')[0],
-      ((c.interests as string[]) || []).join('; '),
-      ((c.tags as string[]) || []).join('; '),
-      c.notes,
-      c.lastContactedAt?.toISOString(),
-      c.createdAt.toISOString(),
-    ].map(escCsv).join(','));
-
-    const csv = [csvHeaders.join(','), ...rows].join('\n');
-
-    const csvMeta = getRequestMeta(request);
-    await logAudit({
-      userId,
-      action: 'view',
-      entityType: 'export' as any,
-      entityId: 'clients-csv',
-      details: { clientCount: allClients.length },
-      ...csvMeta,
-    });
-
-    return new Response(csv, {
-      headers: {
-        'Content-Type': 'text/csv',
-        'Content-Disposition': `attachment; filename="clients-export-${new Date().toISOString().split('T')[0]}.csv"`,
-      },
-    });
-  })
-
-  // CSV export for interactions
-  .get('/interactions/csv', async ({ headers, request }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const allInteractions = await db
-      .select({
-        id: interactions.id,
-        type: interactions.type,
-        title: interactions.title,
-        description: interactions.description,
-        duration: interactions.duration,
-        contactedAt: interactions.contactedAt,
-        createdAt: interactions.createdAt,
-        clientFirstName: clients.firstName,
-        clientLastName: clients.lastName,
-        clientEmail: clients.email,
-      })
-      .from(interactions)
-      .leftJoin(clients, eq(interactions.clientId, clients.id))
-      .where(eq(interactions.userId, userId))
-      .orderBy(desc(interactions.contactedAt));
-
-    const csvHeaders = ['Client Name', 'Client Email', 'Type', 'Title', 'Description', 'Duration (min)', 'Date', 'Created At'];
-
-    const escCsv = (v: any) => {
-      if (v == null) return '';
-      const s = String(v);
-      if (s.includes(',') || s.includes('"') || s.includes('\n')) {
-        return `"${s.replace(/"/g, '""')}"`;
-      }
-      return s;
-    };
-
-    const rows = allInteractions.map(i => [
-      `${i.clientFirstName} ${i.clientLastName}`,
-      i.clientEmail,
-      i.type,
-      i.title,
-      i.description,
-      i.duration,
-      i.contactedAt.toISOString(),
-      i.createdAt.toISOString(),
-    ].map(escCsv).join(','));
-
-    const csv = [csvHeaders.join(','), ...rows].join('\n');
-
-    return new Response(csv, {
-      headers: {
-        'Content-Type': 'text/csv',
-        'Content-Disposition': `attachment; filename="interactions-export-${new Date().toISOString().split('T')[0]}.csv"`,
-      },
-    });
-  })
-
-  // Export summary/stats
-  .get('/summary', async ({ headers }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const [clientCount, emailCount, eventCount, interactionCount, noteCount, templateCount, segmentCount] = await Promise.all([
-      db.select({ count: sql`count(*)` }).from(clients).where(eq(clients.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(communications).where(eq(communications.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(events).where(eq(events.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(interactions).where(eq(interactions.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(clientNotes).where(eq(clientNotes.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(emailTemplates).where(eq(emailTemplates.userId, userId)),
-      db.select({ count: sql`count(*)` }).from(clientSegments).where(eq(clientSegments.userId, userId)),
-    ]);
-
-    return {
-      clients: Number(clientCount[0]?.count || 0),
-      emails: Number(emailCount[0]?.count || 0),
-      events: Number(eventCount[0]?.count || 0),
-      interactions: Number(interactionCount[0]?.count || 0),
-      notes: Number(noteCount[0]?.count || 0),
-      templates: Number(templateCount[0]?.count || 0),
-      segments: Number(segmentCount[0]?.count || 0),
-      exportFormats: ['json', 'clients-csv', 'interactions-csv'],
-    };
-  });
-
-// Need sql import
-import { sql } from 'drizzle-orm';

src/routes/goals.ts

@@ -1,153 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clientGoals, clients } from '../db/schema';
-import { eq, and, desc, sql, ne } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-async function verifyClientOwnership(clientId: string, userId: string) {
-  const [client] = await db.select({ id: clients.id })
-    .from(clients)
-    .where(and(eq(clients.id, clientId), eq(clients.userId, userId)))
-    .limit(1);
-  if (!client) throw new Error('Client not found');
-  return client;
-}
-
-export const goalRoutes = new Elysia()
-  .use(authMiddleware)
-
-  // List goals for a client
-  .get('/clients/:clientId/goals', async ({ params, user }: { params: { clientId: string }; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    return db.select()
-      .from(clientGoals)
-      .where(eq(clientGoals.clientId, params.clientId))
-      .orderBy(desc(clientGoals.createdAt));
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Create goal
-  .post('/clients/:clientId/goals', async ({ params, body, user }: { params: { clientId: string }; body: any; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    const [goal] = await db.insert(clientGoals)
-      .values({
-        clientId: params.clientId,
-        userId: user.id,
-        title: body.title,
-        description: body.description || null,
-        category: body.category || 'other',
-        targetAmount: body.targetAmount || null,
-        currentAmount: body.currentAmount || '0',
-        targetDate: body.targetDate ? new Date(body.targetDate) : null,
-        status: body.status || 'on-track',
-        priority: body.priority || 'medium',
-      })
-      .returning();
-
-    return goal;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      title: t.String({ minLength: 1 }),
-      description: t.Optional(t.String()),
-      category: t.Optional(t.String()),
-      targetAmount: t.Optional(t.String()),
-      currentAmount: t.Optional(t.String()),
-      targetDate: t.Optional(t.String()),
-      status: t.Optional(t.String()),
-      priority: t.Optional(t.String()),
-    }),
-  })
-
-  // Update goal
-  .put('/goals/:goalId', async ({ params, body, user }: { params: { goalId: string }; body: any; user: User }) => {
-    const updateData: Record<string, unknown> = { updatedAt: new Date() };
-    if (body.title !== undefined) updateData.title = body.title;
-    if (body.description !== undefined) updateData.description = body.description;
-    if (body.category !== undefined) updateData.category = body.category;
-    if (body.targetAmount !== undefined) updateData.targetAmount = body.targetAmount;
-    if (body.currentAmount !== undefined) updateData.currentAmount = body.currentAmount;
-    if (body.targetDate !== undefined) updateData.targetDate = body.targetDate ? new Date(body.targetDate) : null;
-    if (body.status !== undefined) updateData.status = body.status;
-    if (body.priority !== undefined) updateData.priority = body.priority;
-
-    const [goal] = await db.update(clientGoals)
-      .set(updateData)
-      .where(and(
-        eq(clientGoals.id, params.goalId),
-        eq(clientGoals.userId, user.id),
-      ))
-      .returning();
-
-    if (!goal) throw new Error('Goal not found');
-    return goal;
-  }, {
-    params: t.Object({ goalId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      title: t.Optional(t.String({ minLength: 1 })),
-      description: t.Optional(t.String()),
-      category: t.Optional(t.String()),
-      targetAmount: t.Optional(t.String()),
-      currentAmount: t.Optional(t.String()),
-      targetDate: t.Optional(t.Nullable(t.String())),
-      status: t.Optional(t.String()),
-      priority: t.Optional(t.String()),
-    }),
-  })
-
-  // Delete goal
-  .delete('/goals/:goalId', async ({ params, user }: { params: { goalId: string }; user: User }) => {
-    const [deleted] = await db.delete(clientGoals)
-      .where(and(
-        eq(clientGoals.id, params.goalId),
-        eq(clientGoals.userId, user.id),
-      ))
-      .returning({ id: clientGoals.id });
-
-    if (!deleted) throw new Error('Goal not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({ goalId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Goals overview (dashboard) - at-risk goals across all clients
-  .get('/goals/overview', async ({ user }: { user: User }) => {
-    const allGoals = await db.select({
-      id: clientGoals.id,
-      clientId: clientGoals.clientId,
-      title: clientGoals.title,
-      category: clientGoals.category,
-      targetAmount: clientGoals.targetAmount,
-      currentAmount: clientGoals.currentAmount,
-      targetDate: clientGoals.targetDate,
-      status: clientGoals.status,
-      priority: clientGoals.priority,
-      clientFirstName: clients.firstName,
-      clientLastName: clients.lastName,
-    })
-      .from(clientGoals)
-      .innerJoin(clients, eq(clientGoals.clientId, clients.id))
-      .where(eq(clientGoals.userId, user.id))
-      .orderBy(desc(clientGoals.updatedAt));
-
-    const total = allGoals.length;
-    const byStatus = {
-      'on-track': allGoals.filter(g => g.status === 'on-track').length,
-      'at-risk': allGoals.filter(g => g.status === 'at-risk').length,
-      'behind': allGoals.filter(g => g.status === 'behind').length,
-      'completed': allGoals.filter(g => g.status === 'completed').length,
-    };
-    const atRiskGoals = allGoals.filter(g => g.status === 'at-risk' || g.status === 'behind');
-    const highPriorityGoals = allGoals.filter(g => g.priority === 'high' && g.status !== 'completed');
-
-    return {
-      total,
-      byStatus,
-      atRiskGoals: atRiskGoals.slice(0, 10),
-      highPriorityGoals: highPriorityGoals.slice(0, 10),
-    };
-  });

src/routes/import.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { clients, events } from '../db/schema';
@@ -161,7 +160,6 @@ async function syncClientEvents(userId: string, client: { id: string; firstName:
 }
 
 export const importRoutes = new Elysia({ prefix: '/clients' })
-  .use(authMiddleware)
   // Preview CSV - returns headers and auto-mapped columns + sample rows
   .post('/import/preview', async ({ body, user }: { body: { file: File }; user: User }) => {
     const text = await body.file.text();
@@ -213,7 +211,6 @@ export const importRoutes = new Elysia({ prefix: '/clients' })
 
     for (let i = 0; i < dataRows.length; i++) {
       const row = dataRows[i];
-      if (!row) continue;
       try {
         const record: Record<string, any> = {};
         
@@ -263,14 +260,12 @@ export const importRoutes = new Elysia({ prefix: '/clients' })
           .returning();
 
         // Sync events
-        if (client) {
+        await syncClientEvents(user.id, {
-          await syncClientEvents(user.id, {
+          id: client.id,
-            id: client.id,
+          firstName: client.firstName,
-            firstName: client.firstName,
+          birthday: client.birthday,
-            birthday: client.birthday,
+          anniversary: client.anniversary,
-            anniversary: client.anniversary,
+        });
-          });
-        }
 
         results.imported++;
       } catch (err: any) {

src/routes/insights.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia } from 'elysia';
 import { db } from '../db';
 import { clients, events } from '../db/schema';
@@ -6,7 +5,6 @@ import { eq, and, sql, lte, gte, isNull, or } from 'drizzle-orm';
 import type { User } from '../lib/auth';
 
 export const insightsRoutes = new Elysia({ prefix: '/insights' })
-  .use(authMiddleware)
   .get('/', async ({ user }: { user: User }) => {
     const now = new Date();
     const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);

src/routes/interactions.ts

@@ -1,143 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { interactions, clients } from '../db/schema';
-import { eq, and, desc } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const interactionRoutes = new Elysia()
-  .use(authMiddleware)
-  // List interactions for a client
-  .get('/clients/:clientId/interactions', async ({ params, user }: { params: { clientId: string }; user: User }) => {
-    // Verify client belongs to user
-    const [client] = await db.select()
-      .from(clients)
-      .where(and(eq(clients.id, params.clientId), eq(clients.userId, user.id)))
-      .limit(1);
-
-    if (!client) throw new Error('Client not found');
-
-    const items = await db.select()
-      .from(interactions)
-      .where(and(eq(interactions.clientId, params.clientId), eq(interactions.userId, user.id)))
-      .orderBy(desc(interactions.contactedAt));
-
-    return items;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Create interaction
-  .post('/clients/:clientId/interactions', async ({ params, body, user }: {
-    params: { clientId: string };
-    body: { type: string; title: string; description?: string; duration?: number; contactedAt: string };
-    user: User;
-  }) => {
-    // Verify client belongs to user
-    const [client] = await db.select()
-      .from(clients)
-      .where(and(eq(clients.id, params.clientId), eq(clients.userId, user.id)))
-      .limit(1);
-
-    if (!client) throw new Error('Client not found');
-
-    const [interaction] = await db.insert(interactions)
-      .values({
-        userId: user.id,
-        clientId: params.clientId,
-        type: body.type,
-        title: body.title,
-        description: body.description,
-        duration: body.duration,
-        contactedAt: new Date(body.contactedAt),
-      })
-      .returning();
-
-    // Auto-update lastContactedAt on the client
-    const contactDate = new Date(body.contactedAt);
-    if (!client.lastContactedAt || contactDate > client.lastContactedAt) {
-      await db.update(clients)
-        .set({ lastContactedAt: contactDate, updatedAt: new Date() })
-        .where(eq(clients.id, params.clientId));
-    }
-
-    return interaction;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      type: t.String({ minLength: 1 }),
-      title: t.String({ minLength: 1 }),
-      description: t.Optional(t.String()),
-      duration: t.Optional(t.Number({ minimum: 0 })),
-      contactedAt: t.String(),
-    }),
-  })
-
-  // Update interaction
-  .put('/interactions/:id', async ({ params, body, user }: {
-    params: { id: string };
-    body: { type?: string; title?: string; description?: string; duration?: number; contactedAt?: string };
-    user: User;
-  }) => {
-    const updateData: Record<string, unknown> = {};
-    if (body.type !== undefined) updateData.type = body.type;
-    if (body.title !== undefined) updateData.title = body.title;
-    if (body.description !== undefined) updateData.description = body.description;
-    if (body.duration !== undefined) updateData.duration = body.duration;
-    if (body.contactedAt !== undefined) updateData.contactedAt = new Date(body.contactedAt);
-
-    const [updated] = await db.update(interactions)
-      .set(updateData)
-      .where(and(eq(interactions.id, params.id), eq(interactions.userId, user.id)))
-      .returning();
-
-    if (!updated) throw new Error('Interaction not found');
-    return updated;
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      type: t.Optional(t.String()),
-      title: t.Optional(t.String()),
-      description: t.Optional(t.String()),
-      duration: t.Optional(t.Number({ minimum: 0 })),
-      contactedAt: t.Optional(t.String()),
-    }),
-  })
-
-  // Delete interaction
-  .delete('/interactions/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [deleted] = await db.delete(interactions)
-      .where(and(eq(interactions.id, params.id), eq(interactions.userId, user.id)))
-      .returning({ id: interactions.id });
-
-    if (!deleted) throw new Error('Interaction not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  })
-
-  // Get all recent interactions across all clients (for dashboard)
-  .get('/interactions/recent', async ({ query, user }: { query: { limit?: string }; user: User }) => {
-    const limit = query.limit ? parseInt(query.limit) : 10;
-
-    const items = await db.select({
-      interaction: interactions,
-      client: {
-        id: clients.id,
-        firstName: clients.firstName,
-        lastName: clients.lastName,
-      },
-    })
-      .from(interactions)
-      .innerJoin(clients, eq(interactions.clientId, clients.id))
-      .where(eq(interactions.userId, user.id))
-      .orderBy(desc(interactions.contactedAt))
-      .limit(limit);
-
-    return items.map(({ interaction, client }) => ({
-      ...interaction,
-      client,
-    }));
-  }, {
-    query: t.Object({ limit: t.Optional(t.String()) }),
-  });

src/routes/meeting-prep.ts

@@ -1,172 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clients, interactions, communications, events, clientNotes } from '../db/schema';
-import { eq, and, desc, gte } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-import { generateMeetingPrep } from '../services/ai';
-
-export const meetingPrepRoutes = new Elysia()
-  .use(authMiddleware)
-  // Get meeting prep for a client
-  .get('/clients/:id/meeting-prep', async ({ params, user, query }: {
-    params: { id: string };
-    user: User;
-    query: { provider?: string };
-  }) => {
-    // Fetch client
-    const [client] = await db.select()
-      .from(clients)
-      .where(and(eq(clients.id, params.id), eq(clients.userId, user.id)))
-      .limit(1);
-
-    if (!client) {
-      throw new Error('Client not found');
-    }
-
-    // Fetch recent interactions (last 10)
-    const recentInteractions = await db.select()
-      .from(interactions)
-      .where(and(eq(interactions.clientId, params.id), eq(interactions.userId, user.id)))
-      .orderBy(desc(interactions.contactedAt))
-      .limit(10);
-
-    // Fetch recent emails (last 5)
-    const recentEmails = await db.select()
-      .from(communications)
-      .where(and(eq(communications.clientId, params.id), eq(communications.userId, user.id)))
-      .orderBy(desc(communications.createdAt))
-      .limit(5);
-
-    // Fetch upcoming events
-    const now = new Date();
-    const upcomingEvents = await db.select()
-      .from(events)
-      .where(and(
-        eq(events.clientId, params.id),
-        eq(events.userId, user.id),
-        gte(events.date, now),
-      ))
-      .orderBy(events.date)
-      .limit(5);
-
-    // Fetch notes
-    const notes = await db.select()
-      .from(clientNotes)
-      .where(and(eq(clientNotes.clientId, params.id), eq(clientNotes.userId, user.id)))
-      .orderBy(desc(clientNotes.createdAt))
-      .limit(10);
-
-    // Calculate relationship health score (0-100)
-    const daysSinceContact = client.lastContactedAt
-      ? Math.floor((now.getTime() - new Date(client.lastContactedAt).getTime()) / (1000 * 60 * 60 * 24))
-      : 999;
-
-    let healthScore = 100;
-    if (daysSinceContact > 90) healthScore -= 40;
-    else if (daysSinceContact > 60) healthScore -= 25;
-    else if (daysSinceContact > 30) healthScore -= 10;
-
-    // Interaction frequency bonus
-    const last90Days = recentInteractions.filter(i => {
-      const d = new Date(i.contactedAt);
-      return (now.getTime() - d.getTime()) < 90 * 24 * 60 * 60 * 1000;
-    });
-    if (last90Days.length >= 5) healthScore = Math.min(100, healthScore + 15);
-    else if (last90Days.length >= 3) healthScore = Math.min(100, healthScore + 10);
-    else if (last90Days.length >= 1) healthScore = Math.min(100, healthScore + 5);
-
-    // Note presence bonus
-    if (notes.length > 0) healthScore = Math.min(100, healthScore + 5);
-
-    healthScore = Math.max(0, Math.min(100, healthScore));
-
-    // Important upcoming dates
-    const importantDates: { type: string; date: string; label: string }[] = [];
-    if (client.birthday) {
-      const bd = new Date(client.birthday);
-      const thisYear = new Date(now.getFullYear(), bd.getMonth(), bd.getDate());
-      if (thisYear < now) thisYear.setFullYear(now.getFullYear() + 1);
-      const daysUntil = Math.ceil((thisYear.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-      if (daysUntil <= 90) {
-        importantDates.push({ type: 'birthday', date: thisYear.toISOString(), label: `Birthday in ${daysUntil} days` });
-      }
-    }
-    if (client.anniversary) {
-      const ann = new Date(client.anniversary);
-      const thisYear = new Date(now.getFullYear(), ann.getMonth(), ann.getDate());
-      if (thisYear < now) thisYear.setFullYear(now.getFullYear() + 1);
-      const daysUntil = Math.ceil((thisYear.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-      if (daysUntil <= 90) {
-        importantDates.push({ type: 'anniversary', date: thisYear.toISOString(), label: `Anniversary in ${daysUntil} days` });
-      }
-    }
-
-    // Build context for AI
-    const clientSummary = {
-      name: `${client.firstName} ${client.lastName}`,
-      company: client.company || 'N/A',
-      role: client.role || 'N/A',
-      industry: client.industry || 'N/A',
-      stage: client.stage || 'lead',
-      interests: client.interests || [],
-      family: client.family,
-      daysSinceLastContact: daysSinceContact,
-    };
-
-    const interactionSummary = recentInteractions.map(i => ({
-      type: i.type,
-      title: i.title,
-      description: i.description,
-      date: i.contactedAt,
-    }));
-
-    const emailSummary = recentEmails.map(e => ({
-      subject: e.subject,
-      status: e.status,
-      date: e.createdAt,
-    }));
-
-    const notesSummary = notes.map(n => n.content).join('\n---\n');
-
-    // Generate AI talking points
-    const provider = (query.provider as 'openai' | 'anthropic') || 'openai';
-    let aiTalkingPoints;
-    try {
-      aiTalkingPoints = await generateMeetingPrep({
-        clientSummary,
-        recentInteractions: interactionSummary,
-        recentEmails: emailSummary,
-        notes: notesSummary,
-        upcomingEvents: upcomingEvents.map(e => ({ type: e.type, title: e.title, date: e.date })),
-        importantDates,
-        provider,
-      });
-    } catch (err) {
-      console.error('AI meeting prep failed:', err);
-      aiTalkingPoints = {
-        suggestedTopics: ['Review current financial goals', 'Discuss market conditions', 'Check in on personal milestones'],
-        conversationStarters: [`How have things been since we last spoke?`],
-        followUpItems: ['Follow up on previous discussion items'],
-        summary: `Meeting with ${client.firstName} ${client.lastName}. Last contact was ${daysSinceContact} days ago.`,
-      };
-    }
-
-    return {
-      client: clientSummary,
-      healthScore,
-      importantDates,
-      recentInteractions: interactionSummary.slice(0, 5),
-      recentEmails: emailSummary.slice(0, 3),
-      upcomingEvents: upcomingEvents.map(e => ({ id: e.id, type: e.type, title: e.title, date: e.date })),
-      notes: notes.slice(0, 5).map(n => ({ id: n.id, content: n.content, pinned: n.pinned, createdAt: n.createdAt })),
-      aiTalkingPoints,
-    };
-  }, {
-    params: t.Object({
-      id: t.String({ format: 'uuid' }),
-    }),
-    query: t.Object({
-      provider: t.Optional(t.String()),
-    }),
-  });

src/routes/merge.ts

@@ -1,259 +0,0 @@
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clients, communications, events, interactions, clientNotes, notifications } from '../db/schema';
-import { and, eq, or, ilike, sql, desc, ne } from 'drizzle-orm';
-import { logAudit, getRequestMeta } from '../services/audit';
-
-export const mergeRoutes = new Elysia({ prefix: '/clients' })
-  // Find potential duplicates for a specific client
-  .get('/:id/duplicates', async ({ params, headers }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const client = await db.query.clients.findFirst({
-      where: (c, { eq: e }) => and(e(c.id, params.id), e(c.userId, userId)),
-    });
-    if (!client) return new Response('Client not found', { status: 404 });
-
-    // Find duplicates by name, email, phone, or company+role
-    const conditions: any[] = [];
-    
-    // Same first+last name (fuzzy)
-    conditions.push(
-      and(
-        ilike(clients.firstName, `%${client.firstName}%`),
-        ilike(clients.lastName, `%${client.lastName}%`)
-      )
-    );
-    
-    // Same email
-    if (client.email) {
-      conditions.push(eq(clients.email, client.email));
-    }
-    
-    // Same phone
-    if (client.phone) {
-      conditions.push(eq(clients.phone, client.phone));
-    }
-
-    const duplicates = await db
-      .select()
-      .from(clients)
-      .where(
-        and(
-          eq(clients.userId, userId),
-          ne(clients.id, params.id),
-          or(...conditions)
-        )
-      )
-      .orderBy(desc(clients.updatedAt));
-
-    // Score each duplicate
-    const scored = duplicates.map(dup => {
-      let score = 0;
-      const reasons: string[] = [];
-
-      // Exact name match
-      if (dup.firstName.toLowerCase() === client.firstName.toLowerCase() && 
-          dup.lastName.toLowerCase() === client.lastName.toLowerCase()) {
-        score += 40;
-        reasons.push('Exact name match');
-      } else if (dup.firstName.toLowerCase().includes(client.firstName.toLowerCase()) ||
-                 client.firstName.toLowerCase().includes(dup.firstName.toLowerCase())) {
-        score += 20;
-        reasons.push('Similar name');
-      }
-
-      // Email match
-      if (client.email && dup.email && dup.email.toLowerCase() === client.email.toLowerCase()) {
-        score += 35;
-        reasons.push('Same email');
-      }
-
-      // Phone match (normalize)
-      if (client.phone && dup.phone) {
-        const norm = (p: string) => p.replace(/\D/g, '');
-        if (norm(dup.phone) === norm(client.phone)) {
-          score += 30;
-          reasons.push('Same phone');
-        }
-      }
-
-      // Same company + role
-      if (client.company && dup.company && 
-          dup.company.toLowerCase() === client.company.toLowerCase()) {
-        score += 10;
-        reasons.push('Same company');
-        if (client.role && dup.role && dup.role.toLowerCase() === client.role.toLowerCase()) {
-          score += 5;
-          reasons.push('Same role');
-        }
-      }
-
-      return { ...dup, duplicateScore: Math.min(score, 100), matchReasons: reasons };
-    });
-
-    // Only return those with score >= 20
-    return scored
-      .filter(d => d.duplicateScore >= 20)
-      .sort((a, b) => b.duplicateScore - a.duplicateScore);
-  })
-
-  // Merge two clients: keep primary, absorb secondary
-  .post('/:id/merge', async ({ params, body, headers, request }) => {
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const primaryId = params.id;
-    const secondaryId = body.mergeFromId;
-
-    if (primaryId === secondaryId) {
-      return new Response('Cannot merge a client with itself', { status: 400 });
-    }
-
-    const [primary, secondary] = await Promise.all([
-      db.query.clients.findFirst({ where: (c, { eq: e }) => and(e(c.id, primaryId), e(c.userId, userId)) }),
-      db.query.clients.findFirst({ where: (c, { eq: e }) => and(e(c.id, secondaryId), e(c.userId, userId)) }),
-    ]);
-
-    if (!primary || !secondary) {
-      return new Response('One or both clients not found', { status: 404 });
-    }
-
-    // Merge fields: primary wins, fill gaps from secondary
-    const mergedFields: Record<string, any> = {};
-    const fillable = ['email', 'phone', 'street', 'city', 'state', 'zip', 'company', 'role', 'industry', 'birthday', 'anniversary', 'notes'] as const;
-    
-    for (const field of fillable) {
-      if (!primary[field] && secondary[field]) {
-        mergedFields[field] = secondary[field];
-      }
-    }
-
-    // Merge interests (union)
-    const primaryInterests = (primary.interests as string[]) || [];
-    const secondaryInterests = (secondary.interests as string[]) || [];
-    const mergedInterests = [...new Set([...primaryInterests, ...secondaryInterests])];
-    if (mergedInterests.length > primaryInterests.length) {
-      mergedFields.interests = mergedInterests;
-    }
-
-    // Merge tags (union)
-    const primaryTags = (primary.tags as string[]) || [];
-    const secondaryTags = (secondary.tags as string[]) || [];
-    const mergedTags = [...new Set([...primaryTags, ...secondaryTags])];
-    if (mergedTags.length > primaryTags.length) {
-      mergedFields.tags = mergedTags;
-    }
-
-    // Merge family
-    if (!primary.family && secondary.family) {
-      mergedFields.family = secondary.family;
-    } else if (primary.family && secondary.family) {
-      const pf = primary.family as any;
-      const sf = secondary.family as any;
-      mergedFields.family = {
-        spouse: pf.spouse || sf.spouse,
-        children: [...new Set([...(pf.children || []), ...(sf.children || [])])],
-      };
-    }
-
-    // Merge notes (append if both have)
-    if (primary.notes && secondary.notes && primary.notes !== secondary.notes) {
-      mergedFields.notes = `${primary.notes}\n\n--- Merged from ${secondary.firstName} ${secondary.lastName} ---\n${secondary.notes}`;
-    }
-
-    // Use more recent lastContactedAt
-    if (secondary.lastContactedAt) {
-      if (!primary.lastContactedAt || secondary.lastContactedAt > primary.lastContactedAt) {
-        mergedFields.lastContactedAt = secondary.lastContactedAt;
-      }
-    }
-
-    // Keep better stage (active > onboarding > prospect > lead > inactive)
-    const stageRank: Record<string, number> = { active: 4, onboarding: 3, prospect: 2, lead: 1, inactive: 0 };
-    if ((stageRank[secondary.stage || 'lead'] || 0) > (stageRank[primary.stage || 'lead'] || 0)) {
-      mergedFields.stage = secondary.stage;
-    }
-
-    mergedFields.updatedAt = new Date();
-
-    // Execute merge in transaction
-    await db.transaction(async (tx) => {
-      // 1. Update primary with merged fields
-      if (Object.keys(mergedFields).length > 0) {
-        await tx.update(clients).set(mergedFields).where(eq(clients.id, primaryId));
-      }
-
-      // 2. Move all secondary's related records to primary
-      await tx.update(communications).set({ clientId: primaryId }).where(eq(communications.clientId, secondaryId));
-      await tx.update(events).set({ clientId: primaryId }).where(eq(events.clientId, secondaryId));
-      await tx.update(interactions).set({ clientId: primaryId }).where(eq(interactions.clientId, secondaryId));
-      await tx.update(clientNotes).set({ clientId: primaryId }).where(eq(clientNotes.clientId, secondaryId));
-      await tx.update(notifications).set({ clientId: primaryId }).where(eq(notifications.clientId, secondaryId));
-
-      // 3. Delete secondary client
-      await tx.delete(clients).where(eq(clients.id, secondaryId));
-    });
-
-    // Audit log
-    const meta = getRequestMeta(request);
-    await logAudit({
-      userId,
-      action: 'update',
-      entityType: 'client',
-      entityId: primaryId,
-      details: {
-        type: 'merge',
-        mergedFromId: secondaryId,
-        mergedFromName: `${secondary.firstName} ${secondary.lastName}`,
-        fieldsUpdated: Object.keys(mergedFields).filter(k => k !== 'updatedAt'),
-      },
-      ...meta,
-    });
-
-    // Get updated primary
-    const updated = await db.query.clients.findFirst({
-      where: (c, { eq: e }) => e(c.id, primaryId),
-    });
-
-    return {
-      success: true,
-      client: updated,
-      merged: {
-        fromId: secondaryId,
-        fromName: `${secondary.firstName} ${secondary.lastName}`,
-        fieldsUpdated: Object.keys(mergedFields).filter(k => k !== 'updatedAt'),
-      },
-    };
-  }, {
-    body: t.Object({
-      mergeFromId: t.String(),
-    }),
-  });

src/routes/network.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { clients } from '../db/schema';
@@ -24,7 +23,6 @@ function toClientProfile(c: typeof clients.$inferSelect): ClientProfile {
 }
 
 export const networkRoutes = new Elysia({ prefix: '/network' })
-  .use(authMiddleware)
   // Get all network matches for the user's clients
   .get('/matches', async (ctx) => {
     const user = (ctx as any).user;

src/routes/notes.ts

@@ -1,105 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clientNotes, clients } from '../db/schema';
-import { eq, and, desc } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const notesRoutes = new Elysia({ prefix: '/clients/:clientId/notes' })
-  .use(authMiddleware)
-  // List notes for a client
-  .get('/', async ({ params, user }: { params: { clientId: string }; user: User }) => {
-    // Verify client belongs to user
-    const [client] = await db.select({ id: clients.id })
-      .from(clients)
-      .where(and(eq(clients.id, params.clientId), eq(clients.userId, user.id)))
-      .limit(1);
-    
-    if (!client) throw new Error('Client not found');
-    
-    const notes = await db.select()
-      .from(clientNotes)
-      .where(eq(clientNotes.clientId, params.clientId))
-      .orderBy(desc(clientNotes.pinned), desc(clientNotes.createdAt));
-    
-    return notes;
-  }, {
-    params: t.Object({
-      clientId: t.String({ format: 'uuid' }),
-    }),
-  })
-
-  // Create note
-  .post('/', async ({ params, body, user }: { params: { clientId: string }; body: { content: string }; user: User }) => {
-    // Verify client belongs to user
-    const [client] = await db.select({ id: clients.id })
-      .from(clients)
-      .where(and(eq(clients.id, params.clientId), eq(clients.userId, user.id)))
-      .limit(1);
-    
-    if (!client) throw new Error('Client not found');
-    
-    const [note] = await db.insert(clientNotes)
-      .values({
-        clientId: params.clientId,
-        userId: user.id,
-        content: body.content,
-      })
-      .returning();
-    
-    return note;
-  }, {
-    params: t.Object({
-      clientId: t.String({ format: 'uuid' }),
-    }),
-    body: t.Object({
-      content: t.String({ minLength: 1 }),
-    }),
-  })
-
-  // Update note
-  .put('/:noteId', async ({ params, body, user }: { params: { clientId: string; noteId: string }; body: { content?: string; pinned?: boolean }; user: User }) => {
-    const updateData: Record<string, unknown> = { updatedAt: new Date() };
-    if (body.content !== undefined) updateData.content = body.content;
-    if (body.pinned !== undefined) updateData.pinned = body.pinned;
-
-    const [note] = await db.update(clientNotes)
-      .set(updateData)
-      .where(and(
-        eq(clientNotes.id, params.noteId),
-        eq(clientNotes.clientId, params.clientId),
-        eq(clientNotes.userId, user.id),
-      ))
-      .returning();
-    
-    if (!note) throw new Error('Note not found');
-    return note;
-  }, {
-    params: t.Object({
-      clientId: t.String({ format: 'uuid' }),
-      noteId: t.String({ format: 'uuid' }),
-    }),
-    body: t.Object({
-      content: t.Optional(t.String({ minLength: 1 })),
-      pinned: t.Optional(t.Boolean()),
-    }),
-  })
-
-  // Delete note
-  .delete('/:noteId', async ({ params, user }: { params: { clientId: string; noteId: string }; user: User }) => {
-    const [deleted] = await db.delete(clientNotes)
-      .where(and(
-        eq(clientNotes.id, params.noteId),
-        eq(clientNotes.clientId, params.clientId),
-        eq(clientNotes.userId, user.id),
-      ))
-      .returning({ id: clientNotes.id });
-    
-    if (!deleted) throw new Error('Note not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({
-      clientId: t.String({ format: 'uuid' }),
-      noteId: t.String({ format: 'uuid' }),
-    }),
-  });

src/routes/notifications.ts

@@ -1,87 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { notifications, clients } from '../db/schema';
-import { eq, and, desc, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const notificationRoutes = new Elysia({ prefix: '/notifications' })
-  .use(authMiddleware)
-  // List notifications
-  .get('/', async ({ query, user }: { query: { limit?: string; unreadOnly?: string }; user: User }) => {
-    const limit = query.limit ? parseInt(query.limit) : 50;
-    const unreadOnly = query.unreadOnly === 'true';
-
-    let conditions = [eq(notifications.userId, user.id)];
-    if (unreadOnly) {
-      conditions.push(eq(notifications.read, false));
-    }
-
-    const items = await db.select({
-      notification: notifications,
-      client: {
-        id: clients.id,
-        firstName: clients.firstName,
-        lastName: clients.lastName,
-      },
-    })
-      .from(notifications)
-      .leftJoin(clients, eq(notifications.clientId, clients.id))
-      .where(and(...conditions))
-      .orderBy(desc(notifications.createdAt))
-      .limit(limit);
-
-    // Unread count
-    const [unreadResult] = await db.select({
-      count: sql<number>`count(*)::int`,
-    })
-      .from(notifications)
-      .where(and(eq(notifications.userId, user.id), eq(notifications.read, false)));
-
-    return {
-      notifications: items.map(({ notification, client }) => ({
-        ...notification,
-        client: client?.id ? client : null,
-      })),
-      unreadCount: unreadResult?.count || 0,
-    };
-  }, {
-    query: t.Object({
-      limit: t.Optional(t.String()),
-      unreadOnly: t.Optional(t.String()),
-    }),
-  })
-
-  // Mark notification as read
-  .put('/:id/read', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [updated] = await db.update(notifications)
-      .set({ read: true })
-      .where(and(eq(notifications.id, params.id), eq(notifications.userId, user.id)))
-      .returning();
-
-    if (!updated) throw new Error('Notification not found');
-    return updated;
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  })
-
-  // Mark all as read
-  .post('/mark-all-read', async ({ user }: { user: User }) => {
-    await db.update(notifications)
-      .set({ read: true })
-      .where(and(eq(notifications.userId, user.id), eq(notifications.read, false)));
-
-    return { success: true };
-  })
-
-  // Delete notification
-  .delete('/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [deleted] = await db.delete(notifications)
-      .where(and(eq(notifications.id, params.id), eq(notifications.userId, user.id)))
-      .returning({ id: notifications.id });
-
-    if (!deleted) throw new Error('Notification not found');
-    return { success: true };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  });

src/routes/profile.ts

@@ -1,13 +1,10 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia, t } from 'elysia';
 import { db } from '../db';
 import { users, userProfiles, accounts } from '../db/schema';
 import { eq, and } from 'drizzle-orm';
 import type { User } from '../lib/auth';
-import { logAudit, getRequestMeta } from '../services/audit';
 
 export const profileRoutes = new Elysia({ prefix: '/profile' })
-  .use(authMiddleware)
   // Get current user's profile
   .get('/', async ({ user }: { user: User }) => {
     // Get user and profile
@@ -129,116 +126,6 @@ export const profileRoutes = new Elysia({ prefix: '/profile' })
     }),
   })
 
-  // Communication style
-  .get('/communication-style', async ({ user }: { user: User }) => {
-    const [profile] = await db.select()
-      .from(userProfiles)
-      .where(eq(userProfiles.userId, user.id))
-      .limit(1);
-    
-    return profile?.communicationStyle || {
-      tone: 'friendly',
-      greeting: '',
-      signoff: '',
-      writingSamples: [],
-      avoidWords: [],
-    };
-  })
-
-  .patch('/communication-style', async ({ body, user, request }: {
-    body: {
-      tone?: string;
-      greeting?: string;
-      signoff?: string;
-      writingSamples?: string[];
-      avoidWords?: string[];
-    };
-    user: User;
-    request: Request;
-  }) => {
-    const [existing] = await db.select()
-      .from(userProfiles)
-      .where(eq(userProfiles.userId, user.id))
-      .limit(1);
-
-    const tone = (body.tone || 'friendly') as 'formal' | 'friendly' | 'casual';
-    const style = {
-      tone,
-      greeting: body.greeting || '',
-      signoff: body.signoff || '',
-      writingSamples: (body.writingSamples || []).slice(0, 3),
-      avoidWords: body.avoidWords || [],
-    };
-
-    if (existing) {
-      await db.update(userProfiles)
-        .set({ communicationStyle: style, updatedAt: new Date() })
-        .where(eq(userProfiles.userId, user.id));
-    } else {
-      await db.insert(userProfiles).values({
-        userId: user.id,
-        communicationStyle: style,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-    }
-
-    const meta = getRequestMeta(request);
-    logAudit({
-      userId: user.id,
-      action: 'update',
-      entityType: 'profile',
-      entityId: user.id,
-      details: { communicationStyle: style },
-      ...meta,
-    });
-
-    return style;
-  }, {
-    body: t.Object({
-      tone: t.Optional(t.String()),
-      greeting: t.Optional(t.String()),
-      signoff: t.Optional(t.String()),
-      writingSamples: t.Optional(t.Array(t.String())),
-      avoidWords: t.Optional(t.Array(t.String())),
-    }),
-  })
-
-  // Onboarding status
-  .get('/onboarding-status', async ({ user }: { user: User }) => {
-    const [profile] = await db.select()
-      .from(userProfiles)
-      .where(eq(userProfiles.userId, user.id))
-      .limit(1);
-
-    return {
-      onboardingComplete: profile?.onboardingComplete ?? false,
-    };
-  })
-
-  // Complete onboarding
-  .post('/complete-onboarding', async ({ user }: { user: User }) => {
-    const [existing] = await db.select()
-      .from(userProfiles)
-      .where(eq(userProfiles.userId, user.id))
-      .limit(1);
-
-    if (existing) {
-      await db.update(userProfiles)
-        .set({ onboardingComplete: true, updatedAt: new Date() })
-        .where(eq(userProfiles.userId, user.id));
-    } else {
-      await db.insert(userProfiles).values({
-        userId: user.id,
-        onboardingComplete: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-    }
-
-    return { success: true, onboardingComplete: true };
-  })
-
   // Change password
   .put('/password', async ({ body, user, set }: {
     body: { currentPassword: string; newPassword: string };
@@ -275,14 +162,6 @@ export const profileRoutes = new Elysia({ prefix: '/profile' })
         eq(accounts.providerId, 'credential'),
       ));
 
-    logAudit({
-      userId: user.id,
-      action: 'password_change',
-      entityType: 'auth',
-      entityId: user.id,
-      details: { event: 'password_changed' },
-    });
-
     return { success: true };
   }, {
     body: t.Object({

src/routes/referrals.ts

@@ -1,203 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { referrals, clients } from '../db/schema';
-import { eq, and, desc, sql, or } from 'drizzle-orm';
-import { alias } from 'drizzle-orm/pg-core';
-import type { User } from '../lib/auth';
-
-async function verifyClientOwnership(clientId: string, userId: string) {
-  const [client] = await db.select({ id: clients.id })
-    .from(clients)
-    .where(and(eq(clients.id, clientId), eq(clients.userId, userId)))
-    .limit(1);
-  if (!client) throw new Error('Client not found');
-  return client;
-}
-
-const referrerClient = alias(clients, 'referrerClient');
-const referredClient = alias(clients, 'referredClient');
-
-export const referralRoutes = new Elysia()
-  .use(authMiddleware)
-
-  // List referrals for a client (given + received)
-  .get('/clients/:clientId/referrals', async ({ params, user }: { params: { clientId: string }; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    const results = await db.select({
-      id: referrals.id,
-      referrerId: referrals.referrerId,
-      referredId: referrals.referredId,
-      type: referrals.type,
-      notes: referrals.notes,
-      status: referrals.status,
-      value: referrals.value,
-      createdAt: referrals.createdAt,
-      updatedAt: referrals.updatedAt,
-      referrerFirstName: referrerClient.firstName,
-      referrerLastName: referrerClient.lastName,
-      referredFirstName: referredClient.firstName,
-      referredLastName: referredClient.lastName,
-    })
-      .from(referrals)
-      .innerJoin(referrerClient, eq(referrals.referrerId, referrerClient.id))
-      .innerJoin(referredClient, eq(referrals.referredId, referredClient.id))
-      .where(and(
-        eq(referrals.userId, user.id),
-        or(
-          eq(referrals.referrerId, params.clientId),
-          eq(referrals.referredId, params.clientId),
-        ),
-      ))
-      .orderBy(desc(referrals.createdAt));
-
-    return results.map(r => ({
-      id: r.id,
-      referrerId: r.referrerId,
-      referredId: r.referredId,
-      type: r.type,
-      notes: r.notes,
-      status: r.status,
-      value: r.value,
-      createdAt: r.createdAt,
-      updatedAt: r.updatedAt,
-      referrer: { id: r.referrerId, firstName: r.referrerFirstName, lastName: r.referrerLastName },
-      referred: { id: r.referredId, firstName: r.referredFirstName, lastName: r.referredLastName },
-    }));
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Create referral
-  .post('/clients/:clientId/referrals', async ({ params, body, user }: { params: { clientId: string }; body: any; user: User }) => {
-    await verifyClientOwnership(params.clientId, user.id);
-
-    // Verify the other client exists and belongs to user
-    const referredClientId = body.referredId;
-    await verifyClientOwnership(referredClientId, user.id);
-
-    const [ref] = await db.insert(referrals)
-      .values({
-        referrerId: params.clientId,
-        referredId: referredClientId,
-        userId: user.id,
-        type: body.type || 'client',
-        notes: body.notes || null,
-        status: body.status || 'pending',
-        value: body.value || null,
-      })
-      .returning();
-
-    return ref;
-  }, {
-    params: t.Object({ clientId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      referredId: t.String({ format: 'uuid' }),
-      type: t.Optional(t.String()),
-      notes: t.Optional(t.String()),
-      status: t.Optional(t.String()),
-      value: t.Optional(t.String()),
-    }),
-  })
-
-  // Update referral
-  .put('/referrals/:referralId', async ({ params, body, user }: { params: { referralId: string }; body: any; user: User }) => {
-    const updateData: Record<string, unknown> = { updatedAt: new Date() };
-    if (body.type !== undefined) updateData.type = body.type;
-    if (body.notes !== undefined) updateData.notes = body.notes;
-    if (body.status !== undefined) updateData.status = body.status;
-    if (body.value !== undefined) updateData.value = body.value;
-
-    const [ref] = await db.update(referrals)
-      .set(updateData)
-      .where(and(
-        eq(referrals.id, params.referralId),
-        eq(referrals.userId, user.id),
-      ))
-      .returning();
-
-    if (!ref) throw new Error('Referral not found');
-    return ref;
-  }, {
-    params: t.Object({ referralId: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      type: t.Optional(t.String()),
-      notes: t.Optional(t.String()),
-      status: t.Optional(t.String()),
-      value: t.Optional(t.String()),
-    }),
-  })
-
-  // Delete referral
-  .delete('/referrals/:referralId', async ({ params, user }: { params: { referralId: string }; user: User }) => {
-    const [deleted] = await db.delete(referrals)
-      .where(and(
-        eq(referrals.id, params.referralId),
-        eq(referrals.userId, user.id),
-      ))
-      .returning({ id: referrals.id });
-
-    if (!deleted) throw new Error('Referral not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({ referralId: t.String({ format: 'uuid' }) }),
-  })
-
-  // Referral stats (dashboard)
-  .get('/referrals/stats', async ({ user }: { user: User }) => {
-    const allReferrals = await db.select({
-      id: referrals.id,
-      referrerId: referrals.referrerId,
-      referredId: referrals.referredId,
-      type: referrals.type,
-      status: referrals.status,
-      value: referrals.value,
-      referrerFirstName: referrerClient.firstName,
-      referrerLastName: referrerClient.lastName,
-    })
-      .from(referrals)
-      .innerJoin(referrerClient, eq(referrals.referrerId, referrerClient.id))
-      .where(eq(referrals.userId, user.id));
-
-    const total = allReferrals.length;
-    const converted = allReferrals.filter(r => r.status === 'converted').length;
-    const conversionRate = total > 0 ? Math.round((converted / total) * 100) : 0;
-    const totalValue = allReferrals
-      .filter(r => r.value)
-      .reduce((sum, r) => sum + parseFloat(r.value || '0'), 0);
-    const convertedValue = allReferrals
-      .filter(r => r.status === 'converted' && r.value)
-      .reduce((sum, r) => sum + parseFloat(r.value || '0'), 0);
-
-    // Top referrers
-    const referrerMap = new Map<string, { name: string; count: number; convertedCount: number }>();
-    for (const r of allReferrals) {
-      const key = r.referrerId;
-      const existing = referrerMap.get(key) || { name: `${r.referrerFirstName} ${r.referrerLastName}`, count: 0, convertedCount: 0 };
-      existing.count++;
-      if (r.status === 'converted') existing.convertedCount++;
-      referrerMap.set(key, existing);
-    }
-    const topReferrers = Array.from(referrerMap.entries())
-      .map(([id, data]) => ({ id, ...data }))
-      .sort((a, b) => b.count - a.count)
-      .slice(0, 10);
-
-    const byStatus = {
-      pending: allReferrals.filter(r => r.status === 'pending').length,
-      contacted: allReferrals.filter(r => r.status === 'contacted').length,
-      converted,
-      lost: allReferrals.filter(r => r.status === 'lost').length,
-    };
-
-    return {
-      total,
-      converted,
-      conversionRate,
-      totalValue,
-      convertedValue,
-      byStatus,
-      topReferrers,
-    };
-  });

src/routes/reports.ts

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../middleware/auth';
 import { Elysia } from 'elysia';
 import { db } from '../db';
 import { clients, events, communications } from '../db/schema';
@@ -6,7 +5,6 @@ import { eq, and, sql, gte, lte, count, desc } from 'drizzle-orm';
 import type { User } from '../lib/auth';
 
 export const reportsRoutes = new Elysia()
-  .use(authMiddleware)
   // Analytics overview
   .get('/reports/overview', async ({ user }: { user: User }) => {
     const userId = user.id;
@@ -86,21 +84,21 @@ export const reportsRoutes = new Elysia()
 
     return {
       clients: {
-        total: totalClients?.count ?? 0,
+        total: totalClients.count,
-        newThisMonth: newClientsMonth?.count ?? 0,
+        newThisMonth: newClientsMonth.count,
-        newThisWeek: newClientsWeek?.count ?? 0,
+        newThisWeek: newClientsWeek.count,
-        contactedRecently: contactedRecently?.count ?? 0,
+        contactedRecently: contactedRecently.count,
-        neverContacted: neverContacted?.count ?? 0,
+        neverContacted: neverContacted.count,
       },
       emails: {
-        total: totalEmails?.count ?? 0,
+        total: totalEmails.count,
-        sent: emailsSent?.count ?? 0,
+        sent: emailsSent.count,
-        draft: emailsDraft?.count ?? 0,
+        draft: emailsDraft.count,
-        sentLast30Days: emailsRecent?.count ?? 0,
+        sentLast30Days: emailsRecent.count,
       },
       events: {
-        total: totalEvents?.count ?? 0,
+        total: totalEvents.count,
-        upcoming30Days: upcomingEvents?.count ?? 0,
+        upcoming30Days: upcomingEvents.count,
       },
     };
   })
@@ -408,11 +406,11 @@ export const reportsRoutes = new Elysia()
       });
     }
 
-    if ((draftCount?.count ?? 0) > 0) {
+    if (draftCount.count > 0) {
       notifications.push({
         id: 'drafts',
         type: 'drafts' as const,
-        title: `${draftCount?.count ?? 0} draft email${(draftCount?.count ?? 0) > 1 ? 's' : ''} pending`,
+        title: `${draftCount.count} draft email${draftCount.count > 1 ? 's' : ''} pending`,
         description: 'Review and send your drafted emails',
         date: new Date().toISOString(),
         link: '/emails',
@@ -436,7 +434,7 @@ export const reportsRoutes = new Elysia()
         overdue: overdueEvents.length,
         upcoming: upcomingEvents.length,
         stale: staleClients.length,
-        drafts: draftCount?.count ?? 0,
+        drafts: draftCount.count,
       },
     };
   });

src/routes/search.ts

@@ -1,267 +0,0 @@
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clients, communications, events, interactions, clientNotes } from '../db/schema';
-import { and, eq, or, ilike, sql, desc } from 'drizzle-orm';
-
-export const searchRoutes = new Elysia({ prefix: '/search' })
-  .get('/', async ({ query, headers }) => {
-    // Auth check
-    const sessionToken = headers['cookie']?.match(/better-auth\.session_token=([^;]+)/)?.[1];
-    const bearerToken = headers['authorization']?.replace('Bearer ', '');
-    
-    let userId: string | null = null;
-    if (sessionToken) {
-      const session = await db.query.sessions.findFirst({
-        where: (s, { eq, gt }) => and(eq(s.token, sessionToken), gt(s.expiresAt, new Date())),
-      });
-      userId = session?.userId ?? null;
-    }
-    if (!userId && bearerToken) {
-      // Service account / bearer auth - get first admin
-      const admin = await db.query.users.findFirst({ where: (u, { eq }) => eq(u.role, 'admin') });
-      userId = admin?.id ?? null;
-    }
-    if (!userId) return new Response('Unauthorized', { status: 401 });
-
-    const q = query.q?.trim();
-    if (!q || q.length < 2) {
-      return { results: [], query: q, total: 0 };
-    }
-
-    const limit = Math.min(Number(query.limit) || 20, 50);
-    const types = query.types?.split(',') || ['clients', 'emails', 'events', 'interactions', 'notes'];
-    const pattern = `%${q}%`;
-
-    const results: Array<{
-      type: string;
-      id: string;
-      title: string;
-      subtitle?: string;
-      clientId?: string;
-      clientName?: string;
-      matchField: string;
-      createdAt: string;
-    }> = [];
-
-    // Search clients
-    if (types.includes('clients')) {
-      const clientResults = await db
-        .select()
-        .from(clients)
-        .where(
-          and(
-            eq(clients.userId, userId),
-            or(
-              ilike(clients.firstName, pattern),
-              ilike(clients.lastName, pattern),
-              ilike(clients.email, pattern),
-              ilike(clients.phone, pattern),
-              ilike(clients.company, pattern),
-              ilike(clients.industry, pattern),
-              ilike(clients.city, pattern),
-              ilike(clients.notes, pattern),
-              sql`${clients.firstName} || ' ' || ${clients.lastName} ILIKE ${pattern}`
-            )
-          )
-        )
-        .orderBy(desc(clients.updatedAt))
-        .limit(limit);
-
-      for (const c of clientResults) {
-        const fullName = `${c.firstName} ${c.lastName}`;
-        let matchField = 'name';
-        if (fullName.toLowerCase().includes(q.toLowerCase())) matchField = 'name';
-        else if (c.email?.toLowerCase().includes(q.toLowerCase())) matchField = 'email';
-        else if (c.phone?.toLowerCase().includes(q.toLowerCase())) matchField = 'phone';
-        else if (c.company?.toLowerCase().includes(q.toLowerCase())) matchField = 'company';
-        else if (c.industry?.toLowerCase().includes(q.toLowerCase())) matchField = 'industry';
-        else if (c.notes?.toLowerCase().includes(q.toLowerCase())) matchField = 'notes';
-
-        results.push({
-          type: 'client',
-          id: c.id,
-          title: fullName,
-          subtitle: [c.company, c.role].filter(Boolean).join(' · ') || c.email || undefined,
-          matchField,
-          createdAt: c.createdAt.toISOString(),
-        });
-      }
-    }
-
-    // Search emails/communications
-    if (types.includes('emails')) {
-      const emailResults = await db
-        .select({
-          id: communications.id,
-          subject: communications.subject,
-          content: communications.content,
-          status: communications.status,
-          clientId: communications.clientId,
-          createdAt: communications.createdAt,
-          clientFirstName: clients.firstName,
-          clientLastName: clients.lastName,
-        })
-        .from(communications)
-        .leftJoin(clients, eq(communications.clientId, clients.id))
-        .where(
-          and(
-            eq(communications.userId, userId),
-            or(
-              ilike(communications.subject, pattern),
-              ilike(communications.content, pattern)
-            )
-          )
-        )
-        .orderBy(desc(communications.createdAt))
-        .limit(limit);
-
-      for (const e of emailResults) {
-        results.push({
-          type: 'email',
-          id: e.id,
-          title: e.subject || '(No subject)',
-          subtitle: `${e.status} · ${e.clientFirstName} ${e.clientLastName}`,
-          clientId: e.clientId,
-          clientName: `${e.clientFirstName} ${e.clientLastName}`,
-          matchField: e.subject?.toLowerCase().includes(q.toLowerCase()) ? 'subject' : 'content',
-          createdAt: e.createdAt.toISOString(),
-        });
-      }
-    }
-
-    // Search events
-    if (types.includes('events')) {
-      const eventResults = await db
-        .select({
-          id: events.id,
-          title: events.title,
-          type: events.type,
-          date: events.date,
-          clientId: events.clientId,
-          createdAt: events.createdAt,
-          clientFirstName: clients.firstName,
-          clientLastName: clients.lastName,
-        })
-        .from(events)
-        .leftJoin(clients, eq(events.clientId, clients.id))
-        .where(
-          and(
-            eq(events.userId, userId),
-            ilike(events.title, pattern)
-          )
-        )
-        .orderBy(desc(events.date))
-        .limit(limit);
-
-      for (const ev of eventResults) {
-        results.push({
-          type: 'event',
-          id: ev.id,
-          title: ev.title,
-          subtitle: `${ev.type} · ${ev.clientFirstName} ${ev.clientLastName}`,
-          clientId: ev.clientId,
-          clientName: `${ev.clientFirstName} ${ev.clientLastName}`,
-          matchField: 'title',
-          createdAt: ev.createdAt.toISOString(),
-        });
-      }
-    }
-
-    // Search interactions
-    if (types.includes('interactions')) {
-      const intResults = await db
-        .select({
-          id: interactions.id,
-          title: interactions.title,
-          description: interactions.description,
-          type: interactions.type,
-          clientId: interactions.clientId,
-          createdAt: interactions.createdAt,
-          clientFirstName: clients.firstName,
-          clientLastName: clients.lastName,
-        })
-        .from(interactions)
-        .leftJoin(clients, eq(interactions.clientId, clients.id))
-        .where(
-          and(
-            eq(interactions.userId, userId),
-            or(
-              ilike(interactions.title, pattern),
-              ilike(interactions.description, pattern)
-            )
-          )
-        )
-        .orderBy(desc(interactions.createdAt))
-        .limit(limit);
-
-      for (const i of intResults) {
-        results.push({
-          type: 'interaction',
-          id: i.id,
-          title: i.title,
-          subtitle: `${i.type} · ${i.clientFirstName} ${i.clientLastName}`,
-          clientId: i.clientId,
-          clientName: `${i.clientFirstName} ${i.clientLastName}`,
-          matchField: i.title.toLowerCase().includes(q.toLowerCase()) ? 'title' : 'description',
-          createdAt: i.createdAt.toISOString(),
-        });
-      }
-    }
-
-    // Search notes
-    if (types.includes('notes')) {
-      const noteResults = await db
-        .select({
-          id: clientNotes.id,
-          content: clientNotes.content,
-          clientId: clientNotes.clientId,
-          createdAt: clientNotes.createdAt,
-          clientFirstName: clients.firstName,
-          clientLastName: clients.lastName,
-        })
-        .from(clientNotes)
-        .leftJoin(clients, eq(clientNotes.clientId, clients.id))
-        .where(
-          and(
-            eq(clientNotes.userId, userId),
-            ilike(clientNotes.content, pattern)
-          )
-        )
-        .orderBy(desc(clientNotes.createdAt))
-        .limit(limit);
-
-      for (const n of noteResults) {
-        const preview = n.content.length > 100 ? n.content.slice(0, 100) + '…' : n.content;
-        results.push({
-          type: 'note',
-          id: n.id,
-          title: preview,
-          subtitle: `Note · ${n.clientFirstName} ${n.clientLastName}`,
-          clientId: n.clientId,
-          clientName: `${n.clientFirstName} ${n.clientLastName}`,
-          matchField: 'content',
-          createdAt: n.createdAt.toISOString(),
-        });
-      }
-    }
-
-    // Sort all results by relevance (clients first, then by date)
-    const typeOrder: Record<string, number> = { client: 0, email: 1, event: 2, interaction: 3, note: 4 };
-    results.sort((a, b) => {
-      const typeDiff = (typeOrder[a.type] ?? 5) - (typeOrder[b.type] ?? 5);
-      if (typeDiff !== 0) return typeDiff;
-      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
-    });
-
-    return {
-      results: results.slice(0, limit),
-      query: q,
-      total: results.length,
-    };
-  }, {
-    query: t.Object({
-      q: t.Optional(t.String()),
-      types: t.Optional(t.String()),
-      limit: t.Optional(t.String()),
-    }),
-  });

src/routes/segments.ts

@@ -1,248 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clientSegments, clients } from '../db/schema';
-import { eq, and, desc, or, ilike, inArray, gte, lte, isNotNull, isNull, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-type SegmentFilters = {
-  stages?: string[];
-  tags?: string[];
-  industries?: string[];
-  cities?: string[];
-  states?: string[];
-  lastContactedBefore?: string;
-  lastContactedAfter?: string;
-  createdBefore?: string;
-  createdAfter?: string;
-  hasEmail?: boolean;
-  hasPhone?: boolean;
-  search?: string;
-};
-
-function buildClientConditions(filters: SegmentFilters, userId: string) {
-  const conditions = [eq(clients.userId, userId)];
-
-  if (filters.stages?.length) {
-    conditions.push(inArray(clients.stage, filters.stages));
-  }
-  if (filters.industries?.length) {
-    conditions.push(inArray(clients.industry, filters.industries));
-  }
-  if (filters.cities?.length) {
-    conditions.push(inArray(clients.city, filters.cities));
-  }
-  if (filters.states?.length) {
-    conditions.push(inArray(clients.state, filters.states));
-  }
-  if (filters.tags?.length) {
-    // Check if client tags JSONB array contains any of the filter tags
-    const tagConditions = filters.tags.map(tag =>
-      sql`${clients.tags}::jsonb @> ${JSON.stringify([tag])}::jsonb`
-    );
-    conditions.push(or(...tagConditions)!);
-  }
-  if (filters.lastContactedBefore) {
-    conditions.push(lte(clients.lastContactedAt, new Date(filters.lastContactedBefore)));
-  }
-  if (filters.lastContactedAfter) {
-    conditions.push(gte(clients.lastContactedAt, new Date(filters.lastContactedAfter)));
-  }
-  if (filters.createdBefore) {
-    conditions.push(lte(clients.createdAt, new Date(filters.createdBefore)));
-  }
-  if (filters.createdAfter) {
-    conditions.push(gte(clients.createdAt, new Date(filters.createdAfter)));
-  }
-  if (filters.hasEmail === true) {
-    conditions.push(isNotNull(clients.email));
-  } else if (filters.hasEmail === false) {
-    conditions.push(isNull(clients.email));
-  }
-  if (filters.hasPhone === true) {
-    conditions.push(isNotNull(clients.phone));
-  } else if (filters.hasPhone === false) {
-    conditions.push(isNull(clients.phone));
-  }
-  if (filters.search) {
-    const q = `%${filters.search}%`;
-    conditions.push(or(
-      ilike(clients.firstName, q),
-      ilike(clients.lastName, q),
-      ilike(clients.email, q),
-      ilike(clients.company, q),
-    )!);
-  }
-
-  return conditions;
-}
-
-export const segmentRoutes = new Elysia({ prefix: '/segments' })
-  .use(authMiddleware)
-  // List saved segments
-  .get('/', async ({ user }: { user: User }) => {
-    return db.select()
-      .from(clientSegments)
-      .where(eq(clientSegments.userId, user.id))
-      .orderBy(desc(clientSegments.pinned), desc(clientSegments.updatedAt));
-  })
-
-  // Preview segment (apply filters, return matching clients)
-  .post('/preview', async ({ body, user }: { body: { filters: SegmentFilters }; user: User }) => {
-    const conditions = buildClientConditions(body.filters, user.id);
-    const results = await db.select()
-      .from(clients)
-      .where(and(...conditions))
-      .orderBy(clients.lastName);
-    return { count: results.length, clients: results };
-  }, {
-    body: t.Object({
-      filters: t.Object({
-        stages: t.Optional(t.Array(t.String())),
-        tags: t.Optional(t.Array(t.String())),
-        industries: t.Optional(t.Array(t.String())),
-        cities: t.Optional(t.Array(t.String())),
-        states: t.Optional(t.Array(t.String())),
-        lastContactedBefore: t.Optional(t.String()),
-        lastContactedAfter: t.Optional(t.String()),
-        createdBefore: t.Optional(t.String()),
-        createdAfter: t.Optional(t.String()),
-        hasEmail: t.Optional(t.Boolean()),
-        hasPhone: t.Optional(t.Boolean()),
-        search: t.Optional(t.String()),
-      }),
-    }),
-  })
-
-  // Get filter options (unique values for dropdowns)
-  .get('/filter-options', async ({ user }: { user: User }) => {
-    const allClients = await db.select({
-      industry: clients.industry,
-      city: clients.city,
-      state: clients.state,
-      tags: clients.tags,
-      stage: clients.stage,
-    })
-      .from(clients)
-      .where(eq(clients.userId, user.id));
-
-    const industries = [...new Set(allClients.map(c => c.industry).filter(Boolean))] as string[];
-    const cities = [...new Set(allClients.map(c => c.city).filter(Boolean))] as string[];
-    const states = [...new Set(allClients.map(c => c.state).filter(Boolean))] as string[];
-    const tags = [...new Set(allClients.flatMap(c => (c.tags as string[]) || []))];
-    const stages = [...new Set(allClients.map(c => c.stage).filter(Boolean))] as string[];
-
-    return { industries: industries.sort(), cities: cities.sort(), states: states.sort(), tags: tags.sort(), stages: stages.sort() };
-  })
-
-  // Create segment
-  .post('/', async ({ body, user }: {
-    body: { name: string; description?: string; filters: SegmentFilters; color?: string; pinned?: boolean };
-    user: User;
-  }) => {
-    const [segment] = await db.insert(clientSegments)
-      .values({
-        userId: user.id,
-        name: body.name,
-        description: body.description,
-        filters: body.filters,
-        color: body.color || '#3b82f6',
-        pinned: body.pinned || false,
-      })
-      .returning();
-    return segment;
-  }, {
-    body: t.Object({
-      name: t.String({ minLength: 1 }),
-      description: t.Optional(t.String()),
-      filters: t.Object({
-        stages: t.Optional(t.Array(t.String())),
-        tags: t.Optional(t.Array(t.String())),
-        industries: t.Optional(t.Array(t.String())),
-        cities: t.Optional(t.Array(t.String())),
-        states: t.Optional(t.Array(t.String())),
-        lastContactedBefore: t.Optional(t.String()),
-        lastContactedAfter: t.Optional(t.String()),
-        createdBefore: t.Optional(t.String()),
-        createdAfter: t.Optional(t.String()),
-        hasEmail: t.Optional(t.Boolean()),
-        hasPhone: t.Optional(t.Boolean()),
-        search: t.Optional(t.String()),
-      }),
-      color: t.Optional(t.String()),
-      pinned: t.Optional(t.Boolean()),
-    }),
-  })
-
-  // Get segment + matching clients
-  .get('/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [segment] = await db.select()
-      .from(clientSegments)
-      .where(and(eq(clientSegments.id, params.id), eq(clientSegments.userId, user.id)))
-      .limit(1);
-    if (!segment) throw new Error('Segment not found');
-
-    const conditions = buildClientConditions(segment.filters as SegmentFilters, user.id);
-    const matchingClients = await db.select()
-      .from(clients)
-      .where(and(...conditions))
-      .orderBy(clients.lastName);
-
-    return { ...segment, clientCount: matchingClients.length, clients: matchingClients };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  })
-
-  // Update segment
-  .put('/:id', async ({ params, body, user }: {
-    params: { id: string };
-    body: { name?: string; description?: string; filters?: SegmentFilters; color?: string; pinned?: boolean };
-    user: User;
-  }) => {
-    const updateData: Record<string, unknown> = { updatedAt: new Date() };
-    if (body.name !== undefined) updateData.name = body.name;
-    if (body.description !== undefined) updateData.description = body.description;
-    if (body.filters !== undefined) updateData.filters = body.filters;
-    if (body.color !== undefined) updateData.color = body.color;
-    if (body.pinned !== undefined) updateData.pinned = body.pinned;
-
-    const [segment] = await db.update(clientSegments)
-      .set(updateData)
-      .where(and(eq(clientSegments.id, params.id), eq(clientSegments.userId, user.id)))
-      .returning();
-    if (!segment) throw new Error('Segment not found');
-    return segment;
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      name: t.Optional(t.String({ minLength: 1 })),
-      description: t.Optional(t.String()),
-      filters: t.Optional(t.Object({
-        stages: t.Optional(t.Array(t.String())),
-        tags: t.Optional(t.Array(t.String())),
-        industries: t.Optional(t.Array(t.String())),
-        cities: t.Optional(t.Array(t.String())),
-        states: t.Optional(t.Array(t.String())),
-        lastContactedBefore: t.Optional(t.String()),
-        lastContactedAfter: t.Optional(t.String()),
-        createdBefore: t.Optional(t.String()),
-        createdAfter: t.Optional(t.String()),
-        hasEmail: t.Optional(t.Boolean()),
-        hasPhone: t.Optional(t.Boolean()),
-        search: t.Optional(t.String()),
-      })),
-      color: t.Optional(t.String()),
-      pinned: t.Optional(t.Boolean()),
-    }),
-  })
-
-  // Delete segment
-  .delete('/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [deleted] = await db.delete(clientSegments)
-      .where(and(eq(clientSegments.id, params.id), eq(clientSegments.userId, user.id)))
-      .returning({ id: clientSegments.id });
-    if (!deleted) throw new Error('Segment not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  });

src/routes/stats.ts

@@ -1,84 +0,0 @@
-import { Elysia } from 'elysia';
-import { db } from '../db';
-import { clients, interactions, communications, events, clientNotes, notifications, users } from '../db/schema';
-import { eq, gte, count, sql } from 'drizzle-orm';
-import { authMiddleware } from '../middleware/auth';
-import type { User } from '../lib/auth';
-
-/**
- * System-wide stats and health metrics for the dashboard.
- */
-export const statsRoutes = new Elysia()
-  .use(authMiddleware)
-  .get('/stats/overview', async ({ user }) => {
-    const userId = user.id;
-
-    const now = new Date();
-    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
-    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-
-    // Client counts
-    const [totalClients] = await db.select({ count: count() })
-      .from(clients).where(eq(clients.userId, userId));
-    const [newClientsThisMonth] = await db.select({ count: count() })
-      .from(clients).where(sql`${clients.userId} = ${userId} AND ${clients.createdAt} >= ${thirtyDaysAgo}`);
-
-    // Interaction counts
-    const [totalInteractions30d] = await db.select({ count: count() })
-      .from(interactions).where(sql`${interactions.userId} = ${userId} AND ${interactions.contactedAt} >= ${thirtyDaysAgo}`);
-    const [totalInteractions7d] = await db.select({ count: count() })
-      .from(interactions).where(sql`${interactions.userId} = ${userId} AND ${interactions.contactedAt} >= ${sevenDaysAgo}`);
-
-    // Email counts
-    const [emailsSent30d] = await db.select({ count: count() })
-      .from(communications).where(sql`${communications.userId} = ${userId} AND ${communications.status} = 'sent' AND ${communications.createdAt} >= ${thirtyDaysAgo}`);
-
-    // Events
-    const [upcomingEvents] = await db.select({ count: count() })
-      .from(events).where(sql`${events.userId} = ${userId} AND ${events.date} >= ${now}`);
-
-    // Unread notifications
-    const [unreadNotifications] = await db.select({ count: count() })
-      .from(notifications).where(sql`${notifications.userId} = ${userId} AND ${notifications.read} = false`);
-
-    // Stage distribution
-    const stageDistribution = await db.select({
-      stage: clients.stage,
-      count: count(),
-    })
-      .from(clients)
-      .where(eq(clients.userId, userId))
-      .groupBy(clients.stage);
-
-    // Recent activity (last 7 days)
-    const interactionsByType = await db.select({
-      type: interactions.type,
-      count: count(),
-    })
-      .from(interactions)
-      .where(sql`${interactions.userId} = ${userId} AND ${interactions.contactedAt} >= ${sevenDaysAgo}`)
-      .groupBy(interactions.type);
-
-    return {
-      clients: {
-        total: totalClients?.count || 0,
-        newThisMonth: newClientsThisMonth?.count || 0,
-        stageDistribution: Object.fromEntries(
-          stageDistribution.map(s => [s.stage || 'unset', s.count])
-        ),
-      },
-      activity: {
-        interactions30d: totalInteractions30d?.count || 0,
-        interactions7d: totalInteractions7d?.count || 0,
-        emailsSent30d: emailsSent30d?.count || 0,
-        interactionsByType: Object.fromEntries(
-          interactionsByType.map(i => [i.type, i.count])
-        ),
-      },
-      upcoming: {
-        events: upcomingEvents?.count || 0,
-        unreadNotifications: unreadNotifications?.count || 0,
-      },
-      generatedAt: new Date().toISOString(),
-    };
-  });

src/routes/tags.ts

@@ -1,120 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { clients } from '../db/schema';
-import { eq, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const tagRoutes = new Elysia({ prefix: '/tags' })
-  .use(authMiddleware)
-  // GET /api/tags - all unique tags with client counts
-  .get('/', async ({ user }: { user: User }) => {
-    const allClients = await db.select({ tags: clients.tags })
-      .from(clients)
-      .where(eq(clients.userId, user.id));
-
-    const tagCounts = new Map<string, number>();
-    for (const client of allClients) {
-      if (client.tags && Array.isArray(client.tags)) {
-        for (const tag of client.tags) {
-          tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-        }
-      }
-    }
-
-    return Array.from(tagCounts.entries())
-      .map(([name, count]) => ({ name, count }))
-      .sort((a, b) => a.name.localeCompare(b.name));
-  })
-
-  // PUT /api/tags/rename - rename a tag across all clients
-  .put('/rename', async ({ body, user }: { body: { oldName: string; newName: string }; user: User }) => {
-    const { oldName, newName } = body;
-    if (!oldName || !newName) throw new Error('oldName and newName are required');
-    if (oldName === newName) return { success: true, updated: 0 };
-
-    const userClients = await db.select({ id: clients.id, tags: clients.tags })
-      .from(clients)
-      .where(eq(clients.userId, user.id));
-
-    let updated = 0;
-    for (const client of userClients) {
-      if (client.tags && Array.isArray(client.tags) && client.tags.includes(oldName)) {
-        const newTags = client.tags.map(t => t === oldName ? newName : t);
-        // Deduplicate
-        const uniqueTags = [...new Set(newTags)];
-        await db.update(clients)
-          .set({ tags: uniqueTags, updatedAt: new Date() })
-          .where(eq(clients.id, client.id));
-        updated++;
-      }
-    }
-
-    return { success: true, updated };
-  }, {
-    body: t.Object({
-      oldName: t.String({ minLength: 1 }),
-      newName: t.String({ minLength: 1 }),
-    }),
-  })
-
-  // DELETE /api/tags/:name - remove a tag from all clients
-  .delete('/:name', async ({ params, user }: { params: { name: string }; user: User }) => {
-    const tagName = decodeURIComponent(params.name);
-
-    const userClients = await db.select({ id: clients.id, tags: clients.tags })
-      .from(clients)
-      .where(eq(clients.userId, user.id));
-
-    let updated = 0;
-    for (const client of userClients) {
-      if (client.tags && Array.isArray(client.tags) && client.tags.includes(tagName)) {
-        const newTags = client.tags.filter(t => t !== tagName);
-        await db.update(clients)
-          .set({ tags: newTags, updatedAt: new Date() })
-          .where(eq(clients.id, client.id));
-        updated++;
-      }
-    }
-
-    return { success: true, removed: updated };
-  }, {
-    params: t.Object({
-      name: t.String(),
-    }),
-  })
-
-  // POST /api/tags/merge - merge multiple tags into one
-  .post('/merge', async ({ body, user }: { body: { sourceTags: string[]; targetTag: string }; user: User }) => {
-    const { sourceTags, targetTag } = body;
-    if (!sourceTags.length || !targetTag) throw new Error('sourceTags and targetTag are required');
-
-    const userClients = await db.select({ id: clients.id, tags: clients.tags })
-      .from(clients)
-      .where(eq(clients.userId, user.id));
-
-    let updated = 0;
-    for (const client of userClients) {
-      if (client.tags && Array.isArray(client.tags)) {
-        const hasAnySource = client.tags.some(t => sourceTags.includes(t));
-        if (hasAnySource) {
-          // Remove source tags, add target tag, deduplicate
-          const newTags = [...new Set([
-            ...client.tags.filter(t => !sourceTags.includes(t)),
-            targetTag,
-          ])];
-          await db.update(clients)
-            .set({ tags: newTags, updatedAt: new Date() })
-            .where(eq(clients.id, client.id));
-          updated++;
-        }
-      }
-    }
-
-    return { success: true, updated };
-  }, {
-    body: t.Object({
-      sourceTags: t.Array(t.String({ minLength: 1 }), { minItems: 1 }),
-      targetTag: t.String({ minLength: 1 }),
-    }),
-  });

src/routes/templates.ts

@@ -1,147 +0,0 @@
-import { authMiddleware } from '../middleware/auth';
-import { Elysia, t } from 'elysia';
-import { db } from '../db';
-import { emailTemplates } from '../db/schema';
-import { eq, and, desc, sql } from 'drizzle-orm';
-import type { User } from '../lib/auth';
-
-export const templateRoutes = new Elysia({ prefix: '/templates' })
-  .use(authMiddleware)
-  // List templates
-  .get('/', async ({ query, user }: { query: { category?: string }; user: User }) => {
-    let conditions = [eq(emailTemplates.userId, user.id)];
-    if (query.category) {
-      conditions.push(eq(emailTemplates.category, query.category));
-    }
-    return db.select()
-      .from(emailTemplates)
-      .where(and(...conditions))
-      .orderBy(desc(emailTemplates.usageCount));
-  }, {
-    query: t.Object({
-      category: t.Optional(t.String()),
-    }),
-  })
-
-  // Get single template
-  .get('/:id', async ({ params, user }: { params: { id: string }; user: User }) => {
-    const [template] = await db.select()
-      .from(emailTemplates)
-      .where(and(eq(emailTemplates.id, params.id), eq(emailTemplates.userId, user.id)))
-      .limit(1);
-    if (!template) throw new Error('Template not found');
-    return template;
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  })
-
-  // Create template
-  .post('/', async ({ body, user }: { body: { name: string; category: string; subject: string; content: string; isDefault?: boolean }; user: User }) => {
-    // If marking as default, unmark others in same category
-    if (body.isDefault) {
-      await db.update(emailTemplates)
-        .set({ isDefault: false })
-        .where(and(eq(emailTemplates.userId, user.id), eq(emailTemplates.category, body.category)));
-    }
-    const [template] = await db.insert(emailTemplates)
-      .values({
-        userId: user.id,
-        name: body.name,
-        category: body.category,
-        subject: body.subject,
-        content: body.content,
-        isDefault: body.isDefault || false,
-      })
-      .returning();
-    return template;
-  }, {
-    body: t.Object({
-      name: t.String({ minLength: 1 }),
-      category: t.String({ minLength: 1 }),
-      subject: t.String({ minLength: 1 }),
-      content: t.String({ minLength: 1 }),
-      isDefault: t.Optional(t.Boolean()),
-    }),
-  })
-
-  // Update template
-  .put('/:id', async (ctx: any) => {
-    const { params, body, user } = ctx as {
-      params: { id: string };
-      body: { name?: string; category?: string; subject?: string; content?: string; isDefault?: boolean };
-      user: User;
-    };
-    // If marking as default, unmark others
-    if (body.isDefault && body.category) {
-      await db.update(emailTemplates)
-        .set({ isDefault: false })
-        .where(and(eq(emailTemplates.userId, user.id), eq(emailTemplates.category, body.category)));
-    }
-    const updateData: Record<string, unknown> = { updatedAt: new Date() };
-    if (body.name !== undefined) updateData.name = body.name;
-    if (body.category !== undefined) updateData.category = body.category;
-    if (body.subject !== undefined) updateData.subject = body.subject;
-    if (body.content !== undefined) updateData.content = body.content;
-    if (body.isDefault !== undefined) updateData.isDefault = body.isDefault;
-
-    const [template] = await db.update(emailTemplates)
-      .set(updateData)
-      .where(and(eq(emailTemplates.id, params.id), eq(emailTemplates.userId, user.id)))
-      .returning();
-    if (!template) throw new Error('Template not found');
-    return template;
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      name: t.Optional(t.String({ minLength: 1 })),
-      category: t.Optional(t.String({ minLength: 1 })),
-      subject: t.Optional(t.String({ minLength: 1 })),
-      content: t.Optional(t.String({ minLength: 1 })),
-      isDefault: t.Optional(t.Boolean()),
-    }),
-  })
-
-  // Use template (increment usage count + return with placeholders filled)
-  .post('/:id/use', async (ctx: any) => {
-    const { params, body, user } = ctx;
-    const [template] = await db.select()
-      .from(emailTemplates)
-      .where(and(eq(emailTemplates.id, params.id), eq(emailTemplates.userId, user.id)))
-      .limit(1);
-    if (!template) throw new Error('Template not found');
-
-    // Increment usage count
-    await db.update(emailTemplates)
-      .set({ usageCount: sql`${emailTemplates.usageCount} + 1` })
-      .where(eq(emailTemplates.id, params.id));
-
-    // Fill placeholders
-    let subject = template.subject;
-    let content = template.content;
-    const vars = body.variables || {};
-    for (const [key, value] of Object.entries(vars)) {
-      const re = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-      subject = subject.replace(re, value as string);
-      content = content.replace(re, value as string);
-    }
-
-    return { subject, content, templateId: template.id, templateName: template.name };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-    body: t.Object({
-      clientId: t.Optional(t.String({ format: 'uuid' })),
-      variables: t.Optional(t.Record(t.String(), t.String())),
-    }),
-  })
-
-  // Delete template
-  .delete('/:id', async (ctx: any) => {
-    const { params, user } = ctx;
-    const [deleted] = await db.delete(emailTemplates)
-      .where(and(eq(emailTemplates.id, params.id), eq(emailTemplates.userId, user.id)))
-      .returning({ id: emailTemplates.id });
-    if (!deleted) throw new Error('Template not found');
-    return { success: true, id: deleted.id };
-  }, {
-    params: t.Object({ id: t.String({ format: 'uuid' }) }),
-  });

src/services/ai.ts

@@ -24,47 +24,13 @@ function getModel(provider: AIProvider = 'openai') {
   throw new Error(`Provider ${provider} not supported`);
 }
 
-// Build communication style instructions
-function buildStyleInstructions(style?: CommunicationStyle | null): string {
-  if (!style) return '';
-  
-  const parts: string[] = [];
-  
-  if (style.tone) {
-    const toneMap: Record<string, string> = {
-      formal: 'Use a formal, professional tone. Maintain distance and respect.',
-      friendly: 'Use a warm, friendly tone. Be personable but still professional.',
-      casual: 'Use a casual, relaxed tone. Be conversational and approachable.',
-    };
-    parts.push(toneMap[style.tone] || '');
-  }
-  
-  if (style.greeting) {
-    parts.push(`Always start emails with this greeting style: "${style.greeting}"`);
-  }
-  
-  if (style.signoff) {
-    parts.push(`Always end emails with this sign-off: "${style.signoff}"`);
-  }
-  
-  if (style.writingSamples && style.writingSamples.length > 0) {
-    parts.push(`Match the writing style of these samples from the advisor:\n${style.writingSamples.map((s, i) => `Sample ${i + 1}: "${s}"`).join('\n')}`);
-  }
-  
-  if (style.avoidWords && style.avoidWords.length > 0) {
-    parts.push(`NEVER use these words/phrases: ${style.avoidWords.join(', ')}`);
-  }
-  
-  return parts.length > 0 ? `\n\nCommunication Style Preferences:\n${parts.join('\n')}` : '';
-}
-
 // Email generation prompt
 const emailPrompt = ChatPromptTemplate.fromMessages([
   ['system', `You are a professional wealth advisor writing to a valued client.
 Maintain a warm but professional tone. Incorporate personal details naturally.
 Keep emails concise (3-4 paragraphs max).
 Do not include subject line - just the body.
-Always sign off with the advisor's actual name and details provided. Never use placeholders like [Your Name].{styleInstructions}`],
+Always sign off with the advisor's actual name and details provided. Never use placeholders like [Your Name].`],
   ['human', `Advisor Info:
 - Name: {advisorName}
 - Title: {advisorTitle}
@@ -81,14 +47,6 @@ Purpose of email: {purpose}
 Generate a personalized email that feels genuine, not templated. End with an appropriate signature using the advisor's real name and details.`],
 ]);
 
-export interface CommunicationStyle {
-  tone?: 'formal' | 'friendly' | 'casual';
-  greeting?: string;
-  signoff?: string;
-  writingSamples?: string[];
-  avoidWords?: string[];
-}
-
 export interface GenerateEmailParams {
   advisorName: string;
   advisorTitle?: string;
@@ -100,7 +58,6 @@ export interface GenerateEmailParams {
   notes: string;
   purpose: string;
   provider?: AIProvider;
-  communicationStyle?: CommunicationStyle | null;
 }
 
 export async function generateEmail(params: GenerateEmailParams): Promise<string> {
@@ -118,7 +75,6 @@ export async function generateEmail(params: GenerateEmailParams): Promise<string
     interests: params.interests.join(', ') || 'not specified',
     notes: params.notes || 'No recent notes',
     purpose: params.purpose,
-    styleInstructions: buildStyleInstructions(params.communicationStyle),
   });
   
   return response;
@@ -156,121 +112,6 @@ export async function generateBirthdayMessage(params: GenerateBirthdayMessagePar
   return response;
 }
 
-// Meeting prep generation
-const meetingPrepPrompt = ChatPromptTemplate.fromMessages([
-  ['system', `You are an AI assistant helping a wealth advisor prepare for a client meeting.
-Analyze the client data and generate useful talking points.
-Be specific and actionable - reference actual data when available.
-Output valid JSON with this structure:
-{{
-  "summary": "Brief 2-3 sentence overview of the client relationship",
-  "suggestedTopics": ["topic1", "topic2", ...],
-  "conversationStarters": ["starter1", "starter2", ...],
-  "followUpItems": ["item1", "item2", ...] 
-}}
-Only output the JSON, nothing else.`],
-  ['human', `Client Profile:
-- Name: {clientName}
-- Company: {clientCompany}
-- Role: {clientRole}
-- Industry: {clientIndustry}
-- Stage: {clientStage}
-- Interests: {clientInterests}
-- Family: {clientFamily}
-- Days since last contact: {daysSinceContact}
-
-Recent Interactions:
-{interactions}
-
-Recent Emails:
-{emails}
-
-Notes:
-{notes}
-
-Upcoming Events:
-{upcomingEvents}
-
-Important Dates:
-{importantDates}
-
-Generate meeting prep JSON.`],
-]);
-
-export interface MeetingPrepInput {
-  clientSummary: {
-    name: string;
-    company: string;
-    role: string;
-    industry: string;
-    stage: string;
-    interests: string[];
-    family?: { spouse?: string; children?: string[] } | null;
-    daysSinceLastContact: number;
-  };
-  recentInteractions: { type: string; title: string; description?: string | null; date: Date | string }[];
-  recentEmails: { subject?: string | null; status?: string | null; date: Date | string }[];
-  notes: string;
-  upcomingEvents: { type: string; title: string; date: Date | string }[];
-  importantDates: { type: string; date: string; label: string }[];
-  provider?: AIProvider;
-}
-
-export interface MeetingPrepOutput {
-  summary: string;
-  suggestedTopics: string[];
-  conversationStarters: string[];
-  followUpItems: string[];
-}
-
-export async function generateMeetingPrep(params: MeetingPrepInput): Promise<MeetingPrepOutput> {
-  const model = getModel(params.provider);
-  const parser = new StringOutputParser();
-  const chain = meetingPrepPrompt.pipe(model).pipe(parser);
-
-  const familyStr = params.clientSummary.family
-    ? `Spouse: ${params.clientSummary.family.spouse || 'N/A'}, Children: ${params.clientSummary.family.children?.join(', ') || 'N/A'}`
-    : 'Not available';
-
-  const response = await chain.invoke({
-    clientName: params.clientSummary.name,
-    clientCompany: params.clientSummary.company,
-    clientRole: params.clientSummary.role,
-    clientIndustry: params.clientSummary.industry,
-    clientStage: params.clientSummary.stage,
-    clientInterests: params.clientSummary.interests.join(', ') || 'Not specified',
-    clientFamily: familyStr,
-    daysSinceContact: String(params.clientSummary.daysSinceLastContact),
-    interactions: params.recentInteractions.length > 0
-      ? params.recentInteractions.map(i => `- [${i.type}] ${i.title} (${new Date(i.date).toLocaleDateString()})${i.description ? ': ' + i.description : ''}`).join('\n')
-      : 'No recent interactions',
-    emails: params.recentEmails.length > 0
-      ? params.recentEmails.map(e => `- ${e.subject || 'No subject'} (${e.status}, ${new Date(e.date).toLocaleDateString()})`).join('\n')
-      : 'No recent emails',
-    notes: params.notes || 'No notes',
-    upcomingEvents: params.upcomingEvents.length > 0
-      ? params.upcomingEvents.map(e => `- ${e.title} (${e.type}, ${new Date(e.date).toLocaleDateString()})`).join('\n')
-      : 'No upcoming events',
-    importantDates: params.importantDates.length > 0
-      ? params.importantDates.map(d => `- ${d.label}`).join('\n')
-      : 'No notable upcoming dates',
-  });
-
-  try {
-    // Extract JSON from response (handle markdown code blocks)
-    const jsonStr = response.replace(/```json?\n?/g, '').replace(/```/g, '').trim();
-    return JSON.parse(jsonStr);
-  } catch {
-    // Fallback if AI returns non-JSON
-    return {
-      summary: response.slice(0, 500),
-      suggestedTopics: ['Review financial goals', 'Market update', 'Personal check-in'],
-      conversationStarters: ['How have things been going?'],
-      followUpItems: ['Send meeting summary'],
-    };
-  }
-}
-
 // Email subject generation
 const subjectPrompt = ChatPromptTemplate.fromMessages([
   ['system', `Generate a professional but warm email subject line for a wealth advisor's email.

src/services/audit.ts

@@ -1,55 +0,0 @@
-import { db } from '../db';
-import { auditLogs } from '../db/schema';
-
-export type AuditAction = 'create' | 'update' | 'delete' | 'view' | 'send' | 'login' | 'logout' | 'password_change';
-export type AuditEntityType = 'client' | 'email' | 'event' | 'template' | 'segment' | 'user' | 'auth' | 'interaction' | 'note' | 'notification' | 'invite' | 'profile';
-
-export interface AuditLogParams {
-  userId?: string | null;
-  action: AuditAction;
-  entityType: AuditEntityType;
-  entityId?: string | null;
-  details?: Record<string, unknown> | null;
-  ipAddress?: string | null;
-  userAgent?: string | null;
-}
-
-export async function logAudit(params: AuditLogParams): Promise<void> {
-  try {
-    await db.insert(auditLogs).values({
-      userId: params.userId || null,
-      action: params.action,
-      entityType: params.entityType,
-      entityId: params.entityId || null,
-      details: params.details || null,
-      ipAddress: params.ipAddress || null,
-      userAgent: params.userAgent || null,
-    });
-  } catch (err) {
-    // Don't let audit logging failures break the app
-    console.error('[AUDIT] Failed to log:', err);
-  }
-}
-
-// Helper to extract IP and User-Agent from request
-export function getRequestMeta(request: Request): { ipAddress: string | null; userAgent: string | null } {
-  return {
-    ipAddress: request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() 
-      || request.headers.get('x-real-ip') 
-      || null,
-    userAgent: request.headers.get('user-agent') || null,
-  };
-}
-
-// Helper to compute diff between old and new values
-export function computeDiff(oldVal: Record<string, unknown>, newVal: Record<string, unknown>): Record<string, { from: unknown; to: unknown }> {
-  const diff: Record<string, { from: unknown; to: unknown }> = {};
-  for (const key of Object.keys(newVal)) {
-    const oldV = oldVal[key];
-    const newV = newVal[key];
-    if (JSON.stringify(oldV) !== JSON.stringify(newV)) {
-      diff[key] = { from: oldV, to: newV };
-    }
-  }
-  return diff;
-}

src/services/jobs.ts

@@ -1,304 +0,0 @@
-import { PgBoss } from 'pg-boss';
-import type { Job } from 'pg-boss';
-import { db } from '../db';
-import { events, notifications, clients, users, interactions, communications } from '../db/schema';
-import { eq, and, gte, lte, sql, count, isNotNull } from 'drizzle-orm';
-import { sendEmail } from './email';
-
-let boss: PgBoss | null = null;
-
-export async function initJobQueue(): Promise<PgBoss> {
-  const connectionString = process.env.DATABASE_URL;
-  if (!connectionString) {
-    throw new Error('DATABASE_URL required for job queue');
-  }
-
-  boss = new PgBoss(connectionString);
-
-  boss.on('error', (error) => {
-    console.error('[pg-boss] Error:', error);
-  });
-
-  await boss.start();
-  console.log('✅ pg-boss job queue started');
-
-  // Register job handlers
-  await boss.work('check-upcoming-events', { localConcurrency: 1 }, checkUpcomingEvents);
-  await boss.work('send-event-reminder', { localConcurrency: 5 }, sendEventReminder);
-  await boss.work('check-birthdays', { localConcurrency: 1 }, checkBirthdays);
-  await boss.work('send-birthday-notification', { localConcurrency: 5 }, sendBirthdayNotification);
-
-  // Schedule daily checks at 8am UTC
-  await boss.schedule('check-upcoming-events', '0 8 * * *', {}, {
-    tz: 'UTC',
-  });
-  await boss.schedule('check-birthdays', '0 8 * * *', {}, {
-    tz: 'UTC',
-  });
-
-  console.log('✅ Job schedules registered');
-  return boss;
-}
-
-export function getJobQueue(): PgBoss | null {
-  return boss;
-}
-
-// Job: Check upcoming events and create notifications
-async function checkUpcomingEvents(jobs: Job[]) {
-  console.log(`[jobs] Running checkUpcomingEvents at ${new Date().toISOString()}`);
-  
-  try {
-    const now = new Date();
-    
-    // Get all events with their reminder windows
-    const allEvents = await db.select({
-      event: events,
-      client: clients,
-    })
-      .from(events)
-      .innerJoin(clients, eq(events.clientId, clients.id));
-
-    let created = 0;
-
-    for (const { event, client } of allEvents) {
-      const reminderDays = event.reminderDays || 7;
-      let eventDate = new Date(event.date);
-
-      // For recurring events, adjust to this year
-      if (event.recurring) {
-        eventDate = new Date(now.getFullYear(), eventDate.getMonth(), eventDate.getDate());
-        // If the date already passed this year, check next year
-        if (eventDate < now) {
-          eventDate = new Date(now.getFullYear() + 1, eventDate.getMonth(), eventDate.getDate());
-        }
-      }
-
-      const daysUntil = Math.ceil((eventDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-
-      // Within reminder window and not already triggered recently
-      if (daysUntil >= 0 && daysUntil <= reminderDays) {
-        // Check if already notified (within last 24h for this event)
-        const dayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-        const existing = await db.select({ id: notifications.id })
-          .from(notifications)
-          .where(and(
-            eq(notifications.eventId, event.id),
-            eq(notifications.userId, event.userId),
-            gte(notifications.createdAt, dayAgo),
-          ))
-          .limit(1);
-
-        if (existing.length === 0) {
-          // Create notification
-          await db.insert(notifications).values({
-            userId: event.userId,
-            type: 'event_reminder',
-            title: daysUntil === 0 ? `Today: ${event.title}` : `${event.title} in ${daysUntil} day${daysUntil !== 1 ? 's' : ''}`,
-            message: `${event.title} for ${client.firstName} ${client.lastName} is ${daysUntil === 0 ? 'today' : `coming up in ${daysUntil} day${daysUntil !== 1 ? 's' : ''}`}.`,
-            clientId: client.id,
-            eventId: event.id,
-          });
-          created++;
-
-          // Also queue email reminder
-          if (boss) {
-            await boss.send('send-event-reminder', {
-              userId: event.userId,
-              eventId: event.id,
-              clientId: client.id,
-              eventTitle: event.title,
-              clientName: `${client.firstName} ${client.lastName}`,
-              daysUntil,
-            });
-          }
-        }
-      }
-    }
-
-    console.log(`[jobs] checkUpcomingEvents: created ${created} notifications`);
-  } catch (error) {
-    console.error('[jobs] checkUpcomingEvents error:', error);
-    throw error;
-  }
-}
-
-// Job: Send email reminder to advisor
-interface EventReminderData {
-  userId: string;
-  eventId: string;
-  clientId: string;
-  eventTitle: string;
-  clientName: string;
-  daysUntil: number;
-}
-
-async function sendEventReminder(jobs: Job<EventReminderData>[]) {
-  const job = jobs[0];
-  if (!job) return;
-  const { userId, eventTitle, clientName, daysUntil } = job.data;
-
-  try {
-    // Get user email
-    const [user] = await db.select({ email: users.email, name: users.name })
-      .from(users)
-      .where(eq(users.id, userId))
-      .limit(1);
-
-    if (!user?.email) {
-      console.log(`[jobs] sendEventReminder: no email for user ${userId}`);
-      return;
-    }
-
-    const subject = daysUntil === 0
-      ? `Reminder: ${eventTitle} is today!`
-      : `Reminder: ${eventTitle} in ${daysUntil} day${daysUntil !== 1 ? 's' : ''}`;
-
-    const content = `Hi ${user.name},\n\nThis is a reminder that "${eventTitle}" for ${clientName} is ${daysUntil === 0 ? 'today' : `coming up in ${daysUntil} day${daysUntil !== 1 ? 's' : ''}`}.\n\nLog in to your Network App to prepare.\n\nBest,\nThe Network App`;
-
-    await sendEmail({
-      to: user.email,
-      subject,
-      content,
-    });
-
-    console.log(`[jobs] Sent event reminder to ${user.email}: ${subject}`);
-  } catch (error) {
-    console.error(`[jobs] sendEventReminder error:`, error);
-    // Don't throw - email failures shouldn't retry aggressively
-  }
-}
-
-// Job: Check upcoming client birthdays across all users
-async function checkBirthdays(jobs: Job[]) {
-  console.log(`[jobs] Running checkBirthdays at ${new Date().toISOString()}`);
-
-  try {
-    const now = new Date();
-    const todayMonth = now.getMonth();
-    const todayDate = now.getDate();
-
-    // Get all clients with birthdays set
-    const allClients = await db.select({
-      client: clients,
-    })
-      .from(clients)
-      .where(isNotNull(clients.birthday));
-
-    let created = 0;
-
-    for (const { client } of allClients) {
-      if (!client.birthday) continue;
-      const bday = new Date(client.birthday);
-      const bdayMonth = bday.getMonth();
-      const bdayDate = bday.getDate();
-
-      // Calculate days until birthday (this year or next)
-      let nextBirthday = new Date(now.getFullYear(), bdayMonth, bdayDate);
-      if (nextBirthday < now) {
-        nextBirthday = new Date(now.getFullYear() + 1, bdayMonth, bdayDate);
-      }
-      const daysUntil = Math.ceil((nextBirthday.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-
-      // Notify 7 days before and on the day
-      if (daysUntil <= 7) {
-        // Check if already notified in last 24h
-        const dayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-        const existing = await db.select({ id: notifications.id })
-          .from(notifications)
-          .where(and(
-            eq(notifications.clientId, client.id),
-            eq(notifications.userId, client.userId),
-            eq(notifications.type, 'birthday_reminder'),
-            gte(notifications.createdAt, dayAgo),
-          ))
-          .limit(1);
-
-        if (existing.length === 0) {
-          const clientName = `${client.firstName} ${client.lastName}`;
-          const title = daysUntil === 0
-            ? `🎂 ${clientName}'s birthday is today!`
-            : `🎂 ${clientName}'s birthday in ${daysUntil} day${daysUntil !== 1 ? 's' : ''}`;
-
-          await db.insert(notifications).values({
-            userId: client.userId,
-            type: 'birthday_reminder',
-            title,
-            message: daysUntil === 0
-              ? `Today is ${clientName}'s birthday! Consider sending a personalized message.`
-              : `${clientName}'s birthday is coming up on ${nextBirthday.toLocaleDateString('en-US', { month: 'long', day: 'numeric' })}. Plan something special!`,
-            clientId: client.id,
-          });
-          created++;
-
-          // Queue email notification to the advisor
-          if (boss) {
-            await boss.send('send-birthday-notification', {
-              userId: client.userId,
-              clientId: client.id,
-              clientName,
-              clientEmail: client.email,
-              daysUntil,
-              birthdayDate: nextBirthday.toISOString(),
-            });
-          }
-        }
-      }
-    }
-
-    console.log(`[jobs] checkBirthdays: created ${created} notifications`);
-  } catch (error) {
-    console.error('[jobs] checkBirthdays error:', error);
-    throw error;
-  }
-}
-
-// Job: Send birthday notification email to advisor
-interface BirthdayNotificationData {
-  userId: string;
-  clientId: string;
-  clientName: string;
-  clientEmail: string | null;
-  daysUntil: number;
-  birthdayDate: string;
-}
-
-async function sendBirthdayNotification(jobs: Job<BirthdayNotificationData>[]) {
-  const job = jobs[0];
-  if (!job) return;
-  const { userId, clientName, clientEmail, daysUntil, birthdayDate } = job.data;
-
-  try {
-    const [user] = await db.select({ email: users.email, name: users.name })
-      .from(users)
-      .where(eq(users.id, userId))
-      .limit(1);
-
-    if (!user?.email) return;
-
-    const bday = new Date(birthdayDate);
-    const dateStr = bday.toLocaleDateString('en-US', { weekday: 'long', month: 'long', day: 'numeric' });
-
-    const subject = daysUntil === 0
-      ? `🎂 ${clientName}'s birthday is today!`
-      : `🎂 ${clientName}'s birthday is ${dateStr}`;
-
-    let content = `Hi ${user.name},\n\n`;
-    if (daysUntil === 0) {
-      content += `Today is ${clientName}'s birthday! 🎉\n\n`;
-      content += `This is a great opportunity to strengthen your relationship with a personalized message.`;
-    } else {
-      content += `${clientName}'s birthday is coming up on ${dateStr} (${daysUntil} day${daysUntil !== 1 ? 's' : ''} away).\n\n`;
-      content += `Plan ahead — a timely birthday message goes a long way in building strong client relationships.`;
-    }
-    if (clientEmail) {
-      content += `\n\nYou can compose a birthday email directly from the Network App.`;
-    }
-    content += `\n\nBest,\nThe Network App`;
-
-    await sendEmail({ to: user.email, subject, content });
-    console.log(`[jobs] Sent birthday notification to ${user.email} for ${clientName}`);
-  } catch (error) {
-    console.error('[jobs] sendBirthdayNotification error:', error);
-  }
-}