@m13v/s4l 1.6.203 → 1.6.204-rc.1

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.203",
-  "installedAt": "2026-07-06T22:55:31.229Z"
+  "version": "1.6.204-rc.1",
+  "installedAt": "2026-07-06T23:23:51.203Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.203",
+  "version": "1.6.204-rc.1",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/menubar/s4l_menubar.py

@@ -227,6 +227,43 @@ REARM_PROMPT = (
     "Do not redo my X connection or project setup — only register the scheduled task. "
     "Keep replies short."
 )
+# Universal diagnose-and-heal prompt behind the ⚠ "Diagnose & fix" menu item. One
+# prompt for EVERY persistent attention state (draft stuck, rate-limited, schedule
+# missing/disabled): the menu bar can only see the symptom, Claude on the box can
+# see the cause. The prompt encodes the known heal patterns (the 2026-07-06
+# dead-claim incident chief among them), forbids code hot patches, and ends by
+# shipping a report back to us via scripts/send_diagnostic_report.py, so every
+# click doubles as fleet telemetry about what actually breaks in the field.
+DIAGNOSE_PROMPT_TEMPLATE = (
+    "The S4L plugin's menu bar on this machine is showing a persistent warning. "
+    "Reason code: {reason}. Detail: {detail}. Diagnose and heal it now.\n"
+    "Evidence lives under ~/.social-autoposter-mcp: activity.json (the producer's "
+    "live drafting label), claude-queue/ (pending/, running/ — each running job "
+    "stamps claim_pid, result/, provider.log, reaper-status.json, drain-status.json) "
+    "and the reaper log at repo/package/skill/logs/launchd-claude-reaper-stderr.log. "
+    "Worker transcripts: the *.jsonl files in the ~/.claude/projects/ entry for the "
+    "~/.s4l-worker directory.\n"
+    "Known heal patterns, in order of likelihood: "
+    "(1) dead claim — a job in claude-queue/running/ whose claim_pid no longer "
+    "exists in ps was orphaned by a killed worker (app quit mid-draft); move its "
+    "json back to claude-queue/pending/<its type>/ under the SAME filename with the "
+    "claim_pid and claimed_at keys deleted, and the every-minute worker will "
+    "re-claim it. "
+    "(2) rate-limited — worker transcripts end in 429/limit errors; nothing local "
+    "to fix, say so in the report. "
+    "(3) schedule missing/disabled — re-register via queue_setup or the host "
+    "create_scheduled_task with the prompt from "
+    "~/.claude/scheduled-tasks/s4l-worker/SKILL.md.\n"
+    "HARD RULE: fix state files only. Never edit, copy, or patch code in "
+    "~/.social-autoposter-mcp or any extension bundle (hot patches are auto-reverted "
+    "and mask the real bug).\n"
+    "Finally — ALWAYS, healed or not — write a short markdown report (symptom, root "
+    "cause, actions taken, current state) to "
+    "~/.social-autoposter-mcp/diagnostics/report-<UTC-timestamp>.md and run "
+    "`~/.social-autoposter-mcp/runtime/.venv/bin/python3 "
+    "~/.social-autoposter-mcp/repo/package/scripts/send_diagnostic_report.py "
+    "<that file>` so the report reaches the S4L developers. Keep replies short."
+)
 
 # A pending draft job older than this (seconds) with nothing claiming it means no
 # routine is draining the queue — the worker would claim within a minute if it
@@ -517,6 +554,29 @@ class S4LMenuBar(rumps.App):
         )
 
 
+    def _diagnose_fix(self, _=None):
+        """Universal ⚠ escape hatch: hand Claude a diagnose-and-heal prompt for
+        whatever persistent attention state the menu bar is showing, via the same
+        clipboard-prompt flow as Set up / Re-arm. The prompt makes Claude ship a
+        report back through send_diagnostic_report.py, so we hear about every
+        field failure this button gets used on — the click itself is also
+        captured, so \"clicked but no report arrived\" is a visible signal."""
+        reason, detail = getattr(self, "_stall_reason_info", ("", "")) or ("", "")
+        if not reason:
+            sched = getattr(self, "_schedule_state_cache", "") or ""
+            reason = f"schedule_{sched}" if sched in ("missing", "disabled") else "unknown"
+        _capture_msg(
+            "S4L diagnose&fix clicked",
+            phase="diagnose_fix",
+            reason=reason,
+        )
+        self._clipboard_prompt(
+            DIAGNOSE_PROMPT_TEMPLATE.format(reason=reason, detail=detail or "n/a"),
+            "Diagnose & fix S4L in Claude",
+            "Claude will diagnose the warning, heal what it safely can, and send "
+            "a report to the S4L developers",
+        )
+
     def _rearm(self, _=None):
         """Register the draft schedule for the CURRENT account via the host
         create_scheduled_task flow (same as onboarding) — it registers under
@@ -2409,6 +2469,10 @@ class S4LMenuBar(rumps.App):
             else:
                 items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
+            # Universal escape hatch for EVERY persistent ⚠ (the draft_stuck and
+            # rate_limited branches previously dead-ended with labels only): hand
+            # Claude a diagnose-and-heal prompt that also reports back to us.
+            items.append(rumps.MenuItem("Diagnose & fix in Claude…", callback=self._diagnose_fix))
             items.append(rumps.separator)
 
         if not runtime_ready:

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.6.203",
+  "version": "1.6.204-rc.1",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.6.203",
+  "version": "1.6.204-rc.1",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",

package/scripts/reap_stale_claude_sessions.py

@@ -637,6 +637,133 @@ def _env_int(name: str, default: int) -> int:
         return default
 
 
+# A claim whose agent-session pid has been ABSENT from the full ps snapshot for this
+# many consecutive reaper cycles is provably dead — requeue its job. Two cycles (not
+# one) so a single torn/raced ps snapshot can never orphan-then-duplicate a live
+# draft. The 2026-07-06 incident this fixes: quitting the Claude app mid-draft killed
+# the claim-holder; the job sat claimed in running/ for the producer's full 30-minute
+# timeout while the menu bar showed ⚠, even though this reaper logged the dead pid
+# every cycle. Absence from the process table is the kernel's word that the process
+# is gone; the only wrong-verdict risk is ps itself failing, which the empty-snapshot
+# guard below covers (pid REUSE makes a dead pid look alive — never the reverse — so
+# reuse can only delay this path, never mistrigger it).
+STALE_CLAIM_STRIKES = _env_int("S4L_REAPER_STALE_CLAIM_STRIKES", 2)
+
+
+def requeue_dead_claims(by_pid, dry=False):
+    """Move running/ jobs whose claim-holder session is provably dead back to
+    pending/<type>/ so the next scheduled worker re-claims them within a tick.
+
+    This is the exact inverse of the atomic claim rename in claude_job.py::cmd_next
+    (pending/<type>/<name> -> running/<name>), with the stale claim stamp scrubbed
+    so the re-claiming worker stamps fresh. The producer is unaffected: it only
+    polls the result path once claimed_at is set, and its timeout still removes
+    both the pending and running paths, so a requeued job cannot outlive its
+    producer. Strike counts persist in claude-queue/stale-claim-strikes.json.
+    Returns the number of jobs requeued. Best-effort: never raises."""
+    requeued = 0
+    try:
+        qroot = os.path.join(_state_dir(), "claude-queue")
+        running = os.path.join(qroot, "running")
+        strikes_path = os.path.join(qroot, "stale-claim-strikes.json")
+        try:
+            names = [
+                n for n in os.listdir(running)
+                if n.endswith(".json") and not n.endswith(".tmp")
+            ]
+        except OSError:
+            return 0
+        try:
+            with open(strikes_path) as f:
+                strikes = json.load(f)
+            if not isinstance(strikes, dict):
+                strikes = {}
+        except Exception:
+            strikes = {}
+        # ps failed / returned nothing: EVERY pid would look dead. Don't strike.
+        if not by_pid:
+            return 0
+        seen = set()
+        for name in names:
+            path = os.path.join(running, name)
+            try:
+                with open(path) as f:
+                    job = json.load(f)
+            except Exception:
+                continue
+            pid = job.get("claim_pid")
+            if not isinstance(pid, int) or pid <= 1:
+                continue  # unstamped claim: nothing to test liveness against
+            seen.add(name)
+            if pid in by_pid:
+                strikes.pop(name, None)  # holder alive -> clean slate
+                continue
+            entry = strikes.get(name)
+            if not isinstance(entry, dict) or entry.get("pid") != pid:
+                entry = {"pid": pid, "strikes": 0}
+            entry["strikes"] = int(entry.get("strikes", 0)) + 1
+            strikes[name] = entry
+            if entry["strikes"] < STALE_CLAIM_STRIKES:
+                continue
+            qtype = job.get("type") or "twitter-prep"
+            pend_dir = os.path.join(qroot, "pending", str(qtype))
+            print(
+                f"[claude-reaper] releasing stale claim: job {name} held by dead"
+                f" pid {pid} for {entry['strikes']} cycles -> requeue to"
+                f" pending/{qtype}",
+                file=sys.stderr,
+            )
+            if dry:
+                continue
+            try:
+                job.pop("claim_pid", None)
+                job.pop("claimed_at", None)
+                os.makedirs(pend_dir, exist_ok=True)
+                dst = os.path.join(pend_dir, name)
+                tmp = dst + f".tmp.{os.getpid()}"
+                with open(tmp, "w") as f:
+                    json.dump(job, f)
+                os.replace(tmp, dst)
+                os.remove(path)
+                strikes.pop(name, None)
+                requeued += 1
+            except Exception as e:
+                print(
+                    f"[claude-reaper] requeue of {name} failed: {e}",
+                    file=sys.stderr,
+                )
+                continue
+            # Fleet visibility: a released claim means a worker died mid-draft on
+            # this install (app quit, crash, logout). Same lane as the reaper's
+            # crash telemetry; best-effort.
+            try:
+                import sentry_init
+                sentry_init.init()
+                sentry_init.capture_message(
+                    f"S4L reaper requeued stale claim (dead pid {pid}): {name}",
+                    level="warning",
+                    tags={"component": "claude_reaper", "phase": "stale_claim_requeue"},
+                )
+                sentry_init.flush(2.0)
+            except Exception:
+                pass
+        # Drop strike entries for jobs that left running/ (drained or timed out).
+        for name in list(strikes):
+            if name not in seen:
+                strikes.pop(name, None)
+        if not dry:
+            try:
+                tmp = strikes_path + f".tmp.{os.getpid()}"
+                with open(tmp, "w") as f:
+                    json.dump(strikes, f)
+                os.replace(tmp, strikes_path)
+            except Exception:
+                pass
+    except Exception:
+        return requeued
+    return requeued
+
+
 def main() -> int:
     dry = "--dry-run" in sys.argv
     max_age = _env_int("S4L_REAPER_MAX_AGE_SEC", DEFAULT_MAX_AGE_SEC)
@@ -777,6 +904,12 @@ def main() -> int:
             file=sys.stderr,
         )
 
+    # Act on the dead set (not just log it): release claims whose holder has been
+    # gone from the process table for STALE_CLAIM_STRIKES consecutive cycles, so a
+    # worker killed mid-draft (app quit, crash, logout) costs the producer ~2-3
+    # minutes instead of its full 30-minute timeout behind a ⚠ menu bar.
+    requeued_claims = requeue_dead_claims(by_pid, dry=dry)
+
     live_pids = set(meta.keys())
 
     killed = 0
@@ -843,6 +976,7 @@ def main() -> int:
         "disclaimer_killed": disclaimers,
         "macos_mcp_killed": macos_killed,
         "archived_sessions": archived_sessions,
+        "requeued_stale_claims": requeued_claims,
         "spared_claim_pids": sorted(claim_pids),
         "worker_probe_seen": stats["worker_probe_seen"],
         "reapable_workers": stats["reapable_workers"],

package/scripts/release-mcpb.sh

@@ -54,7 +54,9 @@
 #   bash scripts/release-mcpb.sh --no-release    # build + pack + verify only (no npm, no GitHub)
 #   bash scripts/release-mcpb.sh --draft         # GitHub release as a draft
 #   bash scripts/release-mcpb.sh --staging       # PRE-release -rc.N (staging channel only)
-#   bash scripts/release-mcpb.sh --promote v1.6.193-rc.2   # ship a tested pre-release to stable
+#   bash scripts/release-mcpb.sh --promote v1.6.193-rc.2   # BLOCKED for -rc tags: stable must
+#                                  # carry clean digits (user rule, 2026-07-06). Commit + push,
+#                                  # then cut stable with --version X.Y.Z. ALLOW_RC_PROMOTE=1 forces.
 
 set -euo pipefail
 
@@ -117,14 +119,28 @@ command -v node >/dev/null || die "node not found on PATH"
 # Flip the SAME artifact the staging box tested: clear GitHub's prerelease flag
 # and mark it latest (so releases/latest + the stable boxes pick it up), and move
 # npm's `latest` dist-tag onto it. Byte-for-byte identical to what was tested;
-# there is no repack, so nothing can drift between test and ship. The version
-# keeps its -rc.N label on purpose (that IS the tested build); cut a fresh stable
-# patch later if you want a clean number.
+# there is no repack, so nothing can drift between test and ship.
+#
+# USER RULE (2026-07-06, after the SECOND in-place rc promote; the first left
+# v1.6.197-rc.16 flagged stable on 2026-07-03): the stable channel must show
+# clean version digits, never an -rc.N label. So promoting an -rc tag in place
+# is BLOCKED by default. Ship the same code with a clean number instead:
+# commit + push (the pack ships the working tree), then
+# `bash scripts/release-mcpb.sh --version X.Y.Z`. Set ALLOW_RC_PROMOTE=1 only
+# for an emergency where a rebuild is riskier than the label.
 if [[ -n "$PROMOTE_TAG" ]]; then
   command -v gh >/dev/null || die "gh CLI not found"
   gh auth status >/dev/null 2>&1 || die "gh not authenticated (run: gh auth login)"
   PTAG="$PROMOTE_TAG"; [[ "$PTAG" == v* ]] || PTAG="v$PTAG"
   PVER="${PTAG#v}"
+  if [[ "$PVER" == *-rc* && "${ALLOW_RC_PROMOTE:-0}" != "1" ]]; then
+    CLEAN_VER="${PVER%%-rc*}"
+    die "stable releases carry clean digits (user rule, 2026-07-06); refusing to promote $PTAG in place.
+  Ship the same code under a clean number instead:
+    1. commit + push the repo (the pipeline pack ships the working tree)
+    2. bash scripts/release-mcpb.sh --version $CLEAN_VER   (pick the next patch if $CLEAN_VER is already published)
+  Emergency override (ships the -rc label to every stable box): ALLOW_RC_PROMOTE=1 bash scripts/release-mcpb.sh --promote $PTAG"
+  fi
   gh release view "$PTAG" -R "$GH_REPO" >/dev/null 2>&1 || die "no release $PTAG to promote"
   say "Promoting $PTAG to stable (in place; same tested artifact, no rebuild)"
   gh release edit "$PTAG" -R "$GH_REPO" --prerelease=false --latest
@@ -493,7 +509,8 @@ if [[ -n "$DRAFT_FLAG" ]]; then
 elif [[ "$DO_STAGING" == "1" ]]; then
   say "Staging pre-release — releases/latest deliberately EXCLUDES it, so stable boxes stay put."
   echo "  Only boxes on the staging channel pull $TAG (via the releases LIST endpoint)."
-  echo "  To ship it to everyone once tested:  bash scripts/release-mcpb.sh --promote $TAG"
+  echo "  To ship it to everyone once tested (stable = clean digits, never -rc): commit + push, then"
+  echo "    bash scripts/release-mcpb.sh --version ${VERSION%%-rc*}   # pick the next patch if that version is already published"
 else
   say "Verifying releases/latest serves $TAG (drives the menu-bar update banner)"
   LATEST_SEEN=""

package/scripts/send_diagnostic_report.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Ship a menu-bar "Diagnose & fix" report back to the S4L developers.
+
+Usage: send_diagnostic_report.py <report.md> [reason-code]
+
+The menu bar's ⚠ "Diagnose & fix in Claude…" item hands Claude a prompt that ends
+with: write a short markdown report of the diagnosis (symptom, root cause, actions
+taken, current state) and run this script on it. We ship it over the same Sentry
+lane the reaper and menu bar already use (sentry_init tags every event with the
+install identity), so field diagnoses land next to the "autopilot needs attention"
+warnings they resolve. The report body rides in the message itself, truncated to
+stay inside Sentry's message limits; the full file stays on disk under
+~/.social-autoposter-mcp/diagnostics/ for follow-up over the QA/SSH lane.
+
+Exit codes: 0 shipped, 1 usage / unreadable file, 2 telemetry unavailable (the
+report file still exists locally either way — say so, never lose the diagnosis).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# 8KB is Sentry's formatted-message ceiling; leave headroom for the header line.
+MAX_BODY_CHARS = 6000
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("usage: send_diagnostic_report.py <report.md> [reason-code]", file=sys.stderr)
+        return 1
+    path = sys.argv[1]
+    reason = sys.argv[2] if len(sys.argv) > 2 else "unspecified"
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            body = f.read().strip()
+    except OSError as e:
+        print(f"cannot read report file: {e}", file=sys.stderr)
+        return 1
+    if not body:
+        print("report file is empty — write the diagnosis first", file=sys.stderr)
+        return 1
+    truncated = len(body) > MAX_BODY_CHARS
+    if truncated:
+        body = body[:MAX_BODY_CHARS] + "\n…[truncated; full report on the box]"
+
+    try:
+        import sentry_init
+        sentry_init.init()
+        sentry_init.capture_message(
+            "S4L field diagnosis report\n\n" + body,
+            level="warning",
+            tags={
+                "component": "diagnose_fix",
+                "phase": "field_report",
+                "reason": reason,
+                "truncated": str(truncated).lower(),
+            },
+        )
+        sentry_init.flush(5.0)
+    except Exception as e:
+        print(
+            f"telemetry unavailable ({e}); report kept locally at {path}",
+            file=sys.stderr,
+        )
+        return 2
+    print(f"report shipped to S4L telemetry (kept locally at {path})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())