@m13v/s4l 1.6.199 → 1.6.201

package/mcp/dist/index.js

@@ -240,13 +240,76 @@ function ensurePlist(p, xml) {
     fs.writeFileSync(p, xml, "utf-8");
     return true;
 }
+// Per-label failure backoff for launchd loads. Karol's box (2026-07-03) looped
+// `bootstrap -> Input/output error 5` + `load -> error 5` several times per heal
+// tick for HOURS, with no label, no stderr detail, and no cooldown: pure log
+// flood, zero diagnosis. launchd's error 5 is a catch-all; the most common
+// FIXABLE cause is the service being disabled in the gui domain, so loadPlist
+// now (a) best-effort `launchctl enable`s the label first, (b) on double
+// failure emits ONE structured relay line carrying the label, plist, both
+// stderr tails, and whether the label appears in the domain's disabled list,
+// and (c) backs off for 6 hours after 3 consecutive failures per label.
+const plistLoadFailures = new Map();
 async function loadPlist(label, plistPath, uid) {
+    const back = plistLoadFailures.get(label);
+    if (back && back.skipUntil > Date.now()) {
+        return {
+            code: 1,
+            stdout: "",
+            stderr: `launchd-load backoff: ${label} failed ${back.count}x; next attempt after ${new Date(back.skipUntil).toISOString()}`,
+        };
+    }
+    // Clears a disabled override when that's the blocker; harmless otherwise.
+    await run("launchctl", ["enable", `gui/${uid}/${label}`], { timeoutMs: 15_000, noTee: true });
     let res = await run("launchctl", ["bootstrap", `gui/${uid}`, plistPath], { timeoutMs: 15_000 });
+    const bootstrapErr = res.code !== 0 ? lastLine(res.stderr || res.stdout) : "";
     if (res.code !== 0) {
         res = await run("launchctl", ["load", plistPath], { timeoutMs: 15_000 });
     }
+    if (res.code !== 0) {
+        const loadErr = lastLine(res.stderr || res.stdout);
+        let disabledEntry = "unknown";
+        try {
+            const disabled = await run("launchctl", ["print-disabled", `gui/${uid}`], {
+                timeoutMs: 15_000,
+                noTee: true,
+            });
+            disabledEntry =
+                (disabled.stdout || "")
+                    .split("\n")
+                    .find((l) => l.includes(label))
+                    ?.trim() || "not-listed";
+        }
+        catch {
+            /* diagnostic only */
+        }
+        const detail = JSON.stringify({
+            label,
+            plist: plistPath,
+            bootstrap_err: bootstrapErr,
+            load_err: loadErr,
+            disabled_entry: disabledEntry,
+        });
+        console.error(`[launchd-load] failed: ${detail}`);
+        logLine("stderr", detail, "launchd-load");
+        const prev = plistLoadFailures.get(label) ?? { count: 0, skipUntil: 0 };
+        prev.count += 1;
+        if (prev.count >= 3) {
+            prev.skipUntil = Date.now() + 6 * 3600_000;
+            const msg = JSON.stringify({ label, backoff_hours: 6, consecutive_failures: prev.count });
+            console.error(`[launchd-load] backing off: ${msg}`);
+            logLine("stderr", `backing off: ${msg}`, "launchd-load");
+        }
+        plistLoadFailures.set(label, prev);
+    }
+    else {
+        plistLoadFailures.delete(label);
+    }
     return res;
 }
+function lastLine(s) {
+    return (s || "").trim().split("\n").slice(-1)[0] || "";
+}
 async function unloadPlist(label, plistPath, uid) {
     let res = await run("launchctl", ["bootout", `gui/${uid}/${label}`], { timeoutMs: 15_000 });
     if (res.code !== 0) {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.199",
-  "installedAt": "2026-07-03T23:40:49.471Z"
+  "version": "1.6.201",
+  "installedAt": "2026-07-04T00:10:10.313Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.199",
+  "version": "1.6.201",
   "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.6.199",
+  "version": "1.6.201",
   "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.199",
+  "version": "1.6.201",
   "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/autopilot_stall_watch.py

@@ -57,7 +57,9 @@ RUNNING_STALL_SECONDS = 900
 # At StartInterval 120 that is ~6 min of continuous stall.
 ALERT_AFTER = 3
 
-WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
+# Includes the current universal worker id; legacy phase pair kept for old
+# installs (same stale-checker drift fix as scheduled_tasks_snapshot.py, 2026-07-03).
+WORKER_TASK_IDS = ("s4l-worker", "saps-worker", "saps-phase1-query", "saps-phase2b-draft")
 
 
 def _state_dir() -> str:

package/scripts/memory_snapshot.py

@@ -696,6 +696,7 @@ def build_summary() -> dict[str, Any]:
         "app_version": _app_version(),
         "claude_desktop_version": claude_desktop_version(),
         "reaper": reaper_status(),
+        "twitter_cycle": twitter_cycle_status(),
         "process_count": len(rows),
         "mem": {
             "total_mb": total,
@@ -796,6 +797,9 @@ def reaper_status() -> dict[str, Any] | None:
             "worker_probe_seen": ds.get("worker_probe_seen"),
             "reapable_workers": ds.get("reapable_workers"),
             "unparsed_worker_procs": ds.get("unparsed_worker_procs"),
+            "unparsed_samples": ds.get("unparsed_samples"),
+            "cwd_fallback_admitted": ds.get("cwd_fallback_admitted"),
+            "s4l_worker_cwd_seen": ds.get("s4l_worker_cwd_seen"),
             "macos_mcp_seen": ds.get("macos_mcp_seen"),
             "leaked_groups": ds.get("leaked_groups"),
             "ps_timed_out": ds.get("ps_timed_out"),
@@ -805,6 +809,33 @@ def reaper_status() -> dict[str, Any] | None:
         return None
 
 
+def twitter_cycle_status() -> dict[str, Any] | None:
+    """Tail of the newest twitter-cycle log, carried on the heartbeat.
+
+    The launchd-driven run-twitter-cycle.sh logs ONLY to a local file, so the
+    cycle's phase progress was invisible centrally: the 2026-07-03 Karol
+    first-draft investigation had a 27-minute blind window (cycle start 22:30 ->
+    cards 22:57) with no way to see which phase the time went to. This block
+    makes "where is the cycle right now" a one-query answer. Best-effort."""
+    try:
+        logs = sorted(
+            (REPO_DIR / "skill" / "logs").glob("twitter-cycle-20*.log"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+        if not logs:
+            return None
+        p = logs[0]
+        lines = [ln.strip() for ln in _tail_lines(p, 8) if ln.strip()]
+        return {
+            "log": p.name,
+            "age_sec": round(time.time() - p.stat().st_mtime, 1),
+            "last_lines": [ln[:200] for ln in lines[-3:]],
+        }
+    except Exception:
+        return None
+
+
 def _tail_lines(path: Path, n: int, approx_line_bytes: int = 4096) -> list[str]:
     """Return the last `n` lines of a possibly-large file without reading it all.
     Reads a bounded tail window (n * approx_line_bytes) from the end. Best-effort."""

package/scripts/reap_stale_claude_sessions.py

@@ -407,6 +407,8 @@ def snapshot():
         "worker_probe_seen": 0,     # procs that look like a claude-code agent worker
         "reapable_workers": 0,      # metadata-confirmed SAPS worker procs (=len(procs))
         "unparsed_worker_procs": 0, # probe-positive but NOT reapable (regex/sig miss)
+        "unparsed_samples": [],     # up to 3 truncated cmdlines of unparsed procs
+        "cwd_fallback_admitted": 0, # unparsed procs rescued via the ~/.s4l-worker cwd proof
         "metadata_spared_nonworkers": 0,
         "metadata_unknown": 0,
         "cwd_confirmed_workers": 0,
@@ -465,18 +467,42 @@ def snapshot():
         if is_probe:
             stats["worker_probe_seen"] += 1
         # (b) claude agent-mode worker sessions — the REAPABLE set.
-        if not all(tok in cmd for tok in SIG_REQUIRED):
-            if is_probe:
-                stats["unparsed_worker_procs"] += 1  # looks like a worker, sig miss
-            continue
-        if any(tok in cmd for tok in SIG_EXCLUDED):
-            continue
-        u = UUID_RE.search(cmd)
-        if not u:
-            # Full signature but the session path shape defeated UUID_RE — THE Karol
-            # blind spot. Count it so the leak is never invisible again.
+        sig_ok = all(tok in cmd for tok in SIG_REQUIRED) and not any(
+            tok in cmd for tok in SIG_EXCLUDED
+        )
+        u = UUID_RE.search(cmd) if sig_ok else None
+        if not sig_ok or not u:
+            # Probe-positive but the full signature / UUID path shape missed — the
+            # signature-drift blind spot. Karol leak #2 (2026-07-03): a newer Claude
+            # Desktop shipped a cmdline shape that defeated SIG_REQUIRED/UUID_RE, all
+            # 46+ workers counted as "unparsed", the reaper killed nothing, and the box
+            # climbed to 98 claude procs / 13.7 GB in under 2 hours. Two responses:
+            #   1. VISIBILITY: keep a few truncated sample cmdlines so the central
+            #      telemetry shows the NEW shape and the signature can be fixed blind.
+            #   2. CWD-PROOF FALLBACK: a probe-positive process whose cwd is the
+            #      dedicated ~/.s4l-worker dir is OURS regardless of cmdline shape
+            #      (interactive sessions never run there). Admit it to the reapable
+            #      set under a synthetic uuid group; the type-driven rule downstream
+            #      still spares claim-holders and newborns, so this can only remove
+            #      provably-idle husks.
             if is_probe:
                 stats["unparsed_worker_procs"] += 1
+                if len(stats["unparsed_samples"]) < 3:
+                    stats["unparsed_samples"].append(cmd[:240])
+                cwd = cwd_index.get(pid) or ""
+                if cwd == S4L_WORKER_CWD or cwd.startswith(S4L_WORKER_CWD + os.sep):
+                    procs.append({
+                        "pid": pid,
+                        "ppid": ppid,
+                        "age": age,
+                        "uuid": "cwd-fallback",
+                        "cmd": cmd,
+                        "resume_id": None,
+                        "session_paths": [],
+                        "scheduled_task_ids": ["probe-cwd-fallback"],
+                        "metadata_source": "probe_cwd_fallback",
+                    })
+                    stats["cwd_fallback_admitted"] += 1
             continue
         worker_meta, reason = worker_session_meta(cmd, session_index)
         if not worker_meta:
@@ -821,6 +847,8 @@ def main() -> int:
         "worker_probe_seen": stats["worker_probe_seen"],
         "reapable_workers": stats["reapable_workers"],
         "unparsed_worker_procs": stats["unparsed_worker_procs"],
+        "unparsed_samples": stats["unparsed_samples"],
+        "cwd_fallback_admitted": stats["cwd_fallback_admitted"],
         "metadata_spared_nonworkers": stats["metadata_spared_nonworkers"],
         "metadata_unknown": stats["metadata_unknown"],
         "cwd_confirmed_workers": stats["cwd_confirmed_workers"],

package/scripts/scheduled_tasks_snapshot.py

@@ -27,7 +27,15 @@ import os
 import sys
 
 # --- Kept in sync with mcp/menubar/s4l_menubar.py ---------------------------
-WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
+# Current installs run ONE universal worker task (s4l-worker). The phase pair
+# is the retired legacy shape kept only so old installs still report. Checking
+# ONLY the legacy names made every current install scream
+# missing_worker_tasks=[saps-phase1-query, saps-phase2b-draft] forever while
+# the real s4l-worker task fired every minute and wasn't even LISTED (Karol,
+# 2026-07-03 — this false alarm derailed the whole onboarding investigation).
+WORKER_TASK_IDS = ("s4l-worker", "saps-worker", "saps-phase1-query", "saps-phase2b-draft")
+CURRENT_WORKER_TASK_IDS = ("s4l-worker", "saps-worker")
+LEGACY_WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
 DEPRECATED_TASK_IDS = ("social-autoposter-autopilot",)
 WORKER_CWD = os.path.join(os.path.expanduser("~"), ".s4l-worker")
 # "Claude*": the host app can run with a custom --user-data-dir (per-account
@@ -88,11 +96,17 @@ def build_summary() -> dict:
             })
 
     mislocated = sum(1 for t in tasks if not t["in_worker_dir"])
+    # "Missing" means NO viable worker lane at all: neither a current universal
+    # task nor the complete legacy pair. Naming every absent id was wrong once
+    # the id set spanned generations (a healthy current install always "misses"
+    # the legacy pair and vice versa).
+    have_current = bool(seen_ids & set(CURRENT_WORKER_TASK_IDS))
+    have_legacy = set(LEGACY_WORKER_TASK_IDS) <= seen_ids
     return {
         "worker_dir_tail": _cwd_tail(WORKER_CWD),
         "registries": registries,
         "worker_tasks": len(tasks),
-        "missing_worker_tasks": sorted(set(WORKER_TASK_IDS) - seen_ids),
+        "missing_worker_tasks": [] if (have_current or have_legacy) else ["s4l-worker"],
         "mislocated": mislocated,
         # all_in_worker_dir is False when there are zero worker tasks too, since
         # "no autopilot registered" is itself a state worth seeing centrally.

package/scripts/snapshot.py

@@ -62,7 +62,13 @@ REQUIRED_FIELDS = ["name", "website", "description", "icp", "voice", "search_top
 # only setup can NEVER report setup_complete (any_ready requires a managed product),
 # leaving the menu bar stuck on "project not set up". (2026-06-30)
 PERSONA_REQUIRED_FIELDS = ["name", "description", "voice", "search_topics"]
-WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
+# Current installs run ONE universal worker task (s4l-worker); the phase pair
+# is the retired legacy shape. Checking ONLY the legacy pair made every current
+# install read "autopilot off" forever (Karol, 2026-07-03: worker fired every
+# minute while this check reported the tasks missing). Keep in sync with
+# scripts/schedule_state.py and mcp/menubar/s4l_menubar.py.
+CURRENT_WORKER_TASK_IDS = ("s4l-worker", "saps-worker")
+LEGACY_WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
 UPDATER_LABEL = "com.m13v.social-autoposter-update"
 AUTOPILOT_STALL_MS = 180_000
 
@@ -179,7 +185,15 @@ def _mode_chosen() -> bool:
 def _autopilot_on() -> bool:
     base = os.path.join(_claude_cfg_dir(), "scheduled-tasks")
     try:
-        return all(os.path.exists(os.path.join(base, t, "SKILL.md")) for t in WORKER_TASK_IDS)
+        if any(
+            os.path.exists(os.path.join(base, t, "SKILL.md"))
+            for t in CURRENT_WORKER_TASK_IDS
+        ):
+            return True
+        return all(
+            os.path.exists(os.path.join(base, t, "SKILL.md"))
+            for t in LEGACY_WORKER_TASK_IDS
+        )
     except Exception:
         return False