@m13v/s4l 1.6.197-rc.10

package/skill/run-moltbook-launchd.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# run-moltbook-launchd.sh — detach wrapper invoked by launchd.
+#
+# Why this exists:
+#   launchd's StartInterval silently SUPPRESSES a scheduled fire when the prior
+#   invocation of the same Label is still alive. The moltbook cycle has a 600s
+#   T0->T1 sleep plus phased posting, so a single run takes 12-25 min and
+#   regularly overlaps the next 15-min slot. Without this wrapper we lost
+#   1-2 of every 4 fires.
+#
+# How it works:
+#   Python double-fork daemon idiom — first fork gives launchd a parent that
+#   exits immediately (so the job is marked complete in milliseconds), setsid
+#   detaches the session, second fork prevents reacquiring a controlling
+#   terminal, then we exec the real pipeline. macOS lacks `setsid(1)` and
+#   `nohup ... & disown` is not enough because launchd reaps the wrapper's
+#   pgid, taking the nohup child with it.
+#
+# Cross-cycle safety:
+#   run_moltbook_cycle.py uses already_posted_thread_ids() against the posts
+#   table at pick time, so two overlapping cycles will not double-post the
+#   same MoltBook thread. The 600s T0->T1 sleep further narrows the window.
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+SCRIPT="$REPO_DIR/skill/run-moltbook.sh"
+OUT="$LOG_DIR/launchd-moltbook-stdout.log"
+ERR="$LOG_DIR/launchd-moltbook-stderr.log"
+
+# Preflight (added 2026-05-02): skip cleanly if Claude is blocked on a
+# quota cap, or if the system is under memory pressure. See
+# scripts/preflight.sh for full design.
+SA_PREFLIGHT_SCRIPT="run-moltbook"
+source "$REPO_DIR/scripts/preflight.sh"
+preflight_skip_if_claude_blocked
+preflight_skip_if_jetsam_pressure
+
+exec /usr/bin/python3 -c "
+import os, sys
+script  = '$SCRIPT'
+out_log = '$OUT'
+err_log = '$ERR'
+
+if os.fork() != 0:
+    os._exit(0)
+os.setsid()
+
+if os.fork() != 0:
+    os._exit(0)
+
+os.chdir('/')
+out_fd = os.open(out_log, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+err_fd = os.open(err_log, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+nul_fd = os.open('/dev/null', os.O_RDONLY)
+os.dup2(nul_fd, 0)
+os.dup2(out_fd, 1)
+os.dup2(err_fd, 2)
+os.execv(script, [script])
+"

package/skill/run-moltbook.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Social Autoposter - MoltBook phased posting cycle.
+#
+# Delegates to scripts/run_moltbook_cycle.py which implements:
+#   - Phase 1: scan hot + new via MoltBook API, snapshot T0
+#   - Sleep 600s (T0 -> T1 momentum window)
+#   - Phase 2a: re-poll for T1, compute delta_score
+#   - Phase 2b: adaptive cap (default 2, bump to 5 when >=3 candidates
+#              show real-time momentum), Claude drafts, Python posts
+#
+# Three reduction levers baked in:
+#   (1) Historical (project, style) engagement block injected into the drafter prompt.
+#   (2) Adaptive cap gated by per-cycle momentum.
+#   (3) T0 -> T1 delta filter: dead threads drop out before Claude sees them.
+#
+# Called by launchd every 30 minutes.
+
+set -euo pipefail
+
+[ -f "$HOME/social-autoposter/.env" ] && source "$HOME/social-autoposter/.env"
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/run-moltbook-$(date +%Y-%m-%d_%H%M%S).log"
+
+# Per-cycle batch id stamped onto every claude_sessions row spawned by this
+# run (via SA_CYCLE_ID env -> log_claude_session.py). 2026-05-10 cycle_id rollout.
+BATCH_ID="mbcycle-$(date +%Y%m%d-%H%M%S)-$$"
+export SA_CYCLE_ID="$BATCH_ID"
+
+echo "=== MoltBook Post Run: $(date) (cycle=$BATCH_ID) ===" | tee "$LOG_FILE"
+
+python3 "$REPO_DIR/scripts/run_moltbook_cycle.py" 2>&1 | tee -a "$LOG_FILE"
+
+echo "=== Run complete: $(date) ===" | tee -a "$LOG_FILE"
+
+find "$LOG_DIR" -name "run-moltbook-*.log" -mtime +7 -delete 2>/dev/null || true

package/skill/run-overlay-watch.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+# Idempotent supervisor for the twitter-harness on-screen overlay watcher.
+#
+# WHAT: keeps exactly ONE `harness_overlay.py watch` process alive. That watcher
+# injects the status overlay into the twitter-harness Chrome window so a human
+# watching the harness sees what the pipeline is doing.
+#
+# WHY a supervisor: the overlay only renders WHILE the watch process runs. It was
+# previously a manual, local-only process, so it never appeared on headless /
+# remote installs. This script makes it self-starting from BOTH install lanes:
+#   - Lane A (npm/cli): launchd job `com.m13v.social-overlay-watch` (StartInterval
+#     60 + RunAtLoad) re-invokes this script every minute; the pgrep guard makes
+#     re-invocation a no-op while the watcher is already up.
+#   - Lane B (.mcpb / pure MCP): the MCP calls this script on draft_cycle /
+#     autopilot-enable / show_browser_to_user, threading S4L_PYTHON + S4L_LOG_DIR.
+#
+# IDEMPOTENT: safe to call on a 60s timer. If a watcher is already running it
+# exits 0 immediately. Otherwise it spawns one detached (nohup, own session) and
+# returns; the spawned watcher then runs until the machine/MCP tears it down.
+#
+# This script is intentionally NOT locked: the overlay UX is expected to evolve.
+
+set -u
+
+# SAPS_->S4L_ env mirror (brand rename 2026-07-03): old plists/tasks still
+# export SAPS_*; new code reads S4L_*. Copy names, never values via eval.
+while IFS='=' read -r _k _; do
+  case "$_k" in SAPS_*) _n="S4L_${_k#SAPS_}"; eval "[ -n \"\${$_n+x}\" ] || export $_n=\"\${$_k}\"";; esac
+done <<EOF_ENV
+$(env | grep '^SAPS_' | cut -d= -f1 | sed 's/$/=/')
+EOF_ENV
+
+# --- resolve the repo this script lives in (works from launchd + MCP cwd) -----
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+OVERLAY_PY="${REPO_DIR}/scripts/harness_overlay.py"
+
+if [ ! -f "${OVERLAY_PY}" ]; then
+  echo "[overlay-watch] harness_overlay.py not found at ${OVERLAY_PY}; nothing to do" >&2
+  exit 0
+fi
+
+# --- idempotency guard: at most one watcher, ever ----------------------------
+# Match the full `harness_overlay.py watch` invocation (NOT a bare `grep -r`, so
+# this never trips the BSD-grep-on-FIFO hang noted in the repo CLAUDE.md).
+if pgrep -f "harness_overlay.py watch" >/dev/null 2>&1; then
+  exit 0
+fi
+
+# --- resolve a python interpreter --------------------------------------------
+# harness_overlay.py self-heals to a playwright-capable interpreter on its own
+# (see _ensure_playwright_interpreter), so any python3 that exists is fine to
+# launch with. Prefer the MCP-threaded S4L_PYTHON (owned uv runtime), then the
+# usual suspects.
+PYBIN=""
+for _cand in \
+  "${S4L_PYTHON:-}" \
+  "/opt/homebrew/bin/python3.11" \
+  "/usr/bin/python3" \
+  "/opt/homebrew/bin/python3"
+do
+  if [ -n "${_cand}" ] && [ -x "${_cand}" ]; then PYBIN="${_cand}"; break; fi
+done
+if [ -z "${PYBIN}" ]; then
+  PYBIN="$(command -v python3 2>/dev/null || true)"
+fi
+if [ -z "${PYBIN}" ]; then
+  echo "[overlay-watch] no python3 found; cannot start overlay watcher" >&2
+  exit 0
+fi
+
+# --- env the watcher needs ---------------------------------------------------
+# S4L_LOG_DIR: where harness_overlay.py reads cycle logs to decide busy/idle.
+# Default to this repo's skill/logs (MCP overrides it to the materialized repo).
+export S4L_LOG_DIR="${S4L_LOG_DIR:-${REPO_DIR}/skill/logs}"
+# CDP target for the twitter harness Chrome (honor BYO-Chrome installs).
+export TWITTER_CDP_URL="${TWITTER_CDP_URL:-http://127.0.0.1:9555}"
+mkdir -p "${S4L_LOG_DIR}" 2>/dev/null || true
+WATCH_LOG="${S4L_LOG_DIR}/overlay-watch.log"
+
+# --- spawn detached ----------------------------------------------------------
+cd "${REPO_DIR}" || exit 0
+echo "[overlay-watch] $(date '+%Y-%m-%d %H:%M:%S') starting watcher py=${PYBIN} cdp=${TWITTER_CDP_URL} log=${S4L_LOG_DIR}" >>"${WATCH_LOG}" 2>&1
+# Spawn the watcher in a NEW SESSION so it outlives this supervisor.
+# When launchd fires this script (StartInterval 60), the script is the job's
+# main process; the moment it exits, launchd reaps the WHOLE job process group.
+# `nohup` only blocks SIGHUP, not that group SIGKILL, so a plain `nohup ... &`
+# child dies the instant we `exit 0` (it survives only when this runs from an
+# interactive shell, which is NOT a launchd job). macOS ships no setsid(1), so
+# use the python we already resolved to os.setsid() off the launchd group, then
+# exec the real watcher. The watcher's own interpreter self-heal (os.execv)
+# keeps the new session.
+nohup "${PYBIN}" -c 'import os, sys
+try:
+    os.setsid()
+except OSError:
+    pass
+os.execv(sys.argv[1], sys.argv[1:])' "${PYBIN}" "${OVERLAY_PY}" watch >>"${WATCH_LOG}" 2>&1 &
+disown 2>/dev/null || true
+exit 0

package/skill/run-reddit-search-launchd.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+# run-reddit-search-launchd.sh — detach wrapper invoked by launchd.
+#
+# Why this exists:
+#   launchd's StartInterval silently SUPPRESSES a scheduled fire when the prior
+#   invocation of the same Label is still alive. Reddit-search cycles vary
+#   (5 iterations of plan+post) and routinely run 15-25 min, so 1-3 of every
+#   4 fires were getting dropped. Throughput collapsed to ~2 cycles/hr instead
+#   of 4.
+#
+# How it works:
+#   This wrapper is what launchd actually invokes. It uses Python's classic
+#   double-fork daemon idiom to spawn the real pipeline in a fresh session
+#   (os.setsid), then exits. macOS lacks the `setsid` binary and a plain
+#   `nohup ... &; disown` is NOT sufficient — launchd cleans up the wrapper's
+#   process group after the wrapper exits and SIGTERMs the nohup'd child too.
+#   The double-fork moves the cycle into its own session/pgid that launchd
+#   no longer tracks, so it survives wrapper exit.
+#
+# Net effect: launchd marks the job complete in milliseconds and fires the
+# next 15-min slot on schedule. Multiple run-reddit-search.sh processes can
+# now live in parallel; the reddit-browser lock (skill/lock.sh) serializes
+# the brief post-phase windows, and post_reddit.py's already_posted filter
+# prevents double-posting across overlapping cycles.
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+SCRIPT="$REPO_DIR/skill/run-reddit-search.sh"
+OUT="$LOG_DIR/launchd-reddit-search-stdout.log"
+ERR="$LOG_DIR/launchd-reddit-search-stderr.log"
+
+# Preflight (added 2026-05-02): skip cleanly if Claude is blocked on a
+# quota cap, or if the system is under memory pressure. Both paths exit 0
+# with a stderr [skipped:] line so launchd treats the slot as consumed.
+# See scripts/preflight.sh for full design.
+SA_PREFLIGHT_SCRIPT="run-reddit-search"
+source "$REPO_DIR/scripts/preflight.sh"
+preflight_skip_if_claude_blocked
+preflight_skip_if_jetsam_pressure
+
+exec /usr/bin/python3 -c "
+import os, sys
+script  = '$SCRIPT'
+out_log = '$OUT'
+err_log = '$ERR'
+
+if os.fork() != 0:
+    os._exit(0)
+os.setsid()
+
+if os.fork() != 0:
+    os._exit(0)
+
+os.chdir('/')
+out_fd = os.open(out_log, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+err_fd = os.open(err_log, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+nul_fd = os.open('/dev/null', os.O_RDONLY)
+os.dup2(nul_fd, 0)
+os.dup2(out_fd, 1)
+os.dup2(err_fd, 2)
+os.execv(script, [script])
+"