From d7f314ff7bd169fa24205f86973336acd7fb2aab Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 13:07:10 -0700
Subject: [PATCH 1/6] examples: cookbook of runnable GTM recipes

Six new scripts plus CLI one-liners covering the searches the API page
shows: seed-domain TAM, icp_prompt search, phrase match with count
first, CRM export enrichment, contacts at discovered companies, and an
agent opening the account through signup(). README is now one table
of script, purpose, and run command.
---
 examples/README.md                       | 30 +++++----
 examples/agent_signup_to_first_search.py | 71 ++++++++++++++++++++
 examples/cli_recipes.sh                  | 29 ++++++++
 examples/contacts_at_results.py          | 58 ++++++++++++++++
 examples/enrich_crm_export.py            | 84 ++++++++++++++++++++++++
 examples/icp_prompt_search.py            | 33 ++++++++++
 examples/phrase_match_count.py           | 36 ++++++++++
 examples/tam_from_seed_domains.py        | 66 +++++++++++++++++++
 8 files changed, 395 insertions(+), 12 deletions(-)
 create mode 100644 examples/agent_signup_to_first_search.py
 create mode 100644 examples/cli_recipes.sh
 create mode 100644 examples/contacts_at_results.py
 create mode 100644 examples/enrich_crm_export.py
 create mode 100644 examples/icp_prompt_search.py
 create mode 100644 examples/phrase_match_count.py
 create mode 100644 examples/tam_from_seed_domains.py

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()

From f03d9f6929b4578b04e7f706232004a211c30d94 Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 14:34:11 -0700
Subject: [PATCH 2/6] fix(sdk): CountParams.exclude_leadgen defaults to false

Regenerated against the platform spec; the SDK was sending true on every
count and narrowing results the caller never filtered out.
---
 CHANGELOG.md                                            | 4 ++++
 packages/discolike/src/discolike/_generated/requests.py | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f07f56..a20830b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## Unreleased
+
+- 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/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):

From d5fcba569b3734769f5c8ae74a602db3562cd7b7 Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 15:44:11 -0700
Subject: [PATCH 3/6] cli: every SDK request field gets a flag, parity enforced
 in tests

discover and count gained variance, min-similarity, consensus,
inclusion-query-id, language, social, subdomain, start-date, redirect,
exclude-leadgen and the auto-* toggles; contacts search, count, and
discover gained the full filter set; match gained per-column flags for
file mode and min-match-confidence; append and segment take query-id;
extract accepts --domain.

test_sdk_parity.py walks every build_request site with ast and fails
on any unforwarded field, so a new SDK field cannot ship without its
flag. icp_text stays out on purpose (dropped in 0.1.1 for icp_prompt)
and dict-typed fields remain --param only; both are allowlisted by
name.
---
 .../src/discolike_cli/company.py              |  15 +-
 .../src/discolike_cli/contacts.py             | 149 +++++++++++++++
 .../src/discolike_cli/discover.py             |  88 +++++++++
 .../discolike-cli/src/discolike_cli/enrich.py |  14 +-
 .../discolike-cli/src/discolike_cli/match.py  |  26 ++-
 packages/discolike-cli/tests/test_company.py  |  24 +++
 .../discolike-cli/tests/test_contacts_cli.py  | 171 +++++++++++++++++-
 packages/discolike-cli/tests/test_discover.py | 114 ++++++++++++
 .../discolike-cli/tests/test_enrich_cli.py    |  37 ++++
 .../discolike-cli/tests/test_match_cli.py     |  55 ++++++
 .../discolike-cli/tests/test_sdk_parity.py    |  99 ++++++++++
 11 files changed, 774 insertions(+), 18 deletions(-)
 create mode 100644 packages/discolike-cli/tests/test_sdk_parity.py

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..d27cc02 100644
--- a/packages/discolike-cli/src/discolike_cli/discover.py
+++ b/packages/discolike-cli/src/discolike_cli/discover.py
@@ -15,6 +15,18 @@
 
 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)."
 
 
 def _parse_param(raw: str) -> tuple[str, str | list[str]]:
@@ -45,8 +57,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 +74,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 +131,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 +177,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 +194,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=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 +216,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)}"

From c1bc338a82a30da29325a7a96f0339a8c40bdf91 Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 19:36:10 -0700
Subject: [PATCH 4/6] changelog: note CLI flag parity in Unreleased

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a20830b..4b98400 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- 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)

From cc52cd1eab3ed4de3709ec772062cad539658f55 Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 19:37:03 -0700
Subject: [PATCH 5/6] release: 0.3.2

---
 CHANGELOG.md                                 | 2 +-
 packages/discolike-cli/pyproject.toml        | 4 ++--
 packages/discolike/pyproject.toml            | 2 +-
 packages/discolike/src/discolike/_version.py | 2 +-
 packages/discolike/tests/test_package.py     | 2 +-
 uv.lock                                      | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4b98400..4bae8c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 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.
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/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/_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" },

From 9784f5ad4e627ad07736e5381abbff542b8623d1 Mon Sep 17 00:00:00 2001
From: Daniel Yudelevich <yudelevi@users.noreply.github.com>
Date: Wed, 2 Sep 2026 19:40:32 -0700
Subject: [PATCH 6/6] cli: count --exclude-leadgen help says off by default

The count command reused the discover help text, which says the
exclusion is on by default. CountParams now defaults it to false.
---
 packages/discolike-cli/src/discolike_cli/discover.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/discolike-cli/src/discolike_cli/discover.py b/packages/discolike-cli/src/discolike_cli/discover.py
index d27cc02..b9c2df1 100644
--- a/packages/discolike-cli/src/discolike_cli/discover.py
+++ b/packages/discolike-cli/src/discolike_cli/discover.py
@@ -27,6 +27,7 @@
 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]]:
@@ -196,7 +197,7 @@ def count_command(
     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=EXCLUDE_LEADGEN_HELP
+        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),