delimit-cli 4.5.0 → 4.5.2

package/gateway/ai/social_queue.py

@@ -0,0 +1,307 @@
+"""Persistent scan queue for the social distribution pipeline (LED-216 Phase 2).
+
+The queue decouples target *scanning* from draft *generation*. Scanners append
+discovered targets here; the draft phase claims pending entries, generates a
+post, and marks them drafted (or failed). This allows the Reddit scanner to
+take 120s without blocking X/HN/devto/etc., and lets the draft stage run
+under its own timeout against a stable backlog.
+
+Storage: append-only JSONL at ``~/.delimit/social_scan_queue.jsonl``. Each
+line is a single queue entry with the schema:
+
+    {
+        "queued_at": "2026-05-02T15:30:00Z",
+        "platform": "reddit",
+        "fingerprint": "reddit:vibecoding:abc123",
+        "source_id": "...",
+        "raw": { /* full target dict from the scanner */ },
+        "status": "pending",       # pending | drafted | drafted_failed | expired
+        "drafted_at": null,
+        "draft_id": null,
+        "error": null
+    }
+
+All writes are atomic (tmp + rename for full rewrites; append-only for the
+hot path). Malformed lines are skipped with a warning rather than crashing
+the whole queue. Dedupe-on-enqueue avoids re-queuing a fingerprint that is
+already pending or was drafted within the last 7 days.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import tempfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+QUEUE_FILE = Path.home() / ".delimit" / "social_scan_queue.jsonl"
+
+DEFAULT_DEDUPE_HOURS = 24 * 7  # don't re-queue a fingerprint within 7 days
+DEFAULT_EXPIRE_HOURS = 24 * 7  # entries older than 7 days roll to expired
+
+PENDING = "pending"
+DRAFTED = "drafted"
+DRAFTED_FAILED = "drafted_failed"
+EXPIRED = "expired"
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _queue_path() -> Path:
+    """Resolve the queue file path. Indirection lets tests monkeypatch it."""
+    return QUEUE_FILE
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        # ``fromisoformat`` accepts both naive and tz-aware strings.
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def _ensure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _iter_entries(path: Optional[Path] = None) -> Iterator[Dict[str, Any]]:
+    """Yield each parsable JSON line from the queue. Skip and log malformed."""
+    p = path or _queue_path()
+    if not p.exists():
+        return
+    try:
+        with open(p, "r", encoding="utf-8") as fh:
+            for ln_no, line in enumerate(fh, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    yield json.loads(line)
+                except (json.JSONDecodeError, ValueError) as exc:
+                    logger.warning(
+                        "social_queue: skipping malformed line %d in %s: %s",
+                        ln_no, p, exc,
+                    )
+                    continue
+    except OSError as exc:
+        logger.warning("social_queue: failed to read %s: %s", p, exc)
+
+
+def _atomic_rewrite(entries: List[Dict[str, Any]], path: Optional[Path] = None) -> None:
+    """Rewrite the queue file atomically via tmp + os.replace."""
+    p = path or _queue_path()
+    _ensure_parent(p)
+    fd, tmp_path = tempfile.mkstemp(prefix=".social_scan_queue.", dir=str(p.parent))
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            for entry in entries:
+                fh.write(json.dumps(entry, sort_keys=True) + "\n")
+        os.replace(tmp_path, p)
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def _append_atomic(entry: Dict[str, Any], path: Optional[Path] = None) -> None:
+    """Append a single line. fsync-friendly: opens in 'a', writes, closes."""
+    p = path or _queue_path()
+    _ensure_parent(p)
+    line = json.dumps(entry, sort_keys=True) + "\n"
+    with open(p, "a", encoding="utf-8") as fh:
+        fh.write(line)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def enqueue(target: Dict[str, Any], dedupe_hours: int = DEFAULT_DEDUPE_HOURS) -> Optional[str]:
+    """Append a scanner target to the queue.
+
+    Returns the fingerprint string on success, or ``None`` when the target
+    was deduped (already pending, or drafted within the dedupe window).
+    Targets without a ``fingerprint`` field are rejected.
+    """
+    fingerprint = (target or {}).get("fingerprint")
+    if not fingerprint:
+        logger.warning("social_queue.enqueue: target missing fingerprint, skipping")
+        return None
+
+    now = datetime.now(timezone.utc)
+    cutoff = now - timedelta(hours=dedupe_hours)
+
+    # Dedupe: scan existing entries for a recent matching fingerprint.
+    for existing in _iter_entries():
+        if existing.get("fingerprint") != fingerprint:
+            continue
+        status = existing.get("status")
+        if status == PENDING:
+            return None
+        if status == DRAFTED:
+            ts = _parse_iso(existing.get("drafted_at") or existing.get("queued_at"))
+            if ts and ts >= cutoff:
+                return None
+        # drafted_failed or expired or older drafted → allow re-enqueue
+
+    entry = {
+        "queued_at": _now_iso(),
+        "platform": target.get("platform", ""),
+        "fingerprint": fingerprint,
+        "source_id": target.get("source_id", ""),
+        "raw": target,
+        "status": PENDING,
+        "drafted_at": None,
+        "draft_id": None,
+        "error": None,
+    }
+    _append_atomic(entry)
+    return fingerprint
+
+
+def claim_pending(platform: Optional[str] = None, limit: int = 20) -> List[Dict[str, Any]]:
+    """Return up to ``limit`` pending entries, optionally filtered by platform.
+
+    Read-only — does NOT mutate state. The caller must call ``mark_drafted``
+    or ``mark_failed`` once it processes the entry. Returns oldest-first
+    (FIFO) so the queue drains in scan order.
+    """
+    out: List[Dict[str, Any]] = []
+    # Build a list because we want oldest-first; JSONL append order = FIFO.
+    for entry in _iter_entries():
+        if entry.get("status") != PENDING:
+            continue
+        if platform and entry.get("platform") != platform:
+            continue
+        out.append(entry)
+        if len(out) >= limit:
+            break
+    return out
+
+
+def _update_entry(fingerprint: str, mutator) -> bool:
+    """Apply ``mutator(entry) -> entry`` to the most recent entry matching
+    fingerprint with status==pending. Returns True on hit, False otherwise.
+    Rewrites the queue atomically.
+    """
+    entries = list(_iter_entries())
+    target_idx = -1
+    for idx in range(len(entries) - 1, -1, -1):
+        e = entries[idx]
+        if e.get("fingerprint") == fingerprint and e.get("status") == PENDING:
+            target_idx = idx
+            break
+    if target_idx < 0:
+        return False
+    entries[target_idx] = mutator(entries[target_idx])
+    _atomic_rewrite(entries)
+    return True
+
+
+def mark_drafted(fingerprint: str, draft_id: str) -> bool:
+    """Mark a pending entry as drafted. Returns True on hit."""
+    def _mutate(entry: Dict[str, Any]) -> Dict[str, Any]:
+        entry["status"] = DRAFTED
+        entry["drafted_at"] = _now_iso()
+        entry["draft_id"] = draft_id or ""
+        entry["error"] = None
+        return entry
+    return _update_entry(fingerprint, _mutate)
+
+
+def mark_failed(fingerprint: str, error: str) -> bool:
+    """Mark a pending entry as drafted_failed with the supplied error string."""
+    def _mutate(entry: Dict[str, Any]) -> Dict[str, Any]:
+        entry["status"] = DRAFTED_FAILED
+        entry["drafted_at"] = _now_iso()
+        entry["error"] = (error or "")[:500]
+        return entry
+    return _update_entry(fingerprint, _mutate)
+
+
+def expire_older_than(hours: int = DEFAULT_EXPIRE_HOURS) -> int:
+    """Roll any pending entry older than ``hours`` into the expired status.
+
+    Returns the count expired. Entries past the window are still kept in the
+    file (for audit), but their status flips so they no longer surface to
+    ``claim_pending``.
+    """
+    cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
+    entries = list(_iter_entries())
+    if not entries:
+        return 0
+    flipped = 0
+    for entry in entries:
+        if entry.get("status") != PENDING:
+            continue
+        ts = _parse_iso(entry.get("queued_at"))
+        if ts is None or ts >= cutoff:
+            continue
+        entry["status"] = EXPIRED
+        entry["error"] = "expired_after_window"
+        flipped += 1
+    if flipped:
+        _atomic_rewrite(entries)
+    return flipped
+
+
+def queue_stats() -> Dict[str, Any]:
+    """Return a snapshot count: ``{pending, drafted, drafted_failed, expired,
+    by_platform: {platform: {pending, drafted, ...}}}``.
+    """
+    totals = {PENDING: 0, DRAFTED: 0, DRAFTED_FAILED: 0, EXPIRED: 0}
+    by_platform: Dict[str, Dict[str, int]] = {}
+    for entry in _iter_entries():
+        status = entry.get("status") or "unknown"
+        if status in totals:
+            totals[status] += 1
+        plat = entry.get("platform") or "unknown"
+        plat_bucket = by_platform.setdefault(plat, {PENDING: 0, DRAFTED: 0, DRAFTED_FAILED: 0, EXPIRED: 0})
+        if status in plat_bucket:
+            plat_bucket[status] += 1
+    return {
+        "pending": totals[PENDING],
+        "drafted": totals[DRAFTED],
+        "drafted_failed": totals[DRAFTED_FAILED],
+        "expired": totals[EXPIRED],
+        "by_platform": by_platform,
+    }
+
+
+__all__ = [
+    "QUEUE_FILE",
+    "PENDING",
+    "DRAFTED",
+    "DRAFTED_FAILED",
+    "EXPIRED",
+    "enqueue",
+    "claim_pending",
+    "mark_drafted",
+    "mark_failed",
+    "expire_older_than",
+    "queue_stats",
+]

package/gateway/ai/supabase_sync.py

@@ -488,8 +488,20 @@ def sync_social_draft(draft: dict):
             client.table("social_drafts").upsert(row).execute()
 
         # ntfy on NEW pending drafts only, dedupe via the WO sent-marker file
-        # (reused — scoped by draft_id vs wo_id so no collision)
-        if row["status"] == "pending":
+        # (reused — scoped by draft_id vs wo_id so no collision).
+        # LED-216 Phase 1: suppress ntfy for capability-drift drafts and the
+        # existing rule-blocked / placeholder buckets — the row still lands
+        # in Supabase for audit, but the founder is NOT paged on a draft
+        # we already know to be unfit for posting.
+        _quality = (row.get("quality") or "").lower()
+        _suppressed_qualities = {
+            "rejected_capability_drift",
+            "placeholder",
+        }
+        if (
+            row["status"] == "pending"
+            and _quality not in _suppressed_qualities
+        ):
             try:
                 _push_draft_notification(row)
             except Exception as exc:

package/gateway/ai/swarm.py

@@ -946,27 +946,45 @@ def hot_reload(reason: str = "update") -> Dict[str, Any]:
     # full subprocess restart.  Modules with global state are skipped.
     reloaded_modules: List[str] = []
     reload_errors: List[str] = []
+    # LED-2071f (2026-04-30): reload LEAVES (modules with no internal
+    # `from ai.X import ...` deps) BEFORE leaves' importers, so when an
+    # importer re-runs its `from` imports during its own reload, it
+    # picks up the freshly-reloaded binding rather than the stale one.
+    # Symptom of the prior order: ai.social_target reloaded before
+    # ai.social, so social_target's `from ai.social import save_draft,
+    # generate_tailored_draft, ...` rebound to the OLD social, then
+    # ai.social reloaded but social_target kept stale fn references.
+    # Fix: ai.social and ai.deliberation (the leaves) come first;
+    # ai.social_target (which imports from social) and ai.loop_engine
+    # (which imports from social_target) come after, in dependency
+    # order.
     HOT_RELOADABLE = [
-        "ai.loop_engine",
-        "ai.social_target",
         "ai.social",
+        "ai.deliberation",  # added 2026-04-09 per LED-805 — CLI stdin fix needed hot reload
         "ai.reddit_scanner",
         "ai.ledger_manager",
-        "ai.deliberation",  # added 2026-04-09 per LED-805 — CLI stdin fix needed hot reload
         "ai.backends.repo_bridge",
         "ai.backends.tools_infra",
         "backends.repo_bridge",  # alias used by server.py lazy imports
+        "ai.social_target",  # depends on ai.social
+        "ai.loop_engine",    # depends on ai.social_target
         "social",  # alias
         "ai.swarm",  # self — reload last
     ]
-    for modname in HOT_RELOADABLE:
-        if modname not in _sys.modules:
-            continue
-        try:
-            importlib.reload(_sys.modules[modname])
-            reloaded_modules.append(modname)
-        except Exception as e:
-            reload_errors.append(f"{modname}: {e}")
+    # Two-pass reload: pass 1 establishes the new leaf modules; pass 2
+    # forces importers to rebind against the now-reloaded leaves. Cheap
+    # (in-process module reload only) but kills the entire stale-binding
+    # class of bugs in one go.
+    for _pass in range(2):
+        for modname in HOT_RELOADABLE:
+            if modname not in _sys.modules:
+                continue
+            try:
+                importlib.reload(_sys.modules[modname])
+                if _pass == 0:
+                    reloaded_modules.append(modname)
+            except Exception as e:
+                reload_errors.append(f"pass{_pass} {modname}: {e}")
 
     # 1. Capture current state for transfer
     state = {

package/gateway/ai/tui.py

@@ -32,7 +32,11 @@ from typing import Any, Dict, List, Optional, Tuple
 
 # -- Data paths ---------------------------------------------------------------
 
-DELIMIT_HOME = Path.home() / ".delimit"
+# LED-1188: route through the canonical resolver so $DELIMIT_HOME /
+# $DELIMIT_NAMESPACE_ROOT overrides apply uniformly across npm + gateway.
+from .continuity import get_namespace_root  # noqa: E402
+
+DELIMIT_HOME = get_namespace_root()
 LEDGER_DIR = DELIMIT_HOME / "ledger"
 SWARM_DIR = DELIMIT_HOME / "swarm"
 MEMORY_DIR = DELIMIT_HOME / "memory"
@@ -721,7 +725,7 @@ class GovernanceBar(Static):
         bar = self.query_one("#gov-bar", Static)
         ledger_count = len(_load_ledger_items("open", 999))
         swarm = _load_swarm_status()
-        mode_file = Path.home() / ".delimit" / "enforcement_mode"
+        mode_file = DELIMIT_HOME / "enforcement_mode"
         mode = mode_file.read_text().strip() if mode_file.exists() else "default"
 
         # Notification badge

package/gateway/ai/x_ranker.py

@@ -0,0 +1,276 @@
+"""X engagement ranker (LED-216 Phase 2, Q4 of the 2026-05-02 distribution panel).
+
+Filters and orders X (Twitter) candidate posts so we reply to the highest-
+yield originals only. The score formula and the 7-day author dedupe are the
+panel's Q4 conclusion: Codex's age-normalized formula plus Opus's API filters
+(``-is:retweet -is:reply lang:en``) and the founder's anti-spammy posture
+("don't hammer the same 5 accounts daily").
+
+Score formula (per the LED-216 Phase 2 directive):
+
+    score = (likes + 2 * retweets + 0.5 * replies + 3 * quotes) / max(age_hours, 1)
+
+Filter pipeline applied in order:
+    1. ``is_op`` → drop reply-chain targets (we only reply to OPs)
+    2. ``lang == 'en'`` → drop non-English (US/UK builder community is the wedge)
+    3. ``is_retweet == False`` → drop retweets
+    4. dedupe authors we replied to in the last ``replied_authors_window_hours``
+    5. sort by score DESC
+
+Tolerant defaults: any field missing on a target is treated as "do not drop"
+so partial Twttr241 payloads still rank instead of being silently filtered.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+SOCIAL_LOG = Path.home() / ".delimit" / "social_log.jsonl"
+
+DEFAULT_WINDOW_HOURS = 24 * 7  # 7 days, per founder's anti-spammy directive
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _social_log_path() -> Path:
+    """Indirection so tests can monkeypatch the log location."""
+    return SOCIAL_LOG
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def _parse_twitter_created_at(value: Optional[str]) -> Optional[datetime]:
+    """Twttr241 ``created_at`` is a Twitter-style timestamp like
+    ``Wed Apr 30 14:23:55 +0000 2026``. Falls back to ISO 8601 for caches
+    that have already normalized the value.
+    """
+    if not value:
+        return None
+    iso = _parse_iso(value)
+    if iso is not None:
+        return iso
+    try:
+        dt = datetime.strptime(value, "%a %b %d %H:%M:%S %z %Y")
+    except (TypeError, ValueError):
+        return None
+    return dt
+
+
+def _normalize_handle(handle: Optional[str]) -> str:
+    if not handle:
+        return ""
+    h = handle.strip().lower()
+    if h.startswith("@"):
+        h = h[1:]
+    return h
+
+
+def _replied_authors_within(window_hours: int, log_path: Optional[Path] = None) -> Set[str]:
+    """Read ``social_log.jsonl`` and return the set of author handles we
+    replied to on Twitter inside the window. Tolerant of malformed lines.
+
+    Twitter replies log either ``replying_to_user`` (Reddit field, rare on X)
+    or carry the original author inside the draft text — we cannot recover
+    that retroactively. The reliable signal is ``handle`` (us) plus
+    ``reply_to_id`` (their tweet id). Without the id->author mapping we use
+    a best-effort: a stored ``replying_to_user`` field if present, else any
+    ``@handle`` token at the start of the post text. Both are conservative
+    forms of dedupe — better to skip a borderline candidate than spam.
+    """
+    p = log_path or _social_log_path()
+    if not p.exists():
+        return set()
+    cutoff = datetime.now(timezone.utc) - timedelta(hours=window_hours)
+    authors: Set[str] = set()
+    try:
+        with open(p, "r", encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                if entry.get("platform") != "twitter":
+                    continue
+                ts = _parse_iso(entry.get("ts"))
+                if ts is None or ts < cutoff:
+                    continue
+                # Preferred: explicit replying_to_user field
+                explicit = _normalize_handle(entry.get("replying_to_user"))
+                if explicit:
+                    authors.add(explicit)
+                    continue
+                # Fallback: leading @handle in the post text. This is the way
+                # X reply text starts when the client appends the reply prefix.
+                text = (entry.get("text") or "").lstrip()
+                if text.startswith("@"):
+                    token = text.split()[0][1:]
+                    token = "".join(c for c in token if c.isalnum() or c == "_").lower()
+                    if token:
+                        authors.add(token)
+    except OSError as exc:
+        logger.warning("x_ranker: failed to read %s: %s", p, exc)
+    return authors
+
+
+def _coerce_int(value: Any) -> int:
+    try:
+        return int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _age_hours(target: Dict[str, Any]) -> float:
+    """Best-effort age in hours from ``target['created_at']`` (ISO or Twitter
+    style). Missing / unparseable timestamps return ``1.0`` so the score is
+    not divided by something pathological — and the candidate is still
+    scoreable rather than dropped.
+    """
+    raw = target.get("created_at") or target.get("created") or ""
+    dt = _parse_twitter_created_at(raw) or _parse_iso(raw)
+    if dt is None:
+        return 1.0
+    delta = datetime.now(timezone.utc) - dt
+    hours = delta.total_seconds() / 3600.0
+    if hours < 1.0:
+        return 1.0
+    return hours
+
+
+# ---------------------------------------------------------------------------
+# Core API
+# ---------------------------------------------------------------------------
+
+
+def score_target(target: Dict[str, Any]) -> float:
+    """Engagement-rate score for a single X candidate.
+
+    score = (likes + 2*retweets + 0.5*replies + 3*quotes) / max(age_hours, 1)
+    """
+    likes = _coerce_int(target.get("likes") or target.get("favorite_count"))
+    retweets = _coerce_int(target.get("retweets") or target.get("retweet_count"))
+    replies = _coerce_int(target.get("reply_count") or target.get("replies"))
+    quotes = _coerce_int(target.get("quote_count") or target.get("quotes"))
+    age = _age_hours(target)
+    raw = likes + 2 * retweets + 0.5 * replies + 3 * quotes
+    return raw / max(age, 1.0)
+
+
+def _is_op(target: Dict[str, Any]) -> bool:
+    """Return True when the target looks like an OP (not a reply-chain post).
+
+    Tolerant: missing flags default to OP rather than dropping. Explicit
+    ``is_reply=True`` or ``in_reply_to_status_id_str`` set is the kill signal.
+    Reply signals win over a stale ``is_op=True`` so a target that carries
+    both (e.g. an upstream scanner sets is_op then a follow-up enrichment
+    flips is_reply) is correctly dropped.
+    """
+    if target.get("is_reply") is True:
+        return False
+    reply_id = target.get("in_reply_to_status_id_str") or target.get("in_reply_to_status_id")
+    if reply_id:
+        return False
+    if target.get("is_op") is False:
+        return False
+    return True
+
+
+def _is_english(target: Dict[str, Any]) -> bool:
+    lang = target.get("lang")
+    if lang is None:
+        # Tolerant default — Twttr241 doesn't always populate lang.
+        return True
+    return str(lang).lower() in ("en", "en-us", "en-gb")
+
+
+def _is_retweet(target: Dict[str, Any]) -> bool:
+    if target.get("is_retweet") is True:
+        return True
+    text = (target.get("content_snippet") or target.get("text") or "").lstrip()
+    if text.startswith("RT @"):
+        return True
+    return False
+
+
+def rank_x_targets(
+    targets: Iterable[Dict[str, Any]],
+    replied_authors_window_hours: int = DEFAULT_WINDOW_HOURS,
+    replied_authors: Optional[Set[str]] = None,
+) -> List[Dict[str, Any]]:
+    """Filter and sort X targets by engagement.
+
+    Args:
+        targets: iterable of candidate target dicts from ``_scan_x``.
+        replied_authors_window_hours: dedupe window for already-replied authors.
+            Default 7 days per founder directive.
+        replied_authors: explicit author set (lowercase, no leading ``@``).
+            When ``None``, the set is read from ``~/.delimit/social_log.jsonl``.
+            Tests inject an explicit set to avoid touching disk.
+
+    Returns:
+        A new list sorted by engagement score DESC. Each item gets a
+        ``_rank_score`` key for downstream observability. Filtered items are
+        dropped (not kept with score=0) so the caller can blindly slice the
+        first N.
+    """
+    if replied_authors is None:
+        replied_authors = _replied_authors_within(replied_authors_window_hours)
+    else:
+        replied_authors = {_normalize_handle(a) for a in replied_authors}
+
+    survivors: List[Dict[str, Any]] = []
+    for t in targets or []:
+        if not isinstance(t, dict):
+            continue
+        if t.get("error"):
+            continue
+
+        # 1. is_op
+        if not _is_op(t):
+            continue
+        # 2. lang == 'en' (tolerant of missing field)
+        if not _is_english(t):
+            continue
+        # 3. drop retweets
+        if _is_retweet(t):
+            continue
+        # 4. dedupe authors we replied to in window
+        author_norm = _normalize_handle(t.get("author"))
+        if author_norm and author_norm in replied_authors:
+            continue
+
+        scored = dict(t)
+        scored["_rank_score"] = round(score_target(t), 4)
+        survivors.append(scored)
+
+    # 5. sort score DESC, stable
+    survivors.sort(key=lambda x: x.get("_rank_score", 0.0), reverse=True)
+    return survivors
+
+
+__all__ = [
+    "DEFAULT_WINDOW_HOURS",
+    "score_target",
+    "rank_x_targets",
+]