@m13v/s4l 1.6.204-rc.21 → 1.6.204-rc.23

package/mcp/dist/index.js

@@ -2706,8 +2706,19 @@ async function autopilotLoaded() {
 // fires every minute, claims ONE job, runs the pipeline's own prompt as its
 // Claude turn, writes the result back, and stops.
 // ===========================================================================
-const QUEUE_WORKER_PROMPT_VERSION = 7; // v7: universal type-blind worker. ONE task claims `--type any`; per-type execution notes (e.g. the v6 incremental-draft pacing for twitter-prep) moved into claude_job.py TYPE_TO_WORKER_NOTES and ride the prompt sidecar, so the worker prompt never mentions job types. Legacy per-type tasks get this same body on refresh and become interchangeable universal workers.
+const QUEUE_WORKER_PROMPT_VERSION = 8; // v8: worker polls internally (claude_job.py next --wait-seconds) instead of single-shot check-then-die. Empirically verified (2026-07-06) that a single long-running Bash call survives well past the host's ~90s between-tool-call inactivity kill — that timer only fires on MODEL silence, not on one in-flight tool call — so one Bash call can safely poll for QUEUE_WORKER_POLL_SECONDS before giving up. This cuts the every-minute spin-up-empty-then-die husk cycle down to roughly one session per poll window instead of one per cron tick. v7: universal type-blind worker. ONE task claims `--type any`; per-type execution notes (e.g. the v6 incremental-draft pacing for twitter-prep) moved into claude_job.py TYPE_TO_WORKER_NOTES and ride the prompt sidecar, so the worker prompt never mentions job types. Legacy per-type tasks get this same body on refresh and become interchangeable universal workers.
 const QUEUE_WORKER_PROMPT_MARKER = "s4l_queue_worker_prompt_version";
+// How long ONE `next --wait-seconds` call polls before giving up and exiting.
+// 240s (4 min): comfortably inside the 900s single-Bash-call survival verified
+// live on 2026-07-06, and covers a meaningful chunk of the ~8min average
+// real job inter-arrival gap measured on the box, while still keeping each
+// worker session bounded. The cron's `* * * * *` cadence remains the outer
+// safety net for whatever the poll window doesn't catch.
+// COUPLING: scripts/reap_stale_claude_sessions.py's S4L_REAPER_CLAIM_GRACE_SEC
+// default MUST stay >= this value + margin — a claimless session inside this
+// poll window is legitimately still working, not a husk, and a too-tight
+// claim_grace would SIGTERM it mid-poll before it ever gets to claim.
+const QUEUE_WORKER_POLL_SECONDS = 240;
 // One spec per worker task. queueType MUST match scripts/claude_job.py TAG_TO_TYPE.
 const QUEUE_WORKERS = [
     { taskId: WORKER_TASK_ID, queueType: "any", human: "universal queue" },
@@ -2831,17 +2842,24 @@ function queueWorkerBody(spec) {
             `other tool, or trying to "investigate", STALLS it forever.`,
         ``,
         `PACING — CRITICAL: this unattended session is terminated ~90 seconds after ` +
-            `your LAST tool call (a host inactivity timeout). Make your first tool call ` +
-            `promptly, and if the job's prompt gives you per-item persist commands to run ` +
-            `(its own quick Bash calls), run them as you complete each item instead of ` +
-            `working silently — those calls are what keep the session alive. The prompt ` +
-            `file may begin with a WORKER EXECUTION NOTES header; follow it exactly.`,
+            `your LAST tool call (a host inactivity timeout). That clock only runs BETWEEN ` +
+            `tool calls, not during one — step 1 below is a single Bash call that can ` +
+            `legitimately take several minutes to return, and that is fine. Make your ` +
+            `first tool call promptly, and once you are drafting (step 2), if the job's ` +
+            `prompt gives you per-item persist commands to run (its own quick Bash calls), ` +
+            `run them as you complete each item instead of working silently — those calls ` +
+            `are what keep the session alive. The prompt file may begin with a WORKER ` +
+            `EXECUTION NOTES header; follow it exactly.`,
         ``,
         `Steps:`,
-        `1. Claim the next job. Run this EXACT Bash command:`,
-        `     ${py} ${job} next --type any --prompt-file --state-dir ${sd}`,
-        `   It prints one line of JSON. If it prints "{}" (empty), there is NO work — ` +
-            `report "no jobs" in one line and STOP. You are done.`,
+        `1. Look for the next job. Run this EXACT Bash command and let it run to ` +
+            `completion — it polls internally for up to ${Math.round(QUEUE_WORKER_POLL_SECONDS / 60)} ` +
+            `minutes before giving up, so it may take a while to return. That is normal: ` +
+            `do NOT interrupt it and do NOT make any other tool call while it is running.`,
+        `     ${py} ${job} next --type any --prompt-file --wait-seconds ${QUEUE_WORKER_POLL_SECONDS} --state-dir ${sd}`,
+        `   It prints one line of JSON once it returns. If it prints "{}" (empty), no ` +
+            `job showed up during the whole poll window — report "no jobs" in one line ` +
+            `and STOP. You are done.`,
         `2. Otherwise it prints {"job_id":"...","prompt_file":"...","schema_file":...}. ` +
             `Use the Read tool to read prompt_file; it is the complete, self-contained ` +
             `instruction the pipeline wrote for you. If the Read result says it is partial ` +

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.204-rc.21",
-  "installedAt": "2026-07-07T03:35:11.473Z"
+  "version": "1.6.204-rc.23",
+  "installedAt": "2026-07-07T03:58:28.853Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.204-rc.21",
+  "version": "1.6.204-rc.23",
   "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_card.py

@@ -908,27 +908,45 @@ class _ReviewController(NSObject):
         self._stats_popover = None
 
     @objc.python_method
-    def _show_popover(self, text, anchor, what):
+    def _show_popover(self, content, anchor, what):
         """One popover surface for both eyes (thread stats, draft details).
         Only one is ever open: the two anchors are far apart, so hover-out
-        closes the first before hover-in opens the other."""
-        if anchor is None or not text:
+        closes the first before hover-in opens the other. `content` is a
+        single string (stats: one compact line) or a list of strings
+        (details: one bulleted row per field, gapped vertically so the
+        fields read as a list instead of one dense run-on paragraph)."""
+        if anchor is None or not content:
             return
         if self._stats_popover is not None and self._stats_popover.isShown():
             return
+        lines = content if isinstance(content, list) else [content]
+        bulleted = len(lines) > 1
+        rows = [f"•  {line}" if bulleted else line for line in lines]
+        row_gap = 8 if bulleted else 0
         font = NSFont.systemFontOfSize_(12)
-        s = NSAttributedString.alloc().initWithString_attributes_(
-            text, {NSFontAttributeName: font}
-        )
-        # Wrap-aware measurement (the details popover is multi-line; option 1 =
-        # NSStringDrawingUsesLineFragmentOrigin). +34: 13px side insets plus
+        # Wrap-aware measurement per row (option 1 = NSStringDrawingUsesLine
+        # FragmentOrigin; a row can itself be multi-line, e.g. the truncated
+        # original-thread text). +34 on width: 13px side insets plus
         # NSTextField's own ~4px internal padding, which otherwise clips the
-        # last word.
-        measured = s.boundingRectWithSize_options_(NSMakeSize(300, 10_000), 1)
-        pw = int(measured.size.width) + 34
-        ph = int(measured.size.height) + 19
+        # last word. +3 on each row's height: buffer against descender
+        # clipping (matches the single-line sizing this replaces).
+        heights = []
+        pw = 0
+        for row in rows:
+            s = NSAttributedString.alloc().initWithString_attributes_(
+                row, {NSFontAttributeName: font}
+            )
+            measured = s.boundingRectWithSize_options_(NSMakeSize(300, 10_000), 1)
+            heights.append(int(measured.size.height) + 3)
+            pw = max(pw, int(measured.size.width))
+        pw += 34
+        ph = sum(heights) + row_gap * (len(rows) - 1) + 16
         view = NSView.alloc().initWithFrame_(NSMakeRect(0, 0, pw, ph))
-        view.addSubview_(_label(NSMakeRect(13, 8, pw - 26, ph - 16), text, size=12))
+        y = ph - 8
+        for row, h in zip(rows, heights):
+            y -= h
+            view.addSubview_(_label(NSMakeRect(13, y, pw - 26, h), row, size=12))
+            y -= row_gap
         vc = NSViewController.alloc().init()
         vc.setView_(view)
         pop = NSPopover.alloc().init()
@@ -963,7 +981,7 @@ class _ReviewController(NSObject):
     @objc.python_method
     def _show_details_popover(self):
         lines = _details_lines(self._drafts[self._idx])
-        self._show_popover("\n".join(lines), self._details_btn, "details")
+        self._show_popover(lines, self._details_btn, "details")
 
     # Click on an eye SHOWS its popover, never toggles it closed: a click is
     # physically preceded by hover (mouseEntered already opened it), so a

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.6.204-rc.21",
+  "version": "1.6.204-rc.23",
   "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.204-rc.21",
+  "version": "1.6.204-rc.23",
   "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/claude_job.py

@@ -200,6 +200,13 @@ VALUE_FLAGS = {
 }
 
 POLL_INTERVAL_S = 2.0
+# Consumer-side poll cadence for `next --wait-seconds` (see cmd_next). Separate
+# constant from POLL_INTERVAL_S (the producer's own wait loop) because the two
+# sides have different cost profiles: the producer polls a single result file
+# it's blocked on anyway, while the worker's poll re-execs claude_job.py itself
+# each pass, so a slightly coarser cadence avoids needless process churn during
+# a multi-minute wait.
+WORKER_POLL_INTERVAL_S = 5.0
 # Per-call budget the producer waits for ONE claude job (a query or a draft-prep
 # reasoning turn). Was 600s, which sat right at the edge of the draft call's real
 # ~9-10 min need: on the QA box ~41% of twitter-prep jobs breached 600s and got
@@ -804,9 +811,11 @@ def _agent_session_pid():
     return None
 
 
-def cmd_next(ns) -> int:
-    _apply_state_dir_override(ns)
-    qtype = ns.type
+def _attempt_claim(ns, qtype: str) -> bool:
+    """One pass over the pending dirs: try to claim the oldest job. Returns True
+    (and prints the claimed job's payload) iff a job was claimed; False if the
+    queue was empty this pass. Split out of cmd_next so the poll loop below can
+    call it repeatedly without duplicating the claim/stamp/print logic."""
     # "any" (the universal type-blind worker) scans EVERY pending type dir;
     # a comma list scans those types; a single type keeps legacy behavior.
     # Job filenames start with a zero-padded nanosecond timestamp, so one
@@ -896,8 +905,34 @@ def cmd_next(ns) -> int:
             payload["prompt"] = job["prompt"]
             payload["schema"] = job.get("schema")
         print(json.dumps(payload))
-        return 0
-    print(json.dumps({}))  # no work
+        return True
+    return False
+
+
+def cmd_next(ns) -> int:
+    _apply_state_dir_override(ns)
+    qtype = ns.type
+    wait_seconds = max(0, ns.wait_seconds or 0)
+    # wait_seconds=0 (default) is the legacy single-shot behavior: one pass,
+    # then done. wait_seconds>0 polls in a bounded loop within THIS ONE process
+    # (one Bash call from the calling session's perspective) instead of relying
+    # on the scheduled task's own cron cadence to re-check. A finished-but-empty
+    # pass sleeps WORKER_POLL_INTERVAL_S and tries again until the deadline.
+    #
+    # COUPLING: the reaper's claim_grace (S4L_REAPER_CLAIM_GRACE_SEC in
+    # reap_stale_claude_sessions.py) must stay >= whatever --wait-seconds the
+    # worker prompt actually passes, plus margin — a claimless session polling
+    # inside this loop is legitimate, not a husk, and a too-tight claim_grace
+    # would SIGTERM it mid-poll before it ever gets a chance to claim.
+    deadline = time.time() + wait_seconds
+    while True:
+        if _attempt_claim(ns, qtype):
+            return 0
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            break
+        time.sleep(min(WORKER_POLL_INTERVAL_S, remaining))
+    print(json.dumps({}))  # no work found within the wait window
     _maybe_self_reap()  # idle turn, no job claimed — safe to retire this session
     return 0
 
@@ -1040,6 +1075,13 @@ def main() -> int:
         action="store_true",
         help="write the prompt/schema to sidecar files and print their paths",
     )
+    pn.add_argument(
+        "--wait-seconds",
+        type=int,
+        default=0,
+        help="poll for a job up to this many seconds before giving up "
+        "(0 = legacy single-shot: check once and return immediately)",
+    )
     pn.set_defaults(func=cmd_next)
 
     pr = sub.add_parser("result", help="store a job's result")

package/scripts/reap_stale_claude_sessions.py

@@ -804,33 +804,28 @@ def main() -> int:
     # never at risk.
     max_group = _env_int("S4L_REAPER_MAX_GROUP", 2)
 
-    # (3) Claim grace — the PRIMARY brake (2026-07-01, per Matthew). A worker checks
-    # the queue EXACTLY ONCE per fire: claude_job.py::cmd_next is single-shot — it
-    # claims one pending job (stamping claim_pid) or prints {} and returns; it never
-    # polls again. So within one cron tick of spawning, a session either CLAIMS a job
-    # (=> it has a "type", is actively drafting, and is spared outright via
-    # running_claim_pids()) or finds the queue empty and becomes a PERMANENT typeless
-    # husk that will NEVER claim again. Those husks are exactly what we want to kill.
+    # (3) Claim grace — the PRIMARY brake (2026-07-01, per Matthew; updated 2026-07-06
+    # for the polling worker). A worker no longer checks the queue exactly once per
+    # fire: claude_job.py::cmd_next now takes --wait-seconds and polls internally for
+    # up to QUEUE_WORKER_POLL_SECONDS (mcp/src/index.ts, 240s default) before giving
+    # up. So a claimless session may be legitimately, actively polling for the WHOLE
+    # poll window — not yet a husk — and only becomes a proven husk once it exits
+    # (prints "{}") without ever stamping a claim_pid. Reaping it mid-poll would kill
+    # a session that might claim a job seconds later.
     #
-    # The ONLY reason to spare a claimless session is that it may not have run its one
-    # cmd_next yet (cold agent-mode boot: skill load + MCP init before the first tool
-    # call). claim_grace bounds that boot+claim window. Measured on the box:
-    # enqueue->claim was ALWAYS < 60s (3-55s across 85 claims); 120s is a generous
-    # margin. Past claim_grace a claimless session is a proven husk -> reap it now,
-    # regardless of the 35-min age ceiling and regardless of group size. This is the
-    # type-driven rule: spare drafters + spare boot-window newborns, reap all the rest.
-    # Worst case of an over-tight grace is a job delayed one tick (it stays in pending
-    # for the next worker), never a lost draft. A DRAFTING session is protected by
-    # claim_pids, not by grace, so no grace value can kill a real draft (this is what
-    # makes the old "~120s code-143 mid-draft kill" impossible now).
+    # claim_grace must therefore bound "boot + one full poll window", not just
+    # "boot + one cmd_next call" as before. It stays the type-driven rule: spare
+    # drafters (claim_pids) + spare in-grace newborns, reap everything else. Worst
+    # case of an over-tight grace is a job delayed until the next cron tick's worker
+    # (it stays in pending), never a lost draft — a DRAFTING session is protected by
+    # claim_pids, not by grace, so no grace value can kill a real draft.
     #
-    # Default 60s (2026-07-01, per Matthew): the boot+claim window is comfortably
-    # inside one cron tick — measured enqueue->claim was always < 60s (3-55s across 85
-    # claims) and that figure ALREADY includes the claiming worker's spawn+boot+cmd_next.
-    # 60s tightens the steady-state floor to ~2-3 warm sessions (one tick of newborns +
-    # any active drafter) instead of ~4, while still never racing a real claim. Bump it
-    # back up via S4L_REAPER_CLAIM_GRACE_SEC if cold boots ever start exceeding a tick.
-    claim_grace = _env_int("S4L_REAPER_CLAIM_GRACE_SEC", 60)
+    # Default 300s (2026-07-06): QUEUE_WORKER_POLL_SECONDS (240s) + ~60s margin for
+    # cold agent-mode boot (skill load + MCP init) and this reaper's own ps-scan
+    # latency. COUPLING: must stay >= QUEUE_WORKER_POLL_SECONDS + margin — if that
+    # constant grows, bump this default (or S4L_REAPER_CLAIM_GRACE_SEC) to match, or
+    # the reaper will SIGTERM a legitimately-polling worker before it ever claims.
+    claim_grace = _env_int("S4L_REAPER_CLAIM_GRACE_SEC", 300)
 
     inflight = count_running_jobs()  # None => queue unreadable => age-gate fallback
     claim_pids = running_claim_pids()  # agent-session pids actively holding a claim