diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f07f56..4bae8c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.3.2 (2026-09-02)
+
+- CLI: every SDK request field now has a flag — `discover`/`count` gain `--variance`, `--min-similarity`, `--consensus`, `--inclusion-query-id`, `--language`, `--social`, `--subdomain`, `--start-date`, `--redirect`, `--exclude-leadgen` and the `--auto-*` toggles; contacts `search`/`count`/`discover` gain the full filter set; `match` gains per-column flags for file mode and `--min-match-confidence`; `append`/`segment` take `--query-id`; `extract` accepts `--domain`. Dict-typed fields stay `--param` only.
+- SDK: `CountParams.exclude_leadgen` now defaults to `False`, matching the platform's `/count` default — counts no longer drop suspected lead-gen sites unless you ask for it. Discover is unchanged.
+
 ## 0.3.1 (2026-09-02)
 
 - SDK: `discolike.signup()` / `discolike.async_signup()` create a DiscoLike account for a person from their work email and name, with no credential required. Returns `SignupResult` with the `next_step` text to relay.
diff --git a/examples/README.md b/examples/README.md
index 20e96da..d503c24 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,17 +1,23 @@
-# Examples
+# Cookbook
 
-Runnable, self-contained scripts showing how to use the DiscoLike Python SDK for common GTM workflows: matching a messy CRM export to DiscoLike contacts, finding verified work emails in bulk, and discovering plus AI-enriching target accounts. Each script is stdlib-plus-SDK only, has an argparse CLI, and is meant to be copied into your own pipeline and adapted.
-
-| Script | What it does |
-|---|---|
-| [`match_crm_contacts.py`](match_crm_contacts.py) | Match a CSV of CRM contacts to DiscoLike persona IDs via `contacts.bulk_match()`, with dual domain keys (website + email domain), resumable JSONL checkpointing, and a persona_id + match_score output CSV |
-| [`find_emails_from_csv.py`](find_emails_from_csv.py) | Find work emails for a CSV of people (first name, last name, domain) via `email.find_batch()` in chunks of 500; only status "found" bills |
-| [`discover_and_enrich.py`](discover_and_enrich.py) | Discover companies matching an ICP with `client.discover()`, then run a DiscoGen research prompt over them with `discogen.process()` and `job.wait()` |
-
-## Running
+Runnable scripts for common GTM workflows on the [DiscoLike API](https://discolike.com/api/), written against the [Python SDK](https://docs.discolike.com/sdk/). Each one is stdlib plus `discolike`, takes its inputs on the command line, and reads your key from `DISCOLIKE_API_KEY`.
 
 ```bash
-pip install discolike
+pip install "discolike[cli]"
 export DISCOLIKE_API_KEY="dl_..."   # create one at https://app.discolike.com/account/management/keys
-python examples/<script>.py --help
 ```
+
+| Script | What it does | How to run |
+|---|---|---|
+| [`tam_from_seed_domains.py`](tam_from_seed_domains.py) | Counts companies in a country and employee bucket, then discovers lookalikes of three seed domains and writes them to CSV | `python examples/tam_from_seed_domains.py stripe.com adyen.com checkout.com US 51,200 --max-records 100 --output tam.csv` |
+| [`icp_prompt_search.py`](icp_prompt_search.py) | Turns a plain-English ICP into a company list with similarity scores | `python examples/icp_prompt_search.py "Series A fintechs in Europe selling to SMBs" --country EU` |
+| [`phrase_match_count.py`](phrase_match_count.py) | Counts sites whose text contains an exact phrase, then lists them | `python examples/phrase_match_count.py "SOC 2" --country US` |
+| [`enrich_crm_export.py`](enrich_crm_export.py) | Adds firmographics (size, revenue, location, industry, business model) to every domain in a CSV | `python examples/enrich_crm_export.py accounts.csv --domain-column website --output enriched.csv` |
+| [`contacts_at_results.py`](contacts_at_results.py) | Discovers companies for an ICP, then finds contacts at the top N filtered by seniority, department, or title | `python examples/contacts_at_results.py "B2B SaaS selling to sales teams" --top 10 --seniority executive --has-email` |
+| [`agent_signup_to_first_search.py`](agent_signup_to_first_search.py) | Opens a DiscoLike account for a person from an agent, relays `next_step`, and runs a first search once `DISCOLIKE_API_KEY` is set | `python examples/agent_signup_to_first_search.py --email jane@acme.com --first-name Jane --last-name Doe` |
+| [`discover_and_enrich.py`](discover_and_enrich.py) | Discovers companies for an ICP, then runs a DiscoGen research prompt over them (needs a BYOK LLM provider) | `python examples/discover_and_enrich.py --icp "Cybersecurity for SMBs" --country US --query "What is their pricing model?"` |
+| [`find_emails_from_csv.py`](find_emails_from_csv.py) | Finds verified work emails for a CSV of first name, last name, domain in batches of 500; only status `found` bills | `python examples/find_emails_from_csv.py people.csv --output emails.csv` |
+| [`match_crm_contacts.py`](match_crm_contacts.py) | Matches a messy CRM contact export to DiscoLike persona IDs with resumable checkpointing | `python examples/match_crm_contacts.py contacts.csv --output matched.csv` |
+| [`cli_recipes.sh`](cli_recipes.sh) | The same searches as `discolike discover`, `discolike count`, `discolike contacts search`, and `discolike signup` one-liners | `bash examples/cli_recipes.sh` |
+
+Every script prints `--help`. Employee ranges are `min,max` strings such as `51,200`; countries are ISO-2 codes or region aliases like `EU`, `DACH`, `APAC`.
diff --git a/examples/agent_signup_to_first_search.py b/examples/agent_signup_to_first_search.py
new file mode 100644
index 0000000..3361d9d
--- /dev/null
+++ b/examples/agent_signup_to_first_search.py
@@ -0,0 +1,71 @@
+"""Open a DiscoLike account for a person, then run a first search once their key exists.
+
+signup() posts {email, first_name, last_name, agent} to https://api.discolike.com/v1/public/signup with no
+auth header and returns a next_step message to relay to the person. No API key comes back: the person
+confirms their email, logs in at https://app.discolike.com, and creates a key under Account > API keys.
+Export that key as DISCOLIKE_API_KEY and rerun this script to make the first discover call.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+
+from discolike import Discolike
+from discolike import DiscolikeError
+from discolike import signup
+from discolike.requests import DiscoverParams
+
+AGENT_NAME = "cookbook"
+API_KEY_ENV = "DISCOLIKE_API_KEY"
+FIRST_SEARCH_PROMPT = "B2B SaaS companies selling to sales teams"
+FIRST_SEARCH_RECORDS = 5
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--email", help="Work email of the person the account is for")
+    parser.add_argument("--first-name", help="Their first name")
+    parser.add_argument("--last-name", help="Their last name")
+    parser.add_argument("--allow-new-email", action="store_true", help="Sign up a second email from this machine")
+    return parser.parse_args()
+
+
+def run_signup(args: argparse.Namespace) -> None:
+    try:
+        result = signup(
+            email=args.email,
+            first_name=args.first_name,
+            last_name=args.last_name,
+            agent=AGENT_NAME,
+            allow_new_email=args.allow_new_email,
+        )
+    except DiscolikeError as exc:
+        print(f"Signup failed: {exc}")
+        return
+    print(f"Signup {result.status} for {result.email} (org {result.org_domain}: {result.org_status})")
+    print(f"Next step: {result.next_step}")
+
+
+def run_first_search() -> None:
+    client = Discolike()
+    companies = client.discover(DiscoverParams(icp_prompt=FIRST_SEARCH_PROMPT, max_records=FIRST_SEARCH_RECORDS))
+    print(f"\nFirst search, {FIRST_SEARCH_PROMPT!r}:")
+    for company in companies:
+        print(f"  {company.domain or '':<32} {company.name or ''}")
+
+
+def main() -> None:
+    args = parse_args()
+    if args.email and args.first_name and args.last_name:
+        run_signup(args)
+    else:
+        print("No --email/--first-name/--last-name given, skipping signup.")
+    if os.environ.get(API_KEY_ENV):
+        run_first_search()
+    else:
+        print(f"\n{API_KEY_ENV} is not set; export it after email confirmation and rerun for the first search.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/cli_recipes.sh b/examples/cli_recipes.sh
new file mode 100644
index 0000000..f3e984a
--- /dev/null
+++ b/examples/cli_recipes.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# The same searches as the Python scripts, as `discolike` CLI one-liners.
+# Install: pip install discolike-cli   Auth: export DISCOLIKE_API_KEY="dl_..." or `discolike auth login`
+set -euo pipefail
+
+# tam_from_seed_domains.py: count the country + size bucket, then discover lookalikes of three seed domains
+discolike count --country US --employee-range 51,200 --format json
+discolike discover --domain stripe.com --domain adyen.com --domain checkout.com \
+  --country US --employee-range 51,200 --max-records 100 --format json
+
+# icp_prompt_search.py: natural-language ICP, domain + name + similarity
+discolike discover --icp-prompt "Series A fintechs in Europe selling to SMBs" --country EU --max-records 25 --format json \
+  | jq -r '.[] | [.domain, .name, .similarity] | @tsv'
+
+# phrase_match_count.py: sites whose text contains an exact phrase, count then list
+discolike count --phrase-match "SOC 2" --country US --format json
+discolike discover --phrase-match "SOC 2" --country US --max-records 50 --format json | jq -r '.[].domain'
+
+# contacts_at_results.py: discover companies, then executives at the first ten of them
+discolike discover --icp-prompt "B2B SaaS companies selling to sales teams" --max-records 10 --format json \
+  | jq -r '.[].domain' \
+  | xargs -I{} printf -- '--domain %s ' {} \
+  | xargs discolike contacts search --seniority executive --has-email --format json
+
+# enrich_crm_export.py: one company profile by domain
+discolike company data stripe.com --format json
+
+# agent_signup_to_first_search.py: open an account for a person, no auth needed
+discolike signup --email jane@acme.com --first-name Jane --last-name Doe --agent cookbook
diff --git a/examples/contacts_at_results.py b/examples/contacts_at_results.py
new file mode 100644
index 0000000..6bc3f3e
--- /dev/null
+++ b/examples/contacts_at_results.py
@@ -0,0 +1,58 @@
+"""Discover companies for an ICP, then find decision makers at the top N by seniority, department, or title."""
+
+from __future__ import annotations
+
+import argparse
+
+from discolike import Discolike
+from discolike.requests import ContactsSearchParams
+from discolike.requests import DiscoverParams
+
+SENIORITIES = ["executive", "vp", "director", "manager", "senior_ic", "mid_level", "entry_level"]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="Natural-language ICP for the company search")
+    parser.add_argument("--country", action="append", help="ISO-2 country code or region alias, repeatable")
+    parser.add_argument("--top", type=int, default=10, help="Companies to search contacts at (default 10)")
+    parser.add_argument("--seniority", action="append", choices=SENIORITIES, help="Persona seniority, repeatable")
+    parser.add_argument("--department", action="append", help="Persona department, e.g. 'Sales - Marketing'")
+    parser.add_argument("--title", action="append", help="Job title term, e.g. 'Head of Growth', repeatable")
+    parser.add_argument("--per-company", type=int, default=3, help="Contacts per company (default 3)")
+    parser.add_argument("--has-email", action="store_true", help="Only contacts with an email address")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    client = Discolike()
+
+    companies = client.discover(
+        DiscoverParams(icp_prompt=args.prompt, country=args.country, max_records=max(args.top, 5))
+    )
+    domains = [company.domain for company in companies[: args.top] if company.domain]
+    print(f"Top {len(domains)} companies: {', '.join(domains)}")
+
+    contacts = client.contacts.search(
+        ContactsSearchParams(
+            domain=domains,
+            seniority=args.seniority,
+            department=args.department,
+            title=args.title,
+            has_email=args.has_email,
+            results_by_company=args.per_company,
+            max_records=max(len(domains) * args.per_company, 20),
+        )
+    )
+    print(f"\n{'domain':<28} {'name':<28} {'title':<40} email")
+    for contact in contacts:
+        print(
+            f"{contact.domain or '':<28} {(contact.name or '')[:28]:<28} "
+            f"{(contact.title or '')[:40]:<40} {contact.email or ''}"
+        )
+    print(f"\n{len(contacts)} contacts across {len({contact.domain for contact in contacts})} companies")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/enrich_crm_export.py b/examples/enrich_crm_export.py
new file mode 100644
index 0000000..6322a9f
--- /dev/null
+++ b/examples/enrich_crm_export.py
@@ -0,0 +1,84 @@
+"""Enrich a CSV of domains with firmographics from the company profile endpoint and write a widened CSV."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import sys
+from pathlib import Path
+
+from discolike import Discolike
+from discolike import DiscolikeError
+from discolike.requests import CompaniesDataParams
+
+ENRICHED_FIELDS = [
+    "dl_name",
+    "dl_employees",
+    "dl_revenue_range",
+    "dl_country",
+    "dl_state",
+    "dl_city",
+    "dl_industry_groups",
+    "dl_business_model",
+    "dl_description",
+    "dl_error",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", type=Path, help="CSV with a domain column")
+    parser.add_argument("--output", type=Path, default=Path("enriched.csv"), help="Output CSV path")
+    parser.add_argument("--domain-column", default="domain", help="Column holding the domain (default: domain)")
+    return parser.parse_args()
+
+
+def top_keys(weights: dict[str, float], *, limit: int = 3) -> str:
+    return "; ".join(key for key, _ in sorted(weights.items(), key=lambda item: item[1], reverse=True)[:limit])
+
+
+def enrich_row(client: Discolike, *, domain: str) -> dict[str, str]:
+    try:
+        profile = client.companies.data(CompaniesDataParams(domain=domain))
+    except DiscolikeError as exc:
+        return {"dl_error": str(exc)}
+    address = profile.address
+    return {
+        "dl_name": profile.name or "",
+        "dl_employees": profile.employees or "",
+        "dl_revenue_range": profile.revenue_range or "",
+        "dl_country": address.country if address else "",
+        "dl_state": address.state if address else "",
+        "dl_city": address.city if address else "",
+        "dl_industry_groups": top_keys(profile.industry_groups),
+        "dl_business_model": top_keys(profile.business_model),
+        "dl_description": profile.description or "",
+        "dl_error": "",
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    with args.input.open(newline="", encoding="utf-8-sig") as handle:
+        reader = csv.DictReader(handle)
+        fieldnames = list(reader.fieldnames or [])
+        rows = list(reader)
+    if args.domain_column not in fieldnames:
+        sys.exit(f"Column {args.domain_column!r} not found in {args.input}; columns are {fieldnames}")
+
+    client = Discolike()
+    enriched = 0
+    with args.output.open(mode="w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames + ENRICHED_FIELDS, extrasaction="ignore")
+        writer.writeheader()
+        for row in rows:
+            domain = row[args.domain_column].strip().lower().removeprefix("www.")
+            extra = enrich_row(client, domain=domain) if domain else {"dl_error": "empty domain"}
+            if not extra.get("dl_error"):
+                enriched += 1
+            writer.writerow({**row, **extra})
+    print(f"Enriched {enriched}/{len(rows)} rows -> {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/icp_prompt_search.py b/examples/icp_prompt_search.py
new file mode 100644
index 0000000..69e46c3
--- /dev/null
+++ b/examples/icp_prompt_search.py
@@ -0,0 +1,33 @@
+"""Describe your ideal customer in plain English and print the matching companies with their similarity score."""
+
+from __future__ import annotations
+
+import argparse
+
+from discolike import Discolike
+from discolike.requests import DiscoverParams
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="Natural-language ICP, e.g. 'Series A fintechs in Europe selling to SMBs'")
+    parser.add_argument("--country", action="append", help="ISO-2 country code or region alias, repeatable")
+    parser.add_argument("--max-records", type=int, default=25, help="Companies to return (5-10000, default 25)")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    client = Discolike()
+    companies = client.discover(
+        DiscoverParams(icp_prompt=args.prompt, country=args.country, max_records=args.max_records)
+    )
+    print(f"{'domain':<32} {'name':<40} similarity")
+    for company in companies:
+        similarity = f"{company.similarity:.0f}" if company.similarity is not None else "-"
+        print(f"{company.domain or '':<32} {(company.name or '')[:40]:<40} {similarity}")
+    print(f"\n{len(companies)} companies for: {args.prompt!r}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/phrase_match_count.py b/examples/phrase_match_count.py
new file mode 100644
index 0000000..fc277eb
--- /dev/null
+++ b/examples/phrase_match_count.py
@@ -0,0 +1,36 @@
+"""Find companies whose website contains an exact phrase: count the match first, then pull the list."""
+
+from __future__ import annotations
+
+import argparse
+
+from discolike import Discolike
+from discolike.requests import CountParams
+from discolike.requests import DiscoverParams
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("phrase", nargs="+", help="Phrases the site must contain (up to 20, 3+ chars each)")
+    parser.add_argument("--country", action="append", required=True, help="ISO-2 country code or region alias")
+    parser.add_argument("--max-records", type=int, default=50, help="Companies to return (5-10000, default 50)")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    client = Discolike()
+
+    total = client.count(CountParams(phrase_match=args.phrase, country=args.country))
+    print(f"{total.count} sites in {', '.join(args.country)} mention {args.phrase}")
+
+    companies = client.discover(
+        DiscoverParams(phrase_match=args.phrase, country=args.country, max_records=args.max_records)
+    )
+    for company in companies:
+        print(f"{company.domain or '':<32} {company.name or ''}")
+    print(f"\nShowing {len(companies)} of {total.count}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/tam_from_seed_domains.py b/examples/tam_from_seed_domains.py
new file mode 100644
index 0000000..828a698
--- /dev/null
+++ b/examples/tam_from_seed_domains.py
@@ -0,0 +1,66 @@
+"""Size a market from three seed domains: count the country + size bucket first, then discover lookalikes into a CSV."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import sys
+from pathlib import Path
+
+from discolike import Discolike
+from discolike.requests import CountParams
+from discolike.requests import DiscoverParams
+
+SEED_DOMAIN_COUNT = 3
+OUTPUT_FIELDS = ["domain", "name", "similarity", "employees", "country", "description"]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "domains", nargs=SEED_DOMAIN_COUNT, help="Three seed domains, e.g. stripe.com adyen.com checkout.com"
+    )
+    parser.add_argument("country", help="ISO-2 country code or region alias, e.g. US, DE, EU, DACH")
+    parser.add_argument("employee_range", help="Employee range as 'min,max', e.g. 51,200")
+    parser.add_argument("--max-records", type=int, default=100, help="Companies to discover (5-10000, default 100)")
+    parser.add_argument("--output", type=Path, default=Path("tam.csv"), help="Output CSV path")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    client = Discolike()
+
+    ceiling = client.count(CountParams(country=[args.country], employee_range=args.employee_range))
+    print(f"Companies in {args.country} with {args.employee_range} employees: {ceiling.count}")
+
+    companies = client.discover(
+        DiscoverParams(
+            domain=args.domains,
+            country=[args.country],
+            employee_range=args.employee_range,
+            max_records=args.max_records,
+        )
+    )
+    if not companies:
+        sys.exit("No lookalikes found; loosen the country or employee range.")
+
+    with args.output.open(mode="w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=OUTPUT_FIELDS)
+        writer.writeheader()
+        for company in companies:
+            writer.writerow(
+                {
+                    "domain": company.domain or "",
+                    "name": company.name or "",
+                    "similarity": company.similarity if company.similarity is not None else "",
+                    "employees": company.employees or "",
+                    "country": company.address.country if company.address else "",
+                    "description": company.description or "",
+                }
+            )
+    print(f"Wrote {len(companies)} lookalikes of {', '.join(args.domains)} to {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/discolike-cli/pyproject.toml b/packages/discolike-cli/pyproject.toml
index 66fe6cc..911943f 100644
--- a/packages/discolike-cli/pyproject.toml
+++ b/packages/discolike-cli/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.3.1"
+version = "0.3.2"
 description = "Official CLI for the DiscoLike API"
 readme = "README.md"
 license = "MIT"
@@ -12,7 +12,7 @@ license-files = ["LICENSE"]
 requires-python = ">=3.10"
 authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
 dependencies = [
-  "discolike==0.3.1",
+  "discolike==0.3.2",
   "typer>=0.12",
   "rich>=13.0",
 ]
diff --git a/packages/discolike-cli/src/discolike_cli/company.py b/packages/discolike-cli/src/discolike_cli/company.py
index ed52872..9c8955c 100644
--- a/packages/discolike-cli/src/discolike_cli/company.py
+++ b/packages/discolike-cli/src/discolike_cli/company.py
@@ -134,12 +134,17 @@ def public_links(
 @handle_errors
 def extract_command(
     ctx: typer.Context,
-    url: str = typer.Argument(..., help="Page URL to extract content from"),
+    url: str | None = typer.Argument(None, help="Page URL to extract content from"),
+    domain: str | None = typer.Option(
+        None, "--domain", help="Bare domain to extract instead of URL (alias for https://DOMAIN, served from cache)."
+    ),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
 ) -> None:
-    """Extract page content from a URL."""
+    """Extract page content from a URL or a bare domain."""
     from discolike_cli.main import get_client
 
-    emit(
-        get_client(ctx).companies.extract(build_request(CompaniesExtractParams, _merge_params(None, url=url))), fmt=fmt
-    )
+    if (url is None) == (domain is None):
+        raise typer.BadParameter("Provide exactly one of URL or --domain")
+
+    request = build_request(CompaniesExtractParams, _merge_params(None, url=url, domain=domain))
+    emit(get_client(ctx).companies.extract(request), fmt=fmt)
diff --git a/packages/discolike-cli/src/discolike_cli/contacts.py b/packages/discolike-cli/src/discolike_cli/contacts.py
index ecc1a10..91d1c9c 100644
--- a/packages/discolike-cli/src/discolike_cli/contacts.py
+++ b/packages/discolike-cli/src/discolike_cli/contacts.py
@@ -25,6 +25,25 @@
 TIMEOUT_HELP = "Max seconds to wait with --wait."
 PARAM_HELP = "Extra key=value query parameter forwarded to the SDK (repeatable)."
 JOBSTART_DATE_HELP = "Job start date filter: min date or 'min,max' range, e.g. 2025-01-01 or 2025-01-01,2025-06-30."
+SUMMARY_HELP = "Filter by profile summary text (semantic search)."
+NEGATE_SUMMARY_HELP = "Exclude contacts matching this summary description."
+NAME_HELP = "Filter by contact name (partial match supported)."
+SKILLS_HELP = "Filter by skill (repeatable)."
+FILTER_STATE_HELP = "Filter by company state/region (repeatable)."
+NEGATE_FILTER_STATE_HELP = "Exclude contacts at companies in this state (repeatable)."
+PERSON_STATE_HELP = "Filter by contact state/region (repeatable)."
+PERSONA_ID_HELP = "Filter by persona ID (repeatable)."
+EMAIL_VALIDATED_HELP = "Only contacts with (or without) a validated email address."
+HAS_PHONE_HELP = "Only contacts with (or without) a phone number."
+HAS_MOBILE_HELP = "Only contacts with (or without) a mobile phone number."
+HAS_LINKEDIN_HELP = "Only contacts with (or without) a LinkedIn profile."
+MIN_CONNECTIONS_HELP = "Minimum LinkedIn connections required."
+INCLUSION_QUERY_ID_HELP = "Include only contacts from companies in this saved query (repeatable)."
+EXCLUSION_QUERY_ID_HELP = "Exclude contacts from companies in this saved query (repeatable)."
+MAX_COMPANIES_HELP = "Maximum number of enriched companies to return; cannot be combined with --max-records."
+RESULTS_BY_COMPANY_HELP = "Maximum contacts per company domain (default 5; 0 removes the cap)."
+INCLUDE_SEARCH_CONTACTS_HELP = "Include contacts from the search index (broader coverage)."
+CONSENSUS_HELP = "Number of query vectors to combine for consensus search."
 
 app = typer.Typer(
     help="Find contacts: search and count by filters, look up or match individuals, and run bulk/generative discovery jobs."
@@ -42,20 +61,43 @@ def search_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
     max_records: int | None = typer.Option(None, help="Maximum number of contacts to return."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
     offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
+    results_by_company: int | None = typer.Option(None, help=RESULTS_BY_COMPANY_HELP),
+    include_search_contacts: bool | None = typer.Option(
+        None, "--include-search-contacts/--no-include-search-contacts", help=INCLUDE_SEARCH_CONTACTS_HELP
+    ),
+    consensus: int | None = typer.Option(None, help=CONSENSUS_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -71,18 +113,37 @@ def search_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
         max_records=max_records,
+        max_companies=max_companies,
         offset=offset,
+        results_by_company=results_by_company,
+        include_search_contacts=include_search_contacts,
+        consensus=consensus,
     )
     emit(get_client(ctx).contacts.search(build_request(ContactsSearchParams, kwargs)), fmt=fmt)
 
@@ -98,18 +159,43 @@ def count_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
+    max_records: int | None = typer.Option(None, help="Maximum number of contacts to count (20-10000)."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
+    offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
+    results_by_company: int | None = typer.Option(None, help=RESULTS_BY_COMPANY_HELP),
+    include_search_contacts: bool | None = typer.Option(
+        None, "--include-search-contacts/--no-include-search-contacts", help=INCLUDE_SEARCH_CONTACTS_HELP
+    ),
+    consensus: int | None = typer.Option(None, help=CONSENSUS_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -125,16 +211,37 @@ def count_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
+        max_records=max_records,
+        max_companies=max_companies,
+        offset=offset,
+        results_by_company=results_by_company,
+        include_search_contacts=include_search_contacts,
+        consensus=consensus,
     )
     emit(get_client(ctx).contacts.count(build_request(ContactsCountParams, kwargs)), fmt=fmt)
 
@@ -220,19 +327,37 @@ def discover_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
     max_records: int | None = typer.Option(None, help="Maximum number of contacts to return."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
     offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
     results_by_company: int | None = typer.Option(
         None, "--results-by-company", help="Maximum contacts returned per company."
@@ -258,17 +383,33 @@ def discover_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
         max_records=max_records,
+        max_companies=max_companies,
         offset=offset,
         results_by_company=results_by_company,
         include_search_contacts=include_search_contacts,
@@ -283,6 +424,12 @@ def generate_command(
     ctx: typer.Context,
     icp_text: str = typer.Option(..., "--icp-text", help="ICP description used to generate contacts."),
     domain: list[str] = typer.Option(..., "--domain", help="Target company domain (repeatable)."),
+    full_domain: list[str] | None = typer.Option(
+        None, "--full-domain", help="Domain to send as full_domains to the generation job (repeatable)."
+    ),
+    partial_domain: list[str] | None = typer.Option(
+        None, "--partial-domain", help="Domain to send as partial_domains to the generation job (repeatable)."
+    ),
     context_mode: str | None = typer.Option(None, "--context-mode", help="Context mode for generation."),
     integration_id: str | None = typer.Option(None, "--integration-id", help="Integration ID to use for generation."),
     search_provider_id: str | None = typer.Option(
@@ -310,6 +457,8 @@ def generate_command(
             None,
             icp_text=icp_text,
             domains=domain,
+            full_domains=full_domain,
+            partial_domains=partial_domain,
             context_mode=context_mode,
             integration_id=integration_id,
             search_provider_id=search_provider_id,
diff --git a/packages/discolike-cli/src/discolike_cli/discover.py b/packages/discolike-cli/src/discolike_cli/discover.py
index beafaeb..b9c2df1 100644
--- a/packages/discolike-cli/src/discolike_cli/discover.py
+++ b/packages/discolike-cli/src/discolike_cli/discover.py
@@ -15,6 +15,19 @@
 
 FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
 PARAM_HELP = "Extra API parameter as KEY=VALUE (comma-separates into a list); see docs.discolike.com"
+SUBDOMAIN_HELP = "Limit results to this subdomain, up to 20, each at least 3 characters (repeatable)."
+NEGATE_SUBDOMAIN_HELP = "Exclude this subdomain, up to 20, each at least 3 characters (repeatable)."
+START_DATE_HELP = "Minimum company start date (YYYY-MM-DD) or range (YYYY-MM-DD,YYYY-MM-DD)."
+REDIRECT_HELP = "Include or exclude domains that redirect to another domain."
+SOCIAL_HELP = (
+    "Filter by social platform presence (repeatable): facebook, instagram, linkedin, pinterest, threads, tiktok, "
+    "twitter, x, yelp, youtube, googleplay, applestore, amazon, vk, bluesky, xing."
+)
+NEGATE_SOCIAL_HELP = "Exclude companies with this social profile (repeatable); same values as --social."
+LANGUAGE_HELP = "Filter by site language as an ISO 639-1 code, e.g. en, de, pb, zt (repeatable)."
+NEGATE_LANGUAGE_HELP = "Exclude this site language (repeatable); same values as --language."
+EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (on by default)."
+COUNT_EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (off by default for count)."
 
 
 def _parse_param(raw: str) -> tuple[str, str | list[str]]:
@@ -45,8 +58,15 @@ def discover_command(
     negate_country: list[str] | None = typer.Option(None, help="Negate the --country filter (repeatable)."),
     state: list[str] | None = typer.Option(None, help="State or region filter (repeatable)."),
     negate_state: list[str] | None = typer.Option(None, help="Negate the --state filter (repeatable)."),
+    subdomain: list[str] | None = typer.Option(None, help=SUBDOMAIN_HELP),
+    negate_subdomain: list[str] | None = typer.Option(None, help=NEGATE_SUBDOMAIN_HELP),
+    language: list[str] | None = typer.Option(None, help=LANGUAGE_HELP),
+    negate_language: list[str] | None = typer.Option(None, help=NEGATE_LANGUAGE_HELP),
+    social: list[str] | None = typer.Option(None, help=SOCIAL_HELP),
+    negate_social: list[str] | None = typer.Option(None, help=NEGATE_SOCIAL_HELP),
     employee_range: str | None = typer.Option(None, help="Employee count range filter."),
     revenue_range: str | None = typer.Option(None, help="Revenue range filter."),
+    start_date: str | None = typer.Option(None, help=START_DATE_HELP),
     business_model: list[str] | None = typer.Option(None, help="Business model filter (repeatable)."),
     negate_business_model: list[str] | None = typer.Option(
         None, help="Negate the --business-model filter (repeatable)."
@@ -55,7 +75,38 @@ def discover_command(
     negate_tech_stack: list[str] | None = typer.Option(None, help="Negate the --tech-stack filter (repeatable)."),
     min_digital_footprint: int | None = typer.Option(None, help="Minimum digital footprint score."),
     max_digital_footprint: int | None = typer.Option(None, help="Maximum digital footprint score."),
+    min_similarity: int | None = typer.Option(None, help="Minimum similarity score to include (0-99)."),
+    variance: str | None = typer.Option(
+        None, help="Result diversity control: LOW, MID_LOW, MEDIUM, MID_HIGH, HIGH, UNRESTRICTED."
+    ),
+    consensus: int | None = typer.Option(
+        None, help="Number of top results for the consensus search vector (1-20); higher reduces specificity."
+    ),
+    redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
+    exclude_leadgen: bool | None = typer.Option(
+        None, "--exclude-leadgen/--no-exclude-leadgen", help=EXCLUDE_LEADGEN_HELP
+    ),
+    retrieval: bool | None = typer.Option(
+        None, "--retrieval/--no-retrieval", help="Enable page data retrieval using the Extract API."
+    ),
+    enhanced: bool | None = typer.Option(
+        None, "--enhanced/--no-enhanced", help="Enable AI-powered result enhancement for improved relevance."
+    ),
+    include_search_domains: bool | None = typer.Option(
+        None,
+        "--include-search-domains/--no-include-search-domains",
+        help="Include the input domains in results (excluded by default).",
+    ),
+    auto_icp_text: bool | None = typer.Option(
+        None, "--auto-icp-text/--no-auto-icp-text", help="Auto-generate ICP text from the provided domain(s)."
+    ),
+    auto_phrase_match: bool | None = typer.Option(
+        None, "--auto-phrase-match/--no-auto-phrase-match", help="Auto-generate phrase matches from ICP text."
+    ),
     exclude_domain: list[str] | None = typer.Option(None, help="Domain to exclude from results (repeatable)."),
+    inclusion_query_id: list[str] | None = typer.Option(
+        None, help="Saved query ID whose domains are included (repeatable); requires the STARTER plan."
+    ),
     exclusion_query_id: list[str] | None = typer.Option(
         None, help="Saved query ID whose results are excluded (repeatable)."
     ),
@@ -81,15 +132,33 @@ def discover_command(
             negate_country=negate_country,
             state=state,
             negate_state=negate_state,
+            subdomain=subdomain,
+            negate_subdomain=negate_subdomain,
+            language=language,
+            negate_language=negate_language,
+            social=social,
+            negate_social=negate_social,
             employee_range=employee_range,
             revenue_range=revenue_range,
+            start_date=start_date,
             business_model=business_model,
             negate_business_model=negate_business_model,
             tech_stack=tech_stack,
             negate_tech_stack=negate_tech_stack,
             min_digital_footprint=min_digital_footprint,
             max_digital_footprint=max_digital_footprint,
+            min_similarity=min_similarity,
+            variance=variance,
+            consensus=consensus,
+            redirect=redirect,
+            exclude_leadgen=exclude_leadgen,
+            retrieval=retrieval,
+            enhanced=enhanced,
+            include_search_domains=include_search_domains,
+            auto_icp_text=auto_icp_text,
+            auto_phrase_match=auto_phrase_match,
             exclude_domain=exclude_domain,
+            inclusion_query_id=inclusion_query_id,
             exclusion_query_id=exclusion_query_id,
             max_records=max_records,
             offset=offset,
@@ -109,8 +178,15 @@ def count_command(
     negate_country: list[str] | None = typer.Option(None, help="Negate the --country filter (repeatable)."),
     state: list[str] | None = typer.Option(None, help="State or region filter (repeatable)."),
     negate_state: list[str] | None = typer.Option(None, help="Negate the --state filter (repeatable)."),
+    subdomain: list[str] | None = typer.Option(None, help=SUBDOMAIN_HELP),
+    negate_subdomain: list[str] | None = typer.Option(None, help=NEGATE_SUBDOMAIN_HELP),
+    language: list[str] | None = typer.Option(None, help=LANGUAGE_HELP),
+    negate_language: list[str] | None = typer.Option(None, help=NEGATE_LANGUAGE_HELP),
+    social: list[str] | None = typer.Option(None, help=SOCIAL_HELP),
+    negate_social: list[str] | None = typer.Option(None, help=NEGATE_SOCIAL_HELP),
     employee_range: str | None = typer.Option(None, help="Employee count range filter."),
     revenue_range: str | None = typer.Option(None, help="Revenue range filter."),
+    start_date: str | None = typer.Option(None, help=START_DATE_HELP),
     business_model: list[str] | None = typer.Option(None, help="Business model filter (repeatable)."),
     negate_business_model: list[str] | None = typer.Option(
         None, help="Negate the --business-model filter (repeatable)."
@@ -119,6 +195,10 @@ def count_command(
     negate_tech_stack: list[str] | None = typer.Option(None, help="Negate the --tech-stack filter (repeatable)."),
     min_digital_footprint: int | None = typer.Option(None, help="Minimum digital footprint score."),
     max_digital_footprint: int | None = typer.Option(None, help="Maximum digital footprint score."),
+    redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
+    exclude_leadgen: bool | None = typer.Option(
+        None, "--exclude-leadgen/--no-exclude-leadgen", help=COUNT_EXCLUDE_LEADGEN_HELP
+    ),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -137,14 +217,23 @@ def count_command(
             negate_country=negate_country,
             state=state,
             negate_state=negate_state,
+            subdomain=subdomain,
+            negate_subdomain=negate_subdomain,
+            language=language,
+            negate_language=negate_language,
+            social=social,
+            negate_social=negate_social,
             employee_range=employee_range,
             revenue_range=revenue_range,
+            start_date=start_date,
             business_model=business_model,
             negate_business_model=negate_business_model,
             tech_stack=tech_stack,
             negate_tech_stack=negate_tech_stack,
             min_digital_footprint=min_digital_footprint,
             max_digital_footprint=max_digital_footprint,
+            redirect=redirect,
+            exclude_leadgen=exclude_leadgen,
         ),
     )
     emit(get_client(ctx).count(request), fmt=fmt)
diff --git a/packages/discolike-cli/src/discolike_cli/enrich.py b/packages/discolike-cli/src/discolike_cli/enrich.py
index a45aa52..d6144b8 100644
--- a/packages/discolike-cli/src/discolike_cli/enrich.py
+++ b/packages/discolike-cli/src/discolike_cli/enrich.py
@@ -19,6 +19,7 @@
 FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
 WAIT_HELP = "Block until the job finishes, streaming progress to stderr."
 TIMEOUT_HELP = "Max seconds to wait with --wait."
+QUERY_ID_HELP = "Saved query ID whose domains are included alongside the file/--domain ones (repeatable)."
 
 
 @handle_errors
@@ -76,6 +77,7 @@ def append_command(
     file: pathlib.Path = typer.Argument(..., help="CSV of domains to enrich."),
     dataset: list[str] | None = typer.Option(None, "--dataset", help="Dataset to append (repeatable)."),
     domain_column: str | None = typer.Option(None, "--domain-column", help="Column in the CSV that holds domains."),
+    query_id: list[str] | None = typer.Option(None, "--query-id", help=QUERY_ID_HELP),
     csv: bool | None = typer.Option(
         None, "--csv/--no-csv", help="Request the enriched rows as CSV (written via --output)."
     ),
@@ -85,7 +87,9 @@ def append_command(
     """Enrich a CSV of domains with DiscoLike datasets."""
     from discolike_cli.main import get_client
 
-    request = build_request(AppendParams, _merge_params(None, dataset=dataset, domain_column=domain_column, csv=csv))
+    request = build_request(
+        AppendParams, _merge_params(None, dataset=dataset, domain_column=domain_column, query_id=query_id, csv=csv)
+    )
     result = get_client(ctx).append(request, file=file)
     if isinstance(result, bytes):
         if output is None:
@@ -102,6 +106,7 @@ def segment_command(
     domain: list[str] | None = typer.Option(None, "--domain", help="Domain to segment (repeatable)."),
     file: pathlib.Path | None = typer.Option(None, "--file", help="CSV of domains to segment (instead of --domain)."),
     domain_column: str | None = typer.Option(None, "--domain-column", help="Column in --file that holds domains."),
+    query_id: list[str] | None = typer.Option(None, "--query-id", help=QUERY_ID_HELP),
     max_segments: int | None = typer.Option(None, "--max-segments", help="Maximum number of segments to produce."),
     wait: bool = typer.Option(False, "--wait", help=WAIT_HELP),
     timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
@@ -116,11 +121,14 @@ def segment_command(
     client = get_client(ctx)
     if file is not None:
         request = build_request(
-            SegmentFileParams, _merge_params(None, domain_column=domain_column, max_segments=max_segments)
+            SegmentFileParams,
+            _merge_params(None, domain_column=domain_column, query_id=query_id, max_segments=max_segments),
         )
         job = client.segment_file(request, file=file)
     else:
         assert domain is not None
-        request = build_request(SegmentParams, _merge_params(None, domains=",".join(domain), max_segments=max_segments))
+        request = build_request(
+            SegmentParams, _merge_params(None, domains=",".join(domain), query_id=query_id, max_segments=max_segments)
+        )
         job = client.segment(request)
     run_job(job, wait=wait, timeout=timeout, fmt=fmt)
diff --git a/packages/discolike-cli/src/discolike_cli/match.py b/packages/discolike-cli/src/discolike_cli/match.py
index 2a162c2..f624628 100644
--- a/packages/discolike-cli/src/discolike_cli/match.py
+++ b/packages/discolike-cli/src/discolike_cli/match.py
@@ -18,6 +18,7 @@
 FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
 WAIT_HELP = "Block until the job finishes, streaming progress to stderr."
 TIMEOUT_HELP = "Max seconds to wait with --wait."
+MIN_MATCH_CONFIDENCE_HELP = "Minimum match_confidence (inclusive, 50-100) a match must have to be returned."
 
 
 @handle_errors
@@ -29,6 +30,7 @@ def match_command(
     state: str | None = typer.Option(None, help="State or region to disambiguate the match."),
     country: str | None = typer.Option(None, help="Country to disambiguate the match."),
     zip_code: str | None = typer.Option(None, help="ZIP or postal code to disambiguate the match."),
+    min_match_confidence: int | None = typer.Option(None, help=MIN_MATCH_CONFIDENCE_HELP),
     strict: bool | None = typer.Option(None, "--strict/--no-strict", help="Toggle strict matching."),
     local_mode: bool | None = typer.Option(None, "--local-mode/--no-local-mode", help="Toggle local matching mode."),
     file: pathlib.Path | None = typer.Option(
@@ -37,6 +39,15 @@ def match_command(
     name_column: str = typer.Option(
         DEFAULT_NAME_COLUMN, "--name-column", help="Column in --file that holds company names."
     ),
+    phone_column: str | None = typer.Option(None, "--phone-column", help="Column in --file that holds phone numbers."),
+    city_column: str | None = typer.Option(None, "--city-column", help="Column in --file that holds cities."),
+    state_column: str | None = typer.Option(None, "--state-column", help="Column in --file that holds states."),
+    country_column: str | None = typer.Option(
+        None, "--country-column", help="Column in --file that holds country codes."
+    ),
+    zip_code_column: str | None = typer.Option(
+        None, "--zip-code-column", help="Column in --file that holds zip codes."
+    ),
     wait: bool = typer.Option(False, "--wait", help=WAIT_HELP),
     timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
@@ -59,6 +70,7 @@ def match_command(
                 state=state,
                 country=country,
                 zip_code=zip_code,
+                min_match_confidence=min_match_confidence,
                 strict=strict,
                 local_mode=local_mode,
             ),
@@ -68,6 +80,18 @@ def match_command(
 
     assert file is not None
     request = build_request(
-        MatchBulkParams, _merge_params(None, name_column=name_column, strict=strict, local_mode=local_mode)
+        MatchBulkParams,
+        _merge_params(
+            None,
+            name_column=name_column,
+            phone_column=phone_column,
+            city_column=city_column,
+            state_column=state_column,
+            country_column=country_column,
+            zip_code_column=zip_code_column,
+            min_match_confidence=min_match_confidence,
+            strict=strict,
+            local_mode=local_mode,
+        ),
     )
     run_job(client.match.bulk(request, file=file), wait=wait, timeout=timeout, fmt=fmt)
diff --git a/packages/discolike-cli/tests/test_company.py b/packages/discolike-cli/tests/test_company.py
index 729f6ca..3b51b18 100644
--- a/packages/discolike-cli/tests/test_company.py
+++ b/packages/discolike-cli/tests/test_company.py
@@ -144,3 +144,27 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     assert request.url.path == "/v1/extract"
     assert request.url.params.get("url") == "https://acme.com/about"
     assert json.loads(result.stdout) == {"text": "hello", "language": "en"}
+
+
+def test_extract_domain_option_replaces_url(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"text": "hello", "language": "en"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["extract", "--domain", "acme.com"])
+    assert result.exit_code == 0, result.output
+    params = captured["request"].url.params
+    assert params.get("domain") == "acme.com"
+    assert "url" not in params
+
+
+def test_extract_requires_exactly_one_of_url_or_domain(install_build_client: Callable[[Handler], None]) -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json={})
+
+    install_build_client(handler)
+    assert runner.invoke(app, ["extract"]).exit_code == 2
+    assert runner.invoke(app, ["extract", "https://acme.com", "--domain", "acme.com"]).exit_code == 2
diff --git a/packages/discolike-cli/tests/test_contacts_cli.py b/packages/discolike-cli/tests/test_contacts_cli.py
index 5a4acf7..d835bb8 100644
--- a/packages/discolike-cli/tests/test_contacts_cli.py
+++ b/packages/discolike-cli/tests/test_contacts_cli.py
@@ -76,6 +76,15 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     ]
 
 
+def test_contacts_search_icp_text_is_removed(install_build_client: Callable[[Handler], None]) -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json=[])
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "search", "--icp-text", "X"])
+    assert result.exit_code == 2
+
+
 def test_contacts_search_forwards_negate_options(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 
@@ -113,15 +122,6 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     assert params.get_list("negate_filter_country") == ["RU"]
 
 
-def test_contacts_search_icp_text_is_removed(install_build_client: Callable[[Handler], None]) -> None:
-    def handler(request: httpx2.Request) -> httpx2.Response:
-        return httpx2.Response(200, json=[])
-
-    install_build_client(handler)
-    result = runner.invoke(app, ["contacts", "search", "--icp-text", "X"])
-    assert result.exit_code == 2
-
-
 def test_contacts_search_unknown_param_passes_through(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 
@@ -346,3 +346,156 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     payload = json.loads(result.stdout)
     assert payload["task_id"] == "dg-1"
     assert payload["task_family"] == "discogen"
+
+
+NEW_CONTACT_FILTER_ARGS = [
+    "--name",
+    "Jane",
+    "--summary",
+    "scaled a sales org",
+    "--negate-summary",
+    "intern",
+    "--skills",
+    "SQL",
+    "--person-state",
+    "CA",
+    "--persona-id",
+    "7",
+    "--filter-state",
+    "TX",
+    "--negate-filter-state",
+    "NY",
+    "--email-validated",
+    "--has-phone",
+    "--no-has-mobile",
+    "--has-linkedin",
+    "--min-connections",
+    "500",
+    "--inclusion-query-id",
+    "q1",
+    "--exclusion-query-id",
+    "q2",
+    "--max-companies",
+    "10",
+    "--results-by-company",
+    "2",
+    "--include-search-contacts",
+    "--consensus",
+    "3",
+]
+
+
+def _assert_new_contact_filters(params: httpx2.QueryParams) -> None:
+    assert params.get("name") == "Jane"
+    assert params.get("summary") == "scaled a sales org"
+    assert params.get("negate_summary") == "intern"
+    assert params.get_list("skills") == ["SQL"]
+    assert params.get_list("person_state") == ["CA"]
+    assert params.get_list("persona_id") == ["7"]
+    assert params.get_list("filter_state") == ["TX"]
+    assert params.get_list("negate_filter_state") == ["NY"]
+    assert params.get("email_validated") == "true"
+    assert params.get("has_phone") == "true"
+    assert params.get("has_mobile") == "false"
+    assert params.get("has_linkedin") == "true"
+    assert params.get("min_connections") == "500"
+    assert params.get_list("inclusion_query_id") == ["q1"]
+    assert params.get_list("exclusion_query_id") == ["q2"]
+    assert params.get("max_companies") == "10"
+    assert params.get("results_by_company") == "2"
+    assert params.get("include_search_contacts") == "true"
+    assert params.get("consensus") == "3"
+
+
+def test_contacts_search_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return httpx2.Response(200, json=[])
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "search", *NEW_CONTACT_FILTER_ARGS])
+    assert result.exit_code == 0, result.output
+    _assert_new_contact_filters(captured["params"])
+
+
+def test_contacts_count_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return httpx2.Response(200, json={"count": 1})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "count", *NEW_CONTACT_FILTER_ARGS, "--max-records", "20", "--offset", "5"])
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    _assert_new_contact_filters(params)
+    assert params.get("max_records") == "20"
+    assert params.get("offset") == "5"
+
+
+def test_contacts_discover_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, object] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["body"] = json.loads(request.content)
+        return httpx2.Response(200, json={"results": {}, "total_contacts": 0})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "discover", *NEW_CONTACT_FILTER_ARGS])
+    assert result.exit_code == 0, result.output
+    assert captured["body"] == {
+        "name": "Jane",
+        "summary": "scaled a sales org",
+        "negate_summary": "intern",
+        "skills": ["SQL"],
+        "person_state": ["CA"],
+        "persona_id": [7],
+        "filter_state": ["TX"],
+        "negate_filter_state": ["NY"],
+        "email_validated": True,
+        "has_phone": True,
+        "has_mobile": False,
+        "has_linkedin": True,
+        "min_connections": 500,
+        "inclusion_query_id": ["q1"],
+        "exclusion_query_id": ["q2"],
+        "max_companies": 10,
+        "results_by_company": 2,
+        "include_search_contacts": True,
+        "consensus": 3,
+    }
+
+
+def test_contacts_generate_forwards_full_and_partial_domains(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, object] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["body"] = json.loads(request.content)
+        return httpx2.Response(200, json={"task_id": "dg-9"})
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "contacts",
+            "generate",
+            "--icp-text",
+            "VPs of Marketing",
+            "--domain",
+            "acme.com",
+            "--full-domain",
+            "done.com",
+            "--partial-domain",
+            "half.com",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert captured["body"] == {
+        "icp_text": "VPs of Marketing",
+        "domains": ["acme.com"],
+        "full_domains": ["done.com"],
+        "partial_domains": ["half.com"],
+    }
diff --git a/packages/discolike-cli/tests/test_discover.py b/packages/discolike-cli/tests/test_discover.py
index 7f3f8c9..edf001e 100644
--- a/packages/discolike-cli/tests/test_discover.py
+++ b/packages/discolike-cli/tests/test_discover.py
@@ -118,6 +118,120 @@ def test_discover_icp_text_option_removed(install_build_client: Callable[[Handle
     assert result.exit_code == 2
 
 
+def test_discover_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return _discover_ok(request)
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "discover",
+            "--subdomain",
+            "shop",
+            "--negate-subdomain",
+            "blog",
+            "--language",
+            "en",
+            "--negate-language",
+            "de",
+            "--social",
+            "linkedin",
+            "--negate-social",
+            "tiktok",
+            "--start-date",
+            "2020-01-01",
+            "--min-similarity",
+            "40",
+            "--variance",
+            "MEDIUM",
+            "--consensus",
+            "3",
+            "--redirect",
+            "--no-exclude-leadgen",
+            "--retrieval",
+            "--enhanced",
+            "--include-search-domains",
+            "--auto-icp-text",
+            "--auto-phrase-match",
+            "--inclusion-query-id",
+            "q1",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    assert params.get_list("subdomain") == ["shop"]
+    assert params.get_list("negate_subdomain") == ["blog"]
+    assert params.get_list("language") == ["en"]
+    assert params.get_list("negate_language") == ["de"]
+    assert params.get_list("social") == ["linkedin"]
+    assert params.get_list("negate_social") == ["tiktok"]
+    assert params.get("start_date") == "2020-01-01"
+    assert params.get("min_similarity") == "40"
+    assert params.get("variance") == "MEDIUM"
+    assert params.get("consensus") == "3"
+    assert params.get("redirect") == "true"
+    assert params.get("exclude_leadgen") == "false"
+    assert params.get("retrieval") == "true"
+    assert params.get("enhanced") == "true"
+    assert params.get("include_search_domains") == "true"
+    assert params.get("auto_icp_text") == "true"
+    assert params.get("auto_phrase_match") == "true"
+    assert params.get_list("inclusion_query_id") == ["q1"]
+
+
+def test_discover_rejects_invalid_variance(install_build_client: Callable[[Handler], None]) -> None:
+    install_build_client(_discover_ok)
+    result = runner.invoke(app, ["discover", "--variance", "BOGUS"])
+    assert result.exit_code == 2
+
+
+def test_count_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return _count_ok(request)
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "count",
+            "--subdomain",
+            "shop",
+            "--negate-subdomain",
+            "blog",
+            "--language",
+            "en",
+            "--negate-language",
+            "de",
+            "--social",
+            "linkedin",
+            "--negate-social",
+            "tiktok",
+            "--start-date",
+            "2020-01-01,2021-01-01",
+            "--no-redirect",
+            "--exclude-leadgen",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    assert params.get_list("subdomain") == ["shop"]
+    assert params.get_list("negate_subdomain") == ["blog"]
+    assert params.get_list("language") == ["en"]
+    assert params.get_list("negate_language") == ["de"]
+    assert params.get_list("social") == ["linkedin"]
+    assert params.get_list("negate_social") == ["tiktok"]
+    assert params.get("start_date") == "2020-01-01,2021-01-01"
+    assert params.get("redirect") == "false"
+    assert params.get("exclude_leadgen") == "true"
+
+
 def test_count_sends_shared_filter_subset(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 
diff --git a/packages/discolike-cli/tests/test_enrich_cli.py b/packages/discolike-cli/tests/test_enrich_cli.py
index 47fdab8..1cb3a3c 100644
--- a/packages/discolike-cli/tests/test_enrich_cli.py
+++ b/packages/discolike-cli/tests/test_enrich_cli.py
@@ -234,3 +234,40 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     install_build_client(handler)
     result = runner.invoke(app, ["segment"])
     assert result.exit_code == 2
+
+
+def test_append_forwards_query_id(tmp_path, install_build_client: Callable[[Handler], None]) -> None:
+    domains_file = tmp_path / "domains.csv"
+    domains_file.write_text("domain\nacme.com\n")
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json=[{"domain": "acme.com"}])
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app, ["append", str(domains_file), "--dataset", "bizdata", "--query-id", "q1", "--query-id", "q2"]
+    )
+    assert result.exit_code == 0, result.output
+    assert captured["request"].url.params.get_list("query_id") == ["q1", "q2"]
+
+
+def test_segment_forwards_query_id_for_domains_and_file(
+    tmp_path, install_build_client: Callable[[Handler], None]
+) -> None:
+    domains_file = tmp_path / "domains.csv"
+    domains_file.write_text("domain\nacme.com\n")
+    captured: list[httpx2.Request] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured.append(request)
+        return httpx2.Response(200, json={"task_id": "sg-1"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["segment", "--domain", "acme.com", "--query-id", "q1"])
+    assert result.exit_code == 0, result.output
+    result = runner.invoke(app, ["segment", "--file", str(domains_file), "--query-id", "q2"])
+    assert result.exit_code == 0, result.output
+    assert captured[0].url.params.get_list("query_id") == ["q1"]
+    assert captured[1].url.params.get_list("query_id") == ["q2"]
diff --git a/packages/discolike-cli/tests/test_match_cli.py b/packages/discolike-cli/tests/test_match_cli.py
index f53fcc2..482df97 100644
--- a/packages/discolike-cli/tests/test_match_cli.py
+++ b/packages/discolike-cli/tests/test_match_cli.py
@@ -217,3 +217,58 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     result = runner.invoke(app, ["match", "--file", str(names_file), "--local-mode"])
     assert result.exit_code == 0, result.output
     assert captured["request"].url.params.get("local_mode") == "true"
+
+
+def test_match_single_forwards_min_match_confidence(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"domain": "acme.com"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["match", "Acme", "--min-match-confidence", "80"])
+    assert result.exit_code == 0, result.output
+    assert captured["request"].url.params.get("min_match_confidence") == "80"
+
+
+def test_match_bulk_forwards_column_flags_and_confidence(
+    tmp_path, install_build_client: Callable[[Handler], None]
+) -> None:
+    names_file = tmp_path / "names.csv"
+    names_file.write_text("name,phone,city,state,country,zip\nAcme,555,Austin,TX,US,78701\n")
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"task_id": "bm-6"})
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "match",
+            "--file",
+            str(names_file),
+            "--phone-column",
+            "phone",
+            "--city-column",
+            "city",
+            "--state-column",
+            "state",
+            "--country-column",
+            "country",
+            "--zip-code-column",
+            "zip",
+            "--min-match-confidence",
+            "75",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["request"].url.params
+    assert params.get("phone_column") == "phone"
+    assert params.get("city_column") == "city"
+    assert params.get("state_column") == "state"
+    assert params.get("country_column") == "country"
+    assert params.get("zip_code_column") == "zip"
+    assert params.get("min_match_confidence") == "75"
diff --git a/packages/discolike-cli/tests/test_sdk_parity.py b/packages/discolike-cli/tests/test_sdk_parity.py
new file mode 100644
index 0000000..49926f9
--- /dev/null
+++ b/packages/discolike-cli/tests/test_sdk_parity.py
@@ -0,0 +1,99 @@
+"""Every SDK request field must be reachable as a first-class CLI flag.
+
+Reads the CLI source with ``ast`` rather than invoking typer, so a new field on
+a request model fails here until the matching command forwards it.
+"""
+
+from __future__ import annotations
+
+import ast
+import pathlib
+from collections.abc import Iterator
+
+import pytest
+
+import discolike.requests as requests_module
+
+CLI_SOURCE_DIR = pathlib.Path(__file__).resolve().parents[1] / "src" / "discolike_cli"
+REQUEST_BUILDER = "build_request"
+# icp_text was dropped from discover and contacts in 0.1.1 in favor of icp_prompt; see the *_icp_text_*_removed tests.
+DELIBERATELY_OMITTED: dict[str, frozenset[str]] = {
+    "DiscoverParams": frozenset({"icp_text"}),
+    "ContactsSearchParams": frozenset({"icp_text"}),
+    "ContactsCountParams": frozenset({"icp_text"}),
+    "ContactFilters": frozenset({"icp_text"}),
+}
+DICT_ONLY_FIELDS: dict[str, frozenset[str]] = {
+    "ContactGenerateRequest": frozenset({"initial_contact_counts"}),
+    "DiscoGenProcessRequest": frozenset({"previous_discogen_data"}),
+    "DiscoGenPersonaProcessRequest": frozenset({"previous_discogen_data"}),
+    "SaveResultsRequest": frozenset({"query_params"}),
+}
+
+
+def _keyword_names(call: ast.Call) -> set[str]:
+    return {keyword.arg for keyword in call.keywords if keyword.arg is not None}
+
+
+def _dict_keys(node: ast.Dict, assignments: dict[str, ast.Call]) -> set[str]:
+    keys: set[str] = set()
+    for key, value in zip(node.keys, node.values, strict=True):
+        if key is None:
+            keys |= _forwarded_fields(argument=value, assignments=assignments)
+        elif isinstance(key, ast.Constant) and isinstance(key.value, str):
+            keys.add(key.value)
+    return keys
+
+
+def _forwarded_fields(argument: ast.expr, assignments: dict[str, ast.Call]) -> set[str]:
+    if isinstance(argument, ast.Name) and argument.id in assignments:
+        argument = assignments[argument.id]
+    if isinstance(argument, ast.Call):
+        return _keyword_names(argument)
+    if isinstance(argument, ast.Dict):
+        return _dict_keys(node=argument, assignments=assignments)
+    return set()
+
+
+def _build_request_sites() -> Iterator[tuple[str, str, set[str]]]:
+    for source_file in sorted(CLI_SOURCE_DIR.glob("*.py")):
+        tree = ast.parse(source_file.read_text())
+        for function in (node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)):
+            assignments = {
+                node.targets[0].id: node.value
+                for node in ast.walk(function)
+                if isinstance(node, ast.Assign)
+                and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and isinstance(node.value, ast.Call)
+            }
+            for call in (node for node in ast.walk(function) if isinstance(node, ast.Call)):
+                callee = call.func.id if isinstance(call.func, ast.Name) else getattr(call.func, "attr", "")
+                if callee != REQUEST_BUILDER or not call.args or not isinstance(call.args[0], ast.Name):
+                    continue
+                forwarded: set[str] = set()
+                for argument in call.args[1:]:
+                    forwarded |= _forwarded_fields(argument=argument, assignments=assignments)
+                yield f"{source_file.stem}.{function.name}", call.args[0].id, forwarded
+
+
+SITES = list(_build_request_sites())
+
+
+@pytest.mark.parametrize(("site", "model_name", "forwarded"), SITES, ids=[f"{s}->{m}" for s, m, _ in SITES])
+def test_cli_forwards_every_sdk_field(site: str, model_name: str, forwarded: set[str]) -> None:
+    model = getattr(requests_module, model_name)
+    excluded = DICT_ONLY_FIELDS.get(model_name, frozenset()) | DELIBERATELY_OMITTED.get(model_name, frozenset())
+    expected = set(model.model_fields) - excluded
+    missing = sorted(expected - forwarded)
+    assert not missing, f"{site} does not forward {model_name} fields: {', '.join(missing)}"
+
+
+def test_every_request_model_has_a_cli_command() -> None:
+    used = {model_name for _, model_name, _ in SITES}
+    declared = {
+        name
+        for name in dir(requests_module)
+        if name.endswith(("Params", "Request")) and hasattr(getattr(requests_module, name), "model_fields")
+    }
+    assert not sorted(declared - used), f"request models with no CLI command: {sorted(declared - used)}"
diff --git a/packages/discolike/pyproject.toml b/packages/discolike/pyproject.toml
index d4cf14c..f18d1e9 100644
--- a/packages/discolike/pyproject.toml
+++ b/packages/discolike/pyproject.toml
@@ -34,7 +34,7 @@ classifiers = [
 ]
 
 [project.optional-dependencies]
-cli = ["discolike-cli==0.3.1"]
+cli = ["discolike-cli==0.3.2"]
 
 [project.urls]
 Homepage = "https://www.discolike.com"
diff --git a/packages/discolike/src/discolike/_generated/requests.py b/packages/discolike/src/discolike/_generated/requests.py
index e101402..59eb002 100644
--- a/packages/discolike/src/discolike/_generated/requests.py
+++ b/packages/discolike/src/discolike/_generated/requests.py
@@ -2535,10 +2535,10 @@ class CountParams(DiscolikeRequest):
     exclude_leadgen: Annotated[
         bool | None,
         Field(
-            description="Exclude suspected lead generation sites. Filters out profiles with score <= 25 that also lack phone, email, and social media presence.",
+            description="Exclude suspected lead generation sites. Filters out profiles with score <= 25 that also lack phone, email, and social media presence. Defaults to false for counts so they are not narrower than the filters given.",
             title="Exclude Leadgen",
         ),
-    ] = True
+    ] = False
 
 
 class FindEmailRequest(DiscolikeRequest):
diff --git a/packages/discolike/src/discolike/_version.py b/packages/discolike/src/discolike/_version.py
index 260c070..f9aa3e1 100644
--- a/packages/discolike/src/discolike/_version.py
+++ b/packages/discolike/src/discolike/_version.py
@@ -1 +1 @@
-__version__ = "0.3.1"
+__version__ = "0.3.2"
diff --git a/packages/discolike/tests/test_package.py b/packages/discolike/tests/test_package.py
index 1564e7a..69dd262 100644
--- a/packages/discolike/tests/test_package.py
+++ b/packages/discolike/tests/test_package.py
@@ -2,4 +2,4 @@
 
 
 def test_version() -> None:
-    assert discolike.__version__ == "0.3.1"
+    assert discolike.__version__ == "0.3.2"
diff --git a/uv.lock b/uv.lock
index d5ab293..efe280e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -374,7 +374,7 @@ dev = [
 
 [[package]]
 name = "discolike-cli"
-version = "0.3.1"
+version = "0.3.2"
 source = { editable = "packages/discolike-cli" }
 dependencies = [
     { name = "discolike" },