@m13v/s4l 1.6.197-rc.7

package/scripts/log_draft.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Persist a Phase 2b draft on a twitter_candidates row.
+
+Called by Claude inside Phase 2b BEFORE the twitter_browser.py post attempt,
+so a CDP / browser / monthly-cap failure doesn't waste the LLM redraft on the
+next cycle. The next cycle's Phase 2b sees draft_reply_text on the salvaged
+row and posts it as-is when fresh (DRAFT_TTL).
+
+Usage:
+    python3 scripts/log_draft.py \\
+        --candidate-id 12345 \\
+        --text "your reply text here" \\
+        --style curious_probe \\
+        [--assigned-style curious_probe --assigned-mode use] \\
+        [--new-style '{"description":"...","example":"...","why_existing_didnt_fit":"..."}'] \\
+        [--platform twitter]
+
+Engagement-style fields (2026-05-22 cutover, closes the Twitter enforcement gap):
+    --assigned-style / --assigned-mode
+        Picker output from saps_pick_style. Persisted to
+        twitter_candidates.assigned_style + .assigned_mode so
+        twitter_post_plan.py can call validate_or_register with the
+        original assignment and coerce USE-mode drift back, or accept the
+        INVENT-mode invention and POST it to /api/v1/engagement-styles/registry.
+        Both flags are optional for backward compatibility; legacy callers
+        that don't pass them get NULL columns and the post path falls back
+        to legacy (uncoerced) behaviour.
+    --new-style
+        JSON object literal with at minimum {description, example,
+        why_existing_didnt_fit}, optionally {note}. Persisted to
+        twitter_candidates.draft_new_style JSONB. Only meaningful in
+        INVENT mode; when present, twitter_post_plan.py bundles it into
+        the validate_or_register decision so the registry endpoint upserts
+        the new style row exactly like Reddit/GitHub/Moltbook do.
+
+Output (JSON):
+    {"logged": true, "candidate_id": 12345, "drafted_at": "..."}
+    {"error": "CANDIDATE_NOT_FOUND", ...}
+    {"error": "ALREADY_POSTED", ...}    # candidate has status != 'pending'
+    {"error": "BAD_NEW_STYLE_JSON", ...}  # --new-style was not parseable
+"""
+
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_patch
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--candidate-id", type=int, required=True)
+    p.add_argument("--text", required=True)
+    p.add_argument("--style", default=None)
+    p.add_argument(
+        "--assigned-style", default=None,
+        help="Picker's USE-mode pinned style name (NULL in INVENT mode).",
+    )
+    p.add_argument(
+        "--assigned-mode", default=None, choices=[None, "use", "invent"],
+        help="Picker mode for this batch: 'use' or 'invent'.",
+    )
+    p.add_argument(
+        "--new-style", default=None,
+        help="JSON object literal {description, example, why_existing_didnt_fit, note?} "
+             "when model invents a new style.",
+    )
+    p.add_argument(
+        "--platform",
+        default="twitter",
+        choices=["twitter"],
+        help="Reserved for future Reddit/LinkedIn drafts; only twitter for now.",
+    )
+    args = p.parse_args()
+
+    text = args.text.strip()
+    if not text:
+        print(json.dumps({"error": "EMPTY_TEXT"}))
+        sys.exit(1)
+
+    # Parse --new-style early so a malformed JSON arg fails before we touch
+    # the DB. We do NOT validate required fields here (description, example,
+    # why_existing_didnt_fit); validate_or_register/register_style does that
+    # at post time so this stays a pure persistence layer.
+    new_style_json = None
+    if args.new_style:
+        try:
+            parsed = json.loads(args.new_style)
+        except Exception as e:
+            print(json.dumps({"error": "BAD_NEW_STYLE_JSON", "detail": str(e)}))
+            sys.exit(1)
+        if not isinstance(parsed, dict):
+            print(json.dumps({"error": "BAD_NEW_STYLE_JSON",
+                              "detail": "must be a JSON object"}))
+            sys.exit(1)
+        new_style_json = json.dumps(parsed)
+
+    # platform is twitter-only today; the by-id endpoint targets twitter_candidates.
+    payload = {
+        "id": args.candidate_id,
+        "action": "set_draft",
+        "text": text,
+        "style": args.style,
+        "assigned_style": args.assigned_style,
+        "assigned_mode": args.assigned_mode,
+    }
+    if new_style_json is not None:
+        # Pass the already-validated JSON string; the endpoint re-parses it.
+        payload["new_style"] = new_style_json
+
+    resp = api_patch(
+        "/api/v1/twitter-candidates/by-id", payload,
+        ok_on_conflict=True, ok_on_404=True,
+    )
+
+    if (resp or {}).get("_not_found"):
+        print(json.dumps({"error": "CANDIDATE_NOT_FOUND", "candidate_id": args.candidate_id}))
+        sys.exit(1)
+    if not (resp or {}).get("ok"):
+        # 409 already_posted (status carried under error.details.status).
+        details = ((resp or {}).get("error") or {}).get("details") or {}
+        print(json.dumps({
+            "error": "ALREADY_POSTED",
+            "candidate_id": args.candidate_id,
+            "status": details.get("status"),
+        }))
+        sys.exit(1)
+
+    candidate = ((resp or {}).get("data") or {}).get("candidate") or {}
+    print(json.dumps({
+        "logged": True,
+        "candidate_id": args.candidate_id,
+        "drafted_at": candidate.get("drafted_at"),
+        "assigned_style": args.assigned_style,
+        "assigned_mode": args.assigned_mode,
+        "new_style_persisted": bool(new_style_json),
+    }))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/log_linkedin_search_attempts.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+log_linkedin_search_attempts.py
+
+Insert one row per (query, project, search_topic, candidates_found,
+serp_quality_score, dropped_below_floor) into linkedin_search_attempts. Reads a JSON array on
+stdin shaped like:
+
+    [
+      {"query": "...", "project": "fazm",   "search_topic": "AI agents", "candidates_found": 0, "serp_quality_score": 1.5, "dropped_below_floor": 0},
+      {"query": "...", "project": "mediar", "search_topic": "RPA replacement", "candidates_found": 7, "serp_quality_score": 8.0, "dropped_below_floor": 3},
+      ...
+    ]
+
+candidates_found is the POST-floor count (cards that passed
+discover_linkedin_candidates.py's velocity floor). dropped_below_floor is
+the per-query count of cards that the SERP returned but the floor rejected;
+absent or 0 for queries the floor didn't run on.
+
+Used by run-linkedin.sh after Phase A scrape parses queries_used out of the
+LLM envelope. Logging zero-result AND low-quality SERP queries here is the
+whole point: linkedin_candidates only has rows for posts that were actually
+extracted, so "query returned 30 influencer slop posts that we skipped" was
+previously invisible.
+
+Pair with top_dud_linkedin_queries.py.
+
+    python3 scripts/log_linkedin_search_attempts.py --batch-id <id> < queries.json
+
+Migrated 2026-06-01 from direct psycopg2/db.py INSERTs to the s4l.ai HTTP API
+(POST /api/v1/linkedin-search-attempts, batch form). No DATABASE_URL needed.
+"""
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_post
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--batch-id", default=None)
+    args = p.parse_args()
+
+    raw = sys.stdin.read().strip()
+    if not raw:
+        print("log_linkedin_search_attempts: empty stdin, nothing to log",
+              file=sys.stderr)
+        return 0
+
+    try:
+        rows = json.loads(raw)
+    except json.JSONDecodeError as e:
+        print(f"log_linkedin_search_attempts: bad JSON on stdin: {e}",
+              file=sys.stderr)
+        return 1
+
+    if not isinstance(rows, list) or not rows:
+        print("log_linkedin_search_attempts: not a list or empty list, nothing to log",
+              file=sys.stderr)
+        return 0
+
+    payload = []
+    for r in rows:
+        if not isinstance(r, dict):
+            continue
+        query = (r.get("query") or "").strip()
+        if not query:
+            continue
+        project = (r.get("project") or "").strip() or None
+        search_topic = (r.get("search_topic") or "").strip() or None
+        candidates_found = r.get("candidates_found")
+        try:
+            candidates_found = int(candidates_found if candidates_found is not None else 0)
+        except (TypeError, ValueError):
+            candidates_found = 0
+        dropped = r.get("dropped_below_floor")
+        try:
+            dropped = int(dropped if dropped is not None else 0)
+        except (TypeError, ValueError):
+            dropped = 0
+        serp = r.get("serp_quality_score")
+        try:
+            serp = float(serp) if serp is not None else None
+        except (TypeError, ValueError):
+            serp = None
+        payload.append({
+            "query": query,
+            "project_name": project,
+            "search_topic": search_topic,
+            "candidates_found": candidates_found,
+            "serp_quality_score": serp,
+            "candidates_dropped_below_floor": dropped,
+            "batch_id": args.batch_id,
+        })
+
+    if not payload:
+        print("log_linkedin_search_attempts: no valid rows after parse, nothing to log",
+              file=sys.stderr)
+        return 0
+
+    resp = api_post("/api/v1/linkedin-search-attempts", payload)
+    inserted = (resp.get("data") or {}).get("inserted", len(payload))
+
+    duds = sum(
+        1 for r in rows
+        if isinstance(r, dict) and not int(r.get("candidates_found") or 0)
+    )
+    low_quality = sum(
+        1 for r in rows
+        if isinstance(r, dict)
+           and r.get("serp_quality_score") is not None
+           and float(r["serp_quality_score"]) < 4.0
+    )
+    print(
+        f"log_linkedin_search_attempts: inserted {inserted} rows "
+        f"({duds} zero-result, {low_quality} low-SERP) for batch={args.batch_id}",
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())