@m13v/s4l 1.6.197-rc.10

package/skill/memory-snapshot.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Append one social-autoposter memory/process snapshot.
+#
+# This wrapper is intentionally tiny and does not source .env: command lines can
+# already contain enough context for diagnostics, and the Python sampler redacts
+# likely secrets before writing its JSONL log.
+
+set -uo pipefail
+
+# 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
+
+REPO_DIR="${REPO_DIR:-$HOME/social-autoposter}"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+cd "$REPO_DIR" || exit 2
+
+PID_FILE="/tmp/social-autoposter-memory-snapshot.pid"
+if [ -f "$PID_FILE" ]; then
+  prev=$(cat "$PID_FILE" 2>/dev/null || true)
+  if [ -n "$prev" ] && kill -0 "$prev" 2>/dev/null; then
+    echo "[memory-snapshot] previous sampler still active pid=$prev; skipping"
+    exit 0
+  fi
+fi
+echo "$$" > "$PID_FILE"
+trap 'rm -f "$PID_FILE"' EXIT INT TERM
+
+PYTHON_BIN="${S4L_PYTHON:-python3}"
+"$PYTHON_BIN" "$REPO_DIR/scripts/memory_snapshot.py" \
+  --output "${S4L_MEMORY_SNAPSHOT_LOG:-$LOG_DIR/memory-snapshots.jsonl}" \
+  --top "${S4L_MEMORY_TOP_N:-30}" \
+  --max-bytes "${S4L_MEMORY_MAX_BYTES:-104857600}"

package/skill/precompute-stats.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# precompute-stats.sh — launchd wrapper for scripts/precompute_dashboard_stats.py.
+#
+# Fires every 5 minutes from com.m13v.social-precompute-stats.plist. Writes
+# funnel_stats_<N>d.json, activity_stats_<H>h.json, style_stats_<H>h.json
+# snapshots under skill/cache/ so the dashboard serves instant responses
+# instead of cold-starting HogQL on every request.
+#
+# Keep this wrapper small. All business logic lives in the Python script.
+
+set -uo pipefail
+
+REPO_DIR="$HOME/social-autoposter"
+
+# shellcheck source=/dev/null
+[ -f "$REPO_DIR/.env" ] && source "$REPO_DIR/.env"
+
+cd "$REPO_DIR" || exit 2
+
+# Single-flight: launchd fires this every 300s, but a single run can take
+# 2-5+ min when PostHog 429s force per-query backoff. Without a lock, slow
+# runs stack into a stampede that saturates HogQL and surfaces as
+# posthog_throttle pills across every project on the dashboard. acquire_lock
+# with a 5s timeout exits 0 cleanly if a prior run is still active.
+# shellcheck source=lock.sh
+source "$REPO_DIR/skill/lock.sh"
+acquire_lock precompute-stats 5
+
+RUN_START=$(date +%s)
+python3 "$REPO_DIR/scripts/precompute_dashboard_stats.py"
+EXIT_CODE=$?
+RUN_ELAPSED=$(( $(date +%s) - RUN_START ))
+
+echo "[$(date +%H:%M:%S)] === done in ${RUN_ELAPSED}s (exit=${EXIT_CODE}) ==="
+exit "$EXIT_CODE"

package/skill/prewarm-funnel.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+# Social Autoposter dashboard funnel cache pre-warmer.
+#
+# /api/funnel/per-day shells out to scripts/funnel_per_day.py which issues one
+# HogQL query per metric per project against PostHog. On a cold cache a single
+# project's call takes 5-25s; without pre-warming the dashboard's per-project
+# breakdown timed out on 19 of 23 projects' funnel fetch on first page-load
+# and rendered them as silent zeros.
+#
+# Strategy: serial calls (not parallel — PostHog rate-limits, and the python
+# script already fans out per-metric internally), longer per-call timeout
+# than the dashboard uses (180s vs 30s frontend), against both the launchd
+# dashboard (3141) and the dev --watch instance (3142, if alive).
+#
+# Scheduled by com.m13v.social-funnel-prewarm.plist every 240s. The server
+# cache TTL is 300s, so a 240s cadence keeps cache continuously hot.
+
+set -uo pipefail
+
+REPO_DIR="${REPO_DIR:-/Users/matthewdi/social-autoposter}"
+LOG_DIR="${REPO_DIR}/skill/logs"
+LOG_FILE="${LOG_DIR}/prewarm-funnel.log"
+mkdir -p "$LOG_DIR"
+
+ts() { date "+%Y-%m-%dT%H:%M:%S%z"; }
+log() { echo "[$(ts)] $*" >> "$LOG_FILE"; }
+
+# Single-instance guard. A full cycle takes 2-5min (25 projects x 2 day-windows
+# x N ports, each call 5-180s); launchd fires every 240s, so without this guard
+# the script stacks (saw 2 stale processes from 11:22 + 11:33 on 2026-05-19
+# both still running at 11:35, multiplying PostHog + dashboard pg-pool load and
+# wedging both Get Started cards and per-project breakdown).
+# macOS ships no flock(1), so we use a PID file: a previous process's PID is
+# considered live iff `kill -0 PID` succeeds and the proc is still bash.
+PID_FILE="/tmp/social-autoposter-prewarm-funnel.pid"
+if [ -f "$PID_FILE" ]; then
+  prev=$(cat "$PID_FILE" 2>/dev/null || true)
+  if [ -n "$prev" ] && kill -0 "$prev" 2>/dev/null && ps -p "$prev" -o comm= 2>/dev/null | grep -qE "bash|sh"; then
+    log "another prewarm cycle (pid=$prev) in progress; skipping this tick"
+    exit 0
+  fi
+fi
+echo "$$" > "$PID_FILE"
+trap 'rm -f "$PID_FILE"' EXIT INT TERM
+
+projects=()
+while IFS= read -r line; do
+  [ -n "$line" ] && projects+=("$line")
+done < <(jq -r '.projects[].name' "$REPO_DIR/config.json")
+
+# Discover live dashboard ports. Probe root URL (no auth, cheap).
+ports=()
+for port in 3141 3142; do
+  if curl -sS -o /dev/null -w "%{http_code}" --max-time 3 "http://127.0.0.1:$port/" 2>/dev/null | grep -qE "^(200|301|302|401|403)$"; then
+    ports+=("$port")
+  fi
+done
+
+if [ "${#ports[@]}" -eq 0 ]; then
+  log "no dashboard listeners on 3141 or 3142; bailing"
+  exit 0
+fi
+
+log "start projects=${#projects[@]} ports=${ports[*]}"
+
+# Warm one call at a time. The bottleneck is PostHog HogQL latency, not local
+# CPU; serializing means cache builds up monotonically as each project lands.
+# Per-call timeout 180s — generous enough that even worst-case cold projects
+# finish, but capped so a wedged PostHog can't hang the launchd job forever.
+ok=0
+fail=0
+slow=0
+
+call_one() {
+  local url="$1"
+  local label="$2"
+  local t code
+  read -r code t < <(curl -sS -o /dev/null -w "%{http_code} %{time_total}" --max-time 180 "$url" 2>/dev/null || echo "000 -1")
+  if [ "$code" = "200" ]; then
+    ok=$((ok+1))
+    # Anything over 10s is "slow"; useful signal that the cache was cold here.
+    if awk "BEGIN{exit !($t > 10)}"; then slow=$((slow+1)); fi
+  else
+    fail=$((fail+1))
+    log "fail $label code=$code time=${t}s"
+  fi
+}
+
+for port in "${ports[@]}"; do
+  for days in 30 91; do
+    # Top-chart "all projects" rollup first — most important call, and it
+    # populates the PostHog-side connection cache for the per-project loop
+    # that follows.
+    call_one "http://127.0.0.1:$port/api/funnel/per-day?days=$days" \
+             "port=$port days=$days project=__all__"
+    for p in "${projects[@]}"; do
+      enc=$(printf '%s' "$p" | jq -sRr @uri)
+      call_one "http://127.0.0.1:$port/api/funnel/per-day?days=$days&project=$enc" \
+               "port=$port days=$days project=$p"
+    done
+  done
+done
+
+log "done ok=$ok fail=$fail slow=$slow"

package/skill/refresh-instagram-tokens.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# refresh-instagram-tokens.sh — Refresh Instagram Graph API long-lived tokens
+# before they expire.
+#
+# IG long-lived tokens last ~60 days; this job runs daily and refreshes any
+# token within REFRESH_BUFFER_DAYS (default 14d) of expiry. The .env file at
+# ~/instagram-graph-api/.env is rewritten atomically on success.
+#
+# Lightweight (no lock needed — read+write to a file we own, no browser/MCP)
+# but we take instagram-poster anyway so a poster/stats/scan run that's mid-
+# flight can finish reading the existing token before we swap it.
+#
+# Logs: skill/logs/refresh-instagram-tokens-YYYY-MM-DD_HHMMSS.log
+
+set -uo pipefail
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/refresh-instagram-tokens-$(date +%Y-%m-%d_%H%M%S).log"
+
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
+log "=== refresh-instagram-tokens fire: $(date) ==="
+
+RUN_START=$(date +%s)
+
+# shellcheck source=lock.sh
+source "$REPO_DIR/skill/lock.sh"
+acquire_lock instagram-poster 30
+
+OUTPUT_FILE="/tmp/refresh-instagram-tokens-$$.out"
+if ! /opt/homebrew/bin/python3.11 "$REPO_DIR/scripts/refresh_instagram_tokens.py" 2>>"$LOG_FILE" | tee -a "$LOG_FILE" >"$OUTPUT_FILE"; then
+    log "refresh_instagram_tokens.py exited non-zero"
+    REFRESHED=0; SKIPPED=0; FAILED=0; ACCOUNTS=0
+else
+    SUMMARY=$(grep '^SUMMARY:' "$OUTPUT_FILE" | tail -1)
+    REFRESHED=$(echo "$SUMMARY" | sed -n 's/.*REFRESHED=\([0-9]*\).*/\1/p'); REFRESHED=${REFRESHED:-0}
+    SKIPPED=$(echo "$SUMMARY" | sed -n 's/.*SKIPPED=\([0-9]*\).*/\1/p'); SKIPPED=${SKIPPED:-0}
+    FAILED=$(echo "$SUMMARY" | sed -n 's/.*FAILED=\([0-9]*\).*/\1/p'); FAILED=${FAILED:-0}
+    ACCOUNTS=$(echo "$SUMMARY" | sed -n 's/.*ACCOUNTS=\([0-9]*\).*/\1/p'); ACCOUNTS=${ACCOUNTS:-0}
+fi
+rm -f "$OUTPUT_FILE"
+
+RUN_ELAPSED=$(( $(date +%s) - RUN_START ))
+
+log "logging run: refreshed=$REFRESHED skipped=$SKIPPED failed=$FAILED accounts=$ACCOUNTS elapsed=${RUN_ELAPSED}s"
+
+/opt/homebrew/bin/python3.11 "$REPO_DIR/scripts/log_run.py" \
+    --script "refresh_instagram_tokens" \
+    --posted "$REFRESHED" \
+    --skipped "$SKIPPED" \
+    --failed "$FAILED" \
+    --cost 0 \
+    --elapsed "$RUN_ELAPSED" >>"$LOG_FILE" 2>&1 || log "log_run.py failed"
+
+log "=== refresh-instagram-tokens done ==="
+exit 0

package/skill/refresh-twitter-following.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# refresh-twitter-following.sh — refresh the cached "who we follow" list for X.
+#
+# Scrapes x.com/<handle>/following via the harness Chrome and uploads the set to
+# /api/v1/followed-accounts. score_twitter_candidates.py's follow-gate reads that
+# set to skip discovered threads whose author we already follow. The follow list
+# changes slowly, so launchd fires this a few times a day
+# (com.m13v.social-refresh-twitter-following).
+#
+# Uses the SAME shared "twitter-browser" lock + harness bootstrap as
+# engage-twitter.sh / run-twitter-cycle.sh, so it never races a live cycle. On
+# lock contention it skips this run (exit 0) and retries next schedule.
+
+set -uo pipefail
+
+LOG_DIR="$HOME/social-autoposter/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/refresh-twitter-following-$(date +%Y-%m-%d_%H%M%S).log"
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
+
+REPO_DIR="$HOME/social-autoposter"
+
+# Shared twitter-browser lock (lock.sh installs the EXIT-trap release) + harness
+# bootstrap (sets/export TWITTER_CDP_URL, provides ensure_twitter_browser_for_backend).
+# shellcheck source=/dev/null
+source "$(dirname "$0")/lock.sh"
+# shellcheck source=/dev/null
+source "$(dirname "$0")/lib/twitter-backend.sh"
+
+log "=== Refresh Twitter following list: $(date) ==="
+log "Acquiring twitter-browser lock (pid=$$)..."
+if ! acquire_lock "twitter-browser" 1800 2>>"$LOG_FILE"; then
+    log "twitter-browser busy (a cycle is running); skipping this refresh."
+    exit 0
+fi
+log "twitter-browser lock held (pid=$$)"
+
+# Probe + launch harness Chrome on port 9555 if needed, then sweep leftover tabs.
+ensure_twitter_browser_for_backend 2>&1 | tee -a "$LOG_FILE"
+
+# Load .env so http_api.py picks up AUTOPOSTER_API_BASE / AUTOPOSTER_API_KEY.
+# shellcheck source=/dev/null
+[ -f "$REPO_DIR/.env" ] && source "$REPO_DIR/.env"
+
+log "Scraping following list + uploading to /api/v1/followed-accounts..."
+python3 "$REPO_DIR/scripts/harvest_twitter_following.py" 2>&1 | tee -a "$LOG_FILE"
+RC=${PIPESTATUS[0]}
+log "harvest_twitter_following.py exit code: $RC"
+
+# Exit 0 regardless: a benign incomplete-scrape (rc=3) or empty (rc=2) should not
+# flag the launchd job as failed; the next schedule retries.
+exit 0

package/skill/reply-risk-digest.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# reply-risk-digest.sh — daily operator email summarizing risky/insightful
+# inbound replies to our replies.
+#
+# Wired by launchd/com.m13v.social-reply-risk-digest.plist. The Python script
+# does the DB read, optional Claude synthesis, and Gmail send.
+
+set -uo pipefail
+
+REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+LOG_FILE="$LOG_DIR/reply-risk-digest-$(date +%Y-%m-%d_%H%M%S).log"
+
+if [ -f "$REPO_DIR/.env" ]; then
+  set -a
+  # shellcheck disable=SC1091
+  source "$REPO_DIR/.env"
+  set +a
+fi
+
+cd "$REPO_DIR" || exit 1
+
+{
+  echo "=== $(date -u +%Y-%m-%dT%H:%M:%SZ) reply-risk-digest ==="
+  /usr/bin/env python3 scripts/reply_risk_digest.py --hours 24 --platform x
+  RC=$?
+  echo "=== exit_code=$RC ==="
+  exit "$RC"
+} >> "$LOG_FILE" 2>&1

package/skill/run-cycle-update-guard.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# run-cycle-update-guard.sh — self-update guard that runs IMMEDIATELY BEFORE
+# the twitter cycle, then hands off to the real cycle wrapper.
+#
+# WHY A WRAPPER (and not an edit to run-twitter-cycle-singleton.sh):
+#   The singleton is a locked pipeline file (chflags uchg). Per repo policy we
+#   never unlock it. So the per-cycle self-update lives here, in front of it:
+#   the launchd plist calls THIS script, which (throttled) checks for a newer
+#   release, updates if behind, then `exec`s the singleton unchanged.
+#
+# THROTTLE: a headless cycle fires often (every ~60s). We do NOT want a network
+#   `npm view` on every fire. The version check runs at most once per
+#   CHECK_INTERVAL_SECS (default 6h), gated by a stamp file. In between, this
+#   wrapper is a near-instant pass-through.
+#
+# DEV SAFETY: social-autoposter-update.sh refuses to update a .git checkout, so
+#   this guard is a no-op update on a dev box (it still execs the cycle).
+
+set -u
+
+REPO_DIR="${S4L_REPO_DIR:-$HOME/social-autoposter}"
+GUARD_DIR="$REPO_DIR/skill"
+UPDATER="$GUARD_DIR/social-autoposter-update.sh"
+SINGLETON="$GUARD_DIR/run-twitter-cycle-singleton.sh"
+STAMP="$REPO_DIR/skill/logs/.last-update-check"
+CHECK_INTERVAL_SECS="${S4L_UPDATE_CHECK_INTERVAL_SECS:-21600}"  # 6h
+
+now="$(date +%s)"
+last=0
+[ -f "$STAMP" ] && last="$(cat "$STAMP" 2>/dev/null || echo 0)"
+# normalize non-numeric stamp to 0
+case "$last" in (*[!0-9]*) last=0 ;; esac
+
+if [ $(( now - last )) -ge "$CHECK_INTERVAL_SECS" ]; then
+  mkdir -p "$(dirname "$STAMP")" 2>/dev/null || true
+  echo "$now" > "$STAMP" 2>/dev/null || true
+  if [ -x "$UPDATER" ]; then
+    # Never let an update hiccup block the posting cycle: run it, ignore failure.
+    bash "$UPDATER" || true
+  fi
+fi
+
+# Hand off to the real (locked) cycle wrapper, preserving any args/env.
+exec /bin/bash "$SINGLETON" "$@"

package/skill/run-draft-and-publish.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# run-draft-and-publish.sh — the launchd kicker entrypoint for the queue-backed
+# draft autopilot (2026-06-24). It is the ONLY way cards are produced on a
+# customer box: there is no host-draft scenario.
+#
+# Runs the REAL pipeline in DRAFT_ONLY mode (inheriting the kicker plist's
+# DRAFT_ONLY=1 / S4L_CLAUDE_PROVIDER=queue env, so Phase 2b drafting routes
+# through the job queue and is drafted by the scheduled-task worker), then MERGES
+# the drafts it produced into the review-queue cards the menu bar shows. Without
+# this merge the cycle's plan would sit in a /tmp batch file nobody reads.
+set -uo pipefail
+
+# 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
+
+REPO_DIR="${S4L_REPO_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
+PY="${S4L_PYTHON:-python3}"
+
+OUT="$(mktemp -t saps_draft_publish.XXXXXX)"
+HB_PID=""  # scan-phase heartbeat (started below); torn down by the EXIT trap
+# Clear the menu-bar activity signal on ANY exit so a crash/early-exit mid-cycle
+# never leaves a stuck "scanning/drafting" label, and stop the heartbeat so it
+# can't outlive the cycle. Best-effort; the || true keeps the trap from changing
+# the cycle's exit code.
+trap 'kill "$HB_PID" 2>/dev/null || true; rm -f "$OUT"; "$PY" "$REPO_DIR/scripts/saps_activity.py" clear 2>/dev/null || true' EXIT
+
+# Narrate the scan phase, GRANULARLY. The CDP scan runs inside the (locked)
+# run-twitter-cycle.sh which has no activity writer; this covers that window until
+# the queue provider flips the label to "finding threads"/"drafting replies".
+# Instead of a frozen "scanning X for threads" for the whole multi-minute scan,
+# each heartbeat recomputes elapsed and scrapes THIS cycle's own stdout ($OUT, the
+# tee target below) for live progress — queries run, and candidates found once
+# Phase 1 reports them — so the menu bar actually moves. Reads $OUT only; never
+# touches the locked cycle. heartbeat() re-stamps ONLY while the state is still
+# "scanning", so once the provider advances the phase it goes quiet (no flicker).
+"$PY" "$REPO_DIR/scripts/saps_activity.py" write scanning "scan: starting" 2>/dev/null || true
+SCAN_T0=$(date +%s)
+(
+  while true; do
+    sleep 20
+    _el=$(( $(date +%s) - SCAN_T0 ))
+    if [ "$_el" -lt 60 ]; then _dur="${_el}s"; else _dur="$(( _el / 60 ))m"; fi
+    _q=$(grep -c "kept=" "$OUT" 2>/dev/null || true); _q=${_q:-0}
+    # Total planned queries IS announced upfront by Phase 1:
+    #   "Lean Phase 1: executing 118 queries via browser-harness CDP"
+    # so show K/total once that line lands (it precedes the per-query "kept=" lines).
+    _total=$(grep -oE "executing [0-9]+ queries" "$OUT" 2>/dev/null | tail -1 | grep -oE "[0-9]+" | head -1 || true)
+    if [ -n "$_total" ]; then _qpart="${_q}/${_total}"; else _qpart="${_q}"; fi
+    _found=$(grep -oE "Batch has [0-9]+" "$OUT" 2>/dev/null | tail -1 | grep -oE "[0-9]+" | tail -1 || true)
+    if [ -n "$_found" ]; then
+      _lbl="scan: ${_dur} · ${_qpart}, ${_found} found"
+    else
+      _lbl="scan: ${_dur} · ${_qpart}"
+    fi
+    "$PY" "$REPO_DIR/scripts/saps_activity.py" heartbeat scanning "$_lbl" 2>/dev/null || true
+  done
+) &
+HB_PID=$!
+
+# Engagement mode (2026-06-26). The menu-bar toggle writes mode.json; this reads
+# it and, in personal_brand mode, exports S4L_FORCE_PROJECT=<persona project> and
+# TWITTER_TAIL_LINK_RATE=0 so the (locked) cycle below drafts link-free organic
+# replies for the persona instead of the normal weighted product pick. In the
+# default promotion mode it exports nothing and the cycle runs exactly as before.
+# Read at cycle runtime (NOT baked into the plist) so flipping the toggle takes
+# effect on the very next cycle with no launchd reload. Best-effort: any failure
+# leaves the env untouched and the promotion pipeline runs.
+eval "$("$PY" "$REPO_DIR/scripts/saps_mode.py" env 2>/dev/null || true)"
+if [ -n "${S4L_FORCE_PROJECT:-}" ]; then
+    echo "[run-draft-and-publish] personal_brand mode: forcing project '$S4L_FORCE_PROJECT' (link-free)" >&2
+fi
+
+# First-run onboarding boost (2026-07-02). The MCP server drops
+# first-run-boost.json into the state dir when it installs the kicker for the
+# very first time. While the marker is live, widen the draft discovery window
+# to 48h (vs the standard 24h draft window) and lift the top-1 card cap so the
+# user's FIRST review batch surfaces several REAL drafts instead of one (or
+# none). The marker is deleted the moment a merge actually delivers cards, or
+# after 24h without any, so every later cycle runs the standard logic.
+BOOST_MARKER="${S4L_STATE_DIR:-$HOME/.social-autoposter-mcp}/first-run-boost.json"
+BOOST_ACTIVE=0
+if [ -f "$BOOST_MARKER" ]; then
+    if [ -n "$(find "$BOOST_MARKER" -mmin +1440 2>/dev/null)" ]; then
+        rm -f "$BOOST_MARKER"
+        echo "[run-draft-and-publish] first-run boost expired (>24h, no cards produced); removed" >&2
+    else
+        BOOST_ACTIVE=1
+        export S4L_DRAFT_FRESHNESS_HOURS="${S4L_FIRST_RUN_FRESHNESS_HOURS:-48}"
+        export S4L_TWITTER_POST_TOP_N="${S4L_FIRST_RUN_TOP_N:-5}"
+        echo "[run-draft-and-publish] first-run boost active: freshness=${S4L_DRAFT_FRESHNESS_HOURS}h top_n=${S4L_TWITTER_POST_TOP_N}" >&2
+    fi
+fi
+
+# Run the cycle; tee stdout so we can scan it for the DRAFT_ONLY_PLAN marker.
+# Phase 2b blocks on the queue until the worker drafts it, so this can take a
+# few minutes — that is expected.
+bash "$REPO_DIR/skill/run-twitter-cycle.sh" 2>&1 | tee "$OUT"
+RC=${PIPESTATUS[0]}
+
+# Deliver the cycle's drafts into the cards.
+MARKER="$(grep -oE 'DRAFT_ONLY_PLAN=\S+\.json' "$OUT" | tail -1)"
+if [ -n "$MARKER" ]; then
+    # merge_review_queue prints ONLY to stderr; capture and re-emit verbatim on
+    # stderr (those [merge_review_queue] marker lines are load-bearing) so the
+    # first-run boost can read the merged count.
+    MERGE_OUT="$("$PY" "$REPO_DIR/scripts/merge_review_queue.py" --plan-from-marker "$MARKER" 2>&1 || true)"
+    [ -n "$MERGE_OUT" ] && printf '%s\n' "$MERGE_OUT" >&2
+    # Consume the first-run boost the moment a merge actually delivers cards, so
+    # the widened window applies to exactly one successful first batch.
+    if [ "$BOOST_ACTIVE" = "1" ] && printf '%s' "$MERGE_OUT" | grep -qE 'merged [1-9][0-9]* new draft'; then
+        rm -f "$BOOST_MARKER"
+        echo "[run-draft-and-publish] first-run boost consumed (cards delivered)" >&2
+    fi
+else
+    echo "[run-draft-and-publish] no DRAFT_ONLY_PLAN marker (cycle rc=$RC); nothing to merge" >&2
+fi
+
+exit "$RC"

package/skill/run-generate-daily-style.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# run-generate-daily-style.sh — Synthesize ONE new human-derived
+# engagement style per platform per fire, from the last 24h of top
+# human replies on each platform.
+#
+# Cadence (launchd, com.m13v.social-daily-human-style.plist): once per day
+# at 08:00 local time.
+#
+# Wraps scripts/generate_daily_human_style.py — which queries
+# thread_top_replies per platform, calls Claude via run_claude.sh, and
+# POSTs each synthesized style to the s4l.ai API route
+# /api/v1/engagement-styles/registry with kind='human_derived' and
+# platform=<platform>. Rows land in engagement_styles_registry alongside
+# seeds and model-invented styles. The engagement_styles picker reads
+# the latest active row per platform with HUMAN_DERIVED_RATE_BY_PLATFORM
+# probability on each pick.
+#
+# Exit codes:
+#   0 — style inserted, OR insufficient input (< 3 replies, logged + skipped)
+#   1 — real failure (DB error, Claude error, JSON parse failure)
+#
+# Logs: skill/logs/daily-human-style-YYYY-MM-DD_HHMMSS.log
+
+set -uo pipefail
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+LOG_FILE="$LOG_DIR/daily-human-style-$(date +%Y-%m-%d_%H%M%S).log"
+
+if [ -f "$REPO_DIR/.env" ]; then
+  set -a
+  # shellcheck disable=SC1091
+  source "$REPO_DIR/.env"
+  set +a
+fi
+
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
+
+log "starting daily human-style synthesizer"
+
+# The Python script invokes scripts/run_claude.sh internally for the Claude
+# call (so cost lands in claude_sessions under script_tag=daily-human-style).
+# We just stream its stdout/stderr to the log file here.
+/usr/bin/python3 "$REPO_DIR/scripts/generate_daily_human_style.py" 2>&1 | tee -a "$LOG_FILE"
+RC=${PIPESTATUS[0]}
+
+log "synthesizer exit code: $RC"
+exit "$RC"

package/skill/run-github-launchd.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# run-github-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 github cycle does a T0
+#   issue search, sleeps ~600s for momentum, then re-fetches and posts. Total
+#   runtime regularly exceeds 15 min, so without this wrapper roughly half of
+#   the scheduled fires got dropped.
+#
+# 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:
+#   post_github.py applies an already_posted filter against the posts table
+#   before drafting, so overlapping cycles will not double-post the same
+#   issue. gh CLI is API-only (no shared browser/profile), so there is no
+#   browser-level lock to coordinate.
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+
+SCRIPT="$REPO_DIR/skill/run-github.sh"
+OUT="$LOG_DIR/launchd-github-stdout.log"
+ERR="$LOG_DIR/launchd-github-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-github"
+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])
+"