lcp-reference-platform 1.0.0__tar.gz → 1.0.2__tar.gz

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/.gitignore

@@ -3,6 +3,7 @@
 
 # Local tooling artifacts — never published
 .gitnexus/
+.freebuff/
 .claude/
 graphify-out/
 CLAUDE.md
@@ -14,3 +15,8 @@ __pycache__/
 .venv/
 data/
 *.sqlite3
+
+# SDK build artifacts (Maven/Gradle) — never published
+implementations/sdk/java/target/
+implementations/sdk/kotlin/.gradle/
+implementations/sdk/kotlin/build/

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcp-reference-platform
-Version: 1.0.0
+Version: 1.0.2
 Summary: Production-oriented reference platform and router for LCP Lead Context Protocol deployments.
 Project-URL: Documentation, https://github.com/SpearSystems/LCP
 Project-URL: Source, https://github.com/SpearSystems/LCP

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/README.md

@@ -18,7 +18,8 @@ hardening.
 - Structured call payable evaluation and per-offer monthly quota reporting.
 - JSON Schema and strict ping-safe validation.
 - Bearer API-key and HMAC authentication.
-- Deterministic offer matching and auction selection.
+- Deterministic offer matching and auction selection, including versioned
+  `lcp.platform.requirements` and `lcp.platform.service_area` extensions.
 - At-least-once buyer webhook delivery.
 - Standalone delivery worker for multi-process deployments.
 - WSGI entry point for a production HTTP process manager.
@@ -126,7 +127,10 @@ lcp-platform-admin privacy erase-lead --lead-id lead_abc123 --actor-id privacy_o
 ```
 
 Offer management is intentionally an operator/admin concern. The public LCP
-surface exposes active offers through `GET /v1/lcp/offers`.
+surface exposes active offers through `GET /v1/lcp/offers`. For fast-changing
+buyer requirements, use the versioned [requirement profiles and service areas](../../docs/REQUIREMENT-PROFILES.md)
+without expanding the universal core or creating a new vertical for each
+category.
 
 ## Run locally
 
@@ -167,6 +171,38 @@ gunicorn --bind 0.0.0.0:8080 --workers 3 --threads 4 \
   --access-logfile - lcp_platform.wsgi:application
 ```
 
+The WSGI path handles binary attachments with the same behavior as the local
+server: the attachment body limit (`LCP_MAX_ATTACHMENT_BYTES`) is selected
+before `wsgi.input` is read, downloads stream raw encrypted bytes (never
+`json.dumps`), and binary headers (`Content-Type`, `Content-Disposition`,
+`Content-Length`) are forwarded. Upload and download with curl:
+
+```bash
+export LCP_ATTACHMENT_FILE=scanned-evidence.pdf
+export LCP_ATTACHMENT_ID=att_evidence_001
+export LCP_ATTACHMENT_SHA256="$(sha256sum "$LCP_ATTACHMENT_FILE" | cut -d' ' -f1)"
+
+# Upload: Bearer-authenticated raw bytes. The route's body limit applies before
+# wsgi.input is read; replace the lead and sender IDs with your own values.
+curl -sS -X POST "$LCP_ENDPOINT/v1/lcp/attachments" \
+  -H "Authorization: Bearer $LCP_API_KEY" \
+  -H "X-LCP-Sender-Id: publisher_001" \
+  -H "X-LCP-Lead-Id: <lead_id>" \
+  -H "X-LCP-Attachment-Id: $LCP_ATTACHMENT_ID" \
+  -H "X-LCP-Attachment-Purpose: supporting_document" \
+  -H "X-LCP-Filename: $LCP_ATTACHMENT_FILE" \
+  -H "X-LCP-Content-SHA256: $LCP_ATTACHMENT_SHA256" \
+  -H "X-LCP-Idempotency-Key: publisher-attachment-001" \
+  -H "Content-Type: application/pdf" \
+  --data-binary @"$LCP_ATTACHMENT_FILE"
+
+# Download: bytes are returned unchanged with the original content headers.
+curl -sS "$LCP_ENDPOINT/v1/lcp/attachments/$LCP_ATTACHMENT_ID" \
+  -H "Authorization: Bearer $LCP_API_KEY" \
+  -H "X-LCP-Sender-Id: publisher_001" \
+  -o evidence.bin
+```
+
 Run `lcp-platform-worker` as a separate supervised process. Place the
 application behind TLS; the included threaded server is intended for local
 operation and smoke tests.
@@ -189,12 +225,47 @@ multiple nodes or high throughput.
 | `GET` | `/v1/lcp/leads/{lead_id}` | Lead status and lifecycle |
 | `GET` | `/health/live` | Unauthenticated process liveness |
 | `GET` | `/health/ready` | Database-backed readiness |
+| `GET` | `/v1/lcp/metrics` | Admin-scoped aggregate worker and retention metrics |
 | `GET` | `/v1/lcp/capabilities` | Capability discovery |
 | `GET` | `/v1/lcp/offers` | Active offer discovery |
 | `GET` | `/v1/lcp/schemas/{name}` | Schema discovery |
 
 The complete transport contract is [api/lcp-openapi.yaml](../../api/lcp-openapi.yaml).
 
+`/v1/lcp/metrics` requires the `platform:admin` scope in an authenticated
+production deployment. It returns queue age, retry depth, lease expiry,
+attachment scanner/deletion backlog, and dead-letter counts only; it never
+returns lead IDs, buyer IDs, tenant IDs, URLs, or consumer payloads.
+
+Exhausted delivery and routing jobs are durable dead letters. Operators can
+inspect and recover them without reading payloads:
+
+```bash
+lcp-platform-admin dead-letter list --status OPEN
+lcp-platform-admin dead-letter quarantine --job-id <job-id>
+lcp-platform-admin dead-letter replay --job-id <job-id>
+```
+
+Lifecycle events are role-scoped and idempotent. A delivered buyer reports
+`ACCEPTED`/`REJECTED`/`DISPUTED`; the publisher reports `CONSENT_WITHDRAWN`
+and `ERASURE_REQUEST`; every applied transition writes an audit record with
+actor, event, and previous status. Status reads are projected by role — a
+buyer sees only its own match decisions, payables, and events:
+
+```bash
+# Buyer confirms the delivered lead (event -> audit row lead.accepted).
+curl -sS -X POST "$LCP_ENDPOINT/v1/lcp/events" \
+  -H "Authorization: Bearer $LCP_API_KEY" \
+  -H "X-LCP-Sender-Id: buyer_001" \
+  -H "X-LCP-Idempotency-Key: buyer-accept-001" \
+  -H "Content-Type: application/json" \
+  -d '{"lcp":{"version":"1.0.0","message":{"type":"event","id":"<uuid>","timestamp":"2026-08-18T00:00:00Z","sender_id":"buyer_001","receiver_id":"platform_001","idempotency_key":"buyer-accept-001"},"payload":{"lead_id":"<lead_id>","event":"ACCEPTED","timestamp":"2026-08-18T00:00:00Z"}}}'
+
+# Publisher reads status; the response contains only publisher-scoped data.
+curl -sS "$LCP_ENDPOINT/v1/lcp/leads/<lead_id>" \
+  -H "Authorization: Bearer $LCP_API_KEY"
+```
+
 ## Tenant and credential model
 
 Every sender has a tenant ID and scopes. Examples include `lead:submit`,

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/lcp_platform/__init__.py

@@ -14,4 +14,4 @@ __all__ = [
     "PublisherNormalizer",
     "RequestError",
 ]
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/lcp_platform/admin.py

@@ -35,6 +35,16 @@ def main() -> None:
     erase_lead.add_argument("--lead-id", required=True)
     erase_lead.add_argument("--actor-id", default="operator")
 
+    dead_letter = commands.add_parser("dead-letter", help="Inspect and recover exhausted worker jobs")
+    dead_letter_sub = dead_letter.add_subparsers(dest="dead_letter_command", required=True)
+    list_dead_letter = dead_letter_sub.add_parser("list")
+    list_dead_letter.add_argument(
+        "--status", choices=["OPEN", "QUARANTINED", "REPLAYED"], default=None
+    )
+    for command_name in ("quarantine", "replay"):
+        command = dead_letter_sub.add_parser(command_name)
+        command.add_argument("--job-id", required=True)
+
     mapping = commands.add_parser("mapping", help="Manage publisher form mappings")
     mapping_sub = mapping.add_subparsers(dest="mapping_command", required=True)
     upsert_mapping = mapping_sub.add_parser("upsert")
@@ -70,6 +80,17 @@ def main() -> None:
             if args.privacy_command == "erase-lead":
                 platform.erase_lead(args.lead_id, actor_id=args.actor_id)
                 print(f"Erased lead {args.lead_id}")
+        elif args.command == "dead-letter":
+            if args.dead_letter_command == "list":
+                print(json.dumps(platform.store.list_dead_letters(args.status), indent=2))
+            elif args.dead_letter_command == "quarantine":
+                if not platform.store.quarantine_dead_letter(args.job_id):
+                    raise SystemExit(f"Dead-letter job not found or already closed: {args.job_id}")
+                print(f"Quarantined dead-letter job {args.job_id}")
+            elif args.dead_letter_command == "replay":
+                if not platform.store.replay_dead_letter(args.job_id):
+                    raise SystemExit(f"Dead-letter job cannot be replayed: {args.job_id}")
+                print(f"Replayed dead-letter job {args.job_id}")
         elif args.command == "mapping":
             with args.file.open(encoding="utf-8") as handle:
                 mapping_data = json.load(handle)

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/lcp_platform/matching.py

@@ -7,6 +7,9 @@ from datetime import datetime, timezone
 from typing import Any
 from zoneinfo import ZoneInfo
 
+from .offer_extensions import evaluate_offer_extensions
+from .storage import parse_iso_datetime
+
 
 _COMPLETENESS = {"minimal": 1, "standard": 2, "rich": 3}
 
@@ -48,15 +51,37 @@ def _in_window(window: dict[str, Any], now: datetime) -> bool:
     return current >= start or current <= end
 
 
-def offer_is_available(offer: dict[str, Any], now: datetime | None = None) -> MatchResult:
-    """Check active status and configured delivery windows."""
+def offer_is_available(
+    offer: dict[str, Any],
+    now: datetime | None = None,
+    *,
+    vertical: str | None = None,
+    channel: str | None = None,
+) -> MatchResult:
+    """Check active status and configured delivery windows.
+
+    A delivery window may narrow an offer to particular verticals or channels.
+    Missing lead criteria cannot satisfy a restricted window; this keeps
+    matching fail-closed when a publisher omits a field that the buyer used to
+    constrain availability.
+    """
     reasons: list[str] = []
     if offer.get("active", True) is not True:
         reasons.append("offer_inactive")
     windows = offer.get("delivery_windows", [])
     if windows:
         current = now or datetime.now(timezone.utc)
-        if not any(_in_window(window, current) for window in windows):
+        matching_windows = []
+        for window in windows:
+            allowed_verticals = window.get("verticals")
+            allowed_channels = window.get("channels")
+            criteria_match = (
+                (not allowed_verticals or vertical in allowed_verticals)
+                and (not allowed_channels or channel in allowed_channels)
+            )
+            if criteria_match and _in_window(window, current):
+                matching_windows.append(window)
+        if not matching_windows:
             reasons.append("outside_delivery_window")
     return MatchResult(not reasons, tuple(reasons))
 
@@ -76,9 +101,33 @@ def match_offer(
     compliance = payload.get("compliance", {})
     quality = payload.get("lead_quality", {})
 
-    available = offer_is_available(offer, now)
+    current = now or datetime.now(timezone.utc)
+    available = offer_is_available(
+        offer,
+        current,
+        vertical=attributes.get("vertical"),
+        channel=payload.get("channel"),
+    )
     reasons.extend(available.reasons)
 
+    consent_expires_at = parse_iso_datetime(compliance.get("consent_expires_at"))
+    if consent_expires_at is not None and consent_expires_at <= current:
+        reasons.append("consent_expired")
+    extensions = offer.get("extensions", {})
+    if isinstance(extensions, dict):
+        required_purposes = extensions.get("lcp.platform.required_consent_purposes", [])
+        contact_purpose = extensions.get("lcp.platform.contact_purpose")
+        if contact_purpose and contact_purpose not in required_purposes:
+            required_purposes = [*required_purposes, contact_purpose] if isinstance(required_purposes, list) else [contact_purpose]
+        if required_purposes:
+            purposes = compliance.get("consent_purposes", [])
+            if not isinstance(required_purposes, list) or not isinstance(purposes, list):
+                reasons.append("consent_purpose_policy_invalid")
+            else:
+                missing = sorted({str(purpose) for purpose in required_purposes} - set(purposes))
+                if missing:
+                    reasons.append("consent_purpose_missing:" + ",".join(missing))
+
     if attributes.get("vertical") != offer.get("vertical"):
         reasons.append("vertical_mismatch")
     allowed_publishers = offer.get("allowed_publisher_ids", [])
@@ -137,6 +186,8 @@ def match_offer(
     if offer.get("reject_blacklist_flagged") and _scrub_status(payload, "blacklist") != "clean":
         reasons.append("blacklist_not_clean")
 
+    reasons.extend(evaluate_offer_extensions(offer, payload))
+
     # Claim-language evidence is intentionally fail-closed. A deployment may
     # provide a namespaced evidence block without putting copy/PII in a ping.
     if offer.get("excluded_claim_language") and not payload.get("extensions", {}).get(

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/lcp_platform/messages.py

@@ -11,7 +11,7 @@ from typing import Any
 from uuid import uuid4
 
 from .auth import signature_for
-from .storage import now_iso
+from .storage import is_expired, now_iso, parse_iso_datetime
 
 
 def _envelope(
@@ -135,6 +135,9 @@ def build_ping(
             "consent": bool(lead.get("compliance", {}).get("consent_evidence")),
             "otp_verified": bool(lead.get("compliance", {}).get("otp_verified")),
             "dnc_checked": bool(lead.get("compliance", {}).get("dnc_checked")),
+            "consent_valid": not is_expired(
+                parse_iso_datetime(lead.get("compliance", {}).get("consent_expires_at"))
+            ),
         },
         "quality_flags": {
             "verified_phone": lead.get("lead_quality", {}).get("verified_phone", False),

lcp_reference_platform-1.0.2/lcp_platform/observability.py

@@ -0,0 +1,23 @@
+"""Request-scoped observability primitives with no consumer-data logging."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+
+_request_id: ContextVar[str | None] = ContextVar("lcp_request_id", default=None)
+
+
+def set_request_id(value: str | None):
+    """Set the request ID for the current execution context."""
+    return _request_id.set(value)
+
+
+def reset_request_id(token) -> None:
+    """Restore the previous request ID after a request finishes."""
+    _request_id.reset(token)
+
+
+def current_request_id() -> str | None:
+    """Return the current request ID, if the call is inside an HTTP request."""
+    return _request_id.get()

lcp_reference_platform-1.0.2/lcp_platform/offer_extensions.py

@@ -0,0 +1,151 @@
+"""Safe, deployment-scoped offer extension matching."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+
+REQUIREMENTS_NAMESPACE = "lcp.platform.requirements"
+SERVICE_AREA_NAMESPACE = "lcp.platform.service_area"
+_ALLOWED_PATH_ROOTS = {"attributes", "location", "provenance"}
+_ALLOWED_OPERATORS = {"equals", "in", "exists", "between", "prefix"}
+
+
+def _path_value(payload: Mapping[str, Any], path: str) -> tuple[bool, Any]:
+    """Read one allowlisted top-level path without evaluating expressions."""
+
+    if path == "channel":
+        return "channel" in payload, payload.get("channel")
+
+    parts = path.split(".")
+    if len(parts) != 2 or parts[0] not in _ALLOWED_PATH_ROOTS or not parts[1]:
+        raise ValueError("path is not an allowed two-level LCP path")
+    container = payload.get(parts[0])
+    if not isinstance(container, Mapping):
+        return False, None
+    return parts[1] in container, container.get(parts[1])
+
+
+def _predicate_match(predicate: Mapping[str, Any], payload: Mapping[str, Any]) -> bool:
+    path = predicate.get("path")
+    operator = predicate.get("operator")
+    if not isinstance(path, str) or not isinstance(operator, str):
+        raise ValueError("predicate requires string path and operator")
+    if operator not in _ALLOWED_OPERATORS:
+        raise ValueError(f"unsupported predicate operator: {operator}")
+
+    present, actual = _path_value(payload, path)
+    if operator == "exists":
+        expected = predicate.get("value")
+        if not isinstance(expected, bool):
+            raise ValueError("exists predicate requires a boolean value")
+        return present is expected
+    if not present:
+        return False
+
+    if operator == "equals":
+        if "value" not in predicate:
+            raise ValueError("equals predicate requires value")
+        return actual == predicate["value"]
+    if operator == "in":
+        values = predicate.get("values")
+        if not isinstance(values, list) or not values:
+            raise ValueError("in predicate requires a non-empty values array")
+        return actual in values
+    if operator == "between":
+        minimum = predicate.get("min")
+        maximum = predicate.get("max")
+        if (
+            isinstance(actual, bool)
+            or not isinstance(actual, (int, float))
+            or isinstance(minimum, bool)
+            or not isinstance(minimum, (int, float))
+            or isinstance(maximum, bool)
+            or not isinstance(maximum, (int, float))
+            or minimum > maximum
+        ):
+            raise ValueError("between predicate requires ordered numeric min and max")
+        return minimum <= actual <= maximum
+    if operator == "prefix":
+        prefix = predicate.get("value")
+        if not isinstance(prefix, str):
+            raise ValueError("prefix predicate requires a string value")
+        return isinstance(actual, str) and actual.startswith(prefix)
+    raise ValueError(f"unsupported predicate operator: {operator}")
+
+
+def _require_profile_identity(profile: Mapping[str, Any], label: str) -> None:
+    if not isinstance(profile.get("profile_id"), str) or not profile["profile_id"]:
+        raise ValueError(f"{label} requires profile_id")
+    if not isinstance(profile.get("version"), str) or not profile["version"]:
+        raise ValueError(f"{label} requires version")
+
+
+def _match_requirements(profile: Any, payload: Mapping[str, Any]) -> list[str]:
+    if not isinstance(profile, Mapping):
+        return ["requirements_profile_invalid"]
+    try:
+        _require_profile_identity(profile, "requirements profile")
+        predicates = profile.get("predicates")
+        if not isinstance(predicates, list) or not predicates:
+            raise ValueError("requirements profile requires predicates")
+        reasons: list[str] = []
+        for predicate in predicates:
+            if not isinstance(predicate, Mapping):
+                raise ValueError("requirements predicate must be an object")
+            if not _predicate_match(predicate, payload):
+                reasons.append("requirements_predicate_mismatch")
+        return reasons
+    except ValueError:
+        return ["requirements_profile_invalid"]
+
+
+def _match_service_area(profile: Any, payload: Mapping[str, Any]) -> list[str]:
+    if not isinstance(profile, Mapping):
+        return ["service_area_profile_invalid"]
+    try:
+        _require_profile_identity(profile, "service-area profile")
+        location = payload.get("location")
+        if not isinstance(location, Mapping):
+            return ["service_area_location_missing"]
+        reasons: list[str] = []
+        for field, reason in (
+            ("countries", "service_area_country_not_supported"),
+            ("state_regions", "service_area_state_not_supported"),
+            ("postal_codes", "service_area_postal_code_not_supported"),
+        ):
+            allowed = profile.get(field)
+            if allowed is None:
+                continue
+            if not isinstance(allowed, list) or not allowed or not all(
+                isinstance(value, str) and value for value in allowed
+            ):
+                raise ValueError(f"{field} must be a non-empty string array")
+            location_field = "state_region" if field == "state_regions" else (
+                "postal_code" if field == "postal_codes" else "country_code"
+            )
+            actual = location.get(location_field)
+            if actual not in allowed:
+                reasons.append(reason)
+        return reasons
+    except ValueError:
+        return ["service_area_profile_invalid"]
+
+
+def evaluate_offer_extensions(
+    offer: Mapping[str, Any],
+    payload: Mapping[str, Any],
+) -> tuple[str, ...]:
+    """Evaluate known platform extensions and return explainable failure reasons."""
+
+    extensions = offer.get("extensions", {})
+    if not isinstance(extensions, Mapping):
+        return ("offer_extensions_invalid",)
+
+    reasons: list[str] = []
+    if REQUIREMENTS_NAMESPACE in extensions:
+        reasons.extend(_match_requirements(extensions[REQUIREMENTS_NAMESPACE], payload))
+    if SERVICE_AREA_NAMESPACE in extensions:
+        reasons.extend(_match_service_area(extensions[SERVICE_AREA_NAMESPACE], payload))
+    return tuple(reasons)

{lcp_reference_platform-1.0.0 → lcp_reference_platform-1.0.2}/lcp_platform/postgres.py

@@ -130,6 +130,22 @@ class PostgresStore(Store):
         db.execute(
             "ALTER TABLE leads ADD COLUMN IF NOT EXISTS tenant_id TEXT NOT NULL DEFAULT 'default'"
         )
+        db.execute("ALTER TABLE leads ADD COLUMN IF NOT EXISTS expires_at TEXT")
+        db.execute("ALTER TABLE leads ADD COLUMN IF NOT EXISTS consent_expires_at TEXT")
+        db.execute("ALTER TABLE leads ADD COLUMN IF NOT EXISTS suppressed INTEGER NOT NULL DEFAULT 0")
+        db.execute("ALTER TABLE offers ADD COLUMN IF NOT EXISTS tenant_id TEXT NOT NULL DEFAULT 'default'")
+        db.execute("ALTER TABLE offers ADD COLUMN IF NOT EXISTS vertical TEXT")
+        for row in db.execute("SELECT offer_id, offer_json FROM offers").fetchall():
+            stored_offer = json.loads(_decode_text(row["offer_json"]))
+            db.execute(
+                "UPDATE offers SET tenant_id = ?, vertical = ? WHERE offer_id = ?",
+                (
+                    str(stored_offer.get("tenant_id", "default")),
+                    stored_offer.get("vertical"),
+                    row["offer_id"],
+                ),
+            )
+        db.execute("CREATE INDEX IF NOT EXISTS idx_offers_discovery ON offers(active, tenant_id, vertical, offer_id)")
         db.execute("ALTER TABLE deliveries ADD COLUMN IF NOT EXISTS lease_owner TEXT")
         db.execute("ALTER TABLE deliveries ADD COLUMN IF NOT EXISTS lease_until TEXT")
         db.execute("ALTER TABLE attachments ADD COLUMN IF NOT EXISTS residency TEXT NOT NULL DEFAULT 'TEST'")
@@ -137,6 +153,7 @@ class PostgresStore(Store):
         db.execute("ALTER TABLE attachments ADD COLUMN IF NOT EXISTS scan_engine TEXT NOT NULL DEFAULT 'unknown'")
         db.execute("ALTER TABLE attachments ADD COLUMN IF NOT EXISTS scanned_at TEXT NOT NULL DEFAULT ''")
         db.execute("ALTER TABLE attachments ADD COLUMN IF NOT EXISTS encryption TEXT NOT NULL DEFAULT 'application_encrypted'")
+        db.execute("ALTER TABLE attachments ADD COLUMN IF NOT EXISTS expires_at TEXT")
 
     def close(self) -> None:
         with self._lock:
@@ -150,17 +167,22 @@ class PostgresStore(Store):
         active_only: bool = True,
     ) -> list[dict[str, Any]]:
         query = "SELECT offer_json FROM offers"
+        clauses: list[str] = []
+        values: list[Any] = []
         if active_only:
-            query += " WHERE active = 1"
-        query += " ORDER BY offer_id"
-        with self._lock:
-            rows = self._connection.execute(query, ()).fetchall()
-        offers = [json.loads(row["offer_json"]) for row in rows]
+            clauses.append("active = 1")
         if vertical:
-            offers = [offer for offer in offers if offer.get("vertical") == vertical]
+            clauses.append("vertical = ?")
+            values.append(vertical)
         if tenant_id:
-            offers = [offer for offer in offers if offer.get("tenant_id") == tenant_id]
-        return offers
+            clauses.append("tenant_id = ?")
+            values.append(tenant_id)
+        if clauses:
+            query += " WHERE " + " AND ".join(clauses)
+        query += " ORDER BY offer_id"
+        with self._lock:
+            rows = self._connection.execute(query, values).fetchall()
+        return [json.loads(_decode_text(row["offer_json"])) for row in rows]
 
     def claim_routing_jobs(
         self,