Add all 3 tiers: relationships, revenue, SLA, sequences, knowledge, briefs, quotes + browser extension

Tier 1:
- Client Relationship Heat Map (/relationships): health scores per contact, trend
  detection, at-risk alerts, 30/90-day email frequency tracking
- Revenue Signal Extraction (/revenue): Claude Haiku scans emails for quotes, invoices,
  unpaid amounts, renewals, upsell opportunities; pipeline value summary
- SLA Tracker (/sla): configurable response tiers per sender domain, breach/warning/ok
  dashboard with progress bars
- Follow-up Sequences (/sequences): multi-step automated follow-up campaigns; enroll
  contacts from email view; APScheduler flushes steps every 4h

Tier 2:
- Knowledge Base (/knowledge): extracts decisions, agreements, prices, commitments from
  email history into searchable entries; bulk extract with one click
- Meeting Briefs (/briefs): pre-meeting context brief from calendar event + email history
  with attendees; open action items, agenda suggestions, watch-outs
- Quote Generator (/quotes): AI extracts project scope from email thread, generates
  line-item quote with GST; track draft→sent→won/lost lifecycle

Tier 3:
- Browser Extension (browser-extension/): Manifest V3 Chrome extension with AI compose
  popup, Gmail draft injection via content script, knowledge base search, Mailair API
  auth via storage

Backend: 7 new services + 7 new routes, all wired into main.py
Frontend: 7 new pages + Layout nav updated, all types + API methods added

Supabase migrations required — see PR description for SQL.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Sai Sridhar

backend/main.py

@@ -15,7 +15,7 @@
 
 from config import settings
 from limiter import limiter
-from routes import auth, emails, actions, replies, integrations, settings as settings_routes, billing, contacts, outlook, calendar, teams, webhooks as webhooks_routes, autoassign, crm_integrations, admin as admin_routes, waitlist as waitlist_routes, push as push_routes, scheduled as scheduled_routes, newsletter as newsletter_routes
+from routes import auth, emails, actions, replies, integrations, settings as settings_routes, billing, contacts, outlook, calendar, teams, webhooks as webhooks_routes, autoassign, crm_integrations, admin as admin_routes, waitlist as waitlist_routes, push as push_routes, scheduled as scheduled_routes, newsletter as newsletter_routes, relationships as relationships_routes, revenue as revenue_routes, sla as sla_routes, sequences as sequences_routes, knowledge as knowledge_routes, briefs as briefs_routes, quotes as quotes_routes
 from workers.email_listener import start_email_listener, stop_email_listener
 
 # ---------------------------------------------------------------------------
@@ -171,6 +171,13 @@ async def generic_exception_handler(request: Request, exc: Exception):
 app.include_router(push_routes.router, prefix="/api")
 app.include_router(scheduled_routes.router, prefix="/api")
 app.include_router(newsletter_routes.router, prefix="/api")
+app.include_router(relationships_routes.router, prefix="/api")
+app.include_router(revenue_routes.router, prefix="/api")
+app.include_router(sla_routes.router, prefix="/api")
+app.include_router(sequences_routes.router, prefix="/api")
+app.include_router(knowledge_routes.router, prefix="/api")
+app.include_router(briefs_routes.router, prefix="/api")
+app.include_router(quotes_routes.router, prefix="/api")
 
 
 # ---------------------------------------------------------------------------

backend/routes/briefs.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+from typing import List, Optional
+from middleware.auth import get_current_user
+from services.brief_service import generate_meeting_brief, list_briefs
+
+router = APIRouter(prefix="/briefs", tags=["briefs"])
+
+
+@router.get("")
+async def get_briefs(current_user: dict = Depends(get_current_user)):
+    return {"briefs": list_briefs(current_user["id"])}
+
+
+class BriefRequest(BaseModel):
+    title: str
+    start_time: str
+    attendee_emails: List[str]
+    description: Optional[str] = None
+
+
+@router.post("", status_code=201)
+async def create_brief(body: BriefRequest, current_user: dict = Depends(get_current_user)):
+    brief = await generate_meeting_brief(
+        user_id=current_user["id"],
+        event=body.model_dump(),
+    )
+    return brief

backend/routes/knowledge.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Depends, Query
+from typing import Optional
+from middleware.auth import get_current_user
+from services.knowledge_service import search_knowledge, list_knowledge, delete_knowledge_entry, extract_knowledge_from_email, bulk_extract_knowledge
+
+router = APIRouter(prefix="/knowledge", tags=["knowledge"])
+
+
+@router.get("")
+async def get_knowledge(
+    q: Optional[str] = Query(None),
+    entry_type: Optional[str] = Query(None),
+    current_user: dict = Depends(get_current_user),
+):
+    if q:
+        entries = search_knowledge(current_user["id"], q, entry_type)
+    else:
+        entries = list_knowledge(current_user["id"], entry_type)
+    return {"entries": entries, "total": len(entries)}
+
+
+@router.post("/extract/{email_id}")
+async def extract_from_email(email_id: str, current_user: dict = Depends(get_current_user)):
+    entries = await extract_knowledge_from_email(email_id, current_user["id"])
+    return {"entries": entries, "count": len(entries)}
+
+
+@router.post("/bulk-extract")
+async def bulk_extract(current_user: dict = Depends(get_current_user)):
+    count = await bulk_extract_knowledge(current_user["id"])
+    return {"extracted": count}
+
+
+@router.delete("/{entry_id}", status_code=204)
+async def delete_entry(entry_id: str, current_user: dict = Depends(get_current_user)):
+    delete_knowledge_entry(entry_id, current_user["id"])

backend/routes/quotes.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from middleware.auth import get_current_user
+from services.quote_service import generate_quote_from_email, list_quotes, update_quote_status
+
+router = APIRouter(prefix="/quotes", tags=["quotes"])
+
+
+@router.get("")
+async def get_quotes(current_user: dict = Depends(get_current_user)):
+    return {"quotes": list_quotes(current_user["id"])}
+
+
+@router.post("/generate/{email_id}", status_code=201)
+async def generate_quote(email_id: str, current_user: dict = Depends(get_current_user)):
+    quote = await generate_quote_from_email(email_id, current_user["id"])
+    if not quote:
+        raise HTTPException(status_code=404, detail="Email not found or quote generation failed")
+    return quote
+
+
+class StatusUpdate(BaseModel):
+    status: str  # draft|sent|accepted|rejected
+
+
+@router.patch("/{quote_id}/status")
+async def patch_status(quote_id: str, body: StatusUpdate, current_user: dict = Depends(get_current_user)):
+    ok = update_quote_status(quote_id, current_user["id"], body.status)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Quote not found")
+    return {"status": body.status}

backend/routes/relationships.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, Depends
+from middleware.auth import get_current_user
+from services.relationship_service import compute_relationship_scores, get_sentiment_history
+
+router = APIRouter(prefix="/relationships", tags=["relationships"])
+
+
+@router.get("")
+async def get_relationships(current_user: dict = Depends(get_current_user)):
+    scores = await compute_relationship_scores(current_user["id"])
+    return {"contacts": scores, "total": len(scores)}
+
+
+@router.get("/{contact_email}/sentiment")
+async def get_sentiment(contact_email: str, days: int = 90, current_user: dict = Depends(get_current_user)):
+    history = await get_sentiment_history(current_user["id"], contact_email, days)
+    return {"contact_email": contact_email, "history": history}

backend/routes/revenue.py

@@ -0,0 +1,39 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from middleware.auth import get_current_user
+from services.revenue_service import (
+    get_revenue_summary,
+    extract_revenue_signals_from_email,
+    scan_recent_emails_for_revenue,
+)
+from database import get_supabase
+
+router = APIRouter(prefix="/revenue", tags=["revenue"])
+
+
+@router.get("/summary")
+async def revenue_summary(current_user: dict = Depends(get_current_user)):
+    return get_revenue_summary(current_user["id"])
+
+
+@router.post("/scan")
+async def scan_emails(current_user: dict = Depends(get_current_user)):
+    count = await scan_recent_emails_for_revenue(current_user["id"])
+    return {"signals_found": count}
+
+
+@router.post("/signals/{email_id}")
+async def extract_from_email(email_id: str, current_user: dict = Depends(get_current_user)):
+    signals = await extract_revenue_signals_from_email(email_id, current_user["id"])
+    return {"signals": signals}
+
+
+class SignalUpdate(BaseModel):
+    status: str  # open|won|lost|dismissed
+
+
+@router.patch("/signals/{signal_id}")
+async def update_signal(signal_id: str, body: SignalUpdate, current_user: dict = Depends(get_current_user)):
+    supabase = get_supabase()
+    supabase.table("revenue_signals").update({"status": body.status}).eq("id", signal_id).eq("user_id", current_user["id"]).execute()
+    return {"status": body.status}

backend/routes/sequences.py

@@ -0,0 +1,71 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from middleware.auth import get_current_user
+from services.sequence_service import (
+    list_sequences, create_sequence, delete_sequence,
+    enroll_in_sequence, list_enrollments, cancel_enrollment,
+)
+
+router = APIRouter(prefix="/sequences", tags=["sequences"])
+
+
+@router.get("")
+async def get_sequences(current_user: dict = Depends(get_current_user)):
+    return {"sequences": list_sequences(current_user["id"])}
+
+
+class SequenceStep(BaseModel):
+    delay_days: int
+    subject_template: str
+    body_template: str
+
+
+class CreateSequenceBody(BaseModel):
+    name: str
+    steps: List[SequenceStep]
+
+
+@router.post("", status_code=201)
+async def post_sequence(body: CreateSequenceBody, current_user: dict = Depends(get_current_user)):
+    seq = create_sequence(
+        user_id=current_user["id"],
+        name=body.name,
+        steps=[s.model_dump() for s in body.steps],
+    )
+    return seq
+
+
+@router.delete("/{seq_id}", status_code=204)
+async def del_sequence(seq_id: str, current_user: dict = Depends(get_current_user)):
+    ok = delete_sequence(seq_id, current_user["id"])
+    if not ok:
+        raise HTTPException(status_code=404, detail="Sequence not found")
+
+
+class EnrollBody(BaseModel):
+    contact_email: str
+    email_id: Optional[str] = None
+
+
+@router.post("/{seq_id}/enroll", status_code=201)
+async def enroll(seq_id: str, body: EnrollBody, current_user: dict = Depends(get_current_user)):
+    enrollment = enroll_in_sequence(
+        user_id=current_user["id"],
+        sequence_id=seq_id,
+        contact_email=body.contact_email,
+        email_id=body.email_id,
+    )
+    if not enrollment:
+        raise HTTPException(status_code=404, detail="Sequence not found")
+    return enrollment
+
+
+@router.get("/enrollments")
+async def get_enrollments(current_user: dict = Depends(get_current_user)):
+    return {"enrollments": list_enrollments(current_user["id"])}
+
+
+@router.post("/enrollments/{enrollment_id}/cancel", status_code=204)
+async def cancel(enrollment_id: str, current_user: dict = Depends(get_current_user)):
+    cancel_enrollment(enrollment_id, current_user["id"])

backend/routes/sla.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import List
+from middleware.auth import get_current_user
+from services.sla_service import get_sla_configs, create_sla_config, delete_sla_config, compute_sla_status
+
+router = APIRouter(prefix="/sla", tags=["sla"])
+
+
+@router.get("/status")
+async def sla_status(current_user: dict = Depends(get_current_user)):
+    return compute_sla_status(current_user["id"])
+
+
+@router.get("/configs")
+async def list_configs(current_user: dict = Depends(get_current_user)):
+    return {"configs": get_sla_configs(current_user["id"])}
+
+
+class SLAConfigBody(BaseModel):
+    tier_name: str
+    max_response_hours: int
+    sender_patterns: List[str] = []
+
+
+@router.post("/configs", status_code=201)
+async def create_config(body: SLAConfigBody, current_user: dict = Depends(get_current_user)):
+    config = create_sla_config(
+        user_id=current_user["id"],
+        tier_name=body.tier_name,
+        max_response_hours=body.max_response_hours,
+        sender_patterns=body.sender_patterns,
+    )
+    return config
+
+
+@router.delete("/configs/{config_id}", status_code=204)
+async def del_config(config_id: str, current_user: dict = Depends(get_current_user)):
+    ok = delete_sla_config(config_id, current_user["id"])
+    if not ok:
+        raise HTTPException(status_code=404, detail="Config not found")