delimit-cli 4.5.1 → 4.5.3

package/gateway/ai/social_capability/fit_floor.py

@@ -0,0 +1,360 @@
+"""Delimit-fit floor (LED-1240 part B — selectivity bar, 2026-05-05).
+
+The validator (``capability_validator``) hard-fails generic-claim drafts
+AFTER the LLM has generated them. That catches drift but burns tokens and
+surfaces weak drafts to founder review. This module pushes the bar
+upstream: a thread/target must pass the Delimit-fit floor BEFORE we even
+draft for it. If the floor rejects, we abstain. Abstain > weak draft.
+
+The fit floor accepts a thread when ANY of these holds:
+
+  1. The text matches a **Delimit-domain signal** (openapi, breaking change,
+     semver, schema diff, merge gate, mcp server, ci governance, soc 2, …).
+  2. The text matches an **AI-coding-orbit signal** (claude code, codex cli,
+     cursor, gemini cli, mcp tool, …) AND a **technical-context word**
+     (ship, merge, deploy, release, PR, review, audit, test, …). Orbit-only
+     mentions without technical context (e.g. "I love Claude Code!") are
+     not enough — that's the signal that produces noise drafts.
+  3. The engagement score is high enough that abstaining has clear
+     opportunity cost (default ≥ 50). High-engagement-but-off-topic threads
+     pass through with ``human_only=True`` so the orchestrator can choose
+     to surface them for human review without auto-drafting.
+
+A failing thread returns a dict with ``reason="no_delimit_fit"`` and is
+NOT drafted. Logging is the caller's job — this module is pure logic.
+
+Topic-coverage cooldown (``recent_topic_drafted``) is a separate function
+that consults ``social_log.jsonl`` (the same source ``x_ranker`` uses for
+author dedupe). If we drafted on the same topic within the cooldown
+window (default 7 days), the next thread on that topic is rejected with
+``reason="topic_cooldown"``.
+
+Centralizing this logic here means ``x_ranker`` (X candidate ordering) and
+``social_target`` (cross-platform target processing) both consume the same
+gate — no drift between surfaces.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, Iterable, Optional, Set, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Default cooldown window for topic coverage. Founder directive (2026-05-05):
+# "if we've already drafted on a similar topic in the last 7 days, abstain on
+# the next one to avoid spam-pattern detection."
+DEFAULT_COOLDOWN_DAYS = 7
+
+# Default high-engagement opportunity-cost threshold. Threads above this score
+# pass the fit floor even without keyword match, but with ``human_only=True``
+# so they don't auto-draft.
+DEFAULT_HIGH_ENGAGEMENT_FLOOR = 50.0
+
+# Same SOCIAL_LOG path as ai.x_ranker — single source of truth for "what we
+# recently posted to". Indirection via a getter so tests can monkeypatch.
+SOCIAL_LOG = Path.home() / ".delimit" / "social_log.jsonl"
+
+
+def _social_log_path() -> Path:
+    """Indirection for tests."""
+    return SOCIAL_LOG
+
+
+# ── Signal vocabularies ──────────────────────────────────────────────
+
+# Direct Delimit-domain signals. These are the canonical surfaces the
+# product addresses. Any one of these is sufficient by itself.
+#
+# Keep this list narrow and concrete — it's the difference between
+# "drafts that have something to say" and "drafts that name-drop a
+# topic". Per the LED-1240 directive: abstain > weak draft.
+DELIMIT_DOMAIN_SIGNALS = (
+    # API governance
+    r"\bopenapi\b",
+    r"\bopen[\s-]?api\b",
+    r"\bapi[\s-]?versioning\b",
+    r"\bbreaking[\s-]?change(?:s)?\b",
+    r"\bsemver\b",
+    r"\bsemantic[\s-]?versioning\b",
+    r"\bschema[\s-]?diff\b",
+    r"\bspec[\s-]?validation\b",
+    r"\bapi[\s-]?spec(?:s)?\b",
+    r"\bapi[\s-]?contract(?:s)?\b",
+    r"\bapi[\s-]?migration(?:s)?\b",
+    r"\brelease[\s-]?notes\b",
+    # Merge / governance
+    r"\bmerge[\s-]?gate\b",
+    r"\bci[\s-]?governance\b",
+    r"\bapi[\s-]?governance\b",
+    # MCP
+    r"\bmcp[\s-]?server(?:s)?\b",
+    r"\bmodel[\s-]?context[\s-]?protocol\b",
+    # Compliance / audit
+    r"\bsoc[\s-]?2\b",
+    r"\bcompliance\b",
+    r"\bauditor(?:s)?\b",
+    r"\battestation(?:s)?\b",
+    r"\baudit[\s-]?trail\b",
+)
+
+# Adjacent / orbit signals — these are common in the AI-coding-assistant
+# ecosystem we live in. By themselves they're noise; combined with a
+# technical-context word they're a real signal.
+ORBIT_SIGNALS = (
+    r"\bclaude[\s-]?code\b",
+    r"\bcodex(?:[\s-]?cli)?\b",
+    r"\bcursor(?:[\s-]?ai)?\b",
+    r"\bgemini[\s-]?cli\b",
+    r"\bmcp[\s-]?tool(?:s)?\b",
+    r"\bmcp\b",
+    r"\bai[\s-]?coding[\s-]?assistant(?:s)?\b",
+    r"\bai[\s-]?agent(?:s)?\b",
+    r"\bai[\s-]?coder(?:s)?\b",
+)
+
+# Technical-context words — these qualify an orbit mention as real signal.
+# The list is what an engineer would actually say when describing an
+# integration / shipping / review / audit moment.
+TECH_CONTEXT_SIGNALS = (
+    r"\bship(?:s|ped|ping)?\b",
+    r"\bmerg(?:e|ed|es|ing)\b",
+    r"\bdeploy(?:s|ed|ing|ment)?\b",
+    r"\brelease(?:s|d|ing)?\b",
+    r"\bpr(?:s)?\b",
+    r"\bpull[\s-]?request(?:s)?\b",
+    r"\breview(?:s|ed|ing)?\b",
+    r"\baudit(?:s|ed|ing)?\b",
+    r"\btest(?:s|ed|ing)?\b",
+    r"\bci(?:/cd)?\b",
+    r"\bgithub[\s-]?action(?:s)?\b",
+    r"\bspec(?:s)?\b",
+    r"\bschema\b",
+    r"\bbreaking\b",
+    r"\bregression(?:s)?\b",
+)
+
+
+# Compiled at module load — case-insensitive, matched against full text.
+_DELIMIT_DOMAIN_RE = re.compile("|".join(DELIMIT_DOMAIN_SIGNALS), re.IGNORECASE)
+_ORBIT_RE = re.compile("|".join(ORBIT_SIGNALS), re.IGNORECASE)
+_TECH_CONTEXT_RE = re.compile("|".join(TECH_CONTEXT_SIGNALS), re.IGNORECASE)
+
+
+# ── Topic extraction (for cooldown) ─────────────────────────────────
+
+# Lightweight topic fingerprint: the union of matched Delimit-domain signals
+# + matched orbit signals (lowercased, deduped). If two threads share a
+# matched signal AND we drafted on one inside the cooldown window, the
+# second one is rejected. This avoids 5-tweets-on-MCP-in-3-days drafts.
+def _extract_topic_fingerprint(text: str) -> Set[str]:
+    """Return the set of canonical signal terms present in ``text``.
+
+    Used as the key for the topic-coverage cooldown. Empty string and
+    ``None`` return an empty set — those threads can never collide.
+    """
+    if not text:
+        return set()
+    out: Set[str] = set()
+    for m in _DELIMIT_DOMAIN_RE.finditer(text):
+        out.add(m.group(0).lower())
+    for m in _ORBIT_RE.finditer(text):
+        out.add(m.group(0).lower())
+    return out
+
+
+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 _recent_topic_fingerprints(
+    cooldown_days: int = DEFAULT_COOLDOWN_DAYS,
+    log_path: Optional[Path] = None,
+) -> Set[str]:
+    """Return the union of topic fingerprints found in ``social_log.jsonl``
+    within the cooldown window. Tolerant of malformed lines.
+    """
+    p = log_path or _social_log_path()
+    if not p.exists():
+        return set()
+    cutoff = datetime.now(timezone.utc) - timedelta(days=cooldown_days)
+    seen: 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
+                ts = _parse_iso(entry.get("ts"))
+                if ts is None or ts < cutoff:
+                    continue
+                # Use the post body + thread title (when present) as the
+                # topic surface. Reddit entries log the thread title
+                # separately; X entries don't have one but the post body
+                # carries the @-prefixed reply context.
+                blob = " ".join(
+                    [
+                        entry.get("text") or "",
+                        entry.get("thread_title") or "",
+                    ]
+                )
+                seen.update(_extract_topic_fingerprint(blob))
+    except OSError as exc:
+        logger.warning("fit_floor: failed to read %s: %s", p, exc)
+    return seen
+
+
+# ── Fit-floor decision ──────────────────────────────────────────────
+
+
+def evaluate_fit(
+    text: str,
+    engagement_score: float = 0.0,
+    high_engagement_floor: float = DEFAULT_HIGH_ENGAGEMENT_FLOOR,
+    recent_topics: Optional[Set[str]] = None,
+) -> Dict[str, Any]:
+    """Decide whether a thread/target passes the Delimit-fit floor.
+
+    Args:
+        text: full thread / target text. Empty string returns a hard
+            rejection (cannot evaluate).
+        engagement_score: pre-computed engagement score (e.g. from
+            ``x_ranker.score_target``). Used for the opportunity-cost
+            carve-out: very high scores pass the floor even without a
+            keyword match, but with ``human_only=True``.
+        high_engagement_floor: score threshold for the carve-out.
+        recent_topics: set of topic fingerprints we've drafted on inside
+            the cooldown window. When the candidate's matched signals
+            intersect this set, the candidate is rejected with
+            ``reason="topic_cooldown"``. ``None`` skips the cooldown
+            check (callers that don't want it just pass ``set()`` or
+            ``None``).
+
+    Returns:
+        Dict with:
+            - ``passed`` (bool)
+            - ``reason`` (str): "delimit_domain" | "orbit_with_context"
+              | "high_engagement_human_only" | "no_delimit_fit"
+              | "topic_cooldown" | "empty_text"
+            - ``human_only`` (bool): True only for the high-engagement
+              carve-out — caller should NOT auto-draft.
+            - ``matched_signals`` (list[str]): which canonical signal terms
+              fired, for audit / replay.
+            - ``topic_fingerprint`` (list[str]): for downstream cooldown
+              tracking.
+    """
+    if not text or not text.strip():
+        return {
+            "passed": False,
+            "reason": "empty_text",
+            "human_only": False,
+            "matched_signals": [],
+            "topic_fingerprint": [],
+        }
+
+    domain_matches = sorted({m.group(0).lower() for m in _DELIMIT_DOMAIN_RE.finditer(text)})
+    orbit_matches = sorted({m.group(0).lower() for m in _ORBIT_RE.finditer(text)})
+    has_tech_context = bool(_TECH_CONTEXT_RE.search(text))
+
+    matched_signals = sorted(set(domain_matches) | set(orbit_matches))
+    topic_fp = matched_signals[:]
+
+    # Cooldown check — runs FIRST among the pass paths so a thread that
+    # would have qualified by Delimit-domain signal is still rejected if
+    # the topic is already covered. (Pass-path checks below only run if
+    # the cooldown didn't kill the candidate.)
+    if recent_topics:
+        overlap = set(topic_fp) & recent_topics
+        if overlap:
+            return {
+                "passed": False,
+                "reason": "topic_cooldown",
+                "human_only": False,
+                "matched_signals": matched_signals,
+                "topic_fingerprint": topic_fp,
+                "cooldown_overlap": sorted(overlap),
+            }
+
+    # Pass path 1: direct Delimit-domain hit.
+    if domain_matches:
+        return {
+            "passed": True,
+            "reason": "delimit_domain",
+            "human_only": False,
+            "matched_signals": matched_signals,
+            "topic_fingerprint": topic_fp,
+        }
+
+    # Pass path 2: orbit hit + technical-context word.
+    if orbit_matches and has_tech_context:
+        return {
+            "passed": True,
+            "reason": "orbit_with_context",
+            "human_only": False,
+            "matched_signals": matched_signals,
+            "topic_fingerprint": topic_fp,
+        }
+
+    # Pass path 3: high-engagement opportunity-cost carve-out. Pass
+    # through but flag human_only so the caller doesn't auto-draft.
+    if engagement_score >= high_engagement_floor:
+        return {
+            "passed": True,
+            "reason": "high_engagement_human_only",
+            "human_only": True,
+            "matched_signals": matched_signals,
+            "topic_fingerprint": topic_fp,
+        }
+
+    # Default: reject.
+    return {
+        "passed": False,
+        "reason": "no_delimit_fit",
+        "human_only": False,
+        "matched_signals": matched_signals,
+        "topic_fingerprint": topic_fp,
+    }
+
+
+# ── Audit logging helpers ──────────────────────────────────────────
+
+def append_jsonl(path: Path, payload: Dict[str, Any]) -> None:
+    """Append a single JSON line to ``path``. Tolerant of write errors —
+    logging must never crash the caller's pipeline.
+    """
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    except OSError as exc:  # pragma: no cover — best-effort logging
+        logger.warning("fit_floor: failed to write %s: %s", path, exc)
+
+
+__all__ = [
+    "DEFAULT_COOLDOWN_DAYS",
+    "DEFAULT_HIGH_ENGAGEMENT_FLOOR",
+    "SOCIAL_LOG",
+    "DELIMIT_DOMAIN_SIGNALS",
+    "ORBIT_SIGNALS",
+    "TECH_CONTEXT_SIGNALS",
+    "evaluate_fit",
+    "append_jsonl",
+    "_extract_topic_fingerprint",
+    "_recent_topic_fingerprints",
+]

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: