@m13v/s4l 1.7.4-rc.4 → 1.7.4

package/mcp/menubar/s4l_menubar.py

@@ -83,9 +83,10 @@ sys.stderr = _TimestampedStderr(sys.stderr)
 # best-effort: a missing repo path or SDK degrades to a silent no-op.
 _sentry = None
 try:
-    # Read the repo dir from the plist env; this read runs
-    # BEFORE scripts/ is on sys.path, so the s4l_env mirror can't help yet.
-    _repo = os.environ.get("S4L_REPO_DIR")
+    # Read the repo dir from the plist env. This runs BEFORE scripts/ is on
+    # sys.path, so the s4l_env mirror cannot help yet; the old key is accepted
+    # only at this bootstrap seam so pre-rename plists can find the mirror.
+    _repo = os.environ.get("S4L_REPO_DIR") or os.environ.get("SAPS_REPO_DIR")
     if _repo:
         _scripts = os.path.join(_repo, "scripts")
         if _scripts not in sys.path:
@@ -337,9 +338,9 @@ UPDATE_PROMPT = "Update the S4L plugin to the latest version."
 # Re-arm goes through the HOST create_scheduled_task path (the same one onboarding
 # uses) — it registers the routines under whatever account is logged in and shows
 # up in Routines. The host tool only runs inside an agent chat, so the menu bar
-# hands Claude this prompt (auto-typed, clipboard+paste fallback). We do NOT write
-# scheduled-tasks.json directly — that can't reliably target a just-switched-into
-# account, which is exactly the bug it caused.
+# hands Claude this prompt (auto-typed, clipboard+paste fallback). The automatic
+# fix can now direct-write after resolving lastActiveOrg; keep this host path for
+# Keychain denial, missing/stale cookie, and other resolution failures.
 REARM_PROMPT = (
     "Set up the S4L draft autopilot schedule for this Claude account. "
     "If queue_setup is available, call it; then for s4l-worker call the host tool "
@@ -398,32 +399,33 @@ DIAGNOSE_PROMPT_TEMPLATE = (
     "<that file>` so the report reaches the S4L developers. Keep replies short."
 )
 
-# A pending draft job older than this (seconds) with nothing claiming it means no
-# routine is draining the queue — the worker would claim within a minute if it
-# were firing. False-positive-free: an idle queue has no pending job at all, so a
-# quiet pipeline (no candidates) never trips this. Comfortably above the host
-# scheduler's per-minute cadence + a slow claim.
-AUTOPILOT_STALL_SECONDS = 180
-
-# A job CLAIMED but never finished (sits in running/ this long) means a worker
-# picked it up and then wedged mid-run (the claude -p drafting child died / never
-# spawned). Generous enough that the longest real drafting turn never trips it.
-# Keep in sync with RUNNING_STALL_SECONDS (scripts/autopilot_stall_watch.py).
-AUTOPILOT_RUNNING_STALL_SECONDS = 900
-
-# The "firing" window (how fresh lastRunAt must be) lives in the single source of
-# truth, scripts/schedule_state.py (FIRING_WINDOW there). _schedule_state delegates
-# to it, so it is intentionally NOT redefined here.
-
-# How long the producer can sit narrating "draft Nm" before we treat
-# the draft as STUCK rather than healthy. The producer writes that label the whole
-# time it blocks waiting for a worker to return a result (up to its 30-min queue
-# timeout). A healthy drain clears in ~1-2 min; if the label has been "drafting"
-# this long, the worker keeps dying mid-run (host inactivity-kill) or never claims,
-# and nothing is draining — so we flip the menu bar from a reassuring spinner to
-# ⚠ instead of letting the stale "drafting (8m)" lie persist. Well above any
-# healthy single drain (the worker itself dies at ~2 min today).
-DRAFT_STUCK_SECONDS = 300
+# Stall thresholds live in the single source of truth, scripts/schedule_state.py
+# (HEALTHY_DRAIN_MAX_SECONDS and the names derived from it) — retune there, not
+# here. Same module that owns FIRING_WINDOW; _schedule_state already delegates to
+# it. The three names cover three distinct failure modes:
+#   AUTOPILOT_STALL_SECONDS          pending job unclaimed → no routine draining
+#                                    (fix: Re-arm). Idle queue has no pending job,
+#                                    so a quiet pipeline never trips it.
+#   AUTOPILOT_RUNNING_STALL_SECONDS  job claimed but wedged in running/ → worker
+#                                    died mid-run (fix: Diagnose).
+#   DRAFT_STUCK_SECONDS              the producer's "draft Nm" label alive this
+#                                    long → end-to-end clock; the only timer that
+#                                    spans claim→die→requeue churn loops, which
+#                                    reset the two per-state timers on every
+#                                    transition while nothing ever completes.
+# The import is best-effort because the S4L_REPO_DIR sys.path insertion near the
+# top of this file is best-effort; the fallback literal mirrors
+# HEALTHY_DRAIN_MAX_SECONDS.
+try:
+    from schedule_state import (  # noqa: E402
+        STALL_SECONDS as AUTOPILOT_STALL_SECONDS,
+        RUNNING_STALL_SECONDS as AUTOPILOT_RUNNING_STALL_SECONDS,
+        DRAFT_STUCK_SECONDS,
+    )
+except Exception:
+    AUTOPILOT_STALL_SECONDS = 1200
+    AUTOPILOT_RUNNING_STALL_SECONDS = 1200
+    DRAFT_STUCK_SECONDS = 1200
 
 # A poll can read a transient "not stuck" moment (e.g. the activity file
 # between one dying worker attempt and the next claim on the same aged job)
@@ -463,6 +465,14 @@ REVIEW_UNATTENDED_SENTRY_SECONDS = 3600.0
 REVIEW_SNOOZE_SECONDS = float(os.environ.get("S4L_REVIEW_SNOOZE_S", "3600"))
 SNOOZE_FILE = os.path.join(st.state_dir(), "review-snooze.json")
 
+# Reveal cadence (2026-07-13): how often FRESH draft cards may pop, independent
+# of how often the pipeline drafts (mode.json `reveal_cadence_secs`, default 1h,
+# 0 = as soon as ready). Only fresh presentations are paced: an already-open
+# card still grows live via extend_active, snooze still parks everything, and
+# the menu's "Review N pending drafts" always bypasses. The last-presented
+# epoch is persisted so a menubar restart mid-interval doesn't re-pop early.
+REVEAL_STAMP_FILE = os.path.join(st.state_dir(), "review-last-presented.json")
+
 
 def _label_elapsed_secs(label):
     """Parse the trailing duration the producer encodes in a drafting activity
@@ -547,6 +557,9 @@ class S4LMenuBar(rumps.App):
         # (0 = not snoozed). Loaded from disk so a menubar restart mid-snooze
         # doesn't re-pop the card the user just put away.
         self._review_snooze_until = self._read_snooze_until()
+        # Reveal cadence: when the last fresh card presentation happened (epoch,
+        # 0 = never). Loaded from disk so a restart mid-interval doesn't re-pop.
+        self._last_presented_at = self._read_last_presented()
         # Unattended-review watchdog state (_maybe_heal_review).
         self._review_heal_at = 0.0
         self._review_unattended_notified = False
@@ -786,8 +799,8 @@ class S4LMenuBar(rumps.App):
         bridge is panel-only), so the reliable path here is: copy the prompt to the
         clipboard, open Claude, and tell the user to paste it. (The dashboard
         widget's button does this in one click via app.sendMessage — no paste.) We
-        do NOT auto-type (focus/timing flaky) and do NOT write the registry directly
-        (can't reliably target a just-switched-into account).
+        do NOT auto-type (focus/timing flaky). This remains the fallback when the
+        automatic direct-write path cannot resolve/decrypt the active org cookie.
 
         The click itself is captured (mirroring _diagnose_fix) — previously this
         button had NO telemetry at all, so a past incident (Karol, 2026-07-07)
@@ -810,15 +823,15 @@ class S4LMenuBar(rumps.App):
 
     def _finish_schedule_setup(self, _=None):
         """One-click fix for schedule_state == 'missing' when
-        scheduled_task_selfheal.can_create_for_active_account() confirms a
-        session directory already exists for the active account (2026-07-08):
-        quit Claude, create the registration via a direct file write (the
-        same heal() the update flow uses — see its module docstring for why
-        this is equivalent to what create_scheduled_task would produce), then
-        relaunch. Primary action for this case now instead of re-arm: no
-        clipboard paste, no chat turn required. Re-arm remains the fallback
-        for the rarer case where no session directory exists yet for the
-        active account (see _build_menu) — fix 5 never fabricates one.
+        scheduled_task_selfheal.can_create_for_active_account() confirms an
+        existing session directory OR the active-org cookie needed to make
+        the exact account/org directory: quit Claude, create the registration
+        via a direct file write (the same heal() the update flow uses — see
+        its module docstring for why this is equivalent to what
+        create_scheduled_task would produce), then relaunch. Primary action
+        for this case now instead of re-arm: no clipboard paste or chat turn.
+        Re-arm remains the fallback when the cookie is unavailable or macOS
+        denies its Safe Storage Keychain read.
 
         No confirm dialog: the restart is already disclosed in the menu item
         label itself ("...(restarts Claude)", _build_menu) — a modal repeating
@@ -898,7 +911,7 @@ class S4LMenuBar(rumps.App):
               to see between cycles) -> the ⚠ stays on continuously instead of
               flickering off. This is the durable signal.
           (2) FAST: a draft job has sat unclaimed in pending/ past
-              AUTOPILOT_STALL_SECONDS -> catches a fresh stall ~3 min in, before
+              AUTOPILOT_STALL_SECONDS -> catches a fresh stall ~20 min in, before
               the first full producer timeout has even latched (1).
           (3) IN-FLIGHT: a draft job was claimed (moved to running/) but never
               finished within AUTOPILOT_RUNNING_STALL_SECONDS -> the worker picked
@@ -1127,6 +1140,40 @@ class S4LMenuBar(rumps.App):
         """Menu callback shim: rumps passes the clicked MenuItem last."""
         self._set_split(share)
 
+    # Reveal-cadence presets (seconds between fresh card pop-ups; 0 = as soon
+    # as drafts are ready). Manual mode.json edits can set any value; the
+    # checkmark then lands on an exact match or none, same as the lane split.
+    REVEAL_CADENCE_PRESETS = (
+        (0, "Immediately"),
+        (1800, "Every 30 minutes"),
+        (3600, "Every hour"),
+        (14400, "Every 4 hours"),
+    )
+
+    def _cadence_label(self, secs=None):
+        """Human label for a cadence value, for menu copy."""
+        if secs is None:
+            secs = st.read_reveal_cadence()
+        for preset, label in self.REVEAL_CADENCE_PRESETS:
+            if round(secs) == preset:
+                return label
+        m = round(secs / 60)
+        return f"Every {m} min" if m else "Immediately"
+
+    def _on_cadence_preset(self, secs, _sender=None):
+        """Menu callback shim: rumps passes the clicked MenuItem last."""
+        written = st.write_reveal_cadence(secs)
+        self._notify(
+            "S4L draft cards",
+            f"New draft cards will show: {self._cadence_label(written).lower()}",
+        )
+        self._sig = None
+        try:
+            self._tick(None)
+        except Exception as e:
+            sys.stderr.write(f"[s4l-menubar] cadence rebuild failed: {e}\n")
+            sys.stderr.flush()
+
     def _set_split(self, share):
         """Set the personal-brand share (pure local mode.json write, same
         contract as _toggle_lane) and rebuild so the checkmark moves instantly."""
@@ -2400,11 +2447,12 @@ class S4LMenuBar(rumps.App):
             self._stall_reason_info = ("", "")
         # Draft worker stuck/killed: the producer narrates "drafting replies (Nm)"
         # the whole time it blocks waiting for a worker to return a result, with NO
-        # idea the worker died. A healthy drain clears in ~1-2 min; once that label
-        # has been "drafting" past DRAFT_STUCK_SECONDS the worker keeps getting
-        # killed mid-run (or never claims) and nothing is draining — flip to ⚠
-        # instead of leaving the reassuring "drafting (8m)" spinner up. Skip when a
-        # more specific cause (rate limit) already owns the reason.
+        # idea the worker died. A healthy drain can run 8-10 min end to end (slot
+        # wait + the drafting turn); once that label has been "drafting" past
+        # DRAFT_STUCK_SECONDS the worker keeps getting killed mid-run (or never
+        # claims) and nothing is draining — flip to ⚠ instead of leaving the
+        # reassuring "drafting (25m)" spinner up. Skip when a more specific cause
+        # (rate limit) already owns the reason.
         #
         # Gated on schedule_state in ("ok", "stalled"), NOT missing/disabled: when
         # the schedule is missing/disabled (e.g. orphaned by an account switch),
@@ -2625,6 +2673,11 @@ class S4LMenuBar(rumps.App):
             int(self._review_snooze_until)
             if time.time() < self._review_snooze_until
             else 0,
+            # Reveal cadence: rebuilds when the preset changes (checkmark +
+            # submenu title) and when a hold starts or lapses (the "Next cards
+            # around HH:MM" line in _state_c).
+            round(st.read_reveal_cadence()),
+            int(self._reveal_hold_until(pending_count)),
         )
         if sig != self._sig:
             self._sig = sig
@@ -2723,6 +2776,37 @@ class S4LMenuBar(rumps.App):
         except Exception:
             pass
 
+    def _read_last_presented(self):
+        try:
+            with open(REVEAL_STAMP_FILE) as f:
+                return float((json.load(f) or {}).get("at") or 0.0)
+        except Exception:
+            return 0.0
+
+    def _stamp_presented(self):
+        """Record a fresh card presentation, mirrored to disk (restart-safe).
+        Starts the next reveal-cadence interval."""
+        self._last_presented_at = time.time()
+        try:
+            with open(REVEAL_STAMP_FILE, "w") as f:
+                json.dump({"at": self._last_presented_at}, f)
+        except Exception:
+            pass
+
+    def _reveal_hold_until(self, pending_count):
+        """Epoch until which the reveal cadence is actually holding fresh cards
+        back (0.0 = no hold). A hold only exists while there is something to
+        hold: pending drafts, no review in flight, and not snoozed (the snooze
+        label and gate take precedence)."""
+        if pending_count <= 0 or self._review_active:
+            return 0.0
+        now = time.time()
+        if now < self._review_snooze_until:
+            return 0.0
+        cadence = st.read_reveal_cadence()
+        until = self._last_presented_at + cadence
+        return until if (cadence > 0 and now < until) else 0.0
+
     def _review_now(self, _=None):
         """Menu: bring the pending draft cards up right now. Clears any snooze;
         this is the one presentation path that may take keyboard focus (the
@@ -2804,6 +2888,17 @@ class S4LMenuBar(rumps.App):
                     sys.stderr.flush()
                 self._last_review_sig = sig
             return
+        # Reveal cadence: hold FRESH pop-ups until the configured interval since
+        # the last presentation has passed (0 = show immediately). Drafting is
+        # untouched; the backlog keeps accumulating and is presented whole once
+        # due. Deliberately after the extend-open-card path above (an on-screen
+        # card keeps growing live) and skipped for focus=True (the menu's
+        # "Review N pending drafts" is an explicit ask). _last_review_sig is NOT
+        # stamped on a hold, so the same set still presents fresh when due.
+        if not focus:
+            cadence = st.read_reveal_cadence()
+            if cadence > 0 and time.time() - self._last_presented_at < cadence:
+                return
         with self._review_lock:
             self._reset_posting_progress_locked()
             self._review_active = True
@@ -2827,6 +2922,7 @@ class S4LMenuBar(rumps.App):
             # Record as shown only AFTER the cards are actually up, so a transient
             # card-UI failure never permanently suppresses this pending set.
             self._last_review_sig = sig
+            self._stamp_presented()
             # No macOS notification for fresh drafts, per explicit user
             # request (2026-07-03): the card itself is the surface. A missed
             # card is the unattended watchdog's job (it heals the window and
@@ -3331,13 +3427,12 @@ class S4LMenuBar(rumps.App):
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             else:
                 items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
-                # Prefer the automatic fix (2026-07-08): if the active account
-                # already has a session directory, _finish_schedule_setup can
-                # create the registration directly (heal() fix 5) with no
-                # clipboard paste needed. Fall back to re-arm only when fix 5
-                # has nowhere to write (no session dir yet for this account —
-                # it never fabricates one), since that's the one case where
-                # only the live create_scheduled_task host tool can help.
+                # Prefer the automatic fix: an existing session directory OR
+                # lastActiveOrg cookie lets _finish_schedule_setup target the
+                # active account exactly (heal() fix 5), with no clipboard
+                # paste. Fall back to the live create_scheduled_task host tool
+                # when neither source is available; decryption denial after a
+                # click is also caught by the post-restart verification.
                 can_selfheal = False
                 try:
                     import scheduled_task_selfheal
@@ -3416,6 +3511,22 @@ class S4LMenuBar(rumps.App):
                 split_menu.add(it)
             items.append(split_menu)
 
+        # Reveal cadence: how often fresh draft cards may pop (the drafting
+        # pipeline is unchanged; this only paces the pop-up). Always offered:
+        # it is the "don't interrupt me every few minutes" control.
+        cadence = st.read_reveal_cadence()
+        cadence_menu = rumps.MenuItem(
+            f"Show draft cards: {self._cadence_label(cadence).lower()}"
+        )
+        for preset, label in self.REVEAL_CADENCE_PRESETS:
+            it = rumps.MenuItem(
+                label,
+                callback=functools.partial(self._on_cadence_preset, preset),
+            )
+            it.state = 1 if round(cadence) == preset else 0
+            cadence_menu.add(it)
+        items.append(cadence_menu)
+
         items.append(rumps.separator)
         items.append(rumps.MenuItem("Open dashboard", callback=self._open_dashboard))
         # The one entry point for overall feedback (the review card no longer
@@ -3554,6 +3665,18 @@ class S4LMenuBar(rumps.App):
                     )
                 )
             )
+        else:
+            # Reveal-cadence hold: the backlog exists but the pop-up is being
+            # paced. Same courtesy line as the snooze; "Review N pending
+            # drafts" above shows them right now regardless.
+            hold_until = self._reveal_hold_until(pending_count)
+            if hold_until:
+                items.append(
+                    self._label(
+                        "Next cards around "
+                        + time.strftime("%H:%M", time.localtime(hold_until))
+                    )
+                )
         # No bulk-discard item here anymore: "Discard all…" lives in the
         # review card's title bar (2026-07-10). Reaching it with no card open
         # is "Review N pending drafts" -> Discard all, two clicks.

package/mcp/menubar/s4l_state.py

@@ -31,7 +31,7 @@ from pathlib import Path
 # The repo dir must be read tolerantly INLINE (old name included) because the
 # mirror module itself lives in $REPO/scripts and isn't importable before the
 # sys.path insertion below. Best-effort: failure degrades to defaults.
-_repo_for_env = os.environ.get("S4L_REPO_DIR")
+_repo_for_env = os.environ.get("S4L_REPO_DIR") or os.environ.get("SAPS_REPO_DIR")
 if _repo_for_env:
     _scripts_for_env = os.path.join(_repo_for_env, "scripts")
     if _scripts_for_env not in sys.path:
@@ -1251,6 +1251,46 @@ def write_split(share):
     return share
 
 
+# Draft-card reveal cadence: minimum seconds between FRESH card pop-ups
+# (0 = present as soon as drafts are ready). Drafting itself is untouched;
+# drafts keep accumulating in the review store and the menubar just paces the
+# pop-up. Lives in mode.json (every writer preserves unknown keys). Presets
+# are the menubar's REVEAL_CADENCE_PRESETS; any non-negative value is valid.
+REVEAL_CADENCE_DEFAULT = 3600.0
+
+
+def read_reveal_cadence():
+    """Seconds between draft-card reveals (0 = immediately, default 1 hour)."""
+    d = read_json(MODE_FILE)
+    try:
+        secs = float(d.get("reveal_cadence_secs"))
+    except (TypeError, ValueError, AttributeError):
+        return REVEAL_CADENCE_DEFAULT
+    return max(0.0, secs)
+
+
+def write_reveal_cadence(secs):
+    """Persist the reveal cadence, preserving every other mode.json key.
+    Returns the written value. Never raises (a menu click must not crash)."""
+    try:
+        secs = max(0.0, float(secs))
+    except (TypeError, ValueError):
+        return read_reveal_cadence()
+    try:
+        payload = read_json(MODE_FILE)
+        if not isinstance(payload, dict):
+            payload = {}
+        payload["reveal_cadence_secs"] = secs
+        p = Path(state_dir()) / MODE_FILE
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(payload))
+        os.replace(str(tmp), str(p))
+    except Exception:
+        pass
+    return secs
+
+
 def write_mode(mode):
     """Legacy single-mode setter: named lane ON, the other OFF (compat)."""
     if mode not in _VALID_MODES:

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.4-rc.4",
+  "version": "1.7.4",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.4-rc.4",
+  "version": "1.7.4",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",
@@ -17,6 +17,7 @@
     "!bin/server.js",
     "!bin/auth.js",
     "scripts/*.py",
+    "scripts/patches/",
     "!scripts/db_direct.py",
     "!scripts/sync_blocked_authors.py",
     "!scripts/backfill_real_clicks.py",
@@ -56,6 +57,7 @@
     "!scripts/_serp_report.py",
     "!scripts/_serp_vs_gsc_report.py",
     "!scripts/_test_since_hook.py",
+    "!scripts/_lock_preempt_test.py",
     "!scripts/add_deploy_metadata.py",
     "!scripts/add_nightowl_to_config.py",
     "!scripts/amplitude_user_lookup.py",
@@ -160,4 +162,4 @@
     "pg": "^8.20.0",
     "ws": "^8.0.0"
   }
-}
+}

package/scripts/active_experiments.py

@@ -40,16 +40,39 @@ ENV_PREFIX = "S4L_EXP_"
 # Keep draft_prompt entries in sync with bin/server.js
 # DRAFT_PROMPT_VARIANT_DEFS and the arm strings in run-twitter-cycle.sh.
 DESCRIPTIONS = {
+    "draft_b_source": {
+        "human_derived": (
+            "Draft B explore slot: style distilled from real top-performing "
+            "human replies (daily synthesizer), least-used first"
+        ),
+        "model_invented": (
+            "Draft B explore slot: freshly invented style from the "
+            "standalone invention job (post 2026-07-10), least-used first"
+        ),
+        "scored_fallback": (
+            "Draft B explore pool was empty; fell back to a second scored "
+            "pick from the proven-style pool"
+        ),
+    },
     "draft_prompt": {
+        "treatment_v3": (
+            "style-as-form: the assigned style is the binding FORM (defining "
+            "move + per-style length + self-check), learned preferences apply "
+            "inside it; keeps the v2 skeleton ban"
+        ),
+        "control_v3": (
+            "plain draft directive, uniform length clamp, no structure ban"
+        ),
+        # v2 arms (skeleton-ban) retired 2026-07-10; v1 arms
+        # (decoupled-product-pivot) retired 2026-07-06; kept so any
+        # straggler card from an old plan still explains itself.
         "treatment_v2": (
-            "skeleton ban: forbids the concede-then-reverse "
+            "v2, retired: skeleton ban, forbids the concede-then-reverse "
             '"easy X / hard Y" structure and forces varied entry points'
         ),
         "control_v2": (
-            "current draft directive (style + product pivot), no structure ban"
+            "v2, retired: draft directive (style + product pivot), no structure ban"
         ),
-        # v1 arms (decoupled-product-pivot) retired 2026-07-06; kept so any
-        # straggler card from an old plan still explains itself.
         "treatment": "v1, retired: product pivot decoupled from the reply",
         "control": "v1, retired: original draft directive",
     },
@@ -99,8 +122,9 @@ def collect(env=None):
         if var.startswith(ENV_PREFIX) and (v or "").strip():
             out[var[len(ENV_PREFIX):].lower()] = v.strip()
     # 2026-07-06: the personal_brand persona directive is now ARM-AWARE in
-    # run-twitter-cycle.sh (treatment_v2 adds the concede-then-reverse skeleton ban,
-    # control_v2 does not), so the assigned draft_prompt arm DOES touch persona
+    # run-twitter-cycle.sh (treatment_v3 adds the skeleton ban + two-layer
+    # style/preferences contract, control_v3 does not), so the assigned
+    # draft_prompt arm DOES touch persona
     # drafts. Keep it stamped so the arm surfaces on persona cards and the per-arm
     # readout covers both lanes. (Previously dropped here because the persona
     # directive overrode both arms wholesale; that is no longer the case.)