@m13v/s4l 1.7.3 → 1.7.4-rc.10

package/scripts/enrich_reply_parents.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""Fill parent-thread linkage on X replies discovered via the notifications lane.
+
+The X notifications feed does not expose the parent tweet id, so
+scan_twitter_mentions_browser.py inserts `replies` rows with mention_id only:
+no post_id, no parent_reply_id, and often no project_name. This script
+resolves the parent chain AFTER the fact, deterministically, with no browser
+and no model: fxtwitter's public JSON (already used by fetch_twitter_t1.py)
+returns `replying_to_status` for any tweet.
+
+Per row with (post_id IS NULL AND parent_reply_id IS NULL):
+  1. fxtwitter GET on their_comment_id -> parent tweet id + handle.
+  2. Walk up the ancestor chain (bounded hops) until the root.
+  3. First ancestor that is one of OUR posts (/api/v1/posts/lookup, wide
+     window) -> PATCH replies.post_id (+ project_name when the row has none).
+  4. Immediate parent that is another tracked reply
+     (/api/v1/replies?their_comment_id=) -> PATCH parent_reply_id + depth.
+  5. Root author -> PATCH thread_author_handle.
+
+Terminal misses (tweet deleted, protected, not-a-reply with nothing to link)
+are remembered in a local state file so recurring runs don't refetch forever.
+
+Usage:
+  python3 scripts/enrich_reply_parents.py --limit 20            # recurring lane
+  python3 scripts/enrich_reply_parents.py --backfill            # all missing rows
+  python3 scripts/enrich_reply_parents.py --ids 546832 542579   # specific rows
+  python3 scripts/enrich_reply_parents.py --limit 5 --dry-run
+
+All DB I/O goes through the s4l.ai HTTP API (http_api), never direct SQL.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get, api_patch  # noqa: E402
+
+STATE_PATH = os.environ.get(
+    "S4L_ENRICH_PARENTS_STATE",
+    os.path.expanduser("~/.social-autoposter-enrich-parents.json"),
+)
+MAX_HOPS = 6
+LOOKUP_DAYS = 3650
+
+
+def load_state():
+    try:
+        with open(STATE_PATH) as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def save_state(state):
+    tmp = STATE_PATH + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(state, f)
+    os.replace(tmp, STATE_PATH)
+
+
+def fetch_fxtwitter(handle, tweet_id):
+    """Returns (status, tweet_dict). status: 'ok' | 'gone' | 'transient'."""
+    url = f"https://api.fxtwitter.com/{handle or 'i'}/status/{tweet_id}"
+    req = urllib.request.Request(url, headers={"User-Agent": "social-autoposter/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        # 401 = protected account, 404 = deleted. Both terminal.
+        if e.code in (401, 404):
+            return "gone", None
+        return "transient", None
+    except Exception:
+        return "transient", None
+    code = data.get("code")
+    if code == 200 and data.get("tweet"):
+        return "ok", data["tweet"]
+    if code in (401, 404):
+        return "gone", None
+    return "transient", None
+
+
+def walk_ancestors(handle, tweet_id, sleep_s):
+    """Ancestor chain bottom-up: [(id, handle), ...] parent first, root last.
+
+    Returns (chain, terminal) where terminal is 'root' when the walk reached a
+    non-reply tweet, or 'cut' when a hop was deleted/protected/transient (the
+    chain up to that point is still usable, but root attribution is not).
+    """
+    chain = []
+    cur_handle, cur_id = handle, tweet_id
+    for _ in range(MAX_HOPS):
+        status, tweet = fetch_fxtwitter(cur_handle, cur_id)
+        time.sleep(sleep_s)
+        if status != "ok":
+            # 'gone' is terminal (deleted/protected); 'transient' must NOT be
+            # remembered, the next run retries it.
+            return chain, status
+        parent_id = tweet.get("replying_to_status")
+        parent_handle = tweet.get("replying_to") or ""
+        if not parent_id:
+            return chain, "root"
+        chain.append((str(parent_id), parent_handle))
+        cur_handle, cur_id = parent_handle, parent_id
+    return chain, "hop_cap"
+
+
+def lookup_our_post(tweet_id):
+    resp = api_get(
+        "/api/v1/posts/lookup",
+        query={"platform": "twitter", "post_id": str(tweet_id), "days": str(LOOKUP_DAYS)},
+    )
+    return (resp.get("data") or {}).get("post") or None
+
+
+def lookup_tracked_reply(tweet_id):
+    resp = api_get(
+        "/api/v1/replies",
+        query={"platform": "x", "their_comment_id": str(tweet_id), "limit": "1"},
+    )
+    rows = (resp.get("data") or {}).get("replies") or []
+    return rows[0] if rows else None
+
+
+def fetch_work(limit, our_account=None, ids=None, before_id=None):
+    if ids:
+        out = []
+        for rid in ids:
+            resp = api_get(f"/api/v1/replies/{rid}")
+            row = (resp.get("data") or {}).get("reply")
+            if row:
+                out.append(row)
+        return out
+    query = {
+        "platform": "x",
+        "missing_parent": "1",
+        "order_by": "id",
+        "limit": str(limit),
+    }
+    if our_account:
+        query["our_account"] = our_account
+    if before_id:
+        query["before_id"] = str(before_id)
+    resp = api_get("/api/v1/replies", query=query)
+    return (resp.get("data") or {}).get("replies") or []
+
+
+def enrich_row(row, state, sleep_s, dry_run):
+    rid = row["id"]
+    tid = str(row.get("their_comment_id") or "")
+    handle = (row.get("their_author") or "").lstrip("@")
+    if not tid:
+        return "no_tweet_id"
+    if state.get(tid):
+        return "state_skip"
+
+    chain, terminal = walk_ancestors(handle, tid, sleep_s)
+    if not chain:
+        if terminal == "transient":
+            return "transient"  # retry next run, no state write
+        # Deleted/protected focal tweet, or a standalone mention (not a reply).
+        state[tid] = "gone" if terminal == "gone" else "not_a_reply"
+        return state[tid]
+
+    patch = {}
+    matched_post = None
+    for anc_id, _anc_handle in chain:
+        post = lookup_our_post(anc_id)
+        if post:
+            matched_post = post
+            break
+    if matched_post:
+        patch["post_id"] = matched_post["id"]
+        if not row.get("project_name") and matched_post.get("project_name"):
+            patch["project_name"] = matched_post["project_name"]
+
+    parent_id, _parent_handle = chain[0]
+    tracked = lookup_tracked_reply(parent_id)
+    if tracked and tracked["id"] != rid:
+        patch["parent_reply_id"] = tracked["id"]
+        patch["depth"] = (tracked.get("depth") or 1) + 1
+
+    if terminal == "root":
+        root_handle = (chain[-1][1] or "").lstrip("@")
+        if root_handle and not row.get("thread_author_handle"):
+            patch["thread_author_handle"] = root_handle
+
+    if not patch:
+        if terminal == "transient":
+            return "transient"  # incomplete walk; retry next run
+        # Full chain walked, nothing of ours in it: a foreign thread. Remember
+        # so we don't rewalk it every run.
+        state[tid] = "no_link"
+        return "no_link"
+
+    if dry_run:
+        print(f"  [DRY] reply {rid}: {json.dumps(patch)}")
+        return "would_patch"
+
+    resp = api_patch(f"/api/v1/replies/{rid}", patch)
+    if resp.get("error"):
+        print(f"  ERROR patching reply {rid}: {resp['error']}", file=sys.stderr)
+        return "patch_error"
+    state[tid] = "linked"
+    kinds = "+".join(k for k in ("post_id", "parent_reply_id", "thread_author_handle") if k in patch)
+    print(f"  linked reply {rid}: {kinds} {json.dumps(patch)}")
+    return "linked"
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Backfill parent-thread linkage on X replies")
+    ap.add_argument("--limit", type=int, default=20, help="rows per run (recurring lane)")
+    ap.add_argument("--backfill", action="store_true", help="keep paging until no work is left")
+    ap.add_argument("--ids", nargs="*", type=int, help="enrich specific reply ids")
+    ap.add_argument("--our-account", default=None, help="scope to one posting handle")
+    ap.add_argument("--all-accounts", action="store_true", help="do not scope by handle")
+    ap.add_argument("--sleep", type=float, default=0.5, help="seconds between fxtwitter calls")
+    ap.add_argument("--dry-run", action="store_true")
+    args = ap.parse_args()
+
+    our_account = args.our_account
+    if not our_account and not args.all_accounts and not args.ids:
+        try:
+            from account_resolver import resolve as _resolve_account
+            our_account = _resolve_account("twitter")
+        except Exception:
+            our_account = None
+        if not our_account:
+            print("No twitter account resolvable; pass --our-account or --all-accounts", file=sys.stderr)
+            sys.exit(1)
+
+    state = load_state()
+    totals = {}
+    seen_ids = set()
+    before_id = None
+    while True:
+        rows = fetch_work(
+            args.limit if not args.backfill else 200, our_account, args.ids, before_id
+        )
+        rows = [r for r in rows if r["id"] not in seen_ids]
+        if not rows:
+            break
+        for row in rows:
+            seen_ids.add(row["id"])
+            # Terminal misses (deleted tweet, foreign thread) never leave the
+            # missing_parent queue; the id cursor pages past them.
+            before_id = row["id"] if before_id is None else min(before_id, row["id"])
+            outcome = enrich_row(row, state, args.sleep, args.dry_run)
+            totals[outcome] = totals.get(outcome, 0) + 1
+            if len(seen_ids) % 25 == 0 and not args.dry_run:
+                save_state(state)
+        if not args.dry_run:
+            save_state(state)
+        if args.ids or not args.backfill:
+            break
+
+    print(f"[enrich_reply_parents] processed={len(seen_ids)} " +
+          " ".join(f"{k}={v}" for k, v in sorted(totals.items())))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/feedback_digest.py

@@ -82,6 +82,13 @@ MAX_EVENTS_PER_RUN = 200
 # degraded (a bad search topic, a draft-quality regression), not that any
 # single draft was wrong in a way the digest model could articulate.
 BULK_NO_REASON_THRESHOLD = int(os.environ.get("S4L_BULK_NO_REASON_THRESHOLD", "3"))
+# Two-draft cards ship raw per-box pointer-dwell ms in draft_choice; this is
+# the read-vs-skim floor for the draft the reviewer did NOT pick. At or above
+# it, keeping the preselected Draft A counts as an informed keep (they read B
+# and stayed); below it the approval says nothing about B. Threshold lives
+# HERE, not in the menubar client, so it can be tuned without a client
+# release.
+DRAFT_READ_MS = int(os.environ.get("S4L_DRAFT_READ_MS", "1000"))
 
 DISALLOWED_TOOLS = (
     "ScheduleWakeup,CronCreate,CronDelete,CronList,EnterPlanMode,EnterWorktree,"
@@ -106,10 +113,54 @@ def load_config():
         return {"projects": []}
 
 
+def _draft_choice(e: dict) -> dict | None:
+    """Parsed draft_choice payload (two-draft cards only). The API returns
+    jsonb as a dict; a locally-buffered event may still carry it as a JSON
+    string. None when absent, unparseable, or missing the unchosen draft
+    (nothing pairwise to say without the loser)."""
+    dc = e.get("draft_choice")
+    if isinstance(dc, str):
+        try:
+            dc = json.loads(dc)
+        except Exception:
+            return None
+    if not isinstance(dc, dict) or not (dc.get("unchosen_text") or "").strip():
+        return None
+    return dc
+
+
 def _event_line(e: dict) -> str:
     """One compact evidence line per event for the prompt."""
     parts = [f"[{e.get('decision')}{'+loved' if e.get('loved') else ''}]"]
     note = (e.get("reject_note") or "").strip()
+    # Two-draft pairwise flags (approvals only: on a reject BOTH drafts died,
+    # so which box the caret sat in carries no preference). Weighting ladder,
+    # explained to the model in build_prompt: an active switch to Draft B is
+    # strong (they necessarily read both); keeping the preselected A counts
+    # only when hover dwell shows they actually read B; a fast approve with B
+    # unread is flagged as exactly that so no preference gets fabricated.
+    dc = _draft_choice(e) if e.get("decision") == "approved" else None
+    show_unchosen = False
+    if dc:
+        if not dc.get("auto_selected"):
+            parts.append("picked_draft_b_over_default_a")
+            show_unchosen = True
+        elif dc.get("visited_other"):
+            # Clicked into B, then came back and approved A: an explicit
+            # head-to-head choice of the default, same strength as a switch
+            # (2026-07-10 user rule: only a zero-interaction approve is
+            # no-signal).
+            parts.append("chose_default_a_after_trying_b")
+            show_unchosen = True
+        else:
+            other_ms = dc.get("hover_b_ms") or 0
+            if other_ms >= DRAFT_READ_MS:
+                parts.append(
+                    f"kept_default_a_after_reading_b={round(other_ms / 1000, 1)}s"
+                )
+                show_unchosen = True
+            else:
+                parts.append("second_draft_not_read")
     if e.get("reject_category"):
         parts.append(f"category={e['reject_category']}")
     elif e.get("decision") == "rejected" and not note:
@@ -147,6 +198,13 @@ def _event_line(e: dict) -> str:
         line += f"\n  user REWROTE it to: {draft[:300]}"
     elif draft:
         line += f"\n  our draft was: {draft[:200]}"
+    if dc and show_unchosen:
+        line += f"\n  the draft they did NOT pick was: {(dc.get('unchosen_text') or '')[:300]}"
+        if dc.get("style") or dc.get("unchosen_style"):
+            line += (
+                f"\n  styles: picked={dc.get('style') or '?'}"
+                f" not_picked={dc.get('unchosen_style') or '?'}"
+            )
     url = (e.get("thread_url") or "").strip()
     if url:
         line += f"\n  thread: {url}"
@@ -205,6 +263,8 @@ NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(no_reaso
 
 Categories: wrong_author = the thread's author/audience was a bad fit; off_topic = the thread itself was a bad fit; bad_draft = thread was fine but the written reply was off; other = see the note. "no_reason_given" means the user rejected without picking a category or typing a note: the rejection itself is real, but WHY is your inference from the author/thread/draft context alone, so treat it as weak evidence. It can corroborate a pattern that reasoned events already show, but a no_reason_given reject never justifies a new entry or an author block on its own, and 2+ of them agreeing still only justify an entry when the shared pattern in their context is unmistakable. "edited_before_approving" with an ORIGINAL/REWROTE pair means the user hand-corrected our draft before posting: the rewrite is a direct statement of the voice they want. Diff the pair; when 2+ edits show the same correction (a phrase type removed, a structure replaced, tone shifted, length cut), distill that recurring pattern into draft_style_notes. Ignore edit content that is lead-specific or cosmetic (typo fixes, one-off facts); learn only what generalizes. "user_checked=profile_click" means the user opened the author's profile before deciding (a strong author-quality signal even without a note). "[approved+loved]" means the user picked the heart in the approve row ("this was a really good one"; approve_level_N in interactions carries the strength, 2 = best of the best): strong positive evidence for audience_prefer and thread selection, worth roughly two plain approvals.
 
+Two-draft cards show a "did NOT pick" pair. "picked_draft_b_over_default_a" means the card offered two drafts with A preselected and the user deliberately clicked into B and approved it: a direct head-to-head preference for the picked draft over the shown alternative, evidence on par with a hand rewrite. "chose_default_a_after_trying_b" means they clicked into B (trying it as the selection) and then came back and approved A: equally explicit, the same head-to-head strength as a switch, just with the default as the winner. "kept_default_a_after_reading_b=Xs" means they kept the preselected A but spent Xs with the pointer over B first: an informed keep, weaker than either explicit choice (reading B does not prove they weighed it; treat like no_reason_given, corroborating a pattern that stronger events already show rather than founding one). "second_draft_not_read" means they approved the default without touching or reading the alternative: NO pairwise signal, never infer anything against the unread draft. When 2+ pairwise events agree, diff the picked texts against the not-picked ones and distill WHAT recurs (tone, structure, length, opener type, directness) into draft_style_notes; the "styles:" line names each side's engagement style, useful when the same style keeps winning or losing.
+
 You can also block SPECIFIC authors via the plan's block_authors list. A block is a permanent hard exclusion of that one handle from all future thread selection, so it is YOUR judgment call, never automatic. Block when the evidence is strong: a wrong_author reject IS a direct human statement about that author (especially with profile_click), and the author context (author_followers, their post, found_via_topic) or the user's note confirms the account itself was the problem rather than the topic. Do NOT block when the reject looks topic-driven (off_topic/bad_draft on a reasonable account) or when you are unsure; the generalizable TYPE entry in audience_avoid is the softer tool for that.
 
 Propose changes to the block. RULES, in priority order:
@@ -333,6 +393,16 @@ def _is_actionable(e: dict) -> bool:
     # as actionable as a reject (and it feeds edit_examples).
     if e.get("edited"):
         return True
+    # An explicit pairwise draft choice (switched to B, or tried B and came
+    # back to A) is style evidence on par with an edit; without this trigger a
+    # reviewer who mostly approves would bank pairwise signals behind the
+    # plain-approvals gate forever. Hover-only informed keeps stay
+    # NON-actionable on purpose: they are corroborating-weight evidence (like
+    # no_reason_given) and ride along with the next real trigger instead of
+    # burning a Claude turn on their own.
+    dc = _draft_choice(e)
+    if dc and (not dc.get("auto_selected") or dc.get("visited_other")):
+        return True
     return bool((e.get("reject_note") or "").strip())
 
 

package/scripts/invent_styles.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""scripts/invent_styles.py — standalone daily engagement-style invention.
+
+Architectural split (2026-07-10, mirrors the 2026-05-28 invent_topics.py
+split): in-cycle style invention (the picker's 5% INVENT_RATE roll) is
+retired. It ran INSIDE the drafting prep session, with the top-performers
+leaderboard and winner exemplars in context, so every "new" style was a
+renamed variant of the currently-winning move (agree-then-relocate /
+concede-then-reverse). Combined with name-only dedup in register_style,
+the registry accumulated hundreds of semantic clones.
+
+This job runs OUTSIDE any drafting context, on the operator Mac only:
+
+  - The registry is GLOBAL across installs (every install reads every
+    style), so invention must NOT fan out per install the way topic
+    invention does. One central daily run is the correct scope; that is
+    the deliberate difference from invent_topics.py's per-install kicker.
+  - The prompt carries the existing style universe and explicitly forbids
+    the dominant structural family; the ask is a style from an
+    UNREPRESENTED family, not a riff on the champion.
+  - Post-hoc semantic dedup (token-Jaccard on description+example, plus a
+    reframe-family heuristic) rejects near-clones; a rejection re-prompts
+    with a grown avoid-list, at most DUPE_RETRIES times.
+  - Accepted styles are registered via engagement_styles.register_style
+    (kind='model_invented'), same as the retired inline path, so pickers
+    see them on their next tick with zero other wiring.
+
+Scheduling: launchd com.m13v.s4l-invent-styles (operator Mac, daily).
+Uses run_claude.sh with tag 'invent-styles'; the tag is NOT in
+claude_job.py TAG_TO_TYPE, so it runs the local `claude -p` lane and has
+no dependency on the Desktop queue worker.
+
+CLI:
+  python3 scripts/invent_styles.py                 # invent + register 1
+  python3 scripts/invent_styles.py --max-new 2
+  python3 scripts/invent_styles.py --dry-run       # propose, don't register
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+_REPO_DIR = os.path.expanduser("~/social-autoposter")
+sys.path.insert(0, os.path.join(_REPO_DIR, "scripts"))
+from engagement_styles import get_all_styles, register_style  # noqa: E402
+
+_RUN_CLAUDE_SH = os.path.join(_REPO_DIR, "scripts", "run_claude.sh")
+SCRIPT_TAG = "invent-styles"
+CALL_TIMEOUT_SEC = 420
+DUPE_RETRIES = 3
+SIMILARITY_THRESHOLD = 0.5  # Jaccard on description+example tokens
+
+# Heuristic markers of the saturated agree-then-relocate/reframe family.
+# A proposal whose description/example leans on these is a clone of the
+# dominant move no matter how novel its name is; reject like a dupe.
+_REFRAME_MARKERS = re.compile(
+    r"\b(reframe|relocat\w+|the real (work|question|problem|cost|part|win)"
+    r"|hidden (cost|part|work|meter)|easy (part|half)|hard(er)? (part|half)"
+    r"|was never (the|about)|nobody (mentions|talks about|tracks|measures)"
+    r"|isn.t the .{0,30}it.s|concede)\b",
+    re.I,
+)
+
+
+def _tokens(text):
+    return set(re.findall(r"[a-z0-9]+", (text or "").lower()))
+
+
+def _jaccard(a, b):
+    ta, tb = _tokens(a), _tokens(b)
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+
+def _style_text(entry):
+    return f"{entry.get('description') or ''} {entry.get('example') or ''}"
+
+
+def _find_near_dupe(proposal, universe):
+    """Return (reason, existing_name) when the proposal is a clone; else None."""
+    name = proposal["name"]
+    if name in universe:
+        return ("name_exists", name)
+    ptext = _style_text(proposal)
+    if _REFRAME_MARKERS.search(f"{proposal.get('description','')} {name}"):
+        return ("reframe_family", "(dominant agree-then-relocate family)")
+    best_name, best_sim = None, 0.0
+    for ename, entry in universe.items():
+        sim = _jaccard(ptext, _style_text(entry))
+        if sim > best_sim:
+            best_name, best_sim = ename, sim
+    if best_sim >= SIMILARITY_THRESHOLD:
+        return (f"jaccard={best_sim:.2f}", best_name)
+    return None
+
+
+def build_prompt(universe, avoid):
+    names = sorted(universe.keys())
+    # Detail only a bounded sample (prompt-size guard): the seeds plus the
+    # most recently registered rows carry enough signal about what already
+    # exists; the full NAME list covers the rest for the model's self-check.
+    detailed = []
+    for name in names:
+        e = universe[name]
+        if e.get("kind") == "seed" or len(detailed) < 40:
+            desc = " ".join((e.get("description") or "").split())[:180]
+            detailed.append(f"- {name}: {desc}")
+        if len(detailed) >= 60:
+            break
+    avoid_block = ""
+    if avoid:
+        avoid_block = (
+            "\nAlready proposed and REJECTED this run (do not resubmit or "
+            "paraphrase): " + ", ".join(avoid) + "\n"
+        )
+    return f"""You maintain the engagement-style registry for a social reply system. A style is a named rhetorical TEMPLATE (description + one example reply) that drafters follow when writing short replies on X/Twitter and Reddit.
+
+PROBLEM: the registry is saturated with ONE structural family: agree-then-relocate (concede the surface point, move the spotlight to the hidden/harder/unmeasured part, often "X is easy, Y is the real work" or "X was never the point, Y is"). Do NOT invent another member of that family, however disguised.
+
+EXISTING STYLE NAMES ({len(names)} total):
+{", ".join(names)}
+
+REPRESENTATIVE DETAILS (sample):
+{chr(10).join(detailed)}
+{avoid_block}
+TASK: invent exactly ONE genuinely new style from a structural family that is missing or rare above. Families worth mining (pick ONE, or another you identify): direct answer with zero framing; first-person confession of a specific failure; pure curious question with no thesis; dry understatement one-liner; enthusiastic cosign with one concrete addition; flat disagreement stated plainly without conceding anything first; a tiny numbered checklist; a vivid analogy that does NOT end in a lesson; deadpan humor riffing on the thread's wording.
+
+Rules:
+- The example must read like a real human reply (lowercase ok), 40-220 chars, NO links, NO product names.
+- The style must be usable across many products and threads, not thread-specific.
+- Your answer will be dedup-checked by token similarity against every existing style's description+example; if you cannot find a genuinely different move, return the saturation envelope instead of forcing a paraphrase.
+
+Answer with ONLY one JSON object, no prose, in one of these two shapes:
+{{"name": "snake_case_name", "description": "...", "example": "...", "why_existing_didnt_fit": "...", "target_chars": <int, the length the example is>}}
+{{"saturated": true, "reason": "..."}}"""
+
+
+def call_claude(prompt):
+    proc = subprocess.run(
+        ["bash", _RUN_CLAUDE_SH, SCRIPT_TAG, "-p", "--output-format", "json",
+         prompt],
+        text=True, capture_output=True, timeout=CALL_TIMEOUT_SEC,
+    )
+    if proc.returncode == 79:
+        raise SystemExit("[invent_styles] provider blocked (exit 79); skipping run")
+    if proc.returncode != 0:
+        raise SystemExit(
+            f"[invent_styles] run_claude.sh exited {proc.returncode}: "
+            f"{(proc.stderr or '')[:400]}")
+    try:
+        envelope = json.loads(proc.stdout)
+        text = envelope.get("result") or ""
+    except json.JSONDecodeError:
+        text = proc.stdout
+    return text
+
+
+def _extract_json(text):
+    """Pull the first parseable JSON object out of model output."""
+    text = (text or "").strip()
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S)
+    if fence:
+        text = fence.group(1)
+    start = text.find("{")
+    while start != -1:
+        for end in range(len(text), start, -1):
+            try:
+                obj = json.loads(text[start:end])
+                if isinstance(obj, dict):
+                    return obj
+            except json.JSONDecodeError:
+                continue
+        start = text.find("{", start + 1)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Standalone style invention job")
+    parser.add_argument("--max-new", type=int, default=1,
+                        help="How many styles to invent this run (default 1)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Propose and dedup-check but do not register")
+    args = parser.parse_args()
+
+    registered = 0
+    for slot in range(max(1, args.max_new)):
+        universe = get_all_styles()
+        avoid = []
+        accepted = None
+        for attempt in range(1 + DUPE_RETRIES):
+            raw = call_claude(build_prompt(universe, avoid))
+            obj = _extract_json(raw)
+            if not obj:
+                print(f"[invent_styles] slot={slot} attempt={attempt} "
+                      f"unparseable output: {raw[:200]!r}", file=sys.stderr)
+                continue
+            if obj.get("saturated"):
+                print(f"[invent_styles] slot={slot} model reports saturation: "
+                      f"{obj.get('reason', '')[:200]}", file=sys.stderr)
+                break
+            name = str(obj.get("name") or "").strip()
+            if not re.fullmatch(r"[a-z0-9_]{3,60}", name):
+                print(f"[invent_styles] slot={slot} bad name {name!r}; retrying",
+                      file=sys.stderr)
+                avoid.append(name or "(unnamed)")
+                continue
+            dupe = _find_near_dupe({**obj, "name": name}, universe)
+            if dupe:
+                reason, existing = dupe
+                print(f"[invent_styles] slot={slot} rejected {name!r}: {reason} "
+                      f"vs {existing}", file=sys.stderr)
+                avoid.append(name)
+                continue
+            accepted = {**obj, "name": name}
+            break
+        if not accepted:
+            continue
+        if args.dry_run:
+            print(json.dumps({"dry_run": True, **accepted}, indent=2))
+            continue
+        status, entry = register_style(
+            accepted["name"],
+            {
+                "description": accepted.get("description", ""),
+                "example": accepted.get("example", ""),
+                "why_existing_didnt_fit": accepted.get("why_existing_didnt_fit", ""),
+                "target_chars": accepted.get("target_chars"),
+            },
+            source_post={"platform": "invent_styles_job", "model": "invent_styles"},
+        )
+        print(f"[invent_styles] slot={slot} register status={status} "
+              f"name={accepted['name']}", file=sys.stderr)
+        if status == "new":
+            registered += 1
+            print(json.dumps({"registered": accepted["name"],
+                              "description": accepted.get("description", "")}))
+    print(f"[invent_styles] done: registered={registered}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()