@m13v/s4l 1.6.199 → 1.6.200

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.200",
+  "installedAt": "2026-07-04T00:00:21.537Z"
 }

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.200",
   "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.200",
   "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.200",
   "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/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"],