@m13v/s4l 1.6.197-rc.10

package/skill/scan-twitter-followups.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# Social Autoposter - X/Twitter thread follow-up scanner
+# Revisits our recent X replies and captures depth-2+ public follow-ups
+# that the /notifications scraper misses (when @-tag is dropped in nested replies).
+# Companion to scan_twitter_mentions_browser.py (run via engage-twitter.sh).
+# Scheduled overnight by launchd (1:14 AM only). Waits up to 30min for the
+# twitter-browser lock to free, then yields. Single overnight firing chosen
+# because twitter-cycle parallel firings keep the lock busy during waking
+# hours; 13:14 PM firing was dropped 2026-05-19 after weeks of "skipping"
+# bails (acquire_lock timeout=0 was the original yield strategy, replaced
+# with a 1800s wait that lets the scan run when twitter-cycle is quieter).
+
+
+set -euo pipefail
+
+# Bootstrap log paths early so the singleton-cleanup output below gets captured
+# in the same log file the rest of the run uses.
+LOG_DIR="$HOME/social-autoposter/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/scan-twitter-followups-$(date +%Y-%m-%d_%H%M%S).log"
+
+# Browser-profile lock shared with all twitter pipelines.
+source "$(dirname "$0")/lock.sh"
+# Harness-only browser bootstrap (twitter-agent path fully removed 2026-05-19).
+# scan_twitter_thread_followups.py uses twitter_browser.py functions, which
+# honor TWITTER_CDP_URL exported by the lib.
+source "$(dirname "$0")/lib/twitter-backend.sh"
+acquire_lock "twitter-browser" 1800
+ensure_twitter_browser_for_backend 2>&1 | tee -a "$LOG_FILE"
+acquire_lock "scan-twitter-followups" 0
+
+[ -f "$HOME/social-autoposter/.env" ] && source "$HOME/social-autoposter/.env"
+
+REPO_DIR="$HOME/social-autoposter"
+# (LOG_DIR/LOG_FILE bootstrapped at top of script.)
+
+echo "=== Scan Twitter Follow-ups Run: $(date) ===" | tee -a "$LOG_FILE"
+START_TS=$(date +%s)
+
+DAYS="${FOLLOWUP_DAYS:-14}"
+MAX_URLS="${FOLLOWUP_MAX_URLS:-40}"
+SCROLL_COUNT="${FOLLOWUP_SCROLLS:-3}"
+
+PYTHONUNBUFFERED=1 python3 "$REPO_DIR/scripts/scan_twitter_thread_followups.py" \
+    --days "$DAYS" --max-urls "$MAX_URLS" --scroll-count "$SCROLL_COUNT" \
+    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 -c "NEW follow-up:" "$LOG_FILE" 2>/dev/null) || FOUND=0
+python3 "$REPO_DIR/scripts/log_run.py" --script "scan_twitter_followups" --posted "$FOUND" --skipped 0 --failed 0 --cost 0 --elapsed "$ELAPSED" || true
+
+echo "=== Scan Twitter Follow-ups complete: $(date) (elapsed ${ELAPSED}s, found ${FOUND}) ===" | tee -a "$LOG_FILE"
+find "$LOG_DIR" -name "scan-twitter-followups-*.log" -mtime +7 -delete 2>/dev/null || true

package/skill/social-autoposter-update.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+# social-autoposter-update.sh — standalone self-updater for SHIPPED client
+# installs. Driven by the launchd/systemd job com.m13v.social-autoposter-update
+# (daily) and reused by the per-cycle guard (run-cycle-update-guard.sh).
+#
+# WHAT IT DOES
+#   1. Refuses to run on a dev/source checkout (presence of .git). A dev box
+#      edits code in place; `npx social-autoposter@latest update` would clobber
+#      the working tree. This is the single most important guard here.
+#   2. Compares the installed package version to the latest published on npm.
+#   3. If behind, runs `npx -y social-autoposter@latest update`, which pulls the
+#      latest tarball, copies it over the install, re-runs install.mjs (re-stamps
+#      dist/version.json + re-registers the MCP). The running MCP keeps the old
+#      code until the client reconnects; the next headless cycle picks it up.
+#
+# Safe to call frequently: the version check is one `npm view` call; the heavy
+# `npx update` only fires when actually behind.
+#
+# Exit codes: 0 = up to date OR updated OK OR skipped (dev box / offline);
+#             non-zero only when the update command itself failed.
+
+set -u
+
+REPO_DIR="${S4L_REPO_DIR:-$HOME/social-autoposter}"
+LOG_DIR="$REPO_DIR/skill/logs"
+LOG="$LOG_DIR/self-update.log"
+mkdir -p "$LOG_DIR" 2>/dev/null || true
+
+log() { echo "[$(date '+%Y-%m-%dT%H:%M:%S%z')] $*" | tee -a "$LOG" >&2; }
+
+# --- guard 1: never self-update a dev/source checkout -----------------------
+if [ -d "$REPO_DIR/.git" ]; then
+  log "skip: $REPO_DIR is a git checkout (dev mode); self-update disabled to avoid clobbering the working tree."
+  exit 0
+fi
+
+# --- resolve installed version ----------------------------------------------
+installed=""
+if [ -f "$REPO_DIR/mcp/dist/version.json" ]; then
+  installed="$(node -e 'try{process.stdout.write(require(process.argv[1]).version||"")}catch(e){}' "$REPO_DIR/mcp/dist/version.json" 2>/dev/null)"
+fi
+if [ -z "$installed" ] && [ -f "$REPO_DIR/package.json" ]; then
+  installed="$(node -e 'try{process.stdout.write(require(process.argv[1]).version||"")}catch(e){}' "$REPO_DIR/package.json" 2>/dev/null)"
+fi
+
+# --- resolve latest published version ---------------------------------------
+latest="$(npm view social-autoposter version 2>/dev/null | tr -d '[:space:]')"
+if [ -z "$latest" ]; then
+  log "skip: could not reach npm to check latest version (offline or registry error). installed=${installed:-unknown}"
+  exit 0
+fi
+
+if [ -n "$installed" ] && [ "$installed" = "$latest" ]; then
+  log "up to date: installed=$installed latest=$latest"
+  exit 0
+fi
+
+log "update available: installed=${installed:-unknown} latest=$latest — running npx social-autoposter@latest update"
+if npx -y social-autoposter@latest update >>"$LOG" 2>&1; then
+  log "update OK -> $latest (takes effect on next MCP reconnect / next headless cycle)"
+  exit 0
+else
+  rc=$?
+  log "update FAILED (exit $rc); staying on installed=${installed:-unknown}"
+  exit "$rc"
+fi

package/skill/stats-instagram.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# stats-instagram.sh — Refresh engagement stats for Instagram posts.
+#
+# Mirrors the per-platform stats pattern used by stats-reddit.sh / stats-twitter.sh
+# but is API-only (no browser): calls IG Graph API insights for each posts row
+# with platform='instagram', updates upvotes/comments_count/views, and logs the
+# run so it surfaces in the dashboard Jobs panel.
+#
+# Logs: skill/logs/stats-instagram-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/stats-instagram-$(date +%Y-%m-%d_%H%M%S).log"
+
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
+log "=== stats-instagram fire: $(date) ==="
+
+RUN_START=$(date +%s)
+
+# Lock — instagram-poster reuses this lane; stats and post must not race.
+# shellcheck source=lock.sh
+source "$REPO_DIR/skill/lock.sh"
+acquire_lock instagram-poster 30
+
+# Step 1: sync any newly-posted media_posts -> posts (idempotent).
+log "step 1: sync_ig_to_posts"
+if ! /opt/homebrew/bin/python3.11 "$REPO_DIR/scripts/sync_ig_to_posts.py" --quiet >>"$LOG_FILE" 2>&1; then
+    log "sync_ig_to_posts failed (continuing to refresh existing rows)"
+fi
+
+# Step 2: refresh stats for all platform='instagram' rows.
+log "step 2: update_instagram_stats"
+OUTPUT_FILE="/tmp/stats-instagram-$$.out"
+if ! /opt/homebrew/bin/python3.11 "$REPO_DIR/scripts/update_instagram_stats.py" 2>>"$LOG_FILE" | tee -a "$LOG_FILE" >"$OUTPUT_FILE"; then
+    log "update_instagram_stats.py exited non-zero — logging run as failed"
+    CHECKED=0; UPDATED=0; NOT_FOUND=0; FAILED=0; VIEWS_REFRESHED=0
+else
+    SUMMARY=$(grep '^SUMMARY:' "$OUTPUT_FILE" | tail -1)
+    CHECKED=$(echo "$SUMMARY" | sed -n 's/.*CHECKED=\([0-9]*\).*/\1/p'); CHECKED=${CHECKED:-0}
+    UPDATED=$(echo "$SUMMARY" | sed -n 's/.*UPDATED=\([0-9]*\).*/\1/p'); UPDATED=${UPDATED:-0}
+    NOT_FOUND=$(echo "$SUMMARY" | sed -n 's/.*NOT_FOUND=\([0-9]*\).*/\1/p'); NOT_FOUND=${NOT_FOUND:-0}
+    FAILED=$(echo "$SUMMARY" | sed -n 's/.*FAILED=\([0-9]*\).*/\1/p'); FAILED=${FAILED:-0}
+    VIEWS_REFRESHED=$(echo "$SUMMARY" | sed -n 's/.*VIEWS_REFRESHED=\([0-9]*\).*/\1/p'); VIEWS_REFRESHED=${VIEWS_REFRESHED:-0}
+fi
+rm -f "$OUTPUT_FILE"
+
+RUN_ELAPSED=$(( $(date +%s) - RUN_START ))
+
+log "logging run: checked=$CHECKED updated=$UPDATED not_found=$NOT_FOUND failed=$FAILED views_refreshed=$VIEWS_REFRESHED elapsed=${RUN_ELAPSED}s"
+
+/opt/homebrew/bin/python3.11 "$REPO_DIR/scripts/log_run.py" \
+    --script "stats_instagram" \
+    --posted 0 \
+    --skipped 0 \
+    --failed "$FAILED" \
+    --replies-refreshed 0 \
+    --checked "$CHECKED" \
+    --updated "$UPDATED" \
+    --removed 0 \
+    --unavailable 0 \
+    --not-found "$NOT_FOUND" \
+    --scanned "$CHECKED" \
+    --changed "$UPDATED" \
+    --views-refreshed "$VIEWS_REFRESHED" \
+    --cost 0 \
+    --elapsed "$RUN_ELAPSED" >>"$LOG_FILE" 2>&1 || log "log_run.py failed"
+
+log "=== stats-instagram done ==="
+exit 0

package/skill/stats-linkedin.sh

@@ -0,0 +1,271 @@
+#!/usr/bin/env bash
+# stats-linkedin.sh — Unified LinkedIn stats refresh.
+#
+# Single pipeline that mirrors the Twitter logic shape: one source of truth
+# (LinkedIn's /in/me/recent-activity/comments/ activity tab), one DB write
+# path across all LinkedIn engagement rows. Replaces:
+#   - The deprecated skill/stats.sh Step 4 (which called the now-stubbed
+#     scripts/scrape_linkedin_stats_browser.py and silently no-op'd).
+#   - The standalone skill/stats-linkedin-comments.sh, which only updated
+#     the legacy `replies` table. This script kept calling that updater
+#     too so we don't lose the ~173 replies-table rows.
+#
+# What this does, in order:
+#   1. Acquire the linkedin-browser lock (serializes against run-linkedin.sh
+#      / engage-linkedin.sh / dm-outreach-linkedin.sh / engage-dm-replies.sh).
+#   2. Run scripts/scrape_linkedin_comment_stats.py ONCE. It CDP-attaches
+#      to the linkedin-harness Chrome on port 9556 (2026-05-26 migration:
+#      replaced the legacy ps-discovery of linkedin-agent MCP. The harness
+#      is multi-client safe so no kill+reopen, no Singleton fight. The
+#      LINKEDIN_CDP_URL env var exported by skill/lib/linkedin-backend.sh
+#      tells linkedin_browser.py to attach via CDP directly), opens a
+#      tab to /in/me/recent-activity/comments/, harvests per-comment
+#      impressions / reactions / replies into a single JSON feed.
+#   3. Run scripts/update_linkedin_stats_from_feed.py — writes the feed
+#      into the `posts` table for rows whose `our_url` carries a
+#      `?commentUrn=` (the 97 pre-existing rows from reply_to_comment +
+#      the 225 rows migrated from the legacy `replies` table on
+#      2026-05-11 + every new row posted 2026-05-11 onward after
+#      linkedin_api.py:comment_on_post was patched to embed it).
+#   4. Release the browser lock; the updater is DB-only.
+#
+# History note (2026-05-11): there used to be a second writer that wrote
+# the same feed into the legacy `replies` table (~257 LinkedIn rows). On
+# 2026-05-11 those rows were migrated into `posts` (Twitter-parity) and
+# the source rows marked status='migrated'. The replies-table writer
+# (scripts/update_linkedin_comment_stats_from_feed.py) and its standalone
+# entrypoint (skill/stats-linkedin-comments.sh) were retired in the same
+# pass. If you see references to them anywhere, they are stale and
+# should be removed.
+#
+# Bot-detection prevention (carries over the carve-out from
+# stats-linkedin-comments.sh; do NOT loosen):
+#   - ONE page.goto per fire to /in/me/recent-activity/comments/.
+#   - ONE page.evaluate; scroll + harvest happen inside the same JS run.
+#   - No clicks, no permalink hops, no "Show more", no Voyager API.
+#   - SESSION_INVALID detection: redirect to /login or /checkpoint -> stop.
+#
+# Cadence: every 4-6h. LinkedIn updates impressions in near real time but
+# per-fire fingerprint risk is non-zero; do not run hotter.
+
+set -euo pipefail
+
+# LinkedIn killswitch (2026-05-27): refuse to run if a prior fire detected
+# session compromise (http_999, authwall, throttle, li_at cleared).
+# State: ~/.claude/social-autoposter/linkedin.killswitch
+# Clear: python3 ~/social-autoposter/scripts/linkedin_killswitch.py clear
+if [ -f "$HOME/.claude/social-autoposter/linkedin.killswitch" ]; then
+    echo "[$(date +%H:%M:%S)] LINKEDIN_KILLSWITCH active. Aborting LinkedIn pipeline."
+    echo "  Re-auth LinkedIn in harness Chrome, then: python3 ~/social-autoposter/scripts/linkedin_killswitch.py clear"
+    exit 0
+fi
+
+source "$(dirname "$0")/lock.sh"
+# 2026-05-26 harness migration: linkedin-backend.sh exports LINKEDIN_CDP_URL
+# (http://127.0.0.1:9556) and exposes ensure_linkedin_browser_for_backend
+# which probes + launches the linkedin-harness Chrome idempotently. The
+# scraper picks up LINKEDIN_CDP_URL automatically via linkedin_browser.py's
+# harness-cdp fast-path.
+source "$(dirname "$0")/lib/linkedin-backend.sh"
+
+# shellcheck source=/dev/null
+[ -f "$HOME/social-autoposter/.env" ] && source "$HOME/social-autoposter/.env"
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+PYTHON_BIN="/opt/homebrew/bin/python3"
+# /usr/bin/python3 is the only interpreter with playwright installed; this
+# matches engage-dm-replies.sh's call to linkedin_browser.py. DB scripts
+# stay on homebrew python where psycopg2 is installed.
+SCRAPER_PYTHON_BIN="/usr/bin/python3"
+
+# Tunables.
+MAX_SCROLLS=400           # 2026-05-28 set to 400 per user direction; natural stagnant>=8 bail should fire well before this (~tick 150). Safety ceiling, not target. Previous: 300 (auto-commit) <- 1000 (runaway 2026-05-27).
+SCRAPER_TIMEOUT_SEC=900   # 15min outer gtimeout. Inner JS deadline now defaults to 10min via S4L_SCRAPER_DEADLINE_MS; the 15min outer is a 5min margin for cdp_attach + page.goto + the JS deadline + finalize().
+
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/stats-linkedin-$(date +%Y-%m-%d_%H%M%S).log"
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
+
+RUN_START=$(date +%s)
+log "=== LinkedIn Stats Run (unified): $(date) ==="
+log "mode: python (no LLM); MAX_SCROLLS=$MAX_SCROLLS; timeout=${SCRAPER_TIMEOUT_SEC}s"
+
+# Coverage hint. Reads via the s4l.ai HTTP API (no DATABASE_URL needed); the
+# linkedin-engagement-comments GET returns every addressable row, so we just
+# count them. Purely informational; never blocks the run.
+COVERAGE=$("$PYTHON_BIN" -c "
+import sys; sys.path.insert(0, '$REPO_DIR/scripts')
+from http_api import api_get
+resp = api_get('/api/v1/linkedin-engagement-comments')
+rows = (resp.get('data') or {}).get('rows') or []
+print(f'posts={len(rows)}')
+" 2>/dev/null || echo "posts=?")
+log "Active LinkedIn comments addressable by this feed: $COVERAGE"
+
+FEED_JSON="$LOG_DIR/stats-linkedin-feed-$(date +%Y%m%d_%H%M%S).json"
+POSTS_SUMMARY_JSON=$(mktemp -t fazm-li-posts-summary.XXXXXX).json
+SCRAPER_STDOUT=$(mktemp -t fazm-li-scrape.XXXXXX).json
+
+# Forensic-bundle directory. The scraper writes screenshots, html, cookies,
+# console.jsonl / navigation.jsonl / network.jsonl + a Python traceback on
+# any non-ok return path here, then tar.gz's it and prints the path to
+# stderr as `[scrape_linkedin] debug_bundle=<tarball>`. We grep that out of
+# the captured stderr below.
+#
+# On session_invalid / captcha_or_checkpoint specifically, we promote the
+# tarball to skill/logs/linkedin-debug-failures/ — that subdir is NOT swept
+# by the 14-day retention sweep at the end of this script. Permanent
+# archive so the next failure can be diff'd byte-for-byte against the last
+# known good/bad bundle.
+DEBUG_BUNDLE_BASE="$LOG_DIR/linkedin-debug"
+DEBUG_BUNDLE_DIR="$DEBUG_BUNDLE_BASE/$(date +%Y%m%d_%H%M%S)"
+DEBUG_FAILURES_DIR="$LOG_DIR/linkedin-debug-failures"
+mkdir -p "$DEBUG_BUNDLE_BASE" "$DEBUG_FAILURES_DIR"
+
+# 1. Acquire the linkedin-browser lock. Two CDP clients hammering the same
+#    DOM corrupt each other's evaluate() calls, so the lock matters even
+#    though we no longer launch a second Chrome.
+#
+#    DELIBERATELY do NOT call ensure_browser_healthy "linkedin" — that
+#    helper SIGKILLs the linkedin-agent MCP and clears Singleton lockfiles
+#    so a second Chrome can launch on the same profile. With the 2026-05-26
+#    harness cutover, scrape_linkedin_comment_stats.py CDP-attaches to the
+#    linkedin-harness Chrome (port 9556) which is multi-client safe.
+acquire_lock "linkedin-browser" 1800
+
+# Probe + launch harness Chrome idempotently if it's down. Safe to call under
+# the linkedin-browser lock; harness CDP supports concurrent clients on the
+# same profile so no SingletonLock fight.
+ensure_linkedin_browser_for_backend
+
+# 2. Run the headed-Chromium scraper (single scrape, shared between writers).
+log "Launching headed Chromium scraper..."
+log "Debug bundle dir (pre-tar): $DEBUG_BUNDLE_DIR"
+SCRAPER_RC=0
+set +e
+SOCIAL_AUTOPOSTER_LINKEDIN_COMMENT_STATS=1 \
+/opt/homebrew/bin/gtimeout "$SCRAPER_TIMEOUT_SEC" \
+    "$SCRAPER_PYTHON_BIN" "$REPO_DIR/scripts/scrape_linkedin_comment_stats.py" \
+        --out "$FEED_JSON" \
+        --max-scrolls "$MAX_SCROLLS" \
+        --debug-dir "$DEBUG_BUNDLE_DIR" \
+    > "$SCRAPER_STDOUT" 2>&1
+SCRAPER_RC=$?
+set -e
+
+# Always release the browser lock; updaters are DB-only.
+release_lock "linkedin-browser"
+# 2026-05-26 harness migration: the linkedin-agent JSON lockfile still gets
+# written by linkedin_browser._acquire_browser_lock for serialization between
+# concurrent Python invocations; sweep it on the way out so it doesn't
+# accumulate stale entries.
+rm -f "$HOME/.claude/linkedin-agent-lock.json"
+
+# Echo scraper output to log.
+cat "$SCRAPER_STDOUT" | tee -a "$LOG_FILE"
+
+# Surface the debug-bundle tarball path. The scraper writes a single
+# `[scrape_linkedin] debug_bundle=<path>` line to stderr right before exit;
+# grep it back out so it's visible in the orchestrator log without needing
+# to unpack the tarball.
+DEBUG_TARBALL=$(grep -m1 -E '^\[scrape_linkedin\] debug_bundle=' "$SCRAPER_STDOUT" | sed -E 's/^\[scrape_linkedin\] debug_bundle=//')
+if [ -n "$DEBUG_TARBALL" ] && [ -f "$DEBUG_TARBALL" ]; then
+    log "Debug bundle: $DEBUG_TARBALL"
+else
+    log "Debug bundle: <missing — scraper did not emit debug_bundle marker>"
+fi
+
+# Also surface the linkedin_browser mode line — this is the #1 signal for
+# answering "did we cdp_attach or cold_launch?" after a failure.
+BROWSER_MODE_LINE=$(grep -m1 -E '^\[linkedin_browser\] mode=' "$SCRAPER_STDOUT" || true)
+if [ -n "$BROWSER_MODE_LINE" ]; then
+    log "Browser mode: $BROWSER_MODE_LINE"
+else
+    log "Browser mode: <missing — _connect_to_running_or_launch never logged>"
+fi
+
+if [ "$SCRAPER_RC" -ne 0 ]; then
+    log "ERROR: scraper exited rc=$SCRAPER_RC"
+    SCRAPER_ERROR=$("$PYTHON_BIN" -c "
+import json, sys
+try:
+    obj = json.load(open('$SCRAPER_STDOUT'))
+    print(obj.get('error', 'unknown'))
+except Exception:
+    print('parse_failed')
+" 2>/dev/null || echo "unknown")
+    log "scraper error code: $SCRAPER_ERROR"
+
+    # Permanent archive of session_invalid / captcha tarballs. We never
+    # want to wake up to another 14-line "session_invalid" log file with
+    # no way to forensically inspect the DOM that triggered it. Keep these
+    # forever (or until the user manually cleans the dir).
+    if [ "$SCRAPER_ERROR" = "session_invalid" ] \
+       || [ "$SCRAPER_ERROR" = "captcha_or_checkpoint" ]; then
+        log "SESSION_INVALID — abort run, do not retry."
+        if [ -n "$DEBUG_TARBALL" ] && [ -f "$DEBUG_TARBALL" ]; then
+            FAILURE_COPY="$DEBUG_FAILURES_DIR/$(basename "$DEBUG_TARBALL" .tar.gz)__${SCRAPER_ERROR}.tar.gz"
+            cp -p "$DEBUG_TARBALL" "$FAILURE_COPY" 2>/dev/null \
+                && log "Archived failure bundle: $FAILURE_COPY" \
+                || log "WARN: failed to archive failure bundle to $FAILURE_COPY"
+        else
+            log "WARN: no debug tarball available to archive for $SCRAPER_ERROR"
+        fi
+    fi
+
+    if [ ! -s "$FEED_JSON" ]; then
+        log "No feed JSON produced; skipping updater."
+        rm -f "$SCRAPER_STDOUT" "$POSTS_SUMMARY_JSON"
+        RUN_ELAPSED=$(( $(date +%s) - RUN_START ))
+        "$PYTHON_BIN" "$REPO_DIR/scripts/log_run.py" \
+            --script "stats_linkedin" \
+            --posted 0 --skipped 0 --failed 1 \
+            --cost "0.0000" --elapsed "$RUN_ELAPSED" \
+            2>/dev/null || true
+        log "=== LinkedIn stats failed: $(date) ==="
+        exit 1
+    fi
+    log "Feed JSON exists despite rc=$SCRAPER_RC; running updater anyway."
+fi
+
+# 3. Apply to `posts` (Twitter-parity table; sole stats target).
+log "Writer: posts table..."
+"$PYTHON_BIN" "$REPO_DIR/scripts/update_linkedin_stats_from_feed.py" \
+    --from-json "$FEED_JSON" \
+    --summary   "$POSTS_SUMMARY_JSON" \
+    2>&1 | tee -a "$LOG_FILE" \
+    || log "WARNING: posts updater exited with code $?"
+
+# 4. Surface counters.
+REFRESHED_POSTS=0
+NOT_FOUND=0
+if [ -s "$POSTS_SUMMARY_JSON" ]; then
+    REFRESHED_POSTS=$("$PYTHON_BIN" -c "import json; print(json.load(open('$POSTS_SUMMARY_JSON')).get('refreshed', 0))" 2>/dev/null || echo 0)
+    NOT_FOUND=$("$PYTHON_BIN" -c "import json; print(json.load(open('$POSTS_SUMMARY_JSON')).get('not_found', 0))" 2>/dev/null || echo 0)
+fi
+log "Comment stats refresh: posts=$REFRESHED_POSTS total=$REFRESHED_POSTS unmatched=$NOT_FOUND"
+
+# 5. Log run to persistent monitor.
+RUN_ELAPSED=$(( $(date +%s) - RUN_START ))
+"$PYTHON_BIN" "$REPO_DIR/scripts/log_run.py" --script "stats_linkedin" \
+    --posted "$REFRESHED_POSTS" --skipped 0 --failed 0 \
+    --cost "0.0000" --elapsed "$RUN_ELAPSED" \
+    2>/dev/null || true
+
+# Cleanup.
+rm -f "$POSTS_SUMMARY_JSON" "$SCRAPER_STDOUT"
+find "$LOG_DIR" -name "stats-linkedin-*.log"  -mtime +14 -delete 2>/dev/null || true
+find "$LOG_DIR" -name "stats-linkedin-feed-*.json" -mtime +7 -delete 2>/dev/null || true
+
+# Debug-bundle retention. Two layers:
+#   - linkedin-debug/<ts>/        : per-fire unpacked dirs, 14d
+#   - linkedin-debug/<ts>.tar.gz  : per-fire tarballs, 14d
+#   - linkedin-debug-failures/    : permanent archive of session_invalid /
+#                                   captcha tarballs; NEVER swept here.
+# Adjust the +14 numbers if disk pressure becomes an issue; do NOT add the
+# failures dir to the find sweep without explicit user instruction.
+find "$DEBUG_BUNDLE_BASE" -maxdepth 1 -type d -name "20*" -mtime +14 -exec rm -rf {} + 2>/dev/null || true
+find "$DEBUG_BUNDLE_BASE" -maxdepth 1 -type f -name "20*.tar.gz" -mtime +14 -delete 2>/dev/null || true
+
+log "=== LinkedIn stats complete: $(date) ==="

package/skill/stats-moltbook.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# stats-moltbook.sh — Moltbook-only stats (API only)
+
+exec "$(dirname "$0")/stats.sh" --platform moltbook

package/skill/stats-reddit.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# stats-reddit.sh — Reddit-only stats (API + view counts)
+
+exec "$(dirname "$0")/stats.sh" --platform reddit

package/skill/stats-twitter.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# stats-twitter.sh — Twitter-only stats (API + fxtwitter)
+
+exec "$(dirname "$0")/stats.sh" --platform twitter