social-autoposter 1.6.80 → 1.6.82

package/mcp/dist/index.js

@@ -1424,6 +1424,96 @@ async function autopilotLoaded() {
     }
     return { autopilot_on, auto_update_on };
 }
+// ---- Autopilot prompt: keep the scheduled task's SKILL.md current ------------
+// The scheduled task's prompt (SKILL.md) is owned by the host and does NOT update
+// when the plugin updates. So a behavior change (the no-improvise / voice-inline /
+// stop-cleanly rules) would never reach an already-scheduled task. We close that
+// gap by REWRITING the task's SKILL.md on server boot when its embedded prompt
+// version is older than what this build ships. The host reads the file fresh on
+// each run, so the next fire picks up the new prompt — no host tool, no user
+// action. Bump AUTOPILOT_PROMPT_VERSION whenever the prompt below changes.
+const AUTOPILOT_PROMPT_VERSION = 1;
+const AUTOPILOT_PROMPT_MARKER = "saps_autopilot_prompt_version";
+function autopilotSkillPath() {
+    const cfg = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+    return path.join(cfg, "scheduled-tasks", AUTOPILOT_TASK_ID, "SKILL.md");
+}
+// The canonical draft-only autopilot prompt: uses ONLY scan_candidates +
+// submit_drafts, drafts from the INLINE project_voices, improvises nothing, and
+// stops cleanly if its tools aren't available.
+function autopilotSkillMd(project) {
+    const body = [
+        `You are running the Social Autoposter draft-only autopilot for the project "${project}". ` +
+            `Run ONE cycle, then stop. DRAFT-ONLY: you must NEVER post to X/Twitter — you only queue ` +
+            `drafts for the user's approval. Use ONLY two tools — scan_candidates and submit_drafts — ` +
+            `and IMPROVISE NOTHING ELSE.`,
+        ``,
+        `Steps:`,
+        `1. Call scan_candidates with project "${project}". It long-polls: if it returns a "Scan in ` +
+            `progress" status, call scan_candidates again (same args) and keep re-calling until it ` +
+            `returns candidates. Never sleep or use background waits. If it returns no candidates, stop ` +
+            `cleanly — nothing to do this cycle.`,
+        `2. The result includes a project_voices field — the brand voice + guardrails for each ` +
+            `candidate's project. Draft from project_voices[<matched_project>] (voice, description, ` +
+            `differentiator, content_guardrails). NEVER read config files, call project_config, or run ` +
+            `Bash/Read to find the voice — everything you need is already in the scan result.`,
+        `3. For each candidate you judge genuinely worth engaging, write ONE on-brand reply (<=250 ` +
+            `chars, match the thread's language, genuinely helpful — not spammy, no hard selling). Skip ` +
+            `the rest.`,
+        `4. Call submit_drafts with the batch_id from scan_candidates and a drafts array of ` +
+            `{candidate_id, reply_text}. This queues them for the menu-bar approval UI. Do NOT call ` +
+            `post_drafts — posting is the user's decision.`,
+        ``,
+        `HARD GUARD: if scan_candidates is NOT available (ToolSearch returns no matching tool — can ` +
+            `happen when a run spawns before the extension's MCP server has reconnected), STOP immediately ` +
+            `and report "S4L tools unavailable, skipping this cycle." Do NOT search the connector registry, ` +
+            `do NOT call list_connectors, do NOT improvise any other tool.`,
+    ].join("\n");
+    return (`---\n` +
+        `name: ${AUTOPILOT_TASK_ID}\n` +
+        `description: Social Autoposter draft-only autopilot for project ${project} — scans X, drafts ` +
+        `on-brand replies (voice inline), queues them for approval. Never posts.\n` +
+        `---\n\n` +
+        body +
+        `\n\n<!-- ${AUTOPILOT_PROMPT_MARKER}: ${AUTOPILOT_PROMPT_VERSION} -->\n`);
+}
+// Read the project name back from an existing autopilot SKILL.md so a rewrite
+// keeps the same project. Null if it can't be determined (then leave it alone).
+function detectAutopilotProject(skillMd) {
+    const m1 = /project[s]?\s+"([^"]+)"/i.exec(skillMd);
+    if (m1)
+        return m1[1];
+    const m2 = /for project\s+([A-Za-z0-9_-]+)/i.exec(skillMd);
+    if (m2)
+        return m2[1];
+    return null;
+}
+// Refresh the scheduled task's SKILL.md when this build ships a newer prompt than
+// what's on disk. Best-effort, synchronous, never throws. Only touches an EXISTING
+// task (onboarding creates the first one), only when stale, and only when the
+// project reads back, so we never write a wrong/blank project.
+function ensureAutopilotPromptCurrent() {
+    try {
+        const skillPath = autopilotSkillPath();
+        if (!fs.existsSync(skillPath))
+            return; // no scheduled task yet
+        const cur = fs.readFileSync(skillPath, "utf-8");
+        const m = new RegExp(`${AUTOPILOT_PROMPT_MARKER}:\\s*(\\d+)`).exec(cur);
+        const curVer = m ? parseInt(m[1], 10) : 0;
+        if (curVer >= AUTOPILOT_PROMPT_VERSION)
+            return; // already current
+        const project = detectAutopilotProject(cur);
+        if (!project) {
+            console.error(`[autopilot] prompt is stale (v${curVer}) but project unreadable from SKILL.md; leaving it`);
+            return;
+        }
+        fs.writeFileSync(skillPath, autopilotSkillMd(project), "utf-8");
+        console.error(`[autopilot] refreshed scheduled-task prompt -> v${AUTOPILOT_PROMPT_VERSION} (was v${curVer}), project=${project}`);
+    }
+    catch (e) {
+        console.error(`[autopilot] ensureAutopilotPromptCurrent error: ${e?.message || e}`);
+    }
+}
 // Assemble everything the panel needs in one shot (projects + X + autopilot +
 // version). Resilient: any probe that throws degrades to a safe default rather
 // than failing the whole snapshot.
@@ -2261,6 +2351,11 @@ async function main() {
     // disk, BEFORE serving, so the very first scan uses the shipped pipeline (not
     // the version first materialized at install). Synchronous + best-effort.
     ensurePipelineCurrent();
+    // Same problem for the scheduled task's prompt: the host owns its SKILL.md and
+    // a plugin update never touches it. Rewrite it on boot when this build ships a
+    // newer prompt version, so behavior changes (no-improvise / voice-inline /
+    // stop-cleanly) reach an already-scheduled task on its next fire. Best-effort.
+    ensureAutopilotPromptCurrent();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`[social-autoposter-mcp] connected. v=${VERSION} repo=${repoDir()}`);

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.80",
-  "installedAt": "2026-06-22T19:14:04.032Z"
+  "version": "1.6.82",
+  "installedAt": "2026-06-22T21:04:08.350Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.80",
+  "version": "1.6.82",
   "description": "Draft, review, approve, and autopilot X/Twitter posts. Thin desktop client over the S4L pipeline.",
   "long_description": "A guided assistant that drafts, reviews, and autopilots X/Twitter posts.\nTo get started:\n1. Click **Configure** and set every tool permission to **Always Allow**.\n2. Copy this prompt: **Set me up on S4L end to end**.\n3. Quit fully with CMD+Q, restart Claude, and paste the prompt into a new chat.",
   "author": {

package/mcp/menubar/s4l_menubar.py

@@ -47,7 +47,6 @@ SETUP_PROMPT = (
     "must interactively sign in or no product can be identified."
 )
 DRAFT_PROMPT = "Run a social-autoposter draft cycle and show me the drafts to review."
-POST_PROMPT = "Post my approved social-autoposter drafts."
 UPDATE_PROMPT = "Update social-autoposter to the latest version."
 
 
@@ -97,7 +96,13 @@ class S4LMenuBar(rumps.App):
         self._last_blocker_code = None
         self._sig = None  # last rendered state signature; skip rebuild if unchanged
         self._review_active = False  # a review-card sequence is on screen
-        self._reviewed_batches = set()  # batch_ids already handled this run
+        # Signature of the pending drafts last presented. We de-dup on the CONTENT
+        # of the pending set, NOT on the batch_id: the server intentionally reuses
+        # a constant batch_id ("review-queue") so a continuous autopilot's drafts
+        # accumulate into one queue. Keying de-dup on that constant suppressed every
+        # later batch for the life of this process (only a restart cleared it),
+        # which is exactly the "drafts queued but no cards" bug.
+        self._last_review_sig = None
         self._spin_i = 0
         self._spinner = None  # fast rumps.Timer animating the title while busy
         # Reliable self-check of our own Accessibility (TCC) grant — this is the
@@ -177,9 +182,6 @@ class S4LMenuBar(rumps.App):
     def _draft(self, _=None):
         self._send_to_claude(DRAFT_PROMPT)
 
-    def _post(self, _=None):
-        self._send_to_claude(POST_PROMPT)
-
     def _update(self, _=None):
         self._send_to_claude(UPDATE_PROMPT)
 
@@ -313,8 +315,13 @@ class S4LMenuBar(rumps.App):
         act = st.read_activity()
         label = act.get("label") if act else None
         if label:
-            self._spin_i = (self._spin_i + 1) % len(SPINNER)
-            self.title = f"S4L {label} {SPINNER[self._spin_i]}"
+            # A "✓" label (e.g. "posted 3/10 ✓") is a momentary confirmation, not
+            # ongoing work — show it without the spinner glyph so it reads as done.
+            if "✓" in label:
+                self.title = f"S4L {label}"
+            else:
+                self._spin_i = (self._spin_i + 1) % len(SPINNER)
+                self.title = f"S4L {label} {SPINNER[self._spin_i]}"
             return
         try:
             if self._spinner is not None:
@@ -391,24 +398,35 @@ class S4LMenuBar(rumps.App):
         if not req:
             return
         batch = req.get("batch_id")
-        if not batch or batch in self._reviewed_batches:
+        if not batch:
             return
         plan = st.read_plan(req.get("plan_path") or "")
         drafts = st.review_drafts(plan)
         # Nothing left to review (empty, missing plan, or all already posted via
-        # the chat surface) — mark handled and clear the signal.
+        # the chat surface) — clear the signal and reset the signature so a future
+        # batch is presented fresh.
         if not drafts:
-            self._reviewed_batches.add(batch)
+            self._last_review_sig = None
             st.clear_review_request()
             return
+        # De-dup on the CONTENT of the pending set (each draft's plan index + reply
+        # text), not the constant batch_id. This means: re-present whenever NEW
+        # drafts arrive (the signature changes), but don't re-pop the identical
+        # cards we already showed for this same pending set. No restart is ever
+        # needed for new pending drafts to surface.
+        sig = tuple((d.get("n"), d.get("reply_text") or "") for d in drafts)
+        if sig == self._last_review_sig:
+            return
         self._review_active = True
-        self._reviewed_batches.add(batch)
         try:
             import s4l_card
 
             s4l_card.present_review(
                 drafts, lambda decisions: self._on_review_done(batch, decisions)
             )
+            # Record as shown only AFTER the cards are actually up, so a transient
+            # card-UI failure never permanently suppresses this pending set.
+            self._last_review_sig = sig
         except Exception as e:
             # Card UI unavailable — don't strand the batch; chat review still works.
             self._review_active = False
@@ -572,9 +590,10 @@ class S4LMenuBar(rumps.App):
         out.append(
             rumps.MenuItem("Run draft cycle in Claude", callback=self._draft)
         )
-        out.append(
-            rumps.MenuItem("Post approved drafts in Claude", callback=self._post)
-        )
+        # No "Post approved drafts" item: approving a review card already posts
+        # directly + programmatically (_on_review_done -> st.post_drafts -> the
+        # CDP poster). A menu button that types a prompt into the chat to do the
+        # same thing was a redundant detour through the model, so it's gone.
         return out
 
 

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.80",
+  "version": "1.6.82",
   "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": "social-autoposter",
-  "version": "1.6.80",
+  "version": "1.6.82",
   "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/twitter_post_plan.py

@@ -45,6 +45,7 @@ import random
 import re
 import subprocess
 import sys
+import time
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -845,6 +846,39 @@ def post_one(c: dict, picker_assignment: dict | None = None) -> tuple[str, str]:
     return ("posted", "")
 
 
+def _saps_state_dir() -> str:
+    return os.environ.get("SAPS_STATE_DIR") or os.path.join(
+        os.path.expanduser("~"), ".social-autoposter-mcp")
+
+
+def _write_activity(label: str) -> None:
+    """Best-effort live status for the S4L menu bar, which polls
+    <state_dir>/activity.json. Mirrors the Node server's writeActivity shape so
+    the menu-bar spinner renders our per-post progress ("posting 3/10", then
+    "posted 3/10 ✓"). Purely cosmetic: a failure here never affects posting."""
+    try:
+        sd = _saps_state_dir()
+        os.makedirs(sd, exist_ok=True)
+        payload = {"state": "working", "label": label,
+                   "since": datetime.now(timezone.utc).isoformat()}
+        with open(os.path.join(sd, "activity.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps(payload) + "\n")
+    except Exception:
+        pass
+
+
+def _clear_activity() -> None:
+    """Remove our status so neither an early exit nor the cron path (which does
+    NOT go through the MCP runTool's clear) leaves a stale 'posting/posted' stuck
+    in the menu bar. Double-clearing with runTool is harmless."""
+    try:
+        p = os.path.join(_saps_state_dir(), "activity.json")
+        if os.path.exists(p):
+            os.remove(p)
+    except Exception:
+        pass
+
+
 def main() -> int:
     ap = argparse.ArgumentParser()
     ap.add_argument("--plan", required=True,
@@ -924,26 +958,37 @@ def main() -> int:
                   f"approved in plan (pass --post-unapproved to override)", flush=True)
         candidates = _kept
 
-    for c in candidates:
-        try:
-            outcome, reason = post_one(c, picker_assignment=picker_assignment)
-        except Exception as e:
-            print(f"[post] candidate {c.get('candidate_id')} crashed: {e}",
-                  flush=True)
-            outcome, reason = ("failed", "exception")
-            cid = c.get("candidate_id")
-            if isinstance(cid, int):
-                update_candidate(cid, "skipped", "exception")
-        if outcome == "posted":
-            posted += 1
-        elif outcome == "skipped":
-            skipped += 1
-            if reason:
-                skip_reasons[reason] = skip_reasons.get(reason, 0) + 1
-        else:
-            failed += 1
-            if reason:
-                fail_reasons[reason] = fail_reasons.get(reason, 0) + 1
+    _total = len(candidates)
+    try:
+        for _idx, c in enumerate(candidates, start=1):
+            # Live per-post status for the S4L menu bar: "posting 3/10" while this
+            # one is in flight, then "posted 3/10 ✓" once it lands. Cosmetic only.
+            _write_activity(f"posting {_idx}/{_total}")
+            try:
+                outcome, reason = post_one(c, picker_assignment=picker_assignment)
+            except Exception as e:
+                print(f"[post] candidate {c.get('candidate_id')} crashed: {e}",
+                      flush=True)
+                outcome, reason = ("failed", "exception")
+                cid = c.get("candidate_id")
+                if isinstance(cid, int):
+                    update_candidate(cid, "skipped", "exception")
+            if outcome == "posted":
+                posted += 1
+                # Flash the confirmation with a short dwell so the menu bar shows
+                # it before the next iteration's "posting" overwrites the label.
+                _write_activity(f"posted {_idx}/{_total} ✓")
+                time.sleep(0.6)
+            elif outcome == "skipped":
+                skipped += 1
+                if reason:
+                    skip_reasons[reason] = skip_reasons.get(reason, 0) + 1
+            else:
+                failed += 1
+                if reason:
+                    fail_reasons[reason] = fail_reasons.get(reason, 0) + 1
+    finally:
+        _clear_activity()
 
     summary = {
         "posted": posted,