multiple structure changes

alembic/versions/0013_desk_and_call_picked_by.py

@@ -0,0 +1,36 @@
+"""leads.sent_to_desk_at, leads.call_picked_by
+
+structure-plan.md Phase 1 -- Contacts becomes the intake hub; a lead only appears on the Cold Call Desk
+once a rep explicitly sends it there (sent_to_desk_at). "Call picked by" (Receptionist / Decision Maker /
+Team Member) is a tag-only mark on the card, never a stage change (call_picked_by).
+
+Both nullable, no default: existing leads get NULL for both -- NOT auto-populated onto the desk. The next
+phase (Cold Call Desk query change) decides how NULL is treated for leads that predate this column; until
+then this migration only adds the columns.
+
+Revision ID: 0013_desk_and_call_picked_by
+Revises: 0012_user_password
+Create Date: 2026-09-22
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0013_desk_and_call_picked_by"
+down_revision: Union[str, None] = "0012_user_password"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column("leads", sa.Column("sent_to_desk_at", sa.DateTime(), nullable=True))
+    op.add_column("leads", sa.Column("call_picked_by", sa.String(length=16), nullable=True))
+    op.create_index("idx_leads_sent_to_desk", "leads", ["sent_to_desk_at"])
+
+
+def downgrade() -> None:
+    op.drop_index("idx_leads_sent_to_desk", table_name="leads")
+    op.drop_column("leads", "call_picked_by")
+    op.drop_column("leads", "sent_to_desk_at")

alembic/versions/0014_hidden_and_callback.py

@@ -0,0 +1,43 @@
+"""leads.hidden_at, leads.callback_at
+
+structure-plan.md Phase 3 -- Cold Call Desk card redesign.
+
+  hidden_at    Dead Line / Not Interested (cold call) mark a lead invisible everywhere -- recorded in the
+               database, shown on no screen. crud.list_leads() (Phase 3) excludes hidden_at IS NOT NULL
+               unconditionally, so every list consumer (Contacts, Pipeline, Cold Call Desk) is covered by
+               one change, with nothing to remember per page. A future phase's audit view will need its
+               own explicit override; none exists yet.
+  callback_at  Callback Scheduled's date/time, asked the same way Meeting Booked asks for meeting_at --
+               deliberately a SEPARATE column, so a callback can never be confused with, or accidentally
+               show on, the Meetings calendar (which reads meeting_at).
+
+Both nullable, no default, no backfill: every existing lead is unaffected (not hidden, no callback set).
+
+Revision ID: 0014_hidden_and_callback
+Revises: 0013_desk_and_call_picked_by
+Create Date: 2026-09-22
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0014_hidden_and_callback"
+down_revision: Union[str, None] = "0013_desk_and_call_picked_by"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column("leads", sa.Column("hidden_at", sa.DateTime(), nullable=True))
+    op.add_column("leads", sa.Column("callback_at", sa.DateTime(), nullable=True))
+    op.create_index("idx_leads_hidden", "leads", ["hidden_at"])
+    op.create_index("idx_leads_callback", "leads", ["callback_at"])
+
+
+def downgrade() -> None:
+    op.drop_index("idx_leads_callback", table_name="leads")
+    op.drop_index("idx_leads_hidden", table_name="leads")
+    op.drop_column("leads", "callback_at")
+    op.drop_column("leads", "hidden_at")

app/api/leads.py

@@ -24,10 +24,12 @@ from app.models import _utcnow as _now
 from app.schemas.lead import (
     AddNoteInput,
     CallOutcomeInput,
+    CallPickedByInput,
     CreateLeadInput,
     FindPhoneInput,
     LeadContactOut,
     LeadOut,
+    MeetingOutcomeInput,
     RevealInput,
     UpdateLeadInput,
 )
@@ -158,13 +160,48 @@ def record_outcome(
     user: User | None = Depends(get_current_user),
 ):
     lead = _require(db, lead_id)
-    updated = crud.apply_call_outcome(db, lead, payload.outcome, payload.rep_notes, payload.meeting_at, user)
+    updated = crud.apply_call_outcome(
+        db, lead, payload.outcome, payload.rep_notes, payload.meeting_at, user, payload.callback_at
+    )
     crud_notify.notify_mentions(
         db, user, payload.mentions, payload.mention_team, text=payload.rep_notes, lead_id=lead_id
     )
     return LeadOut.from_model(updated)
 
 
+@router.post("/leads/{lead_id}/call-picked-by", response_model=LeadOut)
+def call_picked_by(
+    lead_id: int,
+    payload: CallPickedByInput,
+    db: Session = Depends(get_db),
+    user: User | None = Depends(get_current_user),
+):
+    """"Call picked by" row -- tag only, see crud.set_call_picked_by(). structure-plan.md Phase 3."""
+    lead = _require(db, lead_id)
+    return LeadOut.from_model(crud.set_call_picked_by(db, lead, payload.value, user))
+
+
+@router.post("/leads/{lead_id}/needs-email", response_model=LeadOut)
+def needs_email(
+    lead_id: int, db: Session = Depends(get_db), user: User | None = Depends(get_current_user)
+):
+    """"Email Send" button -- see crud.mark_needs_email(). structure-plan.md Phase 3/4."""
+    lead = _require(db, lead_id)
+    return LeadOut.from_model(crud.mark_needs_email(db, lead, user))
+
+
+@router.post("/leads/{lead_id}/meeting-outcome", response_model=LeadOut)
+def meeting_outcome(
+    lead_id: int,
+    payload: MeetingOutcomeInput,
+    db: Session = Depends(get_db),
+    user: User | None = Depends(get_current_user),
+):
+    """Meetings detail popup's 4-way picker -- see crud.set_meeting_outcome(). structure-plan.md Phase 5."""
+    lead = _require(db, lead_id)
+    return LeadOut.from_model(crud.set_meeting_outcome(db, lead, payload.stage, user))
+
+
 @router.post("/leads/{lead_id}/notes", response_model=LeadOut)
 def add_note(
     lead_id: int,
@@ -181,6 +218,15 @@ def add_note(
     return LeadOut.from_model(updated)
 
 
+@router.post("/leads/{lead_id}/send-to-desk", response_model=LeadOut)
+def send_to_desk(
+    lead_id: int, db: Session = Depends(get_db), user: User | None = Depends(get_current_user)
+):
+    """"Send to Cold Call Desk" on Contacts -- see crud.send_to_desk(). structure-plan.md Phase 2."""
+    lead = _require(db, lead_id)
+    return LeadOut.from_model(crud.send_to_desk(db, lead, user))
+
+
 @router.post("/leads/{lead_id}/email-sent", status_code=status.HTTP_204_NO_CONTENT)
 def mark_email_sent(
     lead_id: int, db: Session = Depends(get_db), user: User | None = Depends(get_current_user)

app/constants.py

@@ -25,7 +25,8 @@ ACTIVE_STAGES = {
     "proposal_sent",
 }
 
-CALL_READY_STAGES = {"draft_ready", "followup_due"}
+# Retired by structure-plan.md Phase 3: Cold Call Desk membership is now sent_to_desk_at, not stage.
+# Kept only as a comment for anyone grepping history -- CALL_READY_STAGES = {"draft_ready", "followup_due"}
 
 PHONE_STATUSES = [
     "missing",

app/crud/leads.py

@@ -19,7 +19,7 @@ from typing import Any, Iterable, Sequence
 from sqlalchemy import Select, and_, case, func, or_, select
 from sqlalchemy.orm import Session
 
-from app.constants import ACTIVE_STAGES, CALL_READY_STAGES, DEFAULT_CATEGORY, STAGE_IDS
+from app.constants import ACTIVE_STAGES, DEFAULT_CATEGORY, STAGE_IDS
 from app.models import Lead, SalesProblem
 from app.models import _utcnow as _now
 from app.schemas.lead import CreateLeadInput, UpdateLeadInput, to_decimal
@@ -38,6 +38,11 @@ def list_leads(
 ) -> Sequence[Lead]:
     stmt: Select = select(Lead)
 
+    # Dead Line / Not Interested -- recorded, shown nowhere. Unconditional: every list consumer
+    # (Contacts, Pipeline, Cold Call Desk) is covered here, nothing to remember per page. A single lead
+    # fetched by id (get_lead()) is NOT filtered -- only this list.
+    stmt = stmt.where(Lead.hidden_at.is_(None))
+
     if stage and stage != "all":
         stmt = stmt.where(Lead.pipeline_stage == stage)
 
@@ -176,6 +181,12 @@ def create_lead(db: Session, data: CreateLeadInput, user=None) -> Lead:
         screenshot_path="",
         enrichment_source="",
         enriched_at=None,
+        # Reverses structure-plan.md Phase 2/3's "a lead reaches Cold Call Desk only once Contacts
+        # explicitly sends it" (user, 2026-09-22: "hum ab chahty hein woh leads coldcalldesk me bhi jati
+        # rhyn... jo abhi abhi ati jayengi wo upar coldcalldesk me ati rhyngi") -- now every new lead lands
+        # there immediately, same moment it's created. "Send to Cold Call Desk"/"Resend" stays for a lead
+        # that later left the desk (e.g. Wrong Number) and needs to go back.
+        sent_to_desk_at=now,
     )
     db.add(lead)
     db.commit()
@@ -200,7 +211,9 @@ def lead_from_dict(payload: dict) -> Lead:
         contact_linkedin=(payload.get("contact_linkedin") or "").strip(),
         country=(payload.get("country") or "").strip().upper()[:2],
         industry_tag=(payload.get("industry_tag") or DEFAULT_CATEGORY).strip(),
-        deal_value=to_decimal(payload.get("deal_value") or 15000.0),
+        # structure-plan.md Phase 8: default deal value is 10000 everywhere (was 15000 here, 20000 in
+        # lead_engine.py's CSV import, 18000 in the frontend's Add Lead form).
+        deal_value=to_decimal(payload.get("deal_value") or 10000.0),
         pipeline_stage=payload.get("pipeline_stage") or "draft_ready",
         status="new",
         reason=(payload.get("reason") or "").strip(),
@@ -240,6 +253,11 @@ def lead_from_dict(payload: dict) -> Lead:
         phone_country=(payload.get("phone_country") or "").strip(),
         signalhire_uid=(payload.get("signalhire_uid") or "").strip(),
         discovery_citations=payload.get("discovery_citations") or None,
+        # Reverses structure-plan.md Phase 2/3's "a lead reaches Cold Call Desk only once Contacts
+        # explicitly sends it" (user, 2026-09-22) -- every new lead lands there immediately now,
+        # regardless of source (AI discovery, CSV import, Google Maps, Apollo -- all go through this same
+        # function). See create_lead()'s matching comment above.
+        sent_to_desk_at=now,
     )
 
 
@@ -370,8 +388,23 @@ def _author(user) -> str:
     return f"{name} · " if name else ""
 
 
+# Outcomes that leave the Cold Call Desk -- structure-plan.md Phase 3. Dead Line/Not Interested also go
+# further (hidden everywhere, below); Wrong Number/Callback/Meeting Booked/Closed just leave THIS desk,
+# each landing somewhere else (Contacts, Pipeline, Pipeline+Meetings, Projects respectively).
+_LEAVES_DESK = ("dead_number", "not_interested", "wrong_number", "callback_scheduled", "meeting_booked", "closed")
+# Hidden everywhere (Contacts, Pipeline, Cold Call Desk) -- recorded, shown on no screen. See
+# crud.list_leads()'s unconditional hidden_at filter.
+_HIDES_LEAD = ("dead_number", "not_interested")
+
+
 def apply_call_outcome(
-    db: Session, lead: Lead, outcome: str, rep_notes: str = "", meeting_at: datetime | None = None, user=None
+    db: Session,
+    lead: Lead,
+    outcome: str,
+    rep_notes: str = "",
+    meeting_at: datetime | None = None,
+    user=None,
+    callback_at: datetime | None = None,
 ) -> Lead:
     """Port of db.update_lead_call_outcome, including the appended note format."""
     stamp = datetime.now().strftime("%b %d, %H:%M")
@@ -386,6 +419,12 @@ def apply_call_outcome(
     lead.notes = f"{lead.notes}\n{entry}".strip() if lead.notes else entry
     if meeting_at is not None:
         lead.meeting_at = meeting_at
+    if outcome == "callback_scheduled" and callback_at is not None:
+        lead.callback_at = callback_at
+    if outcome in _LEAVES_DESK:
+        lead.sent_to_desk_at = None
+    if outcome in _HIDES_LEAD:
+        lead.hidden_at = _now()
     lead.updated_at = _now()
     if user is not None:
         lead.last_touched_by_user_id = user.id
@@ -436,6 +475,83 @@ def add_note(db: Session, lead: Lead, text: str, user=None) -> Lead:
     return lead
 
 
+def send_to_desk(db: Session, lead: Lead, user=None) -> Lead:
+    """
+    "Send to Cold Call Desk" on Contacts -- structure-plan.md Phase 1/2. Always allowed (no
+    phone/email gate, per the user's decision): the rep decides when a lead is ready to call.
+    Idempotent -- pressing it again on a lead already on the desk just refreshes the timestamp,
+    same as re-sending.
+    """
+    lead.sent_to_desk_at = _now()
+    lead.updated_at = _now()
+    if user is not None:
+        lead.last_touched_by_user_id = user.id
+    db.commit()
+    db.refresh(lead)
+    from app.crud import call_events
+
+    call_events.record_event(db, lead.id, "sent_to_desk", None, getattr(user, "id", None))
+    return lead
+
+
+def set_call_picked_by(db: Session, lead: Lead, value: str, user=None) -> Lead:
+    """
+    "Call picked by" row (Receptionist / Decision Maker / Team Member) -- structure-plan.md Phase 3.
+    Tag only: no stage change, no queue movement, not logged as a call_events row (it is not itself an
+    action -- the rep still picks a real disposition button separately, same call).
+    """
+    lead.call_picked_by = value
+    lead.updated_at = _now()
+    if user is not None:
+        lead.last_touched_by_user_id = user.id
+    db.commit()
+    db.refresh(lead)
+    return lead
+
+
+def mark_needs_email(db: Session, lead: Lead, user=None) -> Lead:
+    """
+    "Email Send" button -- structure-plan.md Phase 3/4. A forward-looking flag ("this lead now needs an
+    email"), NOT a record that one was sent (that is still Mark Email Sent / record_email_sent,
+    unchanged, and does not touch this). Moves the lead into Pipeline and off the Cold Call Desk; the
+    stage id stays "contacted" (PIPELINE_STAGES' display label is what changed, "Outreach Sent" ->
+    "Email Send" -- see outreach-frontend/lib/constants.ts).
+    """
+    lead.pipeline_stage = "contacted"
+    lead.sent_to_desk_at = None
+    lead.updated_at = _now()
+    if user is not None:
+        lead.last_touched_by_user_id = user.id
+    db.commit()
+    db.refresh(lead)
+    from app.crud import call_events
+
+    call_events.record_event(db, lead.id, "stage_change", "contacted", getattr(user, "id", None))
+    return lead
+
+
+def set_meeting_outcome(db: Session, lead: Lead, stage: str, user=None) -> Lead:
+    """
+    The Meetings detail popup's 4-way picker -- structure-plan.md Phase 5. Was a plain PATCH
+    pipeline_stage before; a dedicated function now because "lost" (Not Interested) must ALSO hide
+    the lead everywhere (same rule as Dead Line/Not Interested on Cold Call Desk, crud.apply_call_outcome()),
+    which the generic UpdateLeadInput deliberately cannot do -- hidden_at is not client-settable through
+    that path, so a manual Pipeline/Contacts stage change to Closed Lost does NOT hide a lead, only this does.
+    """
+    lead.pipeline_stage = stage
+    if stage == "lost":
+        lead.hidden_at = _now()
+    lead.updated_at = _now()
+    if user is not None:
+        lead.last_touched_by_user_id = user.id
+    db.commit()
+    db.refresh(lead)
+    from app.crud import call_events
+
+    call_events.record_event(db, lead.id, "stage_change", stage, getattr(user, "id", None))
+    return lead
+
+
 def delete_lead(db: Session, lead: Lead) -> None:
     db.delete(lead)
     db.commit()
@@ -487,12 +603,13 @@ def get_crm_metrics(db: Session) -> CrmMetrics:
         )
     ).scalar_one()
 
+    # Cold Call Desk's own membership rule, structure-plan.md Phase 3 -- a lead is on the desk once a
+    # rep has explicitly sent it there (sent_to_desk_at), full stop; hidden_at is redundant here (every
+    # outcome that hides a lead also clears sent_to_desk_at, see apply_call_outcome()) but kept explicit
+    # so this count can never drift from crud.list_leads()'s own rule if that ever changes independently.
     call_ready = db.execute(
         select(func.count()).where(
-            and_(
-                Lead.pipeline_stage.in_(CALL_READY_STAGES),
-                Lead.phone_status != "dead_disconnected",
-            )
+            and_(Lead.sent_to_desk_at.is_not(None), Lead.hidden_at.is_(None))
         )
     ).scalar_one()
 

app/models.py

@@ -70,6 +70,9 @@ class Lead(Base):
         Index("idx_leads_industry", "industry_tag"),
         Index("idx_leads_company", "company_name"),
         Index("idx_leads_created", "created_at"),
+        Index("idx_leads_sent_to_desk", "sent_to_desk_at"),
+        Index("idx_leads_hidden", "hidden_at"),
+        Index("idx_leads_callback", "callback_at"),
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
@@ -86,7 +89,11 @@ class Lead(Base):
     contact_phone: Mapped[str] = mapped_column(String(500), default="")
     contact_linkedin: Mapped[str] = mapped_column(String(500), default="")
     industry_tag: Mapped[str] = mapped_column(String(190), default="⚡ Tech & Commercial Products")
-    deal_value: Mapped[Decimal] = mapped_column(Numeric(12, 2), default=Decimal("15000.00"))
+    # structure-plan.md Phase 8: default deal value is 10000 everywhere (was 15000/18000/20000 in three
+    # different places -- create_lead(), lead_from_dict() and this column default all disagreed). This
+    # column default is not actually reachable today (both places that build a Lead() always pass
+    # deal_value explicitly), kept in sync anyway so nothing here still says a different number.
+    deal_value: Mapped[Decimal] = mapped_column(Numeric(12, 2), default=Decimal("10000.00"))
     pipeline_stage: Mapped[str] = mapped_column(String(32), nullable=False, default="draft_ready")
     # Vestigial in the Streamlit app: everything writes "new" and reads pipeline_stage.
     status: Mapped[str] = mapped_column(String(32), nullable=False, default="new")
@@ -175,6 +182,23 @@ class Lead(Base):
     # Follow-ups page filter. "" until a lead has ever been called.
     last_call_outcome: Mapped[str] = mapped_column(String(32), default="")
 
+    # --- structure restructure (revision 0013, structure-plan.md) ---
+    # Set the moment a rep presses "Send to Cold Call Desk" on Contacts; cleared when the lead leaves
+    # the desk on its own (Wrong Number goes back to Contacts and must be re-sent) or advances past it
+    # (Pipeline/Projects). Cold Call Desk's own query is "sent_to_desk_at is not null" -- this REPLACES
+    # "every lead not yet dispositioned" as the desk's membership rule.
+    sent_to_desk_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    # Who picked up the call, from the "Call picked by" row -- tag only, never changes pipeline_stage or
+    # queue position. NULL until set; "" is never written (unlike several other free-text columns above).
+    call_picked_by: Mapped[str | None] = mapped_column(String(16), nullable=True)
+    # Set by Dead Line / Not Interested (cold call), and later Meeting's Not Interested -- the lead is
+    # recorded but shown NOWHERE (crud.list_leads() excludes it unconditionally; a single-lead GET by id
+    # still works). A later phase adds an explicit audit view; until then this is genuinely invisible.
+    hidden_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    # Callback Scheduled's date/time (separate from meeting_at -- a callback is not a meeting and must
+    # never appear on the Meetings calendar). Pipeline shows/filters by this.
+    callback_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+
     contacts: Mapped[list["LeadContact"]] = relationship(
         back_populates="lead", cascade="all, delete-orphan", passive_deletes=True
     )

app/schemas/lead.py

@@ -162,6 +162,17 @@ class LeadOut(BaseModel):
     # None = before login existed.
     created_by_user_id: int | None = None
     last_touched_by_user_id: int | None = None
+    # --- structure restructure (schema revision 0013, structure-plan.md) ---
+    # "" = not on the Cold Call Desk (still in Contacts, or sent back there e.g. by Wrong Number) --
+    # same "" -> unset convention as every other timestamp/string field above, not None.
+    sent_to_desk_at: str = ""
+    # "receptionist" | "decision_maker" | "team_member" | "" -- tag only, see models.Lead.
+    call_picked_by: str = ""
+    # "" = not hidden. Present on LeadOut for completeness; crud.list_leads() already excludes a hidden
+    # lead from every LIST response, so this is only ever seen via GET /leads/{id} directly.
+    hidden_at: str = ""
+    # "" = no callback scheduled. Pipeline shows/filters leads by this.
+    callback_at: str = ""
 
     @classmethod
     def from_model(cls, m: Any) -> "LeadOut":
@@ -219,6 +230,10 @@ class LeadOut(BaseModel):
             last_call_outcome=_s(getattr(m, "last_call_outcome", "")),
             created_by_user_id=getattr(m, "created_by_user_id", None),
             last_touched_by_user_id=getattr(m, "last_touched_by_user_id", None),
+            sent_to_desk_at=_dt_utc(getattr(m, "sent_to_desk_at", None)),
+            call_picked_by=_s(getattr(m, "call_picked_by", "")),
+            hidden_at=_dt_utc(getattr(m, "hidden_at", None)),
+            callback_at=_dt_utc(getattr(m, "callback_at", None)),
             call_tz=call_timezone(
                 _s(m.contact_phone),
                 _s(getattr(m, "phone_country", "")) or _s(getattr(m, "country", "")),
@@ -317,7 +332,8 @@ class CreateLeadInput(BaseModel):
     contact_email: str = Field(default="unknown", max_length=320)
     contact_phone: str = Field(default="", max_length=500)
     country: str = Field(default="", max_length=2)
-    deal_value: float = Field(default=18000.0, ge=0, le=100_000_000)
+    # structure-plan.md Phase 8: default deal value is 10000 everywhere (was 18000 here).
+    deal_value: float = Field(default=10000.0, ge=0, le=100_000_000)
     industry_tag: str = Field(default=DEFAULT_CATEGORY, max_length=120)
     pipeline_stage: PipelineStage = "draft_ready"
     reason: str = Field(default="", max_length=5000)
@@ -392,6 +408,29 @@ class CallOutcomeInput(BaseModel):
     # prompt shown when a rep clicks "🎯 Booked!" (see battlecard.tsx). Other
     # outcomes just omit it.
     meeting_at: datetime | None = None
+    # Only meaningful for outcome="callback_scheduled" -- same date/time prompt style as meeting_at
+    # above, but a SEPARATE column (callback_at) so it never shows on the Meetings calendar.
+    callback_at: datetime | None = None
+
+
+class CallPickedByInput(BaseModel):
+    """POST /leads/{id}/call-picked-by -- the "Call picked by" row. Tag only, see crud.set_call_picked_by()."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    value: Literal["receptionist", "decision_maker", "team_member"]
+
+
+class MeetingOutcomeInput(BaseModel):
+    """
+    POST /leads/{id}/meeting-outcome -- the 4-way picker in the Meetings detail popup
+    (Client Closed / Send Proposal / Needs Follow-up / Not Interested). See
+    crud.set_meeting_outcome(). structure-plan.md Phase 5.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    stage: Literal["won", "proposal_sent", "followup_due", "lost"]
 
 
 class AddNoteInput(BaseModel):

app/services/agent_core.py

@@ -106,7 +106,7 @@ Return a valid JSON array of objects:
     "contact_linkedin": "Direct personal LinkedIn profile URL (https://www.linkedin.com/in/...) or company LinkedIn page (https://www.linkedin.com/company/...)",
     "industry_tag": "Must be one of: '⛳ Custom Golf Carts', '🏎️ Custom Automotive & Mobility', '🛋️ Luxury Furniture & Interiors', '🏗️ Real Estate & Megaprojects', '⛵ Superyachts & Marine', '⚡ Tech & Commercial Products'",
     "country": "ISO 3166-1 alpha-2 code of where this company is actually based, e.g. US, CA, AE, GB",
-    "deal_value": 35000,
+    "deal_value": 10000,
     "reason_no_configurator": "Precise reason why Elipse Studio adds massive value"
   }
 ]
@@ -1278,7 +1278,8 @@ Identify {max_leads} real commercial businesses/brands/exhibitors matching this
         # slice (covers an already-correct code the dict doesn't translate).
         raw_country = (c.get("country") or "").strip()
         country = countries.name_to_iso2(raw_country) or raw_country.upper()[:2]
-        deal_val = float(c.get("deal_value") or 25000.0)
+        # structure-plan.md Phase 8: default deal value is 10000 everywhere (was 25000 here).
+        deal_val = float(c.get("deal_value") or 10000.0)
         # No email draft is generated at discovery any more (it cost output
         # tokens for every lead, most of which never reach follow-up). A draft
         # is written only when a lead is in follow-ups -- see the Follow-ups

app/services/lead_engine.py

@@ -155,7 +155,8 @@ def query_apollo_leads(icp_prompt: str, limit: int = 50, api_key: str = None) ->
                 "contact_phone": scrubbed_phone["phone"],
                 "contact_linkedin": linkedin,
                 "industry_tag": clean_cat,
-                "deal_value": 25000.0,
+                # structure-plan.md Phase 8: default deal value is 10000 everywhere (was 25000 here).
+                "deal_value": 10000.0,
                 "phone_status": scrubbed_phone["status"],
                 "source_prompt": f"Apollo ICP: {icp_prompt}",
             })
@@ -289,7 +290,8 @@ def parse_and_enrich_csv(
         website = ""
         industry_val = ""
         country_val = ""
-        deal_val = 20000.0
+        # structure-plan.md Phase 8: default deal value is 10000 everywhere.
+        deal_val = 10000.0
         deal_found = False
         for row in rows:
             if not website and c_website and row.get(c_website, "").strip():
@@ -301,7 +303,7 @@ def parse_and_enrich_csv(
             if not deal_found and c_deal and row.get(c_deal):
                 try:
                     v = float(re.sub(r"[^\d.]", "", str(row[c_deal])))
-                    deal_val = v if v >= 5000 else 15000.0
+                    deal_val = v if v >= 5000 else 10000.0
                     deal_found = True
                 except Exception:
                     pass

scripts/check_duplicate_leads.py

@@ -0,0 +1,70 @@
+"""
+check_duplicate_leads.py -- read-only: lists every company_name that has more than one Lead row.
+
+Investigating a user report (2026-09-22): "Key West Boats" showing twice on the Pipeline tab. Confirmed:
+every duplicate found so far is source="Manual entry", created 2026-09-15/17 -- crud.is_duplicate() (the
+case-insensitive company_name check) wasn't wired into the "Add a Lead" popover's endpoint until it went
+live 2026-09-17 (see app/api/leads.py create_lead()'s own docstring), so a rep could accidentally submit
+the same company twice before that fix landed. It's already wired into every creation path now (manual,
+AI discovery, CSV import, Google Maps) -- these groups are historical leftovers from just before the fix,
+not an ongoing bug.
+
+    uv run python scripts/check_duplicate_leads.py
+
+Read-only -- prints what it finds, changes nothing. Prints enough per row (deal value, category, meeting/
+callback dates) to tell which one is the real record before deciding which to delete.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import select  # noqa: E402
+
+from app.database import SessionLocal  # noqa: E402
+from app.models import Lead  # noqa: E402
+
+
+def main() -> int:
+    db = SessionLocal()
+    try:
+        leads = list(db.scalars(select(Lead).order_by(Lead.company_name, Lead.created_at)).all())
+        groups: dict[str, list[Lead]] = defaultdict(list)
+        for lead in leads:
+            key = (lead.company_name or "").strip().lower()
+            if key:
+                groups[key].append(lead)
+
+        dupes = {k: v for k, v in groups.items() if len(v) > 1}
+        if not dupes:
+            print("No duplicate company names found.")
+            return 0
+
+        print(f"{len(dupes)} company name(s) with more than one lead row:\n")
+        for key, rows in sorted(dupes.items(), key=lambda kv: -len(kv[1])):
+            print(f"'{rows[0].company_name}' -- {len(rows)} rows:")
+            for lead in rows:
+                print(
+                    f"    #{lead.id:<6} stage={lead.pipeline_stage:<15} "
+                    f"deal_value={lead.deal_value}  industry_tag={lead.industry_tag!r}"
+                )
+                print(
+                    f"           meeting_at={lead.meeting_at}  callback_at={lead.callback_at}  "
+                    f"sent_to_desk_at={lead.sent_to_desk_at}  hidden_at={lead.hidden_at}"
+                )
+                print(
+                    f"           created_at={lead.created_at}  source={lead.source_prompt!r}  "
+                    f"notes={'yes' if (lead.notes or '').strip() else 'no'}"
+                )
+            print()
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_auto_desk.py

@@ -0,0 +1,62 @@
+"""
+check_structure_auto_desk.py -- offline: every new lead now lands on Cold Call Desk immediately
+(user, 2026-09-22: "hum ab chahty hein woh leads coldcalldesk me bhi jati rhyn... jo abhi abhi ati
+jayengi wo upar coldcalldesk me ati rhyngi"). Reverses structure-plan.md Phase 2/3's "a lead reaches
+the desk only once Contacts explicitly sends it".
+
+    uv run python scripts/check_structure_auto_desk.py
+
+No database, no network -- throwaway in-memory SQLite. Covers both lead-creation paths: create_lead()
+(manual Add Lead popover) and add_lead_dict()/lead_from_dict() (AI discovery, CSV import, Google Maps,
+Apollo -- all four go through the same function).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import create_engine  # noqa: E402
+from sqlalchemy.orm import sessionmaker  # noqa: E402
+from sqlalchemy.pool import StaticPool  # noqa: E402
+
+import app.models  # noqa: E402,F401
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import Base  # noqa: E402
+from app.schemas.lead import CreateLeadInput  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def main() -> int:
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    db = sessionmaker(bind=engine)()
+
+    print("\ncreate_lead() -- manual Add Lead popover")
+    lead = crud_leads.create_lead(db, CreateLeadInput(company_name="Manual Co"))
+    check("sent_to_desk_at set at creation", lead.sent_to_desk_at is not None)
+    # Cold Call Desk's own membership rule (components/cold-call/cold-call-view.tsx): every non-hidden
+    # lead with sent_to_desk_at set. list_leads() has no separate "call ready" filter of its own.
+    fetched = next(l for l in crud_leads.list_leads(db) if l.id == lead.id)
+    check("on the call-ready queue (list_leads + sent_to_desk_at set)", fetched.sent_to_desk_at is not None)
+
+    print("\nadd_lead_dict() -- AI discovery / CSV import / Google Maps / Apollo (shared path)")
+    for label in ("AI Co", "CSV Co", "Maps Co", "Apollo Co"):
+        lead = crud_leads.add_lead_dict(db, {"company_name": label, "source_prompt": "CSV Batch Import"})
+        check(f"{label}: sent_to_desk_at set at creation", lead.sent_to_desk_at is not None)
+
+    print(f"\n{'FAILED: ' + str(FAILED) if FAILED else 'All checks passed.'}")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_phase1.py

@@ -0,0 +1,82 @@
+"""
+check_structure_phase1.py -- offline: do the new Phase 1 columns (structure-plan.md) line up?
+
+    uv run python scripts/check_structure_phase1.py
+
+No database, no network. Checks: the model has sent_to_desk_at/call_picked_by, the migration
+0013 adds exactly those two columns and reverses cleanly, and LeadOut.from_model() round-trips
+both through a throwaway in-memory SQLite lead. This only proves the plumbing is consistent --
+it does NOT touch Neon, so `uv run alembic upgrade head` is still required separately.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import create_engine, inspect  # noqa: E402
+from sqlalchemy.orm import sessionmaker  # noqa: E402
+from sqlalchemy.pool import StaticPool  # noqa: E402
+
+import app.models  # noqa: E402,F401
+from app.database import Base  # noqa: E402
+from app.models import Lead  # noqa: E402
+from app.schemas.lead import LeadOut  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def main() -> int:
+    print("\nmodel + migration")
+    cols = {c.name for c in Lead.__table__.columns}
+    check("Lead has sent_to_desk_at", "sent_to_desk_at" in cols)
+    check("Lead has call_picked_by", "call_picked_by" in cols)
+
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    db_cols = {c["name"] for c in inspect(engine).get_columns("leads")}
+    check("sent_to_desk_at actually lands in the table DDL", "sent_to_desk_at" in db_cols)
+    check("call_picked_by actually lands in the table DDL", "call_picked_by" in db_cols)
+
+    print("\nLeadOut round-trip")
+    db = sessionmaker(bind=engine)()
+    lead = Lead(company_name="Acme")
+    db.add(lead)
+    db.commit()
+    db.refresh(lead)
+    out = LeadOut.from_model(lead)
+    check("a fresh lead reads sent_to_desk_at as '' (not on the desk)", out.sent_to_desk_at == "")
+    check("a fresh lead reads call_picked_by as ''", out.call_picked_by == "")
+
+    from datetime import datetime
+
+    lead.sent_to_desk_at = datetime(2026, 9, 22, 10, 0)
+    lead.call_picked_by = "receptionist"
+    db.commit()
+    db.refresh(lead)
+    out2 = LeadOut.from_model(lead)
+    check("sent_to_desk_at serializes as a UTC ISO string ('Z' suffix)", out2.sent_to_desk_at.endswith("Z"))
+    check("call_picked_by round-trips", out2.call_picked_by == "receptionist")
+
+    # Wrong Number's "leaves the desk" behaviour: clearing sent_to_desk_at.
+    lead.sent_to_desk_at = None
+    db.commit()
+    db.refresh(lead)
+    check("clearing sent_to_desk_at (Wrong Number -> back to Contacts) reads back as ''",
+          LeadOut.from_model(lead).sent_to_desk_at == "")
+
+    print()
+    print("All checks passed." if not FAILED else f"{FAILED} check(s) FAILED")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_phase2.py

@@ -0,0 +1,73 @@
+"""
+check_structure_phase2.py -- offline: "Send to Cold Call Desk" (structure-plan.md Phase 2).
+
+    uv run python scripts/check_structure_phase2.py
+
+No database, no network -- throwaway in-memory SQLite. Covers: sending a fresh lead marks it (and is
+attributed to the signed-in user), re-sending an already-sent lead just refreshes the timestamp, it is
+logged as an activity event, and a lead nobody has sent yet reads as "" (matches structure-plan.md's
+"Cold Call Desk query becomes sent_to_desk_at is not null").
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import select  # noqa: E402
+from sqlalchemy.orm import sessionmaker  # noqa: E402
+from sqlalchemy.pool import StaticPool  # noqa: E402
+from sqlalchemy import create_engine  # noqa: E402
+
+import app.models  # noqa: E402,F401
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import Base  # noqa: E402
+from app.models import CallEvent, User  # noqa: E402
+from app.schemas.lead import LeadOut  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def main() -> int:
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    db = sessionmaker(bind=engine)()
+
+    ali = User(email="ali@elipsestudio.com", name="Ali Khan", is_active=True)
+    db.add(ali)
+    db.commit()
+
+    lead = crud_leads.add_lead_dict(db, {"company_name": "Acme"})
+    check("a fresh lead is not on the desk", LeadOut.from_model(lead).sent_to_desk_at == "")
+
+    sent = crud_leads.send_to_desk(db, lead, ali)
+    out = LeadOut.from_model(sent)
+    check("sending it sets sent_to_desk_at", out.sent_to_desk_at != "")
+    check("sending it credits the signed-in user as last-touched", sent.last_touched_by_user_id == ali.id)
+
+    events = db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all()
+    check("it is logged as one activity event", len(events) == 1 and events[0].event_type == "sent_to_desk")
+    check("the event is attributed to the user", events[0].user_id == ali.id)
+
+    first_stamp = sent.sent_to_desk_at
+    resent = crud_leads.send_to_desk(db, lead, None)  # re-send with nobody signed in
+    check("re-sending refreshes the timestamp", resent.sent_to_desk_at is not None
+          and resent.sent_to_desk_at >= first_stamp)
+    check("re-sending with nobody signed in still works (no crash)", True)
+    check("re-sending logs a second event", len(db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all()) == 2)
+
+    print()
+    print("All checks passed." if not FAILED else f"{FAILED} check(s) FAILED")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_phase3.py

@@ -0,0 +1,124 @@
+"""
+check_structure_phase3.py -- offline: Cold Call Desk card redesign (structure-plan.md Phase 3).
+
+    uv run python scripts/check_structure_phase3.py
+
+No database, no network -- throwaway in-memory SQLite. Covers: which outcomes leave the desk
+(sent_to_desk_at cleared) vs stay on it, Dead Line/Not Interested hiding a lead from every list
+query while a direct-by-id fetch still finds it, Wrong Number leaving the desk WITHOUT hiding it,
+Callback Scheduled's separate callback_at column, "Call picked by" (tag only, no call_events row),
+and "Email Send" (crud.mark_needs_email: stage -> contacted, leaves the desk, one activity event).
+"""
+
+from __future__ import annotations
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import create_engine, select  # noqa: E402
+from sqlalchemy.orm import sessionmaker  # noqa: E402
+from sqlalchemy.pool import StaticPool  # noqa: E402
+
+import app.models  # noqa: E402,F401
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import Base  # noqa: E402
+from app.models import CallEvent  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def fresh_lead(db, name: str):
+    lead = crud_leads.add_lead_dict(db, {"company_name": name})
+    crud_leads.send_to_desk(db, lead)
+    return lead
+
+
+def visible_ids(db) -> set[int]:
+    return {l.id for l in crud_leads.list_leads(db)}
+
+
+def main() -> int:
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    db = sessionmaker(bind=engine)()
+
+    print("\nDead Line / Not Interested -- hidden everywhere")
+    for outcome, label in [("dead_number", "Dead Line"), ("not_interested", "Not Interested")]:
+        lead = fresh_lead(db, f"{label} Co")
+        crud_leads.apply_call_outcome(db, lead, outcome)
+        check(f"{label}: hidden_at is set", lead.hidden_at is not None)
+        check(f"{label}: leaves the desk too", lead.sent_to_desk_at is None)
+        check(f"{label}: excluded from list_leads()", lead.id not in visible_ids(db))
+        check(f"{label}: still fetchable directly by id", crud_leads.get_lead(db, lead.id) is not None)
+
+    print("\nWrong Number -- leaves the desk, stays visible (not hidden)")
+    lead = fresh_lead(db, "Wrong Number Co")
+    crud_leads.apply_call_outcome(db, lead, "wrong_number")
+    check("hidden_at is NOT set", lead.hidden_at is None)
+    check("leaves the desk", lead.sent_to_desk_at is None)
+    check("still shows in list_leads() (back in Contacts)", lead.id in visible_ids(db))
+    check("last_call_outcome records it for the Contacts badge", lead.last_call_outcome == "wrong_number")
+
+    print("\nCallback Scheduled -- separate column, leaves the desk, stays visible")
+    lead = fresh_lead(db, "Callback Co")
+    when = datetime(2026, 9, 25, 14, 30)
+    crud_leads.apply_call_outcome(db, lead, "callback_scheduled", callback_at=when)
+    check("callback_at is set to the given time", lead.callback_at == when)
+    check("meeting_at is untouched (never confused with a meeting)", lead.meeting_at is None)
+    check("leaves the desk", lead.sent_to_desk_at is None)
+    check("still shows in list_leads() (visible in Pipeline)", lead.id in visible_ids(db))
+
+    print("\nMeeting Booked / Closed -- leave the desk (unchanged destination, new desk-leaving rule)")
+    for outcome in ("meeting_booked", "closed"):
+        lead = fresh_lead(db, f"{outcome} Co")
+        crud_leads.apply_call_outcome(db, lead, outcome)
+        check(f"{outcome}: leaves the desk", lead.sent_to_desk_at is None)
+        check(f"{outcome}: not hidden", lead.hidden_at is None)
+
+    print("\nVoicemail / Hang Up / No Answer -- STAY on the desk")
+    for outcome in ("voicemail", "hang_up", "no_answer"):
+        lead = fresh_lead(db, f"{outcome} Co")
+        before = lead.sent_to_desk_at
+        crud_leads.apply_call_outcome(db, lead, outcome)
+        check(f"{outcome}: sent_to_desk_at unchanged", lead.sent_to_desk_at == before)
+
+    print("\nCall picked by -- tag only")
+    lead = fresh_lead(db, "Tag Co")  # fresh_lead() itself logs one "sent_to_desk" event -- that is the baseline
+    before_stage, before_desk = lead.pipeline_stage, lead.sent_to_desk_at
+    before_events = len(db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all())
+    crud_leads.set_call_picked_by(db, lead, "receptionist")
+    check("call_picked_by is set", lead.call_picked_by == "receptionist")
+    check("pipeline_stage is untouched", lead.pipeline_stage == before_stage)
+    check("sent_to_desk_at is untouched (still on the desk)", lead.sent_to_desk_at == before_desk)
+    after_events = len(db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all())
+    check("no NEW call_events row is created", after_events == before_events, f"{before_events} -> {after_events}")
+    crud_leads.set_call_picked_by(db, lead, "team_member")
+    check("re-tagging overwrites the previous mark", lead.call_picked_by == "team_member")
+
+    print("\nEmail Send (mark_needs_email) -- flags for email, moves to Pipeline, leaves the desk")
+    lead = fresh_lead(db, "Email Send Co")  # fresh_lead() logs one "sent_to_desk" event -- the baseline
+    before_events = len(db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all())
+    crud_leads.mark_needs_email(db, lead)
+    check("stage becomes contacted (\"Email Send\")", lead.pipeline_stage == "contacted")
+    check("leaves the desk", lead.sent_to_desk_at is None)
+    events = db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all()
+    check("logs exactly ONE NEW activity event", len(events) == before_events + 1)
+    check("...and it is a stage_change", events[-1].event_type == "stage_change" and events[-1].outcome == "contacted")
+    check("still shows in list_leads() (visible in Pipeline)", lead.id in visible_ids(db))
+
+    print()
+    print("All checks passed." if not FAILED else f"{FAILED} check(s) FAILED")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_phase5.py

@@ -0,0 +1,73 @@
+"""
+check_structure_phase5.py -- offline: Meetings 4-way outcome picker (structure-plan.md Phase 5).
+
+    uv run python scripts/check_structure_phase5.py
+
+No database, no network -- throwaway in-memory SQLite. Covers: crud.set_meeting_outcome() for all four
+outcomes -- Client Closed / Send Proposal / Needs Follow-up just change stage (unchanged behaviour);
+Not Interested ALSO hides the lead (the whole point of this phase); a manual stage-dropdown PATCH to
+"lost" (Contacts/Pipeline's own Closed Lost option) does NOT hide a lead -- only this dedicated path does.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import create_engine, select  # noqa: E402
+from sqlalchemy.orm import sessionmaker  # noqa: E402
+from sqlalchemy.pool import StaticPool  # noqa: E402
+
+import app.models  # noqa: E402,F401
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import Base  # noqa: E402
+from app.models import CallEvent  # noqa: E402
+from app.schemas.lead import UpdateLeadInput  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def main() -> int:
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    db = sessionmaker(bind=engine)()
+
+    print("\nClient Closed / Send Proposal / Needs Follow-up -- stage only, never hidden")
+    for stage in ("won", "proposal_sent", "followup_due"):
+        lead = crud_leads.add_lead_dict(db, {"company_name": f"{stage} Co"})
+        crud_leads.set_meeting_outcome(db, lead, stage)
+        check(f"{stage}: pipeline_stage is set", lead.pipeline_stage == stage)
+        check(f"{stage}: not hidden", lead.hidden_at is None)
+        events = db.scalars(select(CallEvent).where(CallEvent.lead_id == lead.id)).all()
+        check(f"{stage}: logs one stage_change event", len(events) == 1 and events[0].outcome == stage)
+
+    print("\nNot Interested -- hides the lead everywhere")
+    lead = crud_leads.add_lead_dict(db, {"company_name": "Not Interested Co"})
+    crud_leads.set_meeting_outcome(db, lead, "lost")
+    check("pipeline_stage is lost", lead.pipeline_stage == "lost")
+    check("hidden_at is set", lead.hidden_at is not None)
+    check("excluded from list_leads()", lead.id not in {l.id for l in crud_leads.list_leads(db)})
+    check("still fetchable directly by id", crud_leads.get_lead(db, lead.id) is not None)
+
+    print("\nManual stage change to Closed Lost (Contacts/Pipeline dropdown) does NOT hide a lead")
+    lead = crud_leads.add_lead_dict(db, {"company_name": "Manual Lost Co"})
+    crud_leads.update_lead(db, lead, UpdateLeadInput(pipeline_stage="lost"))
+    check("pipeline_stage is lost", lead.pipeline_stage == "lost")
+    check("hidden_at is NOT set -- only the meeting-outcome path hides a lead", lead.hidden_at is None)
+    check("still shows in list_leads()", lead.id in {l.id for l in crud_leads.list_leads(db)})
+
+    print()
+    print("All checks passed." if not FAILED else f"{FAILED} check(s) FAILED")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_structure_phase8.py

@@ -0,0 +1,75 @@
+"""
+check_structure_phase8.py -- offline: default deal value is 10000 everywhere (structure-plan.md Phase 8).
+
+    uv run python scripts/check_structure_phase8.py
+
+No database, no network. Checks all five places a default deal value used to disagree (15000/18000/20000):
+the Lead model's own column default, lead_from_dict()'s fallback (AI/Maps leads), lead_engine.py's CSV
+importer (its own default AND its "value too small, don't trust it" fallback), and CreateLeadInput's
+schema default (manual Add Lead, POST /leads). All five now read 10000.
+"""
+
+from __future__ import annotations
+
+import sys
+from decimal import Decimal
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import app.models  # noqa: E402,F401
+from app.crud.leads import lead_from_dict  # noqa: E402
+from app.models import Lead  # noqa: E402
+from app.schemas.lead import CreateLeadInput  # noqa: E402
+from app.services.lead_engine import parse_and_enrich_csv  # noqa: E402
+
+FAILED = 0
+
+
+def check(label: str, ok: bool, detail: str = "") -> None:
+    global FAILED
+    FAILED += 0 if ok else 1
+    print(f"  [{'ok  ' if ok else 'FAIL'}] {label}" + ("" if ok else f"   {detail}"))
+
+
+def main() -> int:
+    print("\nLead model column default")
+    col = Lead.__table__.columns["deal_value"]
+    check("Lead.deal_value defaults to 10000.00", col.default.arg == Decimal("10000.00"), str(col.default.arg))
+
+    print("\nlead_from_dict() -- AI / Maps leads with no deal_value given")
+    lead = lead_from_dict({"company_name": "No Deal Value Co"})
+    check("defaults to 10000", lead.deal_value == Decimal("10000.00"), str(lead.deal_value))
+
+    print("\nCreateLeadInput -- POST /leads (Add a Lead) schema default")
+    created = CreateLeadInput(company_name="Schema Default Co")
+    check("defaults to 10000.0", created.deal_value == 10000.0, str(created.deal_value))
+
+    print("\nCSV import -- lead_engine.parse_and_enrich_csv()")
+    no_deal_csv = "Company,Website\nNo Deal Co,example.com\n"
+    result = parse_and_enrich_csv(no_deal_csv)
+    check("row with no deal-value column at all defaults to 10000", result["leads"][0]["deal_value"] == 10000.0,
+          str(result["leads"][0]["deal_value"]))
+
+    junk_csv = "Company,Deal Value\nJunk Deal Co,not-a-real-number\n"
+    result2 = parse_and_enrich_csv(junk_csv)
+    check("an unparseable Deal Value cell also defaults to 10000", result2["leads"][0]["deal_value"] == 10000.0,
+          str(result2["leads"][0]["deal_value"]))
+
+    too_small_csv = "Company,Deal Value\nTiny Deal Co,500\n"
+    result3 = parse_and_enrich_csv(too_small_csv)
+    check("a parsed value under 5000 (untrustworthy) falls back to 10000, not the raw 500",
+          result3["leads"][0]["deal_value"] == 10000.0, str(result3["leads"][0]["deal_value"]))
+
+    real_csv = "Company,Deal Value\nReal Deal Co,75000\n"
+    result4 = parse_and_enrich_csv(real_csv)
+    check("a real value >= 5000 is kept as-is, not overridden", result4["leads"][0]["deal_value"] == 75000.0,
+          str(result4["leads"][0]["deal_value"]))
+
+    print()
+    print("All checks passed." if not FAILED else f"{FAILED} check(s) FAILED")
+    return 1 if FAILED else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/delete_lead_by_id.py

@@ -0,0 +1,57 @@
+"""
+delete_lead_by_id.py -- permanently deletes one lead, by id, after printing it for confirmation.
+
+Generic cleanup tool for the duplicate-lead groups check_duplicate_leads.py finds (user, 2026-09-22 --
+"Key West Boats" and several others turned out to be manually double-added before the create_lead()
+duplicate check went live 2026-09-17). Deletes exactly one id per run, on purpose -- no bulk mode -- so a
+wrong id typed in only ever costs one lead, not a whole company's history.
+
+    uv run python scripts/delete_lead_by_id.py <id>             # dry run -- prints the lead, deletes nothing
+    uv run python scripts/delete_lead_by_id.py <id> --apply     # actually deletes it, permanently
+
+Irreversible once run with --apply -- lead_contacts rows for it cascade-delete too.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import SessionLocal  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("lead_id", type=int, help="the lead's id, e.g. from check_duplicate_leads.py")
+    parser.add_argument("--apply", action="store_true", help="actually delete (default: dry run only)")
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        lead = crud_leads.get_lead(db, args.lead_id)
+        if not lead:
+            print(f"No lead with id #{args.lead_id}.")
+            return 1
+
+        print(f"#{lead.id}  {lead.company_name}")
+        print(f"  stage={lead.pipeline_stage}  deal_value={lead.deal_value}  industry_tag={lead.industry_tag!r}")
+        print(f"  meeting_at={lead.meeting_at}  callback_at={lead.callback_at}")
+        print(f"  created_at={lead.created_at}  source={lead.source_prompt!r}")
+
+        if not args.apply:
+            print(f"\nDry run only -- re-run with --apply to permanently delete #{lead.id}.")
+            return 0
+
+        crud_leads.delete_lead(db, lead)
+        print(f"\nDeleted #{lead.id} ({lead.company_name}) permanently.")
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/delete_user.py

@@ -0,0 +1,85 @@
+"""
+delete_user.py -- remove (or just switch off) one account. Admin tool, dry run by default.
+
+    uv run python scripts/delete_user.py --email demo@elipsestudio.com              # shows what it would do
+    uv run python scripts/delete_user.py --email demo@elipsestudio.com --apply      # deletes the account
+    uv run python scripts/delete_user.py --email demo@elipsestudio.com --deactivate --apply   # keeps it, blocks sign-in
+
+What a delete does to the person's history (the database rows point at the user with ON DELETE SET NULL):
+their calls, notes, stage changes, added leads and bulk jobs stay, but read as "Unassigned" from then on, and they
+disappear from the Today and Weekly Report rows. Notifications sent TO them are removed. Nothing else is touched.
+If you would rather keep their name on old activity, use --deactivate: they cannot sign in and drop out of the @mention
+list, and their history keeps their name. A deleted email can sign up again later while it is still on the approved list.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import func, select  # noqa: E402
+
+from app.crud import users as crud_users  # noqa: E402
+from app.database import SessionLocal  # noqa: E402
+from app.models import CallEvent, Job, Lead, Notification  # noqa: E402
+
+
+def count(db, stmt) -> int:
+    return int(db.execute(stmt).scalar_one())
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--email", required=True)
+    ap.add_argument("--apply", action="store_true", help="actually do it (without this it only reports)")
+    ap.add_argument("--deactivate", action="store_true", help="switch the account off instead of deleting it")
+    args = ap.parse_args()
+    email = args.email.strip().lower()
+
+    db = SessionLocal()
+    try:
+        user = crud_users.get_user_by_email(db, email)
+        if user is None:
+            print(f"No account for {email}. Run scripts/check_users.py to see the exact emails.")
+            return 1
+
+        uid = user.id
+        n_events = count(db, select(func.count()).select_from(CallEvent).where(CallEvent.user_id == uid))
+        n_created = count(db, select(func.count()).select_from(Lead).where(Lead.created_by_user_id == uid))
+        n_touched = count(db, select(func.count()).select_from(Lead).where(Lead.last_touched_by_user_id == uid))
+        n_jobs = count(db, select(func.count()).select_from(Job).where(Job.user_id == uid))
+        n_in = count(db, select(func.count()).select_from(Notification).where(Notification.user_id == uid))
+        n_out = count(db, select(func.count()).select_from(Notification).where(Notification.actor_user_id == uid))
+
+        print(f"Account: {user.email}  (id {uid}, name {user.name!r}, {'active' if user.is_active else 'already inactive'})")
+        print(f"  actions recorded (calls, notes, stage changes, emails): {n_events}")
+        print(f"  leads added: {n_created}   leads last touched: {n_touched}   bulk jobs started: {n_jobs}")
+        print(f"  notifications received: {n_in}   notifications they sent: {n_out}")
+        print()
+        if args.deactivate:
+            print("Would: switch the account off (cannot sign in, leaves the @mention list). History keeps the name.")
+        else:
+            print("Would: DELETE the account. The actions/leads/jobs above stay but become 'Unassigned';")
+            print("       notifications received are deleted; notifications they sent lose the sender name.")
+        if not args.apply:
+            print("\nDry run: nothing changed. Add --apply to do it.")
+            return 0
+
+        if args.deactivate:
+            user.is_active = False
+            db.commit()
+            print(f"\nDone. {email} is deactivated.")
+        else:
+            db.delete(user)
+            db.commit()
+            print(f"\nDone. {email} is deleted.")
+    finally:
+        db.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/revert_last_csv_import.py

@@ -0,0 +1,87 @@
+"""
+revert_last_csv_import.py — permanently deletes the most recent CSV-import batch (user request,
+2026-09-22: "kal raat ko jo humny csv sy leads add ki thin woh revert krdyn sari, ~105 leads, permanent
+delete"). Same dry-run-by-default / --apply convention as cleanup_partial_september_import.py.
+
+Only ever touches leads with source_prompt == "CSV Batch Import" (never any other source) -- and only the
+most recent CONTIGUOUS cluster of them (gaps between consecutive created_at values under 4 hours are
+treated as the same import run; a gap of 4+ hours starts a new, untouched, older batch). This finds "last
+night's import" without hardcoding a date/timezone, so it can't accidentally reach back into an older CSV
+import (e.g. the September tab) that happens to share the same source_prompt.
+
+    uv run python scripts/revert_last_csv_import.py            # dry run -- prints what it would delete
+    uv run python scripts/revert_last_csv_import.py --apply    # actually deletes it, permanently
+
+Irreversible once run with --apply -- lead_contacts rows for each lead cascade-delete with it. Read the
+dry-run output carefully (company count, name list, created_at range, who added them) before applying.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from datetime import timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import select  # noqa: E402
+
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import SessionLocal  # noqa: E402
+from app.models import Lead, User  # noqa: E402
+
+# Leads created closer together than this are treated as one import run.
+BATCH_GAP = timedelta(hours=4)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--apply", action="store_true", help="actually delete (default: dry run only)")
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        candidates = list(
+            db.scalars(
+                select(Lead).where(Lead.source_prompt == "CSV Batch Import").order_by(Lead.created_at.desc())
+            ).all()
+        )
+        if not candidates:
+            print("No CSV-imported leads found at all -- nothing to do.")
+            return 0
+
+        batch = [candidates[0]]
+        for lead in candidates[1:]:
+            if batch[-1].created_at - lead.created_at <= BATCH_GAP:
+                batch.append(lead)
+            else:
+                break
+
+        users = {u.id: u.name or u.email for u in db.scalars(select(User)).all()}
+
+        print(f"Most recent CSV-import batch: {len(batch)} lead(s)")
+        print(f"  created_at range: {batch[-1].created_at} .. {batch[0].created_at} (UTC)")
+        older = len(candidates) - len(batch)
+        if older:
+            print(f"  ({older} older CSV-imported lead(s) exist from before this batch -- NOT touched)")
+        print()
+        for lead in batch:
+            who = users.get(lead.created_by_user_id, "—") if lead.created_by_user_id else "—"
+            print(f"  #{lead.id:<6} {lead.company_name:<40} created_at={lead.created_at}  by={who}")
+
+        if not args.apply:
+            print(f"\nDry run only -- {len(batch)} lead(s) would be permanently deleted.")
+            print("Check the count and date range above match what you expect, then re-run with --apply.")
+            return 0
+
+        for lead in batch:
+            crud_leads.delete_lead(db, lead)
+        print(f"\nDeleted {len(batch)} lead(s) permanently (their lead_contacts rows cascade-deleted with them).")
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/review_duplicate_leads.py

@@ -0,0 +1,154 @@
+"""
+review_duplicate_leads.py -- scores each row in a duplicate-company group and recommends which to keep.
+
+check_duplicate_leads.py found 22 companies with more than one Lead row, all source="Manual entry",
+created 2026-09-15/17 (before create_lead()'s duplicate check went live 2026-09-17 -- see that script's
+docstring). Reviewing all 22 pairs by hand in chat doesn't scale, so this scores each row:
+
+    +100  has notes (a rep actually wrote something -- the strongest "this one is real" signal)
+    +10 * stage rank (lost=1, draft_ready=0, followup_due=2, contacted=3, meeting_booked=4,
+                       proposal_sent=5, won=6 -- "lost" ranks above draft_ready because it required an
+                       actual outcome, not just sitting untouched)
+    +5    meeting_at or callback_at is set
+
+A group only gets an automatic recommendation when exactly one row has the highest score (a clear win),
+OR every tied top-scoring row has IDENTICAL deal_value and industry_tag (a true no-information-loss
+duplicate, e.g. three byte-for-byte-identical rows). Every other tie -- most commonly "both rows have
+notes" or "both are untouched but disagree on category/value" -- is never auto-resolved. It prints as
+NEEDS MANUAL REVIEW with full detail on every row, and nothing about it is touched.
+
+    uv run python scripts/review_duplicate_leads.py            # dry run -- prints recommendations only
+    uv run python scripts/review_duplicate_leads.py --apply    # deletes the CLEAR-WIN groups only
+
+Groups flagged NEEDS MANUAL REVIEW are never touched by --apply -- use delete_lead_by_id.py for those,
+one id at a time, after deciding by hand.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from sqlalchemy import select  # noqa: E402
+
+from app.crud import leads as crud_leads  # noqa: E402
+from app.database import SessionLocal  # noqa: E402
+from app.models import Lead  # noqa: E402
+
+STAGE_RANK = {
+    "draft_ready": 0,
+    "lost": 1,
+    "followup_due": 2,
+    "contacted": 3,
+    "meeting_booked": 4,
+    "proposal_sent": 5,
+    "won": 6,
+}
+
+
+def score(lead: Lead) -> int:
+    s = 0
+    if (lead.notes or "").strip():
+        s += 100
+    s += STAGE_RANK.get(lead.pipeline_stage, 0) * 10
+    if lead.meeting_at or lead.callback_at:
+        s += 5
+    return s
+
+
+def describe(lead: Lead) -> str:
+    return (
+        f"#{lead.id:<6} stage={lead.pipeline_stage:<15} deal_value={lead.deal_value}  "
+        f"industry_tag={lead.industry_tag!r}  notes={'yes' if (lead.notes or '').strip() else 'no'}  "
+        f"created_at={lead.created_at}"
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--apply", action="store_true", help="delete the clear-win groups (default: dry run)")
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        leads = list(db.scalars(select(Lead).order_by(Lead.company_name, Lead.created_at)).all())
+        groups: dict[str, list[Lead]] = defaultdict(list)
+        for lead in leads:
+            key = (lead.company_name or "").strip().lower()
+            if key:
+                groups[key].append(lead)
+        dupes = {k: v for k, v in groups.items() if len(v) > 1}
+
+        if not dupes:
+            print("No duplicate company names found.")
+            return 0
+
+        to_delete: list[Lead] = []
+        needs_review: list[list[Lead]] = []
+
+        for rows in dupes.values():
+            scored = [(score(r), r) for r in rows]
+            top = max(s for s, _ in scored)
+            leaders = [r for s, r in scored if s == top]
+
+            if len(leaders) == 1:
+                keep = leaders[0]
+                losers = [r for r in rows if r.id != keep.id]
+                print(f"'{keep.company_name}' -- CLEAR WIN, keep #{keep.id}, delete {[r.id for r in losers]}")
+                print(f"  KEEP   {describe(keep)}")
+                for l in losers:
+                    print(f"  DELETE {describe(l)}")
+                print()
+                to_delete.extend(losers)
+                continue
+
+            identical = all(
+                (r.deal_value, r.industry_tag) == (leaders[0].deal_value, leaders[0].industry_tag)
+                for r in leaders
+            )
+            if identical:
+                keep = min(leaders, key=lambda r: r.created_at)
+                losers = [r for r in rows if r.id != keep.id]
+                print(
+                    f"'{keep.company_name}' -- IDENTICAL duplicate(s), keep oldest #{keep.id}, "
+                    f"delete {[r.id for r in losers]}"
+                )
+                print(f"  KEEP   {describe(keep)}")
+                for l in losers:
+                    print(f"  DELETE {describe(l)}")
+                print()
+                to_delete.extend(losers)
+                continue
+
+            needs_review.append(rows)
+
+        if needs_review:
+            print(f"\n{'=' * 60}\n{len(needs_review)} group(s) NEED MANUAL REVIEW -- not touched:\n")
+            for rows in needs_review:
+                print(f"'{rows[0].company_name}':")
+                for r in rows:
+                    print(f"  {describe(r)}")
+                print()
+
+        print(f"{'=' * 60}")
+        print(f"{len(to_delete)} lead(s) recommended for deletion across the clear-win groups above.")
+        print(f"{len(needs_review)} group(s) need a manual decision (use delete_lead_by_id.py after choosing).")
+
+        if not args.apply:
+            print("\nDry run only -- re-run with --apply to delete the clear-win groups' losers.")
+            return 0
+
+        for lead in to_delete:
+            crud_leads.delete_lead(db, lead)
+        print(f"\nDeleted {len(to_delete)} lead(s).")
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/seed_leads.py

@@ -9,6 +9,10 @@ want the sample rows.
     uv run python scripts/seed_leads.py
 
 Skips any company already present, so it is safe to re-run.
+
+structure-plan.md Phase 8: every deal_value here was made 10000, at the user's explicit request ("sab
+jaga kr dy" -- do it everywhere) -- they were previously varied (17500-21000) on purpose so the sample
+data didn't look uniform; that reasoning is now overridden by the same-default-everywhere rule.
 """
 
 from __future__ import annotations
@@ -34,7 +38,7 @@ VERIFIED_SAMPLE_LEADS = [
         "contact_phone": "+1 (843) 881-8883",
         "contact_linkedin": "https://www.linkedin.com/in/hal-garrett-b02b6623",
         "industry_tag": "⛳ Custom Golf Carts",
-        "deal_value": 18500.0,
+        "deal_value": 10000.0,
         "reason": "Buyers customize body paint, upholstery stitching, lift kits, and rim styles using static gallery photos, leading to drop-offs before requesting a quote.",
         "subject": "3D cart builder for Garrett's Custom Golf Carts",
         "body": "Hi Hal,\n\nI was looking at your custom golf cart builds at Garrett's, specifically your custom diamond-stitched seating and lift kit options. Your builds look great.\n\nRight now, buyers browse static photos to imagine custom paint and upholstery combinations. We build real-time 3D web configurators that let customers customize paint, seats, and rims in 3D directly on your site before buying.\n\nWould you be open to a quick demo tailored for your custom builds? You can pick a time here: https://calendly.com/bilal-lania-elipsestudio/15-mins-meeting\n\nBest,\nBilal\nElipse Studio"
@@ -48,7 +52,7 @@ VERIFIED_SAMPLE_LEADS = [
         "contact_phone": "+1 (803) 865-8016",
         "contact_linkedin": "https://www.linkedin.com/company/tidewater-carts",
         "industry_tag": "⛳ Custom Golf Carts",
-        "deal_value": 21000.0,
+        "deal_value": 10000.0,
         "reason": "Offers extensive custom colors, tops, and high-performance lift packages, but currently relies on static inventory listings.",
         "subject": "Interactive 3D configurator for Tidewater Carts",
         "body": "Hi Team,\n\nI came across Tidewater Carts while researching top custom golf cart builders in the US. Your custom lifted builds and sound bar packages stand out.\n\nSince buyers often want to compare custom body colors and seat patterns before ordering, an interactive 3D configurator on your website would allow them to visualize their build live and submit quote-ready specifications.\n\nWould you be open to seeing a 5-minute visual demo? Feel free to pick a time here: https://calendly.com/bilal-lania-elipsestudio/15-mins-meeting\n\nBest,\nBilal\nElipse Studio"
@@ -62,7 +66,7 @@ VERIFIED_SAMPLE_LEADS = [
         "contact_phone": "+1 (800) 508-4813",
         "contact_linkedin": "https://www.linkedin.com/company/performance-golf-carts",
         "industry_tag": "⛳ Custom Golf Carts",
-        "deal_value": 19500.0,
+        "deal_value": 10000.0,
         "reason": "High-volume custom builder with extensive parts & accessories inventory that would see higher conversions with live 3D visual customization.",
         "subject": "3D visualizer for Performance Golf Carts",
         "body": "Hi Team,\n\nI was browsing your custom EZ-GO and Club Car inventory at Performance Golf Carts. Your Double Take body kits and custom wheels look sharp.\n\nRight now, buyers browse 2D images to pick options. We create interactive 3D configurators that let customers swap body colors, seats, and lift kits in real time on your website.\n\nAre you open to exploring a quick 3D demo tailored for your builds? You can grab a time here: https://calendly.com/bilal-lania-elipsestudio/15-mins-meeting\n\nBest,\nBilal\nElipse Studio"
@@ -76,7 +80,7 @@ VERIFIED_SAMPLE_LEADS = [
         "contact_phone": "+1 (949) 328-9899",
         "contact_linkedin": "https://www.linkedin.com/company/apex-golf-carts",
         "industry_tag": "⛳ Custom Golf Carts",
-        "deal_value": 17500.0,
+        "deal_value": 10000.0,
         "reason": "Specializes in luxury street-legal electric carts with premium custom finishes that require high-end 3D visualization.",
         "subject": "3D customization for Apex Golf Carts",
         "body": "Hi Team,\n\nI was checking out your luxury street-legal electric cart models at Apex. The modern styling and premium interior finishes look exceptional.\n\nSince high-end buyers expect interactive digital experiences, a real-time 3D configurator on your site would let clients customize their cart exterior, wheels, and seating in full 3D before inquiring.\n\nWould you be open to a brief preview of how this looks in action? Pick a convenient time here: https://calendly.com/bilal-lania-elipsestudio/15-mins-meeting\n\nBest,\nBilal\nElipse Studio"
@@ -90,7 +94,7 @@ VERIFIED_SAMPLE_LEADS = [
         "contact_phone": "+1 (712) 324-4900",
         "contact_linkedin": "https://www.linkedin.com/company/streetrod-golf-cars",
         "industry_tag": "⛳ Custom Golf Carts",
-        "deal_value": 18000.0,
+        "deal_value": 10000.0,
         "reason": "Handcrafted vintage hot rod replica golf carts with bespoke paint and chrome options, ideal for high-ticket 3D interactive customization.",
         "subject": "Real-time 3D configurator for Streetrod Golf Cars",
         "body": "Hi Team,\n\nI was admiring your handcrafted hot rod golf cars at Streetrod. The vintage fiberglass bodywork and custom chrome details are works of art.\n\nFor bespoke vehicles at this price point, an interactive 3D web configurator allows collectors to test paint colors, flame graphics, and wheel packages in photorealistic 3D directly on your site.\n\nWould you be open to seeing a quick concept tailored for Streetrod? You can choose a time here: https://calendly.com/bilal-lania-elipsestudio/15-mins-meeting\n\nBest,\nBilal\nElipse Studio"

scripts/smoke_test.py

@@ -137,7 +137,7 @@ def main() -> int:
         "company_website": "https://example.com",
         "contact_email": "probe@example.com",
         "industry_tag": EMOJI_CATEGORY,
-        "deal_value": 24000,
+        "deal_value": 10000,  # structure-plan.md Phase 8: matches the app-wide default (was 24000).
     }, timeout=15)
     check("POST /leads -> 201", r.status_code == 201, f"{r.status_code} {r.text[:200]}")
     if not r.ok: