@m13v/s4l 1.6.197-rc.10

package/skill/run-scan-moltbook-replies.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# Social Autoposter - Moltbook reply scanner
+# Runs scan_moltbook_replies.py on its own launchd schedule.
+# Pure API; typically finishes in <1min, so uses a short 15min lock wait.
+
+
+set -euo pipefail
+
+source "$(dirname "$0")/lock.sh"
+acquire_lock "scan-moltbook-replies" 900
+
+[ -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-scan-moltbook-replies-$(date +%Y-%m-%d_%H%M%S).log"
+
+echo "=== Scan Moltbook Replies Run: $(date) ===" | tee "$LOG_FILE"
+START_TS=$(date +%s)
+
+PYTHONUNBUFFERED=1 python3 "$REPO_DIR/scripts/scan_moltbook_replies.py" 2>&1 | tee -a "$LOG_FILE" || true
+
+ELAPSED=$(( $(date +%s) - START_TS ))
+# grep -c prints "0" AND exits 1 on zero matches, so `|| echo 0` was
+# appending a second "0" and making FOUND multiline, which silently broke
+# log_run.py. Use `|| FOUND=0` so the fallback only fires when the file is
+# unreadable.
+FOUND=$(grep -ci "new repl" "$LOG_FILE" 2>/dev/null) || FOUND=0
+# Pull scan-stage counters out of the "Notification scan complete:" line that
+# scan_moltbook_replies.py prints. Same key format as Reddit's scanner. Renders
+# as scanned/new/excluded pills on the dashboard scan-replies row so empty
+# cycles read as "scanned N / 0 new" instead of all-zeros.
+SCAN_LINE=$(grep -m1 "^Notification scan complete:" "$LOG_FILE" 2>/dev/null || true)
+SCAN_ARG=""
+if [ -n "$SCAN_LINE" ]; then
+  scan_seen=$(echo "$SCAN_LINE" | grep -oE "seen=[0-9]+" | head -1 | cut -d= -f2)
+  scan_new=$(echo "$SCAN_LINE" | grep -oE "new_pending=[0-9]+" | head -1 | cut -d= -f2)
+  scan_excl=$(echo "$SCAN_LINE" | grep -oE "excluded_author=[0-9]+" | head -1 | cut -d= -f2)
+  scan_self=$(echo "$SCAN_LINE" | grep -oE "self_filtered=[0-9]+" | head -1 | cut -d= -f2)
+  scan_back=$(echo "$SCAN_LINE" | grep -oE "backfill_skipped=[0-9]+" | head -1 | cut -d= -f2)
+  scan_excl_total=$(( ${scan_excl:-0} + ${scan_self:-0} ))
+  parts=""
+  [ -n "$scan_seen" ] && parts="${parts}scanned=${scan_seen},"
+  [ -n "$scan_new" ]  && parts="${parts}new=${scan_new},"
+  [ "$scan_excl_total" -gt 0 ] && parts="${parts}excluded=${scan_excl_total},"
+  [ -n "$scan_back" ] && parts="${parts}backfill=${scan_back},"
+  SCAN_ARG="${parts%,}"
+fi
+if [ -n "$SCAN_ARG" ]; then
+  python3 "$REPO_DIR/scripts/log_run.py" --script "scan_moltbook_replies" --posted "$FOUND" --skipped 0 --failed 0 --cost 0 --elapsed "$ELAPSED" --scan "$SCAN_ARG" || true
+else
+  python3 "$REPO_DIR/scripts/log_run.py" --script "scan_moltbook_replies" --posted "$FOUND" --skipped 0 --failed 0 --cost 0 --elapsed "$ELAPSED" || true
+fi
+
+echo "=== Scan Moltbook Replies complete: $(date) (elapsed ${ELAPSED}s) ===" | tee -a "$LOG_FILE"
+find "$LOG_DIR" -name "run-scan-moltbook-replies-*.log" -mtime +7 -delete 2>/dev/null || true

package/skill/run-twitter-cycle-launchd.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# run-twitter-cycle-launchd.sh — detach wrapper invoked by launchd.
+#
+# Why this exists:
+#   launchd's StartCalendarInterval silently SUPPRESSES a scheduled fire when
+#   the prior invocation of the same Label is still alive. The Twitter cycle
+#   takes 25-45 min wall-clock (Phase 2b-gen runs SEO landing-page generation
+#   per candidate, ~5-8 min each, lock-free). At a 15-min cadence that means
+#   2-3 of every 4 fires get dropped on the floor; throughput collapses to
+#   1 cycle/45min instead of 4 cycles/hr.
+#
+# 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 :00/:15/:30/:45 slot on schedule. Multiple run-twitter-cycle.sh
+# processes can now live in parallel; the twitter-browser lock
+# (skill/lock.sh, 3600s timeout) handles the brief browser-using windows
+# (Phase 1 scrape, Phase 2b-prep draft, Phase 2c post — minutes each), and
+# Phase 0 is guarded by a Postgres advisory lock to prevent salvage-UPDATE
+# races between overlapping cycles.
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+SCRIPT="$REPO_DIR/skill/run-twitter-cycle.sh"
+OUT="$LOG_DIR/launchd-twitter-cycle-stdout.log"
+ERR="$LOG_DIR/launchd-twitter-cycle-stderr.log"
+
+exec /usr/bin/python3 -c "
+import os, sys
+script  = '$SCRIPT'
+out_log = '$OUT'
+err_log = '$ERR'
+
+# First fork — parent (launchd's tracked process) exits immediately so
+# launchd marks the job complete. Child continues as session leader.
+if os.fork() != 0:
+    os._exit(0)
+os.setsid()
+
+# Second fork — guarantees the daemon cannot reacquire a controlling
+# terminal and detaches one level further from any process-group cleanup.
+if os.fork() != 0:
+    os._exit(0)
+
+# Grandchild: redirect stdio, exec the real cycle script.
+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-twitter-cycle-singleton.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# run-twitter-cycle-singleton.sh — launchd entry wrapper for the twitter
+# post-comments cycle.
+#
+# CONCURRENCY: this wrapper NO LONGER enforces one-at-a-time. As of 2026-06-01
+# that is handled inside run-twitter-cycle.sh itself via:
+#     preflight_acquire_slot_or_skip "twitter-cycle" 1
+# which EVERY launch path hits (launchd, MCP draft_cycle/autopilot, manual
+# `bash skill/run-twitter-cycle.sh`). The old guard that used to live here
+# (Phase 0 external-cycle detect + the /tmp/sa-twitter-cycle-singleton.lock
+# mkdir claim) only governed the launchd path, never the MCP/manual paths, so
+# it let out-of-band cycles slip through and then conflicted with the in-script
+# gate. It was redundant belt-and-suspenders and is removed. Single source of
+# truth for concurrency is now the preflight slot gate.
+#
+# SNAPSHOT (the one load-bearing job left here): copy the cycle script to a temp
+# file and run THAT, so an in-place edit of run-twitter-cycle.sh mid-run (e.g.
+# the auto-commit agent committing a rewrite) cannot corrupt bash's byte-offset
+# execution of a live cycle. run-twitter-cycle.sh hardcodes
+# REPO_DIR="$HOME/social-autoposter" (no $0/BASH_SOURCE), so the /tmp copy
+# resolves the repo identically.
+# 2026-05-28 incident: commit 0ac29141 landed mid-run, byte-offset misaligned,
+# the cycle skipped its unconditional release_lock + Variant-A sleep, then
+# re-acquired its own still-held twitter-browser lock and self-deadlocked.
+#
+# NEVER KILL: per user instruction 2026-05-22, this wrapper does not
+# SIGTERM/SIGKILL anything. With concurrency now enforced by the slot gate,
+# there is nothing to preempt anyway.
+#
+# Logs:
+#   - skill/logs/twitter-cycle-singleton.log -> wrapper start/done + snapshot events
+#   - launchd stdout/stderr (configured in the plist) receive the cycle's output
+
+set -u
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+SINGLETON_LOG="$LOG_DIR/twitter-cycle-singleton.log"
+CYCLE_SCRIPT="$REPO_DIR/skill/run-twitter-cycle.sh"
+SNAPSHOT=""
+
+mkdir -p "$LOG_DIR"
+
+ts() { date '+%Y-%m-%d %H:%M:%S'; }
+log() { echo "[$(ts)] $*" >> "$SINGLETON_LOG"; }
+
+# Release the snapshot temp file on any exit path.
+trap 'rm -f "$SNAPSHOT"; log "[wrapper] done pid=$$ rc=${EXIT_CODE:-?}"' EXIT
+
+log "[wrapper] start pid=$$"
+
+SNAPSHOT="/tmp/sa-twitter-cycle-snapshot-$$.sh"
+cp "$CYCLE_SCRIPT" "$SNAPSHOT"
+if ! /bin/bash -n "$SNAPSHOT" 2>/dev/null; then
+  log "[wrapper] snapshot syntax check failed (caught mid-edit?); aborting, launchd retries next fire"
+  exit 1
+fi
+
+# Foreground run of the snapshot. Do NOT exec (so the trap fires on completion).
+/bin/bash "$SNAPSHOT"
+EXIT_CODE=$?
+exit "$EXIT_CODE"