@m13v/s4l 1.7.6-rc.8 → 1.7.6

package/scripts/engagement_styles.py

@@ -1048,6 +1048,51 @@ def compute_target_distribution(platform, context="posting"):
 INVENT_RATE = 0.0  # retired inline roll (was 0.05, ~1 in 20 posts)
 CURATED_TOP_N = 5   # size of the invent-mode reference list (top 5 by score)
 
+# Draft-prompt treatment_v4 assigns NO real engagement style, on ANY platform
+# that participates in the S4L_DRAFT_PROMPT_VARIANT experiment (currently
+# Twitter and Reddit, both of which export it via
+# draft_prompt_core.pick_draft_prompt_arm() before picking a style). This is
+# the ONE place that decision is made: pick_style_for_post() and
+# pick_exploration_style() below both short-circuit on it, so every caller
+# (Twitter's s4l_pick_style bash wrapper, Reddit's direct Python call, and
+# any future platform driver) gets the same behavior for free, with nothing
+# to remember to wire up per-platform. A caller that reads the env var
+# directly instead of routing through these functions is the only way to
+# miss this. Must match draft_prompt_core.py's ARM_TREATMENT = "treatment_v4".
+# 2026-07-17: consolidated here after a real bug -- the same "treatment_v4 =
+# no style" check used to live only in run-twitter-cycle.sh (Twitter's bash
+# driver), one layer above this shared function, so Reddit (which calls
+# pick_style_for_post() directly, bypassing that bash script entirely) never
+# got it: Reddit kept assigning a real style, the model still correctly
+# wrote "voice_first" per get_assigned_style_prompt()'s render-side check
+# below, and validate_or_register()'s USE-mode drift protection silently
+# coerced "voice_first" back to the real assigned style at post time.
+STYLE_SENTINEL_TREATMENT = "voice_first"
+
+
+def _is_treatment_v4():
+    return (os.environ.get("S4L_DRAFT_PROMPT_VARIANT") or "").strip() == "treatment_v4"
+
+
+def _treatment_v4_assignment():
+    """The single no-style assignment returned by both pickers below when
+    _is_treatment_v4(). style is the literal sentinel, not None/empty, on
+    purpose: this makes the assignment identical to what the model is told
+    to output (see get_assigned_style_prompt), so validate_or_register's
+    first, simplest check (style == assigned_style -> valid) accepts it
+    with no special-casing anywhere downstream, on either platform."""
+    return {
+        "mode": "use",
+        "style": STYLE_SENTINEL_TREATMENT,
+        "description": None,
+        "example": None,
+        "note": None,
+        "target_chars": None,
+        "reference_styles": [],
+        "distribution_snapshot": [],
+        "picked_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+    }
+
 # Fallback target comment length (chars) for any style that lacks an explicit
 # target_chars (legacy DB rows, cold-start before the registry is reachable).
 # Set just above the top-human-reply median (~74) so the long tail of styles
@@ -1207,6 +1252,9 @@ def pick_style_for_post(platform, context="posting",
             "picked_at": ISO-8601 UTC,
         }
     """
+    if _is_treatment_v4():
+        return _treatment_v4_assignment()
+
     rnd = rng or random
 
     # Human-derived branch (2026-05-22, second pass): on every platform,
@@ -1377,6 +1425,12 @@ def pick_exploration_style(platform, context="posting", exclude=None,
     posted draft's engagement write the style's first real score, and
     winners graduate into the Draft-A pool through the normal sampler.
     """
+    if _is_treatment_v4():
+        # No exploration under treatment_v4 (see STYLE_SENTINEL_TREATMENT
+        # above): return None so the caller's existing "pool empty, fall
+        # back to the scored picker" path fires, which routes through
+        # pick_style_for_post() and converges on the same sentinel.
+        return None
     rnd = rng or random
     try:
         never = set(PLATFORM_POLICY.get(platform, {}).get("never", []))
@@ -1463,112 +1517,95 @@ def get_assigned_style_prompt(platform, assignment, context="posting"):
     policy = PLATFORM_POLICY.get(platform, PLATFORM_POLICY["reddit"])
     lines = []
 
-    if assignment["mode"] == "use":
-        # Draft-prompt A/B v4 (voice-first, 2026-07-15 RESET of v3): v3's
-        # treatment rendered the style as the BINDING FORM of the draft
-        # (defining move + per-style length for EVERY assignment + self-check
-        # + two-layer learned_preferences contract). v4 replaces that
-        # wholesale: measured, real voice signal (the account's own corpus +
-        # voice.examples + learned_preferences, all handled in the
-        # DRAFT_DIRECTIVE built by run-twitter-cycle.sh) is meant to be the
-        # DOMINANT signal, and a generic cross-account style template
-        # dictating structure/length was competing with that. treatment_v4
-        # keeps the style as an optional idea for angle/length only, never a
-        # required shape. The arm is read from the env HERE because this
-        # block is rendered inside the cycle process where
-        # run-twitter-cycle.sh assigns and exports S4L_DRAFT_PROMPT_VARIANT
-        # (stamp-at-source: that same process also stamps the arm onto every
-        # plan candidate via active_experiments). Downstream/post-time
-        # consumers never re-read this env. Unset or control_v4 (and every
-        # non-twitter caller, which never has the env) renders the legacy
-        # block below unchanged — that block IS the v4 control arm, same as
-        # it was the v3 control arm; v1-v3 arm strings are retired and will
-        # never match here again, so this branch is now unreachable for any
-        # value except "treatment_v4".
-        _dp_arm = (os.environ.get("S4L_DRAFT_PROMPT_VARIANT") or "").strip()
-        if _dp_arm == "treatment_v4":
-            _tc = assignment.get("target_chars") or DEFAULT_TARGET_CHARS
-            lines.append(
-                f"## Your assigned engagement style: **{assignment['style']}** "
-                "(an optional idea for angle and length, NOT a required structure)"
-            )
-            lines.append("")
-            lines.append(
-                f"This style was selected by the picker (weighted by live "
-                f"click-driven performance across {platform}). Draw on it for "
-                f"inspiration when it fits naturally. The voice/preferences "
-                f"priority order in the draft directive below takes precedence "
-                f"whenever it pulls in a different direction — never force this "
-                f"style's shape at the cost of that."
-            )
-            lines.append("")
-            lines.append(f"Platform tone: {policy.get('note', '')}")
-            lines.append("")
-            lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
-            if assignment.get("example"):
-                lines.append(f'  Example: "{assignment["example"]}"')
-            if assignment.get("note"):
-                lines.append(f"  Note: {assignment['note']}")
+    # Draft-prompt A/B v4 (voice-first, 2026-07-15 RESET of v3; style
+    # assignment dropped entirely 2026-07-17): v3's treatment rendered the
+    # style as the BINDING FORM of the draft. v4 first demoted it to "an
+    # optional idea for angle/length", but a real 21-pair batch comparison
+    # showed the demoted style block was STILL polluting context: the
+    # picker's one canonical example for a batch's assigned style bled its
+    # own vocabulary into every candidate that batch regardless of topic
+    # (e.g. a batch drawing 'attention_is_the_input' produced 6/6 drafts
+    # pivoting on "who's paying attention", across unrelated threads). Style
+    # is now not shown to the model AT ALL for treatment_v4: the account's
+    # real voice corpus + learned_preferences are the sole drafting signal.
+    # The arm is read from the env HERE because this block is rendered
+    # inside the cycle process where run-twitter-cycle.sh assigns and
+    # exports S4L_DRAFT_PROMPT_VARIANT (stamp-at-source: that same process
+    # also stamps the arm onto every plan candidate via active_experiments).
+    # Unset or control_v4 (and every non-twitter caller, which never has the
+    # env) renders the legacy block below unchanged — that block IS the v4
+    # control arm, same as it was the v3 control arm.
+    #
+    # pick_style_for_post()/pick_exploration_style() (above, in this same
+    # module) already refuse to assign a real style under treatment_v4 and
+    # return STYLE_SENTINEL_TREATMENT itself as `assignment["style"]`, so
+    # this render-side check and that pick-side check agree by construction
+    # instead of by convention -- no separate literal to keep in sync here.
+    if _is_treatment_v4():
+        lines.append(
+            "## Engagement style: not used for this draft (voice-first mode)"
+        )
+        lines.append("")
+        lines.append(
+            "This account's real voice (the ACCOUNT VOICE CORPUS block and "
+            "voice.examples) and learned_preferences drive this reply, not a "
+            "named engagement style — no style name, description, example, "
+            "or length target is assigned this draft. "
+            f'In your output JSON, set "engagement_style" to exactly '
+            f'"{STYLE_SENTINEL_TREATMENT}" and leave "new_style" as null, for BOTH '
+            "Draft A and Draft B. Do not invent, reuse, or reference any "
+            "other style name for this draft."
+        )
+    elif assignment["mode"] == "use":
+        # This IS the v4 control arm (unchanged since v3 control / v2's control
+        # text). treatment_v4 never reaches here; see the sentinel branch above.
+        lines.append(f"## Your assigned engagement style: **{assignment['style']}**")
+        lines.append("")
+        lines.append(
+            f"This style was selected by the picker (weighted by live "
+            f"click-driven performance across {platform}). Use it. Do not "
+            f"swap it for a different listed style."
+        )
+        lines.append("")
+        lines.append(f"Platform tone: {policy.get('note', '')}")
+        lines.append("")
+        lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
+        if assignment.get("example"):
+            lines.append(f'  Example: "{assignment["example"]}"')
+        if assignment.get("note"):
+            lines.append(f"  Note: {assignment['note']}")
+        # LENGTH A/B CONCLUDED 2026-06-04: control won, so the prompt always
+        # uses the legacy generic length guidance. The treatment's per-style
+        # target prompt remains preserved only in the shipped experiment card.
+        #
+        # EXCEPTION (2026-07-11, Draft-B explore slot): exploration
+        # assignments (pick_exploration_style, marked by `source`) honor the
+        # style's own target_chars so the A/B pair diverges on the length
+        # axis too. The uniform clamp flattened every draft to the same
+        # 2-sentence shape (user: "the older drafts looked all very similar
+        # in terms of the length"). The 06-04 conclusion still governs the
+        # scored path, which never carries `source`.
+        _explore_tc = assignment.get("target_chars")
+        if (assignment.get("source") in ("human_derived", "model_invented")
+                and _explore_tc):
             lines.append("")
             lines.append(
-                f"**LENGTH: aim for about {int(_tc)} characters** "
+                f"**LENGTH: aim for about {int(_explore_tc)} characters** "
                 "(this style's own winning length; within about 30% either "
-                "way is fine, never above 250) unless the account's own real "
-                "examples run clearly shorter or longer, in which case match "
-                "them instead. This applies to the comment text only; any "
-                "link/CTA the system appends afterward is separate."
+                "way is fine, never above 250). Let the target set the form: "
+                "a very short target means one clipped line, a long one can "
+                "breathe. Do NOT default to the usual two-sentence shape. "
+                "This applies to the comment text only; any link/CTA the "
+                "system appends afterward is separate."
             )
         else:
-            lines.append(f"## Your assigned engagement style: **{assignment['style']}**")
             lines.append("")
             lines.append(
-                f"This style was selected by the picker (weighted by live "
-                f"click-driven performance across {platform}). Use it. Do not "
-                f"swap it for a different listed style."
+                "**LENGTH: keep it tight.** One or two sentences, well under the "
+                "250-character Twitter limit. A short, sharp reply almost always "
+                "beats a paragraph. This applies to the comment text only; any "
+                "link/CTA the system appends afterward is separate."
             )
-            lines.append("")
-            lines.append(f"Platform tone: {policy.get('note', '')}")
-            lines.append("")
-            lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
-            if assignment.get("example"):
-                lines.append(f'  Example: "{assignment["example"]}"')
-            if assignment.get("note"):
-                lines.append(f"  Note: {assignment['note']}")
-            # LENGTH A/B CONCLUDED 2026-06-04: control won, so the prompt always
-            # uses the legacy generic length guidance. The treatment's per-style
-            # target prompt remains preserved only in the shipped experiment card.
-            #
-            # EXCEPTION (2026-07-11, Draft-B explore slot): exploration
-            # assignments (pick_exploration_style, marked by `source`) honor the
-            # style's own target_chars so the A/B pair diverges on the length
-            # axis too. The uniform clamp flattened every draft to the same
-            # 2-sentence shape (user: "the older drafts looked all very similar
-            # in terms of the length"). The 06-04 conclusion still governs the
-            # scored path, which never carries `source`.
-            #
-            # (The draft-prompt v3 treatment arm above supersedes this clamp
-            # for its cycles; this legacy branch IS the v3 control arm.)
-            _explore_tc = assignment.get("target_chars")
-            if (assignment.get("source") in ("human_derived", "model_invented")
-                    and _explore_tc):
-                lines.append("")
-                lines.append(
-                    f"**LENGTH: aim for about {int(_explore_tc)} characters** "
-                    "(this style's own winning length; within about 30% either "
-                    "way is fine, never above 250). Let the target set the form: "
-                    "a very short target means one clipped line, a long one can "
-                    "breathe. Do NOT default to the usual two-sentence shape. "
-                    "This applies to the comment text only; any link/CTA the "
-                    "system appends afterward is separate."
-                )
-            else:
-                lines.append("")
-                lines.append(
-                    "**LENGTH: keep it tight.** One or two sentences, well under the "
-                    "250-character Twitter limit. A short, sharp reply almost always "
-                    "beats a paragraph. This applies to the comment text only; any "
-                    "link/CTA the system appends afterward is separate."
-                )
         lines.append("")
         lines.append(
             'In your output JSON, set "engagement_style" to exactly '
@@ -1835,13 +1872,15 @@ def get_content_rules(platform):
     ]
 
     platform_rules = {
-        "reddit": [
-            "Go BIMODAL: either 1 punchy sentence (<100 chars, highest avg upvotes) or 4-5 sentences of real substance. AVOID the 2-3 sentence dead zone.",
-            "Lead with personal experience or observation ('I tried X' / 'I noticed X' / 'the part that broke for me was X') rather than instructional advice ('you should X'). Whether you can speak AS the project's maker is governed by the VOICE RELATIONSHIP rule.",
-            "No markdown in Reddit (no ##, **, numbered lists). Casual tone, lowercase OK, fragments OK.",
-            "NEVER mention product names (fazm, assrt, pieline, cyrano, terminator, mk0r, s4l). NEVER include URLs or links.",
-            "Statements beat questions. Be authoritative, not inquisitive. No 'anyone else experience this?'",
-        ],
+        # Reddit-specific rules deprecated 2026-07-18 (user decision): the
+        # 2026-04-13 "data-driven" claims behind them (bimodal length,
+        # statements>questions, first-person openings) no longer reproduce on
+        # current posts data, and they blocked X/Reddit draft-prompt parity.
+        # The reddit DRAFT prompt no longer includes content rules at all
+        # (draft_prompt_core dropped @CONTENT_RULES@); only the engage rail
+        # still renders this, now common-rules-only. The stale hardcoded
+        # product-name list that lived here is gone with them.
+        "reddit": [],
         "twitter": [
             "Keep it short: 1-2 sentences max. Fragments and lowercase OK.",
             "Direct product mentions OK when relevant (unlike Reddit).",

package/scripts/feedback_digest.py

@@ -83,7 +83,7 @@ import learned_preferences as lp  # noqa: E402
 REPO_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 RUN_CLAUDE_SH = os.path.join(REPO_DIR, "scripts", "run_claude.sh")
 LOCK_PATH = os.path.expanduser("~/.social-autoposter-mcp/feedback-digest.lock")
-MAX_EVENTS_PER_RUN = 200
+MAX_EVENTS_PER_RUN = 5
 # A cluster of reason-less rejects in one batch is a signal worth flagging
 # even when no shared textual pattern justifies a learned_preferences entry:
 # pure volume with no discernible pattern usually means something upstream
@@ -277,6 +277,31 @@ def build_prompt(project: dict, events: list[dict], overall_events: list[dict] |
             f"{plat_lines}"
         )
 
+    ex_pairs = block.get("edit_examples") or []
+    if ex_pairs:
+        ex_lines = "\n".join(
+            f"{i + 1}. ORIGINAL (ours): {e.get('original', '')}\n"
+            f"   FINAL (user rewrote to): {e.get('final', '')}"
+            for i, e in enumerate(ex_pairs)
+        )
+        edit_examples_block = (
+            f"\n\nACCUMULATED EDIT EXAMPLES ({len(ex_pairs)} total, newest "
+            "first): each is a draft the user hand-rewrote on the review card "
+            "before approving it, so every FINAL is a direct statement of the "
+            "voice they want. The drafting model NO LONGER sees these pairs "
+            "directly, so the ONLY way a rewrite's lesson reaches drafting is "
+            "if you distill it into a draft_style_notes entry. Even a SINGLE "
+            "example with a clear correction (a phrase type removed, a "
+            "structure replaced, tone or length shifted) is enough to write a "
+            "draft_style_notes entry and "
+            "embed a short before/after fragment as an anchor (e.g. rewrote "
+            "'X' to 'Y') so the concrete rewrite travels with the rule. Ignore "
+            "lead-specific or cosmetic edits (typo fixes, one-off facts); learn "
+            f"only what generalizes across products.\n{ex_lines}"
+        )
+    else:
+        edit_examples_block = ""
+
     return f"""You maintain the SINGLE, install-wide learned_preferences block for this social-posting pipeline (shared across every configured project, not just "{project.get('name')}"). It distills the user's own approve/reject decisions on draft cards into short standing preferences that steer future thread selection and drafting across ALL projects. It is SOFT guidance read by the drafting model, not a filter.
 
 The events below all happened to come from project "{project.get('name')}"'s cards, but since the block is shared, only propose an entry that generalizes to a human reviewer's standing taste or quality bar (voice, tone, structural habits, author-quality signals, what counts as a good vs bad reply) — NOT something that is true only because of this one product's specific audience, niche, or content angle (e.g. "prefers accounts studying for nursing boards" belongs to one product's ICP, not to every project this reviewer runs). When the evidence is really project-specific, prefer NO change over forcing it into the shared block.
@@ -285,31 +310,31 @@ CURRENT learned_preferences (shared by every project):
 {json.dumps({k: block[k] for k in ("audience_avoid", "audience_prefer", "thread_avoid", "draft_style_notes")}, indent=2)}
 
 CURRENT voice.never: {json.dumps(voice_never)}
-CURRENT content_guardrails.do_not: {json.dumps(guard_do_not)}
+CURRENT content_guardrails.do_not: {json.dumps(guard_do_not)}{edit_examples_block}
 
-NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(no_reason)} of the rejects without a stated reason, {len(approved)} approved, {len(loved)} of the approvals loved, {len(plat_removed)} platform moderation strikes):
+NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(approved)} approved, {len(loved)} of the approvals loved, {len(plat_removed)} platform moderation strikes):
 {ev_lines}{overall_block}{platform_block}
 
-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.
+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. (Rejects with no category and no note are filtered out before this prompt, so every reject below carries a real reason.) "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; even a single edit that shows a clear correction (a phrase type removed, a structure replaced, tone shifted, length cut) is enough to distill into draft_style_notes, and several agreeing only make it stronger. 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.
+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 it as weak, corroborating a pattern that stronger events already show rather than founding one on its own). "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. A single pairwise choice is enough: diff the picked text against the not-picked one and distill WHAT differs (tone, structure, length, opener type, directness) into draft_style_notes, and several agreeing only make it stronger; the "styles:" line names each side's engagement style, useful when the same style keeps winning or losing.
 
-"[platform_removed]" and "[platform_banned]" events are MACHINE-DERIVED moderation outcomes, not human card decisions; weigh them on their own track, never as a statement of the reviewer's taste. platform_removed means a moderator or platform filter removed one of our posts: the lesson is the CONTENT pattern (what reads as promotional, off-topic, or AI-written in that kind of venue), feeding thread_avoid or draft_style_notes. One removal is one community's judgment: treat it like a reasoned reject (it may justify one narrowly-scoped entry since the moderation context states the venue and outcome explicitly), and generalize only when 2+ removals share a pattern. platform_banned means a community blocked our account outright: the strongest platform-side evidence, but the specific venue is ALREADY hard-blocked by the pipeline, so never spend an entry naming an individual community; the only lesson worth an entry is a venue TYPE pattern (e.g. what kinds of communities keep rejecting us) once 2+ bans or removals show it. Platform events never justify block_authors (there is no author at fault) and never touch audience_prefer.
+"[platform_removed]" and "[platform_banned]" events are MACHINE-DERIVED moderation outcomes, not human card decisions; weigh them on their own track, never as a statement of the reviewer's taste. platform_removed means a moderator or platform filter removed one of our posts: the lesson is the CONTENT pattern (what reads as promotional, off-topic, or AI-written in that kind of venue), feeding thread_avoid or draft_style_notes. A removal is a hard, machine-known fact (not an inferred taste signal), so a SINGLE removal is enough: treat it like a reasoned reject and distill the content-pattern lesson right away, since the moderation context states the venue and outcome explicitly; more removals sharing a pattern only make it stronger. platform_banned means a community blocked our account outright: the strongest platform-side evidence, but the specific venue is ALREADY hard-blocked by the pipeline, so never spend an entry naming an individual community; the only lesson worth an entry is a venue TYPE pattern (e.g. what kinds of communities keep rejecting us), and a single ban or removal is enough to name that TYPE. Platform events never justify block_authors (there is no author at fault) and never touch audience_prefer.
 
 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:
 1. Be conservative. Prefer NO changes over speculative ones. An empty plan is a good plan when the evidence is thin.
-2. Generalize only what the evidence supports: 2+ events agreeing justify a general entry; a single reject justifies at most one narrowly-scoped entry, and only when its note, interactions, or author context (follower count, their post, discovery topic) makes the reason explicit. Exceptions: a single loved approval can justify one audience_prefer/thread entry when the pattern it shows is clear, and OVERALL FEEDBACK lines are explicit user instructions that outrank inferred signals; reflect each one in the most fitting list even from a single line, rewritten as a standing preference.
+2. A SINGLE reasoned event is enough to justify an entry; you do NOT need multiple events agreeing. When a reject carries a category, a note, a profile-click, or clear author/thread context, or an approval is loved, or the user edited the draft, or they made an explicit two-draft choice, distill the lesson right away into the most fitting list, generalized to the TYPE (never an individual handle or a one-off fact). More events agreeing only make the pattern stronger; they are not a precondition. OVERALL FEEDBACK lines are explicit user instructions that outrank inferred signals; reflect each one even from a single line, rewritten as a standing preference.
 3. Describe author/audience TYPES, never individual handles. "crypto/web3-native accounts shilling tokens" is right; "@someguy" is wrong. Preferences must generalize.
 4. Approvals are counter-evidence. If approvals contradict an existing entry, propose removing or narrowing it. Also propose removing entries that events show are stale.
-5. bad_draft events feed draft_style_notes (or, ONLY for a clearly recurring phrasing complaint, voice_never_add / guardrails_do_not_add; use those sparingly, they touch curated fields).
-6. Each entry: one sentence, under 200 characters, plain language, no em dashes, no hashtags, understandable a month from now without these events.
-7. Respect the cap: at most {lp.MAX_ENTRIES_PER_LIST} entries per list. If a list is full, fold the new signal into an existing entry via remove+add.
+5. bad_draft events feed draft_style_notes (or, for a clearly recurring phrasing complaint, voice_never_add / guardrails_do_not_add). voice.never and content_guardrails.do_not are the CURRENT project's curated fields, shown above; you may ADD to them and also REMOVE entries (voice_never_remove / guardrails_do_not_remove) when an approval or the user's feedback shows an entry is now wrong or stale. There is no cap. remove values must match an existing entry exactly.
+6. Keep each entry plain language, no em dashes, no hashtags, understandable a month from now without these events. There is NO length or per-list count cap. A draft_style_notes entry SHOULD embed a short before/after fragment from the edit examples when one fits (e.g. rewrote 'X' to 'Y'); that anchor is the only way the concrete rewrite reaches the drafting model. audience_avoid, audience_prefer, and thread_avoid stay short type descriptions with no example.
+7. Never propose a note that tells the writer to drop, strip, omit, or leave out the product link or url, or to remove trailing punctuation. Those contradict the tail-link bridge feature and are auto-rejected on write, so spend no entry on them even if an edit example shows the user deleting a link.
 8. Scope check (this block is shared across every project): before proposing an entry, ask whether it would still make sense read from a totally different product's cards. If it only makes sense for "{project.get('name')}" specifically, don't add it.
 
 OUTPUT: a single JSON object, nothing else. Schema:
-{{"changes": {{"audience_avoid": {{"add": [], "remove": []}}, "audience_prefer": {{"add": [], "remove": []}}, "thread_avoid": {{"add": [], "remove": []}}, "draft_style_notes": {{"add": [], "remove": []}}}}, "voice_never_add": [], "guardrails_do_not_add": [], "block_authors": [{{"handle": "somehandle", "reason": "one short sentence citing the evidence"}}], "rationale": "one short sentence"}}
+{{"changes": {{"audience_avoid": {{"add": [], "remove": []}}, "audience_prefer": {{"add": [], "remove": []}}, "thread_avoid": {{"add": [], "remove": []}}, "draft_style_notes": {{"add": [], "remove": []}}}}, "voice_never_add": [], "voice_never_remove": [], "guardrails_do_not_add": [], "guardrails_do_not_remove": [], "block_authors": [{{"handle": "somehandle", "reason": "one short sentence citing the evidence"}}], "rationale": "one short sentence"}}
 "remove" values must match existing entries EXACTLY. Omit empty keys if you like; an all-empty plan means "no changes"."""
 
 
@@ -467,6 +492,24 @@ def digest_project(project: dict, platform: str, dry_run: bool,
             f"count={len(no_reason)} threshold={BULK_NO_REASON_THRESHOLD} "
             f"event_ids=[{ids}] (volume signal, logged regardless of whether "
             "the digest model finds a shared textual pattern below)")
+    # no_reason_given rejects (no category, no note): the user rejected but left
+    # no learnable reason, so DROP them from the digest entirely (2026-07-17 user
+    # rule). Mark them processed so they never clog the small fetch window, then
+    # remove them from the working set before any actionability / prompt logic.
+    if no_reason:
+        nr_ids = [int(e["id"]) for e in no_reason
+                  if isinstance(e.get("id"), int) or str(e.get("id", "")).isdigit()]
+        if nr_ids and not dry_run:
+            try:
+                api_patch("/api/v1/review-events",
+                          {"ids": nr_ids, "action": "mark_processed",
+                           "processed_batch": f"digest-noreason-{_now_stamp()}"})
+            except Exception as e:
+                log(f"project={name} no_reason_mark_processed_failed={e}")
+        log(f"project={name} platform={platform} ignored_no_reason={len(no_reason)} "
+            "(not processed into learnings)")
+        _drop = {id(e) for e in no_reason}
+        events = [e for e in events if id(e) not in _drop]
     if not overall_events and not platform_events and not any(_is_actionable(e) for e in events):
         log(f"project={name} platform={platform} events={len(events)} "
             "plain_approvals_only, no digest (they ride along with the next actionable event)")

package/scripts/find_threads.py

@@ -29,14 +29,15 @@ except Exception:
     def _resolve_account(_platform):  # type: ignore[unused-arg]
         return None
 
-CONFIG_PATH = os.path.expanduser("~/social-autoposter/config.json")
+# THE canonical config loader (scripts/config.py): S4L_CONFIG_PATH / state-dir /
+# S4L_REPO_DIR aware, mtime-cached. Replaces this file's hand-rolled loader and
+# its hardcoded config path (the S4L-4H dead-path class on customer boxes).
+import os as _cfg_os, sys as _cfg_sys
+_cfg_sys.path.insert(0, _cfg_os.path.dirname(_cfg_os.path.abspath(__file__)))
+from config import config_path as _canonical_config_path, load_config
+CONFIG_PATH = _canonical_config_path()
 
 
-def load_config():
-    if os.path.exists(CONFIG_PATH):
-        with open(CONFIG_PATH) as f:
-            return json.load(f)
-    return {}
 
 
 def fetch_json(url, headers=None, user_agent="social-autoposter/1.0"):
@@ -451,7 +452,8 @@ def main():
         project_config.get("subreddits", config.get("subreddits", []))
         if project_config else config.get("subreddits", [])
     )
-    reddit_username = config.get("accounts", {}).get("reddit", {}).get("username", "")
+    from account_resolver import resolve as _resolve_account
+    reddit_username = _resolve_account("reddit") or ""
     user_agent = f"social-autoposter/1.0 (u/{reddit_username})" if reddit_username else "social-autoposter/1.0"
 
     # Rate limit check

package/scripts/github_tools.py

@@ -36,12 +36,15 @@ def _github_account_filter():
         return (" AND our_account = %s", [h])
     return ("", [])
 
-CONFIG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "config.json")
+# THE canonical config loader (scripts/config.py): S4L_CONFIG_PATH / state-dir /
+# S4L_REPO_DIR aware, mtime-cached. Replaces this file's hand-rolled loader and
+# its hardcoded config path (the S4L-4H dead-path class on customer boxes).
+import os as _cfg_os, sys as _cfg_sys
+_cfg_sys.path.insert(0, _cfg_os.path.dirname(_cfg_os.path.abspath(__file__)))
+from config import config_path as _canonical_config_path, load_config as _load_config
+CONFIG_PATH = _canonical_config_path()
 
 
-def _load_config():
-    with open(CONFIG_PATH) as f:
-        return json.load(f)
 
 
 def _excluded_repos_and_authors(config):
@@ -88,9 +91,10 @@ def _save_repo_gone_cache(cache):
 
 
 def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}}):
-    """Fetch and cache (gone, has_issues, has_discussions) for owner/repo.
-    Two-tier cache (in-process + 24h on-disk JSON). Returns a dict
-    {gone: bool, has_issues: bool, has_discussions: bool}."""
+    """Fetch and cache (gone, has_issues, has_discussions, stars) for
+    owner/repo. Two-tier cache (in-process + 24h on-disk JSON). Returns a dict
+    {gone: bool, has_issues: bool, has_discussions: bool, stars: int|None}.
+    stars is None when the repo payload was unavailable (404, network)."""
     key = f"{owner}/{repo}".lower()
     if key in _mem:
         return _mem[key]
@@ -100,11 +104,12 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
     entry = _disk["data"].get(key)
     now = int(time.time())
     if (entry and (now - int(entry.get("checked_at", 0))) < _REPO_GONE_TTL_SEC
-            and "has_issues" in entry):
+            and "has_issues" in entry and "stars" in entry):
         state = {
             "gone": bool(entry.get("gone")),
             "has_issues": bool(entry.get("has_issues", True)),
             "has_discussions": bool(entry.get("has_discussions", True)),
+            "stars": entry.get("stars"),
         }
         _mem[key] = state
         return state
@@ -114,7 +119,8 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
             capture_output=True, text=True, timeout=20,
         )
     except Exception:
-        state = {"gone": False, "has_issues": True, "has_discussions": True}
+        state = {"gone": False, "has_issues": True, "has_discussions": True,
+                 "stars": None}
         _mem[key] = state
         return state
     if proc.returncode == 0:
@@ -122,20 +128,27 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
             data = json.loads(proc.stdout or "{}")
         except Exception:
             data = {}
+        try:
+            stars = int(data.get("stargazers_count"))
+        except (TypeError, ValueError):
+            stars = None
         state = {
             "gone": False,
             "has_issues": bool(data.get("has_issues", True)),
             "has_discussions": bool(data.get("has_discussions", True)),
+            "stars": stars,
         }
     else:
         err = ((proc.stderr or "") + (proc.stdout or "")).lower()
         gone = ("not found" in err or "http 404" in err)
-        state = {"gone": gone, "has_issues": True, "has_discussions": True}
+        state = {"gone": gone, "has_issues": True, "has_discussions": True,
+                 "stars": None}
     _mem[key] = state
     _disk["data"][key] = {
         "gone": state["gone"],
         "has_issues": state["has_issues"],
         "has_discussions": state["has_discussions"],
+        "stars": state["stars"],
         "checked_at": now,
     }
     _save_repo_gone_cache(_disk["data"])