delimit-cli 4.5.13 → 4.6.0

package/gateway/ai/social_capability/fit_floor.py

@@ -45,10 +45,19 @@ 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 cooldown window for topic coverage.
+# Original founder directive (2026-05-05): 7 days to avoid spam-pattern detection.
+# Revised 2026-05-12 (LED-1356, panel-unanimous): 7 days × cross-platform global
+# scope was producing 57% abstention rate (115/200 recent abstentions =
+# topic_cooldown) and effectively blocked every Delimit-relevant topic for a
+# full week after one draft. Reduced to 48h AND scoped per-platform/per-subreddit
+# so a Reddit/r/mcp draft no longer cools an HN draft on MCP, and a Reddit/r/mcp
+# draft no longer cools a Reddit/r/programming draft on MCP. Different audiences,
+# different scans.
+DEFAULT_COOLDOWN_HOURS = 48
+# Backwards-compat alias for any callers that still pass `cooldown_days=` —
+# converted to hours internally. Don't add new callers using this name.
+DEFAULT_COOLDOWN_DAYS = DEFAULT_COOLDOWN_HOURS / 24
 
 # Default high-engagement opportunity-cost threshold. Threads above this score
 # pass the fit floor even without keyword match, but with ``human_only=True``
@@ -179,18 +188,63 @@ def _parse_iso(value: Optional[str]) -> Optional[datetime]:
     return dt
 
 
+def _log_entry_scope_key(entry: dict) -> str:
+    """LED-1356 platform-scoped cooldown key. Reddit cooldowns are per-subreddit
+    (different subreddits = different audiences); HN/devto/X are global within
+    the platform. Cross-platform doesn't cool.
+
+    Returns:
+        - "reddit:r/<name>" for Reddit entries with a subreddit field
+        - "reddit" for Reddit entries without (legacy fallback)
+        - The platform name itself for hn / devto / x / twitter
+        - "unknown" when the entry doesn't carry a platform
+    """
+    platform = (entry.get("platform") or "").lower()
+    if not platform:
+        return "unknown"
+    if platform == "reddit":
+        sub = (entry.get("subreddit") or "").lower()
+        if sub:
+            sub = sub.lstrip("r/")
+            return f"reddit:r/{sub}"
+        return "reddit"
+    # twitter and x are aliases for the same audience
+    if platform == "twitter":
+        return "x"
+    return platform
+
+
 def _recent_topic_fingerprints(
-    cooldown_days: int = DEFAULT_COOLDOWN_DAYS,
+    cooldown_hours: float = DEFAULT_COOLDOWN_HOURS,
     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.
+    cooldown_days: Optional[float] = None,
+) -> Dict[str, Set[str]]:
+    """Return platform-scoped topic fingerprints from ``social_log.jsonl``
+    within the cooldown window.
+
+    LED-1356 changes (2026-05-12, panel-unanimous):
+    - Window default 7d → 48h.
+    - Return shape Set[str] → Dict[scope_key, Set[str]] so callers can ask
+      "what topics has THIS audience seen recently" instead of the prior
+      "global union of every topic across every platform."
+    - `cooldown_days` is preserved as backwards-compat kwarg; converted to
+      hours internally.
+
+    Callers should look up the relevant set via the dict and pass it to
+    ``evaluate_fit(..., recent_topics=...)``. A target's scope is computed
+    via :func:`_log_entry_scope_key` on the target dict.
+
+    Returns dict mapping scope_key → set of canonical signal fingerprints
+    drafted on for that scope within the window.
     """
     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()
+        return {}
+    # Backwards compatibility: if cooldown_days passed, convert to hours.
+    if cooldown_days is not None:
+        cooldown_hours = float(cooldown_days) * 24.0
+    cutoff = datetime.now(timezone.utc) - timedelta(hours=cooldown_hours)
+    seen: Dict[str, Set[str]] = {}
     try:
         with open(p, "r", encoding="utf-8") as fh:
             for line in fh:
@@ -204,6 +258,7 @@ def _recent_topic_fingerprints(
                 ts = _parse_iso(entry.get("ts"))
                 if ts is None or ts < cutoff:
                     continue
+                scope_key = _log_entry_scope_key(entry)
                 # 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
@@ -214,12 +269,55 @@ def _recent_topic_fingerprints(
                         entry.get("thread_title") or "",
                     ]
                 )
-                seen.update(_extract_topic_fingerprint(blob))
+                fps = _extract_topic_fingerprint(blob)
+                if not fps:
+                    continue
+                seen.setdefault(scope_key, set()).update(fps)
     except OSError as exc:
         logger.warning("fit_floor: failed to read %s: %s", p, exc)
     return seen
 
 
+def topics_for_scope(
+    recent_topics_dict: Dict[str, Set[str]],
+    scope_key: str,
+) -> Set[str]:
+    """Convenience helper: look up the topic set for a given scope.
+
+    Returns empty set if the scope has no recent activity in the window.
+    Callers should pass the result as ``evaluate_fit(..., recent_topics=...)``.
+    """
+    return recent_topics_dict.get(scope_key, set())
+
+
+def target_scope_key(target: dict) -> str:
+    """Compute the scope key for a target dict (for cooldown lookup).
+
+    Mirror of :func:`_log_entry_scope_key` for the inbound target side.
+    Targets may carry `platform` plus (for Reddit) `subreddit` extracted
+    from the thread URL.
+    """
+    platform = (target.get("platform") or "").lower()
+    if not platform:
+        return "unknown"
+    if platform == "reddit":
+        sub = (target.get("subreddit") or "").lower()
+        if not sub:
+            # Try to extract from canonical_url / thread_url
+            url = target.get("canonical_url") or target.get("thread_url") or ""
+            import re as _re
+            m = _re.search(r"/r/([A-Za-z0-9_]+)", url)
+            if m:
+                sub = m.group(1).lower()
+        if sub:
+            sub = sub.lstrip("r/")
+            return f"reddit:r/{sub}"
+        return "reddit"
+    if platform == "twitter":
+        return "x"
+    return platform
+
+
 # ── Fit-floor decision ──────────────────────────────────────────────
 
 
@@ -348,6 +446,7 @@ def append_jsonl(path: Path, payload: Dict[str, Any]) -> None:
 
 __all__ = [
     "DEFAULT_COOLDOWN_DAYS",
+    "DEFAULT_COOLDOWN_HOURS",
     "DEFAULT_HIGH_ENGAGEMENT_FLOOR",
     "SOCIAL_LOG",
     "DELIMIT_DOMAIN_SIGNALS",
@@ -357,4 +456,7 @@ __all__ = [
     "append_jsonl",
     "_extract_topic_fingerprint",
     "_recent_topic_fingerprints",
+    "_log_entry_scope_key",
+    "target_scope_key",
+    "topics_for_scope",
 ]