@m13v/s4l 1.7.2 → 1.7.4-rc.1

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()

package/scripts/merge_review_queue.py

@@ -19,6 +19,15 @@ Usage:
 
 State dir (for review-request.json) honors $S4L_STATE_DIR; the review-queue plan
 lives in $S4L_TMP_DIR or /tmp (matching the MCP's planPath()).
+
+LEDGER SEMANTICS (read this before counting anything in review-queue.json):
+the queue is APPEND-FOREVER — handled candidates are never removed, they are
+flag-stamped in place (posted / terminal+terminal_reason / post_failed /
+approved). "Not posted" is therefore NOT "awaiting review"; in an old queue
+most rows are retired. The canonical classifier is
+mcp/menubar/s4l_state.py::candidate_state(); the honest pending-cards count is
+its awaiting_review bucket, mirrored into review-request.json's .count here at
+merge time.
 """
 
 from __future__ import annotations
@@ -318,10 +327,21 @@ def main() -> int:
         _atomic_write(dst, plan_obj)
         ensure_store_symlink()
 
-        # Refresh the review-request marker the menu bar polls (count = pending,
-        # not posted, not terminal -- a just-pruned expired card must not still
-        # inflate the badge).
-        pending_count = len([c for c in merged if not c.get("posted") and not c.get("terminal")])
+        # Refresh the review-request marker the menu bar polls. count = cards
+        # actually awaiting review (mirrors s4l_state.candidate_state()'s
+        # awaiting_review bucket): approved-unposted and post_failed rows are
+        # settled decisions, counting them inflated the badge and misled every
+        # human/agent reading the marker.
+        pending_count = len(
+            [
+                c
+                for c in merged
+                if not c.get("posted")
+                and not c.get("terminal")
+                and not c.get("post_failed")
+                and not c.get("approved")
+            ]
+        )
         project = ns.project or batch.get("project") or (new_cands[0].get("matched_project") if new_cands else None)
         _atomic_write(
             review_request_path(),

package/scripts/pick_project.py

@@ -74,10 +74,17 @@ def recent_posts_by_project(platform=None, days=RECENT_WINDOW_DAYS):
 
 
 def _eligible_pool(config, platform=None, exclude=None):
-    """Projects eligible for selection: enabled, weight>0, platform-compatible."""
+    """Projects eligible for selection: enabled, weight>0, non-persona,
+    platform-compatible.
+
+    Persona entries (`persona: true`) are structurally excluded: they run ONLY
+    via the personal_brand lane's force-inject (s4l_mode.persona_name), never
+    via this promotion lottery, regardless of their `enabled` flag.
+    """
     pool = [
         p for p in config.get("projects", [])
         if p.get("enabled", True) and p.get("weight", 0) > 0
+        and p.get("persona") is not True
     ]
     if exclude:
         excluded = {n.lower() for n in exclude}
@@ -122,8 +129,10 @@ def pick_project(config, platform=None, exclude=None):
         return picks[0]
     if exclude:
         return None
-    # No eligible project at all: legacy fallback to any project in config.
-    projects = config.get("projects", [])
+    # No eligible project at all: legacy fallback to any non-persona project.
+    projects = [
+        p for p in config.get("projects", []) if p.get("persona") is not True
+    ]
     return random.choice(projects) if projects else None
 
 

package/scripts/recent_self_posts.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""scripts/recent_self_posts.py — cross-cycle anti-repetition context.
+
+Prints a prompt block listing OUR most recent posted replies on a platform
+(across ALL projects), so a drafting session can see what this account
+already sounds like and deliberately diverge. This is the cross-cycle
+complement to author_history_block.py (which is per-author only): before
+2026-07-10 the model never saw its own recent output across threads and
+kept recycling the same openers and sentence skeletons cycle after cycle.
+
+The block is explicitly NEGATIVE context ("do not sound like these"), the
+opposite of the top_performers few-shots. Keep it that way: never add
+engagement numbers or any "this one did well" framing here, or the model
+will read it as examples to imitate.
+
+Wired into (one callsite):
+  - skill/run-twitter-cycle.sh  (Phase 2b-prep PREP_PROMPT)
+
+CLI:
+  python3 scripts/recent_self_posts.py --platform twitter --limit 20
+
+Stdout is a ready-to-inject prompt block; EMPTY stdout when there are no
+rows or on any failure (the cycle must never block on this context).
+Stderr carries diagnostics only.
+"""
+
+import argparse
+import os
+import sys
+
+REPO_DIR = os.path.expanduser("~/social-autoposter")
+sys.path.insert(0, os.path.join(REPO_DIR, "scripts"))
+from http_api import api_get  # noqa: E402
+
+# Truncation length per reply. Long enough to expose the opener + skeleton
+# (the parts the model must avoid repeating), short enough that 20 rows stay
+# a small fraction of the prompt.
+SNIPPET_CHARS = 220
+
+
+def _load_active_campaign_suffixes():
+    """Best-effort list of active campaign suffix literals to strip.
+
+    Same contract as author_history_block._load_active_campaign_suffixes:
+    the block must never teach the model to echo a campaign suffix (the
+    tool layer appends its own copy at post time). On failure returns [].
+    """
+    suffixes = []
+    try:
+        resp = api_get(
+            "/api/v1/campaigns",
+            query={"status": "active", "has_suffix": "true", "limit": 500},
+        )
+        rows = ((resp or {}).get("data") or {}).get("campaigns") or []
+        for r in rows:
+            s = (r.get("suffix") or "").strip()
+            if s and s not in suffixes:
+                suffixes.append(s)
+    except Exception as e:
+        print(f"[recent_self_posts] suffix load failed: {e!r}", file=sys.stderr)
+    return suffixes
+
+
+def _strip_suffixes(text, suffixes):
+    """Trailing-only, idempotent strip (mirrors author_history_block)."""
+    if not text or not suffixes:
+        return text
+    cleaned = text.rstrip()
+    changed = True
+    while changed:
+        changed = False
+        for sfx in suffixes:
+            if sfx and cleaned.endswith(sfx):
+                cleaned = cleaned[: -len(sfx)].rstrip()
+                changed = True
+    return cleaned
+
+
+def _snippet(text, suffixes):
+    """One-line, suffix-stripped, truncated rendering of a reply."""
+    t = _strip_suffixes((text or "").strip(), suffixes)
+    t = " ".join(t.split())  # collapse newlines/runs of whitespace
+    if len(t) > SNIPPET_CHARS:
+        t = t[: SNIPPET_CHARS - 1].rstrip() + "…"
+    return t
+
+
+def build_block(platform, limit):
+    """Return the prompt block string, or "" when nothing to show."""
+    resp = api_get(
+        "/api/v1/posts",
+        query={
+            "platform": platform,
+            "status": "active",
+            "order_by": "posted_at",
+            "order_dir": "desc",
+            "limit": str(limit),
+        },
+    )
+    rows = ((resp or {}).get("data") or {}).get("posts") or []
+    suffixes = _load_active_campaign_suffixes()
+    items = []
+    for r in rows:
+        snip = _snippet(r.get("our_content"), suffixes)
+        if not snip:
+            continue
+        date = str(r.get("posted_at") or "")[:10]
+        proj = r.get("project_name") or "(no project)"
+        items.append(f"{len(items) + 1}. [{date} | {proj}] {snip}")
+        if len(items) >= limit:
+            break
+    if not items:
+        return ""
+    header = (
+        "## YOUR RECENT REPLIES (cross-cycle anti-repetition; NEGATIVE examples)\n"
+        f"The {len(items)} most recent replies this account posted, all projects. "
+        "This is what you ALREADY sound like. It is NOT a list to imitate. "
+        "Hard rules for every draft this cycle:\n"
+        "- Do NOT reuse any opener below (the first 6-8 words' shape counts, "
+        "not just the exact words).\n"
+        "- Do NOT reuse their sentence skeletons, rhetorical moves, or pet "
+        "phrases (recurring words like 'actually', 'the real X', copula "
+        "reframes 'X is the Y').\n"
+        "- If a draft you are writing starts to echo any entry below, stop "
+        "and rewrite it from a different entry point.\n"
+    )
+    return header + "\n".join(items)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Render the cross-cycle recent-self-replies prompt block")
+    parser.add_argument("--platform", default="twitter")
+    parser.add_argument("--limit", type=int, default=20)
+    args = parser.parse_args()
+    try:
+        block = build_block(args.platform, max(1, min(args.limit, 50)))
+    except Exception as e:
+        print(f"[recent_self_posts] failed: {e!r}", file=sys.stderr)
+        block = ""
+    if block:
+        print(block)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/release-mcpb.sh

@@ -460,7 +460,21 @@ if [[ "$DO_NPM" == "1" ]]; then
          fs.writeFileSync(p, JSON.stringify(j,null,2)+'\n');
          console.log('  temp copy renamed to $S4L_ALIAS_PKG@'+j.version+' (repo package.json untouched)');
        " \
-       && ( cd "$S4L_PUB_DIR/package" && npm publish --access=public ${NPM_TAG_ARGS[@]+"${NPM_TAG_ARGS[@]}"} ); then
+       && (
+            # The registry's large-upload path flakes (TLS bad record mac / EPIPE)
+            # often enough that one attempt let the alias lane silently drift for
+            # three rc's (rc.16/21/22, caught 2026-07-10). Retry, and between
+            # attempts check whether the upload actually landed despite the
+            # client-side error (EPIPE can be a false negative).
+            cd "$S4L_PUB_DIR/package" || exit 1
+            for _try in 1 2 3; do
+              npm publish --access=public ${NPM_TAG_ARGS[@]+"${NPM_TAG_ARGS[@]}"} && exit 0
+              sleep 3
+              [[ "$(curl -s -o /dev/null -w '%{http_code}' "$S4L_ALIAS_URL")" == "200" ]] && exit 0
+              echo "  dual-publish attempt $_try/3 failed" >&2
+            done
+            exit 1
+          ); then
       for _ in 1 2 3 4 5; do
         sleep 2
         [[ "$(curl -s -o /dev/null -w '%{http_code}' "$S4L_ALIAS_URL")" == "200" ]] && break

package/scripts/s4l_mode.py

@@ -58,14 +58,15 @@ Usage:
     s4l_mode.py split               # print the personal-brand share (0.0-1.0)
     s4l_mode.py split <value>       # set it; accepts 70, 70%, or 0.7
 
-Draft-only (2026-07-06): a third, independent flag in mode.json, DEFAULT ON.
-While ON (the normal state), every cycle stops before posting and its drafts
-become review cards. When an OPERATOR turns it off, run-draft-and-publish.sh
-runs promotion-lane cycles with DRAFT_ONLY=0 so they POST autonomously (the
-rolling virality bar is the quality gate). Persona-lane cycles ALWAYS stay
-draft-only (review cards) regardless. Deliberately NOT exposed on any user
-surface (no MCP tool param, no menubar toggle): this CLI and mode.json are the
-only way to flip it.
+Draft-only (2026-07-06, single global switch as of 2026-07-08): a third,
+independent flag in mode.json, DEFAULT ON. While ON (the normal state), every
+cycle stops before posting and its drafts become review cards. When an
+OPERATOR turns it off, run-draft-and-publish.sh runs EVERY lane (promotion AND
+personal_brand) with DRAFT_ONLY=0 so they POST autonomously (promotion
+additionally runs behind the rolling virality bar). This applies uniformly
+across lanes; persona-lane cycles do NOT stay draft-only when the flag is off.
+Deliberately NOT exposed on any user surface (no MCP tool param, no menubar
+toggle): this CLI and mode.json are the only way to flip it.
 `env` additionally exports S4L_CYCLE_LANE=<lane> for both lanes so the wrapper
 knows which lane this cycle is without re-deriving it.