multiple issues resolves

app/constants.py

@@ -42,6 +42,11 @@ CALL_OUTCOMES = [
     "not_interested",
     "callback_scheduled",
     "receptionist",
+    "decision_maker",
+    "no_answer",
+    "hang_up",
+    "wrong_number",
+    "closed",
 ]
 
 # The emoji is part of the stored key, not decoration. Requires utf8mb4.

app/crud/call_events.py

@@ -23,14 +23,23 @@ from app.models import CallEvent, Lead
 
 _ALL_CALL_OUTCOMES = (
     "meeting_booked", "voicemail", "dead_number", "not_interested",
-    "callback_scheduled", "receptionist",
+    "callback_scheduled", "receptionist", "decision_maker",
+    "no_answer", "hang_up", "wrong_number", "closed",
+)
+# Outcomes that mean a live person picked up, decision maker or not. Not
+# no_answer/hang_up (no conversation) or wrong_number (never actually reached
+# the company at all, same reasoning as dead_number). "closed" IS a real,
+# positive conversation (the client is closing the deal), so it counts.
+_CONNECTED_OUTCOMES = (
+    "not_interested", "callback_scheduled", "meeting_booked", "receptionist",
+    "decision_maker", "closed",
+)
+# Outcomes that route a lead back into the follow-up queue -- matches
+# _OUTCOME_STAGE in crud/leads.py exactly.
+_FOLLOWUP_OUTCOMES = (
+    "voicemail", "callback_scheduled", "receptionist", "decision_maker",
+    "no_answer", "hang_up",
 )
-# Outcomes that mean a live person picked up, decision maker or not.
-_CONNECTED_OUTCOMES = ("not_interested", "callback_scheduled", "meeting_booked", "receptionist")
-# Outcomes that mean an actual decision-maker conversation happened.
-_DECISION_MAKER_OUTCOMES = ("not_interested", "callback_scheduled", "meeting_booked")
-# Outcomes that route a lead back into the follow-up queue.
-_FOLLOWUP_OUTCOMES = ("voicemail", "callback_scheduled", "receptionist")
 
 
 def _now() -> datetime:
@@ -130,7 +139,12 @@ def _metrics_for_window(db: Session, start: datetime, end: datetime) -> dict:
         "disconnected": _count_outcomes(db, start, end, ("dead_number",)),
         "voicemail": _count_outcomes(db, start, end, ("voicemail",)),
         "receptionist": _count_outcomes(db, start, end, ("receptionist",)),
-        "decision_maker": _count_outcomes(db, start, end, _DECISION_MAKER_OUTCOMES),
+        # A real disposition button now (Cold Call Desk), same as
+        # Receptionist -- not derived from other outcomes anymore, per user
+        # request 2026-09-17 (the old derived count from
+        # not_interested/callback_scheduled/meeting_booked was confusing:
+        # "yeh kya chiz hai, hum kaise add kar rahe hain").
+        "decision_maker": _count_outcomes(db, start, end, ("decision_maker",)),
     }
 
 

app/crud/leads.py

@@ -304,6 +304,18 @@ _OUTCOME_STAGE = {
     "not_interested": "lost",
     "callback_scheduled": "followup_due",
     "receptionist": "followup_due",
+    "decision_maker": "followup_due",
+    # Didn't reach anyone -- worth trying again, same as voicemail.
+    "no_answer": "followup_due",
+    "hang_up": "followup_due",
+    # This number doesn't reach the company at all -- a dead end, same as
+    # dead_number. (Renamed from "irrelevant" per user request 2026-09-17.)
+    "wrong_number": "lost",
+    # Client is closing the deal (confirmed positive, not yet final) --
+    # confirmed live 2026-09-17: NOT "business shut down" (that reading was
+    # wrong). Advances to Proposal Sent, same as the deal actually
+    # progressing, rather than sitting in the call queue.
+    "closed": "proposal_sent",
 }
 
 

app/schemas/lead.py

@@ -32,7 +32,7 @@ PhoneStatus = Literal[
 ]
 CallOutcome = Literal[
     "meeting_booked", "voicemail", "dead_number", "not_interested", "callback_scheduled",
-    "receptionist",
+    "receptionist", "decision_maker", "no_answer", "hang_up", "wrong_number", "closed",
 ]
 
 assert set(STAGE_IDS) == set(PipelineStage.__args__)  # keeps constants.py honest

app/services/agent_core.py

@@ -42,7 +42,7 @@ log = _logging.getLogger("outreach.agent_core")
 
 from app.config import settings
 from app.constants import STANDARD_CATEGORIES
-from app.services import validation
+from app.services import countries, validation
 from app.services.providers.grok import GROQ_BASE_URL, get_groq_key
 from app.services.secrets import (
     get_apollo_key,
@@ -1006,11 +1006,24 @@ Identify {max_leads} real commercial businesses/brands/exhibitors matching this
     candidates = _generate_json(prompt_content, system_instruction=SYSTEM_PROMPT, temperature=0.3)
 
     if not candidates or not isinstance(candidates, list):
+        # Confirmed live 2026-09-17: this fires whenever the whole cascade
+        # fails, and the single most common real cause is the Gemini
+        # free-tier daily quota (20 requests/day PER MODEL) being exhausted
+        # across all 5 cascade models, with the Groq fallback then also
+        # failing to return parseable JSON. The generic message below used to
+        # give no hint of this -- a rep just saw "0 leads" with no way to
+        # tell an actual outage apart from a quota that resets tomorrow.
+        # Full detail is always in the server logs either way.
         return {
             "saved": 0,
             "skipped_duplicates": [],
             "leads": [],
-            "error": "No companies found from Gemini or Groq",
+            "error": (
+                "No companies found -- Gemini and Groq both failed to respond. "
+                "The most common cause is Gemini's free-tier daily quota being "
+                "exhausted; check the server logs for the exact reason, or try "
+                "again later / after the quota resets."
+            ),
         }
 
     candidates = candidates[:max_leads]
@@ -1038,7 +1051,16 @@ Identify {max_leads} real commercial businesses/brands/exhibitors matching this
         # actually found -- showing under "Unknown", never under the country
         # actually searched for. Same fallback as qualify.py: the model's
         # own answer wins, else guess from the resolved website's domain.
-        country = (c.get("country") or "").strip().upper()[:2]
+        #
+        # Confirmed live 2026-09-17 (same bug as qualify.py's payload build):
+        # the model doesn't reliably return a real ISO2 code -- "UK" or
+        # "United Kingdom" both slip through as literal text, and the Country
+        # filter compares against real codes ("GB"), so a lead like that
+        # matches no filter selection. name_to_iso2() catches common
+        # names/aliases; only an unrecognized value falls back to the raw
+        # 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)
         subject = c.get("subject", f"Question regarding {company_name}")
         raw_body = c.get("body", "")

app/services/qualify.py

@@ -32,7 +32,7 @@ from datetime import datetime
 from app.crud import contacts as crud_contacts
 from app.crud import leads as crud_leads
 from app.database import SessionLocal
-from app.services import agent_core, contact_ingest, scraper, signalhire, validation
+from app.services import agent_core, contact_ingest, countries, scraper, signalhire, validation
 from app.services.providers import get_provider
 from app.services.providers.base import Candidate
 from app.services.urlguard import UnsafeUrlError, ensure_public_http_url
@@ -336,7 +336,20 @@ async def _qualify_one(
             # prompt (providers/grok.py INSTRUCTIONS rule 7) -- region (the
             # website-TLD guess computed above for phone parsing) is only the
             # fallback when the model left it blank.
-            "country": (cand.country or region).strip().upper()[:2],
+            #
+            # Confirmed live 2026-09-17: the model doesn't reliably return a
+            # real ISO2 code -- "UK" or "United Kingdom" both slipped through
+            # as literal text before (a bare .upper()[:2] on "United Kingdom"
+            # produces "UN", garbage; even "UK" itself is not the real code,
+            # which is "GB"). The country filter dropdown/Cold Call Desk
+            # compares against real ISO2 codes, so a lead saved with anything
+            # else silently never matches ANY filter selection and looks like
+            # it vanished. name_to_iso2() catches common names/aliases (incl.
+            # "uk" -> "GB"); only an unrecognized value falls back to the old
+            # raw-slice behavior (covers the case where the model already
+            # returned a correct code countries.py doesn't need to translate).
+            "country": countries.name_to_iso2(cand.country)
+            or (cand.country or region).strip().upper()[:2],
             "reason": (cand.why_fit or "")[:2000],
             "source_prompt": f"qualify: {icp_prompt}"[:500],
             "has_3d": False,

scripts/backfill_country_codes.py

@@ -0,0 +1,81 @@
+"""
+backfill_country_codes.py — fix leads saved with a non-standard country
+value instead of a real ISO 3166-1 alpha-2 code.
+
+Confirmed live 2026-09-17: plain AI Discovery (app/services/qualify.py
+_qualify_one, before this fix) trusted the model's raw `country` output --
+"UK" or "United Kingdom" text both got saved as-is (or mangled to "UN" by a
+bare .upper()[:2] on the full name). The Country filter (Cold Call Desk,
+Pipeline, Contacts) compares against real codes ("GB" for United Kingdom),
+so a lead like that silently matched NO filter selection and looked like it
+had vanished. qualify.py now runs every candidate's country through
+countries.name_to_iso2() before saving; this script fixes leads that were
+already written wrong before that fix shipped.
+
+Only touches leads where name_to_iso2(lead.country) resolves to something
+DIFFERENT from what's already stored -- an already-correct code like "GB"
+isn't a name/alias in that dict and is left untouched.
+
+Dry-run by default -- prints exactly what it would change and changes
+nothing in the database. Re-run with --apply to actually change it.
+
+    uv run python scripts/backfill_country_codes.py            # dry run
+    uv run python scripts/backfill_country_codes.py --apply    # apply it
+
+Always run without --apply first and read the output before adding --apply.
+"""
+
+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 select  # noqa: E402
+
+from app.database import SessionLocal  # noqa: E402
+from app.models import Lead  # noqa: E402
+from app.services.countries import name_to_iso2  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--apply", action="store_true", help="actually fix country (default: dry run only)")
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        rows = list(db.scalars(select(Lead).where(Lead.country != "")).all())
+        print(f"Scanning {len(rows)} lead(s) with a country set...")
+
+        changes: list[tuple[Lead, str, str]] = []
+        for lead in rows:
+            fixed = name_to_iso2(lead.country)
+            if fixed and fixed != lead.country:
+                changes.append((lead, lead.country, fixed))
+
+        if not changes:
+            print("Nothing to backfill -- every stored country is already a real ISO2 code.")
+            return 0
+
+        print(f"\n{len(changes)} lead(s) have a non-standard country value:")
+        for lead, old, new in changes:
+            print(f"  #{lead.id:<6} {lead.company_name[:40]:<40} {old!r:<10} -> {new}")
+
+        if not args.apply:
+            print("\nDry run only -- re-run with --apply to write these changes.")
+            return 0
+
+        for lead, _old, new in changes:
+            lead.country = new
+        db.commit()
+        print(f"\nApplied: {len(changes)} lead(s) updated.")
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_recent_jobs.py

@@ -0,0 +1,77 @@
+"""
+check_recent_jobs.py — read-only diagnostic for "I ran a Discover search and
+some leads seem to be missing."
+
+Prints the most recent N jobs of a given kind (default "discover") with
+their status, requested count vs. actually saved count, skipped duplicates,
+and any error -- the definitive source of truth for what a run actually did,
+instead of guessing from lead timestamps alone.
+
+    uv run python scripts/check_recent_jobs.py                    # last 10 discover jobs
+    uv run python scripts/check_recent_jobs.py --kind qualify
+    uv run python scripts/check_recent_jobs.py --limit 20
+"""
+
+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 select  # noqa: E402
+
+from app.database import SessionLocal  # noqa: E402
+from app.models import Job  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--kind", default="discover")
+    parser.add_argument("--limit", type=int, default=10)
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        rows = list(
+            db.scalars(
+                select(Job)
+                .where(Job.kind == args.kind)
+                .order_by(Job.created_at.desc())
+                .limit(args.limit)
+            ).all()
+        )
+        if not rows:
+            print(f"No '{args.kind}' jobs found at all.")
+            return 0
+
+        print(f"Most recent {len(rows)} '{args.kind}' job(s):\n")
+        for job in rows:
+            print(f"job {job.id}  status={job.status}  created_at={job.created_at}")
+            print(f"    message: {job.message!r}")
+            if job.error:
+                print(f"    ERROR: {job.error}")
+            result = job.result or {}
+            if isinstance(result, dict):
+                saved = result.get("saved")
+                skipped = result.get("skipped_duplicates") or []
+                rejected = result.get("rejected") or []
+                err = result.get("error")
+                print(f"    saved={saved}  skipped_duplicates={len(skipped)}  rejected={len(rejected)}")
+                if skipped:
+                    print(f"      skipped (already existed): {skipped}")
+                if rejected:
+                    print("      rejected:")
+                    for r in rejected:
+                        print(f"        - {r}")
+                if err:
+                    print(f"      result error: {err}")
+            print()
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/check_recent_leads.py

@@ -0,0 +1,60 @@
+"""
+check_recent_leads.py — read-only diagnostic for "I just generated a lead
+and it's not showing where I expect."
+
+Prints the most recent N leads with every field a filter/queue check reads:
+pipeline_stage and phone_status (Cold Call Desk's CALL_QUEUE_STAGES filter),
+industry_tag (Category filter), country (Country filter), and source_prompt
+(the Source filter's leadSource() derivation).
+
+    uv run python scripts/check_recent_leads.py            # last 10
+    uv run python scripts/check_recent_leads.py --limit 25
+"""
+
+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 select  # noqa: E402
+
+from app.database import SessionLocal  # noqa: E402
+from app.models import Lead  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--limit", type=int, default=10)
+    args = parser.parse_args()
+
+    db = SessionLocal()
+    try:
+        rows = list(
+            db.scalars(
+                select(Lead).order_by(Lead.created_at.desc(), Lead.id.desc()).limit(args.limit)
+            ).all()
+        )
+        if not rows:
+            print("No leads in the database at all.")
+            return 0
+
+        print(f"Most recent {len(rows)} lead(s):\n")
+        for lead in rows:
+            print(f"#{lead.id} {lead.company_name}")
+            print(f"    created_at:     {lead.created_at}")
+            print(f"    pipeline_stage: {lead.pipeline_stage!r}")
+            print(f"    phone_status:   {lead.phone_status!r}")
+            print(f"    industry_tag:   {lead.industry_tag!r}")
+            print(f"    country:        {lead.country!r}")
+            print(f"    source_prompt:  {lead.source_prompt!r}")
+            print()
+        return 0
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())