@m13v/s4l 1.7.1-rc.2 → 1.7.1-rc.21

package/scripts/release-mcpb.sh

@@ -45,6 +45,16 @@
 # the EXACT tested artifact ships to everyone. Nothing can drift between test and
 # ship because there is no repack.
 #
+# FIXED STAGING DOWNLOAD LINK (2026-07-07, step 7b): stable has a permanent
+# "latest" URL (releases/latest/download/social-autoposter.mcpb); staging did
+# not, because GitHub's releases/latest hard-excludes prereleases with no
+# override. Every --staging run now also mirrors the .mcpb onto a separate,
+# non-version-tagged release ("staging-latest") so this URL never changes:
+#   https://github.com/m13v/s4l/releases/download/staging-latest/social-autoposter.mcpb
+# The tag deliberately isn't semver-shaped, so version.ts/snapshot.py's real
+# "newest rc" resolution (which requires a ^\d+\.\d+\.\d+ tag) ignores it —
+# it is a convenience download link only, never a candidate update source.
+#
 # Usage:
 #   bash scripts/release-mcpb.sh                 # patch bump, npm + .mcpb + GitHub (STABLE)
 #   bash scripts/release-mcpb.sh --bump minor
@@ -68,6 +78,12 @@ MCP_DIR="$REPO_ROOT/mcp"
 BUNDLE="$MCP_DIR/social-autoposter.mcpb"
 GH_REPO="m13v/s4l"
 SIZE_CAP_MB=180
+# Floating alias release for a fixed "always the newest staging build" download
+# link, mirroring what releases/latest/download/<asset> already gives stable.
+# GitHub's own releases/latest excludes prereleases with no override, so there is
+# no built-in equivalent for the rc channel — see step 7b below for why a
+# non-semver tag here is safe (never confuses the real update-detection code).
+STAGING_ALIAS_TAG="staging-latest"
 
 TAG_OVERRIDE=""
 VERSION_OVERRIDE=""
@@ -496,6 +512,38 @@ say "Released $TAG"
 echo "  asset: social-autoposter.mcpb (${MB}MB)"
 [[ -n "$URL" ]] && echo "  $URL"
 
+# ---- 7b. Fixed "always latest staging" download link ------------------------
+# Mirrors the asset just uploaded above onto a SEPARATE release tagged
+# "$STAGING_ALIAS_TAG" (not a version), so the download URL never changes:
+#   https://github.com/$GH_REPO/releases/download/$STAGING_ALIAS_TAG/social-autoposter.mcpb
+# Safe by construction: latestFromGithubListStaging() (mcp/src/version.ts) and
+# _latest_from_github_list_staging() (scripts/snapshot.py) both require
+# tag_name to match ^\d+\.\d+\.\d+ before treating a release as a candidate
+# "newest" build; a tag literally named "staging-latest" fails that check and
+# is silently skipped by both, so this alias can never get mistaken for a real
+# rc and can never confuse which build a box installs. It exists ONLY to give
+# humans (and scripts) one fixed bookmark — actual boxes still resolve "newest"
+# from the real per-release rc tags via the releases LIST endpoint, unchanged.
+if [[ "$DO_STAGING" == "1" ]]; then
+  say "Mirroring asset onto the fixed staging-latest alias"
+  ALIAS_NOTES="Always mirrors the newest staging pre-release's .mcpb asset (currently $TAG).
+
+Fixed download link (never changes): https://github.com/$GH_REPO/releases/download/$STAGING_ALIAS_TAG/social-autoposter.mcpb
+
+Not a real release — do not install from the tag page; use the asset link above. Actual per-build releases are tagged by version (e.g. $TAG)."
+  if gh release view "$STAGING_ALIAS_TAG" -R "$GH_REPO" >/dev/null 2>&1; then
+    gh release upload "$STAGING_ALIAS_TAG" "$BUNDLE" -R "$GH_REPO" --clobber
+    gh release edit "$STAGING_ALIAS_TAG" -R "$GH_REPO" --notes "$ALIAS_NOTES" >/dev/null
+  else
+    gh release create "$STAGING_ALIAS_TAG" "$BUNDLE" \
+      -R "$GH_REPO" \
+      --title "social-autoposter (staging — always latest)" \
+      --notes "$ALIAS_NOTES" \
+      --prerelease
+  fi
+  echo "  https://github.com/$GH_REPO/releases/download/$STAGING_ALIAS_TAG/social-autoposter.mcpb"
+fi
+
 # ---- 8. Verify the update banner will fire ---------------------------------
 # The menu-bar "⬆ Update available" banner (mcp/src/version.ts::versionStatus)
 # resolves "latest" from GitHub releases/latest, which is what .mcpb boxes (no

package/scripts/reset-test-machine.sh

@@ -17,9 +17,12 @@
 #              disturbing the rest of the environment.
 #   --deep     FULL NUKE — the plugin reset above PLUS the shared layer it touches:
 #              per-agent Chrome profiles + cookies (reddit/linkedin/twitter), the
-#              browser-harness backend, and the packaged toolchain (uv binary, uv
-#              cache, Chromium ~1.7G). Other tools that rely on uv/Chromium
-#              re-provision afterward. Use to reproduce a true bare-metal box.
+#              browser-harness backend, the packaged toolchain (uv binary + uv
+#              data/cache, Chromium ~1.7G), the uv PATH shim in your shell rc, the
+#              real Google Chrome.app the provisioner installs, and Google's
+#              Keystone updater. Reproduces a genuinely bare-metal box (as if S4L
+#              had never run). Other tools that rely on uv/Chrome/Chromium
+#              re-provision afterward — intended for DEDICATED test machines.
 #
 # Usage:
 #   scripts/reset-test-machine.sh            # dry run: print what the plugin reset WOULD remove
@@ -205,6 +208,27 @@ echo "[1] MCP state dir (uv-owned python, venv, materialized repo, runtime.json,
 rm_path "$HOME_DIR/.social-autoposter-mcp" "state"
 echo
 
+# ---- 1a. compat symlink ~/social-autoposter -> materialized repo -----------
+# The .mcpb provisioner plants ~/social-autoposter as a symlink INTO the state
+# dir (so the pipeline's hardcoded $HOME/social-autoposter paths resolve). The
+# state-dir wipe in [1] leaves it DANGLING. Remove it — but ONLY when it is a
+# symlink resolving into .social-autoposter-mcp, so a developer's real clone (or
+# their own ~/social-autoposter symlink to a working tree) is never touched.
+echo "[1a] compat symlink ~/social-autoposter (plugin-planted)"
+SA_LINK="$HOME_DIR/social-autoposter"
+if [ -L "$SA_LINK" ]; then
+  SA_TARGET="$(readlink "$SA_LINK" 2>/dev/null || true)"
+  case "$SA_TARGET" in
+    *.social-autoposter-mcp/*|*.social-autoposter-mcp) rm_path "$SA_LINK" "compat-symlink" ;;
+    *) echo "  (leaving $SA_LINK -> $SA_TARGET — not a plugin-planted symlink)" ;;
+  esac
+elif [ -e "$SA_LINK" ]; then
+  echo "  (leaving $SA_LINK — a real directory/clone, not a plugin-planted symlink)"
+else
+  echo "  (no ~/social-autoposter symlink)"
+fi
+echo
+
 # ---- 1b. Claude Desktop .mcpb extension -----------------------------------
 # A .mcpb (Desktop) install scatters THREE artifacts under ~/Library/Application
 # Support/Claude/, NONE of which live in the state dir removed in [1]: the
@@ -532,6 +556,23 @@ if [ "$DEEP" -eq 1 ]; then
   rm_path "$HOME_DIR/.local/bin/uv"                "uv-bin"
   rm_path "$HOME_DIR/.local/bin/uvx"               "uvx-bin"
   rm_path "$HOME_DIR/.cache/uv"                    "uv-cache"
+  # uv's DATA dir (installed standalone Pythons + tool venvs) and its PATH shim
+  # survive the bin removal — a bare box has neither. The uv installer also
+  # appends `. "$HOME/.local/bin/env"` to the shell rc files; strip that exact
+  # line so no uv PATH shim lingers.
+  rm_path "$HOME_DIR/.local/share/uv"             "uv-data"
+  rm_path "$HOME_DIR/.local/bin/env"              "uv-env-script"
+  for rc in "$HOME_DIR/.zshrc" "$HOME_DIR/.zprofile" "$HOME_DIR/.profile" \
+            "$HOME_DIR/.bash_profile" "$HOME_DIR/.bashrc"; do
+    [ -f "$rc" ] || continue
+    if grep -q '\.local/bin/env' "$rc" 2>/dev/null; then
+      echo "  edit    strip uv env-shim line from $rc"
+      if [ "$DRY" -eq 0 ]; then
+        cp "$rc" "$rc.bak" 2>/dev/null || true
+        grep -v '\.local/bin/env' "$rc" > "$rc.tmp" 2>/dev/null && mv "$rc.tmp" "$rc"
+      fi
+    fi
+  done
   echo "  WARN    --deep removed uv + ms-playwright; other tools on this machine that rely on them will re-provision."
 else
   echo "  (left uv + ~/Library/Caches/ms-playwright + ~/.cache/uv in place)"
@@ -539,6 +580,47 @@ fi
 fi
 echo
 
+# ---- 6b. DEEP: packaged Google Chrome + its Keystone updater ----------------
+# The provisioner installs a REAL Google Chrome.app (runtime.ts Step 7) — the
+# browser the scanner drives over CDP — that NO other reset step removes, plus
+# installing it drops Google's Keystone auto-updater (LaunchAgents + support
+# dirs). A bare box had none of this. --deep removes all of it so the Chrome
+# install step is exercised fresh. NOTE: this touches the machine's Google Chrome
+# globally, not just S4L — hence --deep / test-box only.
+if [ "$PLUGIN_ONLY" -eq 1 ]; then
+  echo "[6b] packaged Google Chrome + Keystone updater — skipped (plugin reset; pass --deep to remove)"
+else
+  echo "[6b] packaged Google Chrome + Keystone updater — $([ "$DEEP" -eq 1 ] && echo ENABLED || echo 'skipped (pass --deep)')"
+  if [ "$DEEP" -eq 1 ]; then
+    # Stop Chrome + unload the Keystone/updater agents before deleting their plists.
+    if [ "$DRY" -eq 0 ]; then
+      pkill -f 'Google Chrome' 2>/dev/null || true
+      for lbl in com.google.keystone.agent com.google.keystone.xpcservice com.google.GoogleUpdater.wake; do
+        launchctl bootout "gui/$(id -u)/$lbl" 2>/dev/null || true
+      done
+    fi
+    rm_path "/Applications/Google Chrome.app"            "google-chrome"
+    rm_path "$HOME_DIR/Applications/Google Chrome.app"   "google-chrome-user"
+    for p in \
+      "$HOME_DIR/Library/Application Support/Google" \
+      "$HOME_DIR/Library/Google" \
+      "$HOME_DIR/Library/Caches/Google" \
+      "$HOME_DIR/Library/Caches/com.google.Chrome" \
+      "$HOME_DIR/Library/Caches/com.google.Keystone" \
+      "$HOME_DIR/Library/LaunchAgents/com.google.keystone.agent.plist" \
+      "$HOME_DIR/Library/LaunchAgents/com.google.keystone.xpcservice.plist" \
+      "$HOME_DIR/Library/LaunchAgents/com.google.GoogleUpdater.wake.plist" \
+      "$HOME_DIR/Library/LaunchAgents/com.google.GoogleUpdater.plist"; do
+      rm_path "$p" "google"
+    done
+    for f in "$HOME_DIR"/Library/Preferences/com.google.Chrome*.plist; do
+      [ -e "$f" ] && rm_path "$f" "google-pref"
+    done
+    echo "  WARN    --deep removed Google Chrome + Keystone updater machine-wide."
+  fi
+fi
+echo
+
 # ---- 7. settle & verify (defeat Claude auto-relaunch resurrection) ---------
 # Claude Desktop can RELAUNCH after step [0] — on auto-update (ShipIt), a macOS
 # re-open, or a login item — and a relaunched host re-materializes a skeleton

package/scripts/s4l_mode.py

@@ -249,11 +249,13 @@ def set_split(value) -> float:
 def get_draft_only() -> bool:
     """Whether every cycle stops at review cards (DEFAULT: True).
 
-    False (operator opt-out via `draft-only off`) means promotion-lane cycles
-    POST autonomously behind the rolling virality bar. Persona-lane cycles are
-    unaffected either way: they always stay draft-only so the user's own voice
-    keeps human review. Reads the retired `autopilot` key (inverted) from
-    mode.json files written before the 2026-07-06 rename.
+    False (operator opt-out via `draft-only off`) means EVERY lane (promotion
+    AND personal_brand) POSTs autonomously; promotion additionally runs behind
+    the rolling virality bar. As of 2026-07-08 this is a single global switch,
+    not promotion-only: see skill/run-draft-and-publish.sh's DRAFT_ONLY_FLAG
+    gate, which applies this value uniformly across lanes. Reads the retired
+    `autopilot` key (inverted) from mode.json files written before the
+    2026-07-06 rename.
     """
     try:
         data = json.loads(mode_file().read_text())

package/scripts/scheduled_tasks_snapshot.py

@@ -159,6 +159,108 @@ def build_summary() -> dict:
     }
 
 
+STATE_CACHE_PATH = os.path.join(
+    os.path.expanduser("~"), ".social-autoposter-mcp", "scheduled-tasks-last-state.json"
+)
+
+
+def _load_last_state() -> dict:
+    try:
+        with open(STATE_CACHE_PATH) as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _save_last_state(state: dict) -> None:
+    try:
+        os.makedirs(os.path.dirname(STATE_CACHE_PATH), exist_ok=True)
+        tmp = f"{STATE_CACHE_PATH}.tmp.{os.getpid()}"
+        with open(tmp, "w") as f:
+            json.dump(state, f)
+        os.replace(tmp, STATE_CACHE_PATH)
+    except Exception:
+        pass
+
+
+def _registry_key(reg: dict) -> str:
+    return f"{reg.get('data_dir')}/{reg.get('account')}/{reg.get('session')}"
+
+
+def _report_registry_change(message: str, changes: list) -> None:
+    """Best-effort Sentry breadcrumb for a registry transition. Silent no-op if
+    sentry-sdk/S4L_REPO_DIR are unavailable, so this stays additive and never
+    threatens the script's primary --summary (heartbeat) path."""
+    try:
+        repo = os.environ.get("S4L_REPO_DIR")
+        if repo:
+            scripts_dir = os.path.join(repo, "scripts")
+            if scripts_dir not in sys.path:
+                sys.path.insert(0, scripts_dir)
+        import sentry_init
+
+        sentry_init.init()
+        sentry_init.capture_message(
+            message,
+            level="info",
+            tags={"component": "scheduled-tasks-snapshot", "issue": "registry_change"},
+            extra={"changes": changes},
+        )
+        sentry_init.flush()
+    except Exception:
+        pass
+
+
+def diff_and_emit(per_registry: list) -> list:
+    """Compare the current per-registry worker_ids/enabled state against the
+    last observed state (cached locally) and emit ONE distinct event per real
+    transition: a registry gaining/losing the worker task, `enabled` flipping,
+    or a registry appearing/disappearing entirely. Silent when nothing changed.
+
+    This exists because reconstructing "when did the registry actually change"
+    previously required diffing dozens of raw --summary snapshots by hand (see
+    the Karol 2026-07-07 update-orphan investigation) — every poll logged full
+    state unconditionally, with no distinct signal for an actual transition.
+    Returns the list of change strings (empty if nothing changed). Best-effort:
+    never raises, and never touches the registry files themselves."""
+    changes: list = []
+    try:
+        last = _load_last_state()
+        current = {}
+        for reg in per_registry:
+            key = _registry_key(reg)
+            snap = {
+                "worker_ids": sorted(reg.get("worker_ids") or []),
+                "enabled": bool(reg.get("enabled")),
+            }
+            current[key] = snap
+            prev = last.get(key)
+            if prev is None:
+                if snap["worker_ids"]:
+                    changes.append(
+                        f"{key}: registry appeared with worker_ids={snap['worker_ids']} "
+                        f"enabled={snap['enabled']}"
+                    )
+                continue
+            if prev.get("worker_ids") != snap["worker_ids"] or prev.get("enabled") != snap["enabled"]:
+                changes.append(
+                    f"{key}: worker_ids {prev.get('worker_ids')}->{snap['worker_ids']} "
+                    f"enabled {prev.get('enabled')}->{snap['enabled']}"
+                )
+        for key, prev in last.items():
+            if key not in current and (prev or {}).get("worker_ids"):
+                changes.append(f"{key}: registry disappeared (had worker_ids={prev.get('worker_ids')})")
+
+        if changes:
+            message = "scheduled-tasks registry changed: " + "; ".join(changes)
+            sys.stderr.write(f"[scheduled-tasks-snapshot] {message}\n")
+            _report_registry_change(message, changes)
+        _save_last_state(current)
+    except Exception:
+        pass
+    return changes
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
@@ -169,6 +271,11 @@ def main() -> int:
     args = parser.parse_args()
 
     summary = build_summary()
+    # Side effect deliberately confined to the standalone-script path (not
+    # build_summary(), which s4l_menubar.py also imports in-process on every
+    # warning capture — doing the diff there would cache-thrash and could
+    # double-report on every menu-bar poll instead of once per real change).
+    diff_and_emit(summary.get("per_registry") or [])
     if args.summary:
         sys.stdout.write(json.dumps(summary, separators=(",", ":")))
     else:

package/scripts/send_gmail_report.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Generic Gmail-API send helper for Claude-authored reports.
+
+Extracted out of sentry_digest.py so any skill doc (Claude spawned in a
+--dangerously-skip-permissions session) can send a report email without
+duplicating the Gmail plumbing. Body is read from a file, not a CLI arg, so
+large HTML/markdown reports don't hit shell quoting/length limits.
+
+Same Gmail token as strike_alert.py / daily_stats_email.py: i@m13v.com via
+~/gmail-api/token_i_at_m13v.com.json.
+
+Usage:
+    python3 scripts/send_gmail_report.py \\
+        --to i@m13v.com \\
+        --subject "[Sentry] s4l: 1 new critical issue" \\
+        --body-file /tmp/report.html \\
+        [--html]   # body-file content is HTML (default: plain text)
+"""
+
+import argparse
+import base64
+import os
+import sys
+from email.mime.text import MIMEText
+
+GMAIL_TOKEN_PATH = os.path.expanduser("~/gmail-api/token_i_at_m13v.com.json")
+GMAIL_SCOPES = ["https://mail.google.com/"]
+
+
+def _scrub_dashes(s):
+    if not s:
+        return s
+    return s.replace("—", ",").replace("–", ",")
+
+
+def gmail_service():
+    from google.auth.transport.requests import Request
+    from google.oauth2.credentials import Credentials
+    from googleapiclient.discovery import build
+
+    creds = Credentials.from_authorized_user_file(GMAIL_TOKEN_PATH, GMAIL_SCOPES)
+    if creds.expired and creds.refresh_token:
+        creds.refresh(Request())
+        with open(GMAIL_TOKEN_PATH, "w") as f:
+            f.write(creds.to_json())
+    return build("gmail", "v1", credentials=creds)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--to", required=True)
+    parser.add_argument("--subject", required=True)
+    parser.add_argument("--body-file", required=True, help="Path to a file containing the email body.")
+    parser.add_argument("--html", action="store_true", help="Body file content is HTML (default: plain text).")
+    args = parser.parse_args()
+
+    with open(args.body_file) as f:
+        body = f.read()
+
+    subtype = "html" if args.html else "plain"
+    msg = MIMEText(body, subtype)
+    msg["to"] = args.to
+    msg["subject"] = _scrub_dashes(args.subject)
+
+    service = gmail_service()
+    raw = base64.urlsafe_b64encode(msg.as_bytes()).decode("utf-8")
+    result = service.users().messages().send(userId="me", body={"raw": raw}).execute()
+    print(f"Email sent: {result['id']}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"ERROR sending email: {e}", file=sys.stderr)
+        sys.exit(1)