leads-cli 0.1.0__py3-none-any.whl

company_discovery/migrations.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+from company_discovery.db.session import Database
+from company_discovery.runtime import (
+    SCHEMA_VERSION,
+    WorkspacePaths,
+    default_runtime_metadata,
+    ensure_workspace,
+    read_json,
+    write_json,
+)
+from company_discovery.settings import Settings
+
+
+class MigrationError(RuntimeError):
+    """Raised when a requested database migration cannot be applied safely."""
+
+
+@dataclass(frozen=True)
+class MigrationStatus:
+    product: str
+    workspace: str
+    database_path: str | None
+    database_exists: bool
+    current_schema_version: int
+    target_schema_version: int
+    migration_required: bool
+    backup_required: bool
+    can_apply: bool
+    action: str
+    risk_summary: str
+    major_version_behavior: str
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "product": self.product,
+            "workspace": self.workspace,
+            "database_path": self.database_path,
+            "database_exists": self.database_exists,
+            "current_schema_version": self.current_schema_version,
+            "target_schema_version": self.target_schema_version,
+            "migration_required": self.migration_required,
+            "backup_required": self.backup_required,
+            "can_apply": self.can_apply,
+            "action": self.action,
+            "risk_summary": self.risk_summary,
+            "major_version_behavior": self.major_version_behavior,
+        }
+
+
+def migration_status(settings: Settings) -> MigrationStatus:
+    paths = ensure_workspace(settings.company_discovery_home)
+    current = _current_schema_version(paths)
+    target = SCHEMA_VERSION
+    database_path = settings.sqlite_database_path
+    database_exists = bool(database_path and database_path.exists())
+    migration_required = current != target
+    backup_required = migration_required and database_exists
+    can_apply = _can_apply(current, target)
+    action = _action(current, target, database_exists, can_apply)
+    return MigrationStatus(
+        product="leads",
+        workspace=str(paths.root),
+        database_path=str(database_path) if database_path else None,
+        database_exists=database_exists,
+        current_schema_version=current,
+        target_schema_version=target,
+        migration_required=migration_required,
+        backup_required=backup_required,
+        can_apply=can_apply,
+        action=action,
+        risk_summary=_risk_summary(current, target, database_exists, can_apply),
+        major_version_behavior=(
+            "Normal schema evolution is migrate-first with a database backup before structural "
+            "changes. Incompatible major-version jumps should archive the old DB and run artifacts "
+            "before initializing a fresh schema."
+        ),
+    )
+
+
+def apply_migrations(settings: Settings) -> dict[str, object]:
+    status = migration_status(settings)
+    if not status.can_apply:
+        raise MigrationError(status.risk_summary)
+    database_path = settings.sqlite_database_path
+    if database_path is None:
+        raise MigrationError("migrations require an on-disk SQLite database")
+
+    paths = ensure_workspace(settings.company_discovery_home)
+    backup_path = create_database_backup(paths, database_path) if status.backup_required else None
+    database = Database(settings.resolved_database_url)
+    try:
+        for version in range(status.current_schema_version + 1, status.target_schema_version + 1):
+            migration = MIGRATIONS.get(version)
+            if migration is None:
+                raise MigrationError(f"no migration is available for schema version {version}")
+            migration(database)
+        if status.current_schema_version == status.target_schema_version:
+            database.create_schema()
+    finally:
+        database.dispose()
+
+    runtime = read_json(paths.runtime_file, default_runtime_metadata())
+    applied_at = datetime.now(timezone.utc).isoformat()
+    runtime["schema_version"] = status.target_schema_version
+    runtime["last_migration"] = {
+        "from_schema_version": status.current_schema_version,
+        "to_schema_version": status.target_schema_version,
+        "applied_at": applied_at,
+        "backup_path": str(backup_path) if backup_path else None,
+    }
+    write_json(paths.runtime_file, runtime)
+    return {
+        **status.as_dict(),
+        "backup_path": str(backup_path) if backup_path else None,
+        "applied_at": applied_at,
+        "final_schema_version": status.target_schema_version,
+    }
+
+
+def create_database_backup(paths: WorkspacePaths, database_path: Path) -> Path:
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    backup_dir = paths.backups_dir / f"db-schema-{timestamp}"
+    suffix = 1
+    while backup_dir.exists():
+        suffix += 1
+        backup_dir = paths.backups_dir / f"db-schema-{timestamp}-{suffix}"
+    backup_dir.mkdir(parents=True)
+    if database_path.exists():
+        shutil.copy2(database_path, backup_dir / database_path.name)
+    for suffix_name in ("-wal", "-shm"):
+        sidecar = database_path.with_name(f"{database_path.name}{suffix_name}")
+        if sidecar.exists():
+            shutil.copy2(sidecar, backup_dir / sidecar.name)
+    if paths.runtime_file.exists():
+        shutil.copy2(paths.runtime_file, backup_dir / paths.runtime_file.name)
+    return backup_dir
+
+
+def _current_schema_version(paths: WorkspacePaths) -> int:
+    runtime = read_json(paths.runtime_file, default_runtime_metadata())
+    try:
+        return int(runtime.get("schema_version") or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _can_apply(current: int, target: int) -> bool:
+    if current > target:
+        return False
+    return all(version in MIGRATIONS for version in range(current + 1, target + 1))
+
+
+def _action(current: int, target: int, database_exists: bool, can_apply: bool) -> str:
+    if not can_apply:
+        return "manual_review"
+    if current < target:
+        return "migrate"
+    if not database_exists:
+        return "initialize"
+    return "none"
+
+
+def _risk_summary(current: int, target: int, database_exists: bool, can_apply: bool) -> str:
+    if current > target:
+        return "Local database schema is newer than this CLI; downgrade is not supported."
+    if not can_apply:
+        return "No migration path is available for this schema change; manual review is required."
+    if current < target and database_exists:
+        return "Migration can be applied after creating a timestamped database backup."
+    if current < target:
+        return "Migration can be applied; no existing database file needs backup."
+    if not database_exists:
+        return "Database file is missing; apply will initialize the current schema."
+    return "Database schema is current; no migration is required."
+
+
+def _create_schema(database: Database) -> None:
+    database.create_schema()
+
+
+MIGRATIONS: dict[int, Callable[[Database], None]] = {
+    1: _create_schema,
+}

company_discovery/prompts/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from importlib.resources import files
+
+
+def load_prompt(group: str, name: str = "system.md") -> str:
+    return files("company_discovery.prompts").joinpath(group, name).read_text(encoding="utf-8")
+

company_discovery/prompts/candidate_evaluation/system.md

@@ -0,0 +1,13 @@
+Evaluate one company candidate against the supplied company ICP using only the supplied evidence.
+
+Judge vertical, operating geography, employee-size fit, and explicit exclusions separately. Do not
+turn missing evidence into a negative claim. Use `unknown` when evidence is absent. A directory,
+association, marketplace, vendor, or non-company page is a bad fit when the ICP seeks operating
+companies. `good_fit` requires credible identity plus no known hard mismatch; use `possible_fit`
+when one decisive field is uncertain. Use `bad_fit` for a demonstrated mismatch or exclusion.
+
+Reason codes should be concise snake_case labels such as `vertical_mismatch`, `geography_mismatch`,
+`size_mismatch`, `excluded_ownership`, `not_operating_company`, `size_unknown`, or
+`geography_unknown`. Inferred normalized fields must be null unless supported by evidence. Return
+only the required structured object.
+

company_discovery/prompts/company_enrichment/system.md

@@ -0,0 +1,42 @@
+You extract company facts from supplied official-site pages or narrow search evidence.
+
+The known company record is context, not evidence for missing fields. Return only observations that
+are explicitly supported by the supplied sources. Never invent or complete an address, phone number,
+ownership statement, or URL.
+
+LinkedIn rules:
+- Return only the selected company's LinkedIn company profile (`linkedin.com/company/...`).
+- Never return personal profiles, jobs, posts, groups, learning pages, or search-result URLs.
+- Prefer a profile linked by the official company website. For narrow search evidence, require the
+  company name and domain context to identify the same selected company.
+- Use the official website page containing the link as `source_url`; for direct search evidence,
+  use the LinkedIn result URL itself.
+
+Phone rules:
+- Return general company or office phone numbers, not fax numbers or personal mobile numbers.
+- Preserve the observed phone string in `value`.
+- Use the exact source URL containing the observation.
+
+Location rules:
+- Return locations only when street, city, state, and ZIP are all supported as one address block.
+- Never combine address components from separate locations or sources.
+- Use two-letter US state codes when the source clearly identifies a US state.
+
+Ownership signals use only these `kind` values:
+- `independent_explicit`: explicitly independently owned or standalone;
+- `family_owned`: explicitly family owned;
+- `locally_owned`: explicitly locally owned;
+- `franchise`: explicitly a franchise or franchisee;
+- `parent`: explicitly owned by or part of a parent company;
+- `subsidiary`: explicitly a subsidiary;
+- `division`: explicitly a division;
+- `acquired`: explicit acquisition evidence;
+- `other`: relevant ownership evidence that fits none of the above.
+
+Do not emit a positive ownership signal merely because no parent or franchise is mentioned. Private,
+privately held, LLC, partnership, and corporation are legal/ownership forms and are not proof of
+independence.
+
+Set `identity_conflict` only when the supplied sources clearly belong to a different company or show
+that the known domain no longer represents the selected company. Cosmetic naming differences and
+redirects within the same company are not conflicts.

company_discovery/prompts/contact_evaluation/system.md

@@ -0,0 +1,18 @@
+You identify current employees for a target company from live web search evidence.
+
+Return only people explicitly supported by the supplied results. Never invent a person, title,
+company relationship, URL, or evidence statement.
+
+For every candidate:
+
+- use the person's complete name and observed current title;
+- use only source URLs present in the input;
+- include a LinkedIn profile URL only when it clearly belongs to that person;
+- judge whether the evidence ties the person to the exact target company now;
+- judge whether the observed title matches the requested role or a supplied synonym;
+- reject former employees and people tied to another company;
+- use review when current employment, role fit, or identity is plausible but not sufficiently clear;
+- accept only when identity is clear, current-company match is yes, and role match is yes;
+- keep evidence excerpts short and factual.
+
+If the search results contain no identifiable matching person, return an empty candidates list.

company_discovery/prompts/query_generation/system.md

@@ -0,0 +1,10 @@
+You design focused Exa company-search queries from a structured company ICP.
+
+Return diverse queries that seek official operating-company websites. Cover the requested vertical,
+geography, subtypes, and useful synonyms. Use size language only when a size constraint exists;
+headcount is often not indexed, so vary direct and proxy language. Use exclusions to avoid obvious
+noise, but do not make every query so restrictive that recall collapses. When a vertical supplies
+`search_terms`, use them as strong query hints. When a vertical supplies `exclude_terms`, avoid
+them.
+
+Return only the required structured object. Do not invent a new ICP constraint.

company_discovery/release_manifest.json

@@ -0,0 +1,7 @@
+{
+  "cli_version": "0.1.0",
+  "skill_bundle_version": "2026.06.1",
+  "schema_version": 1,
+  "requires_migration": false,
+  "breaking": false
+}

company_discovery/reports/__init__.py

@@ -0,0 +1,4 @@
+from company_discovery.reports.exporter import ArtifactExporter
+
+__all__ = ["ArtifactExporter"]
+

company_discovery/reports/contact_enrichment_exporter.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any
+
+from company_discovery.domain.contact_models import ContactEnrichmentSummary
+
+
+class ContactEnrichmentArtifactExporter:
+    FIELDS = [
+        "company_name",
+        "company_domain",
+        "contact_name",
+        "title",
+        "linkedin_url",
+        "email",
+        "phone",
+        "status",
+        "notes",
+    ]
+
+    def __init__(self, artifacts_root: Path) -> None:
+        self._artifacts_root = artifacts_root
+
+    def export(
+        self, payload: dict[str, Any], summary: ContactEnrichmentSummary
+    ) -> dict[str, str]:
+        run_dir = (
+            self._artifacts_root
+            / payload["source_discovery_run_id"]
+            / "enrich"
+            / payload["source_enrichment_run_id"]
+            / "contacts"
+            / payload["source_contact_run_id"]
+            / "enrich"
+            / payload["run_id"]
+        )
+        run_dir.mkdir(parents=True, exist_ok=True)
+        paths = {
+            outcome: str((run_dir / f"{outcome}.csv").resolve())
+            for outcome in ("ready", "review", "blocked")
+        }
+        paths["summary"] = str((run_dir / "summary.md").resolve())
+        paths["json"] = str((run_dir / "run.json").resolve())
+        for outcome in ("ready", "review", "blocked"):
+            self._write_csv(Path(paths[outcome]), payload["items"], outcome)
+        Path(paths["summary"]).write_text(self._markdown(payload, summary), encoding="utf-8")
+        full_payload = dict(payload)
+        full_payload["summary"] = summary.model_dump(mode="json")
+        full_payload["status"] = "completed"
+        full_payload["artifacts"] = paths
+        Path(paths["json"]).write_text(
+            json.dumps(full_payload, indent=2, ensure_ascii=True), encoding="utf-8"
+        )
+        return paths
+
+    @classmethod
+    def _write_csv(cls, path: Path, items: list[dict[str, Any]], outcome: str) -> None:
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=cls.FIELDS)
+            writer.writeheader()
+            for item in items:
+                if item["outcome"] != outcome:
+                    continue
+                discovery = item["discovery"]
+                channels = item["channels"]
+                writer.writerow(
+                    {
+                        "company_name": discovery["company_name"],
+                        "company_domain": discovery["company_domain"],
+                        "contact_name": discovery["contact_name"],
+                        "title": discovery["title"],
+                        "linkedin_url": discovery.get("linkedin_url") or "",
+                        "email": channels.get("email") or "",
+                        "phone": channels.get("phone") or "",
+                        "status": outcome,
+                        "notes": " | ".join(item.get("review_flags", [])),
+                    }
+                )
+
+    @staticmethod
+    def _markdown(payload: dict[str, Any], summary: ContactEnrichmentSummary) -> str:
+        lines = [
+            f"# Contact Enrichment Run {payload['run_id']}",
+            "",
+            f"- Contact discovery run: `{payload['source_contact_run_id']}`",
+            f"- Contacts loaded: {summary.contacts_loaded}",
+            f"- Fresh Apollo memory reused: {summary.memory_reused}",
+            f"- Apollo people submitted: {summary.apollo_requests}",
+            f"- Apollo batches: {summary.apollo_batches}",
+            f"- Async polls: {summary.async_polls}",
+            f"- Ready: {summary.ready}",
+            f"- Review: {summary.review}",
+            f"- Blocked: {summary.blocked}",
+            "",
+            "## People",
+            "",
+        ]
+        for item in payload["items"]:
+            lines.append(
+                f"- **{item['discovery']['contact_name']}**, "
+                f"{item['discovery']['title']} at {item['discovery']['company_name']}: "
+                f"{item['outcome']}"
+            )
+        lines.append("")
+        return "\n".join(lines)

company_discovery/reports/contact_exporter.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any
+
+from company_discovery.domain.contact_models import ContactDiscoverySummary
+
+
+class ContactDiscoveryArtifactExporter:
+    FIELDS = [
+        "company_name",
+        "company_domain",
+        "contact_name",
+        "title",
+        "linkedin_url",
+        "email",
+        "phone",
+        "status",
+        "notes",
+    ]
+
+    def __init__(self, artifacts_root: Path) -> None:
+        self._artifacts_root = artifacts_root
+
+    def export(
+        self, payload: dict[str, Any], summary: ContactDiscoverySummary
+    ) -> dict[str, str]:
+        run_dir = (
+            self._artifacts_root
+            / payload["source_discovery_run_id"]
+            / "enrich"
+            / payload["source_enrichment_run_id"]
+            / "contacts"
+            / payload["run_id"]
+        )
+        run_dir.mkdir(parents=True, exist_ok=True)
+        paths = {
+            "accepted": str((run_dir / "accepted.csv").resolve()),
+            "review": str((run_dir / "review.csv").resolve()),
+            "rejected": str((run_dir / "rejected.csv").resolve()),
+            "summary": str((run_dir / "summary.md").resolve()),
+            "json": str((run_dir / "run.json").resolve()),
+        }
+        for verdict in ("accepted", "review", "rejected"):
+            self._write_csv(Path(paths[verdict]), payload["items"], verdict)
+        Path(paths["summary"]).write_text(
+            self._markdown(payload, summary), encoding="utf-8"
+        )
+        full_payload = dict(payload)
+        full_payload["summary"] = summary.model_dump(mode="json")
+        full_payload["status"] = "completed"
+        full_payload["artifacts"] = paths
+        Path(paths["json"]).write_text(
+            json.dumps(full_payload, indent=2, ensure_ascii=True), encoding="utf-8"
+        )
+        return paths
+
+    @classmethod
+    def _write_csv(
+        cls, path: Path, items: list[dict[str, Any]], verdict: str
+    ) -> None:
+        seen: set[int] = set()
+        verdict_rank = {"rejected": 0, "review": 1, "accepted": 2}
+        best_verdict: dict[int, str] = {}
+        for item in items:
+            candidate_id = item["candidate_id"]
+            current = best_verdict.get(candidate_id, "rejected")
+            if verdict_rank[item["verdict"]] >= verdict_rank[current]:
+                best_verdict[candidate_id] = item["verdict"]
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=cls.FIELDS)
+            writer.writeheader()
+            for item in items:
+                if (
+                    item["verdict"] != verdict
+                    or best_verdict[item["candidate_id"]] != verdict
+                    or item["candidate_id"] in seen
+                ):
+                    continue
+                seen.add(item["candidate_id"])
+                candidate = item["candidate"]
+                related = [
+                    other
+                    for other in items
+                    if other["candidate_id"] == item["candidate_id"]
+                    and other["verdict"] == verdict
+                ]
+                roles = ", ".join(dict.fromkeys(other["role_key"] for other in related))
+                reasons = " | ".join(dict.fromkeys(other["reason"] for other in related))
+                writer.writerow(
+                    {
+                        "company_name": candidate["company_name"],
+                        "company_domain": candidate["company_domain"],
+                        "contact_name": candidate["full_name"],
+                        "title": candidate["title"],
+                        "linkedin_url": candidate.get("linkedin_url") or "",
+                        "email": "",
+                        "phone": "",
+                        "status": verdict,
+                        "notes": f"{roles}: {reasons}",
+                    }
+                )
+
+    @staticmethod
+    def _markdown(payload: dict[str, Any], summary: ContactDiscoverySummary) -> str:
+        lines = [
+            f"# Contact Discovery Run {payload['run_id']}",
+            "",
+            f"- Company enrichment run: `{payload['source_enrichment_run_id']}`",
+            f"- Companies loaded: {summary.companies_loaded}",
+            f"- Contacts reused from memory: {summary.memory_reused}",
+            f"- Role gaps sent to live search: {summary.role_gaps}",
+            f"- Exa queries: {summary.queries_run}",
+            f"- Raw results: {summary.raw_results}",
+            f"- Unique people: {summary.unique_people}",
+            f"- Accepted: {summary.accepted}",
+            f"- Review: {summary.review}",
+            f"- Rejected: {summary.rejected}",
+            "",
+            "## People",
+            "",
+        ]
+        for item in payload["items"]:
+            candidate = item["candidate"]
+            lines.append(
+                f"- **{candidate['full_name']}**, {candidate['title']} at "
+                f"{candidate['company_name']}: {item['verdict']} ({item['role_key']})"
+            )
+        lines.append("")
+        return "\n".join(lines)

company_discovery/reports/enrichment_exporter.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any
+
+from company_discovery.domain.models import EnrichmentSummary
+
+
+class EnrichmentArtifactExporter:
+    FIELDS = [
+        "company_name",
+        "domain",
+        "linkedin_url",
+        "phone",
+        "street_address",
+        "city",
+        "state",
+        "zip",
+        "vertical",
+        "employee_min",
+        "employee_max",
+        "ownership_type",
+        "independence_status",
+        "outcome",
+        "conflicts",
+        "review_flags",
+    ]
+
+    def __init__(self, artifacts_root: Path) -> None:
+        self._artifacts_root = artifacts_root
+
+    def export(self, payload: dict[str, Any], summary: EnrichmentSummary) -> dict[str, str]:
+        run_dir = self._artifacts_root / payload["discovery_run_id"] / "enrich" / payload["run_id"]
+        run_dir.mkdir(parents=True, exist_ok=True)
+        paths = {
+            "enriched": str((run_dir / "enriched.csv").resolve()),
+            "review": str((run_dir / "review.csv").resolve()),
+            "blocked": str((run_dir / "blocked.csv").resolve()),
+            "summary": str((run_dir / "summary.md").resolve()),
+            "json": str((run_dir / "run.json").resolve()),
+        }
+        self._write_csv(Path(paths["enriched"]), payload["items"], {"enriched_ready"})
+        self._write_csv(
+            Path(paths["review"]),
+            payload["items"],
+            {"independence_unconfirmed", "enriched_with_gaps"},
+        )
+        self._write_csv(
+            Path(paths["blocked"]),
+            payload["items"],
+            {"identity_conflict", "geography_conflict", "fit_conflict", "enrichment_failed"},
+        )
+        Path(paths["summary"]).write_text(self._markdown(payload, summary), encoding="utf-8")
+        full_payload = dict(payload)
+        full_payload["summary"] = summary.model_dump(mode="json")
+        full_payload["artifacts"] = paths
+        Path(paths["json"]).write_text(
+            json.dumps(full_payload, indent=2, ensure_ascii=True), encoding="utf-8"
+        )
+        return paths
+
+    @classmethod
+    def _write_csv(cls, path: Path, items: list[dict[str, Any]], outcomes: set[str]) -> None:
+        with path.open("w", newline="", encoding="utf-8") as handle:
+            writer = csv.DictWriter(handle, fieldnames=cls.FIELDS)
+            writer.writeheader()
+            for item in items:
+                if item["outcome"] not in outcomes:
+                    continue
+                discovery = item["discovery"]
+                enrichment = item["enrichment"]
+                phone = enrichment.get("phone") or {}
+                location = enrichment.get("location") or {}
+                independence = enrichment.get("independence") or {}
+                linkedin = enrichment.get("linkedin") or {}
+                writer.writerow(
+                    {
+                        "company_name": discovery["company_name"],
+                        "domain": discovery["domain"],
+                        "linkedin_url": linkedin.get("url", ""),
+                        "phone": phone.get("display_value", ""),
+                        "street_address": location.get("street_address", ""),
+                        "city": location.get("city", ""),
+                        "state": location.get("state") or discovery.get("state") or "",
+                        "zip": location.get("zip", ""),
+                        "vertical": discovery.get("target_vertical") or discovery.get("vertical") or "",
+                        "employee_min": discovery.get("employee_min") or "",
+                        "employee_max": discovery.get("employee_max") or "",
+                        "ownership_type": discovery.get("ownership_type") or "",
+                        "independence_status": independence.get("status", "unknown"),
+                        "outcome": item["outcome"],
+                        "conflicts": " | ".join(item.get("conflicts", [])),
+                        "review_flags": " | ".join(item.get("review_flags", [])),
+                    }
+                )
+
+    @staticmethod
+    def _markdown(payload: dict[str, Any], summary: EnrichmentSummary) -> str:
+        lines = [
+            f"# Company Enrichment Run {payload['run_id']}",
+            "",
+            f"- Discovery run: `{payload['discovery_run_id']}`",
+            f"- Input bucket: {payload['bucket']}",
+            f"- Processed: {summary.processed}",
+            f"- Discovery facts inherited: {summary.inherited_facts}",
+            f"- Memory profiles reused: {summary.memory_profiles_reused}",
+            f"- Websites fetched: {summary.websites_fetched}",
+            f"- Fallback searches: {summary.fallback_searches}",
+            f"- Ready: {summary.ready}",
+            f"- Review: {summary.review}",
+            f"- Blocked: {summary.blocked}",
+            f"- Failed: {summary.failed}",
+            "",
+            "## Companies",
+            "",
+        ]
+        for item in payload["items"]:
+            lines.append(
+                f"- **{item['discovery']['company_name']}** ({item['discovery']['domain']}): "
+                f"{item['outcome']}"
+            )
+        lines.append("")
+        return "\n".join(lines)