@m13v/s4l 1.7.5-rc.2 → 1.7.5-rc.21

package/mcp/menubar/s4l_state.py

@@ -48,7 +48,11 @@ except Exception:
 # both mutate it; without this a concurrent interleave would drop an approval.
 _approved_lock = threading.Lock()
 
-# Mirrors shared/onboarding-ledger.cjs MILESTONES (same order).
+# Mirrors shared/onboarding-ledger.cjs MILESTONES (same order). The ledger's
+# OPTIONAL milestones (reddit_connected / reddit_verified) are deliberately NOT
+# listed here, same as x_verified: this list drives the offline completeness
+# check and the step list, and optional platform milestones must never make an
+# X-only box read as "Setting up".
 MILESTONES = [
     "environment_checked",
     "runtime_ready",
@@ -60,7 +64,8 @@ MILESTONES = [
     "tasks_scheduled",
 ]
 
-# Mirrors panel.ts MILESTONE_LABELS.
+# Mirrors panel.ts MILESTONE_LABELS. Includes labels for optional milestones so
+# server-snapshot rows (which include them once touched) render nicely.
 MILESTONE_LABELS = {
     "environment_checked": "Environment checked",
     "runtime_ready": "Runtime ready",
@@ -70,6 +75,8 @@ MILESTONE_LABELS = {
     "project_ready": "Project ready",
     "topics_seeded": "Topics seeded",
     "tasks_scheduled": "Tasks scheduled",
+    "reddit_connected": "Reddit connected",
+    "reddit_verified": "Reddit verified",
 }
 
 # Mirrors index.ts TWITTER_AUTOPILOT_LABEL.
@@ -190,14 +197,49 @@ def read_onboarding():
                 return "complete"
         return st
 
+    # Any-of platform completion (mirror of onboarding-ledger.cjs
+    # milestoneSatisfied, 2026-07-15): a reddit-only install must read complete.
+    # x_connected also counts when reddit_connected is complete, and
+    # profile_scanned (an X-account scan) is required only while X is the
+    # connected platform. reddit_* ids are read straight from the raw ledger
+    # dict; they are deliberately not in MILESTONES (optional, never gating).
+    def _satisfied(mid):
+        if _status(mid) == "complete":
+            return True
+        reddit_done = (ms.get("reddit_connected") or {}).get("status") == "complete"
+        if mid == "x_connected":
+            return reddit_done
+        if mid == "profile_scanned":
+            return _status("x_connected") != "complete" and reddit_done
+        return False
+
+    # Omit pristine-pending rows the other platform satisfies (reddit-only
+    # install: x_connected / profile_scanned), and append touched optional
+    # reddit rows, mirroring the server snapshot's row filtering.
     milestones = [
-        {"id": mid, **(ms.get(mid) or {}), "status": _status(mid)} for mid in MILESTONES
+        {"id": mid, **(ms.get(mid) or {}), "status": _status(mid)}
+        for mid in MILESTONES
+        if not (_status(mid) in (None, "pending") and _satisfied(mid))
     ]
-    complete = all(_status(mid) == "complete" for mid in MILESTONES)
+    for mid in ("reddit_connected", "reddit_verified"):
+        st = (ms.get(mid) or {}).get("status")
+        if st and st != "pending":
+            milestones.append({"id": mid, **(ms.get(mid) or {}), "optional": True})
+    complete = all(_satisfied(mid) for mid in MILESTONES)
+    # Blocker suppression, mirror of the server snapshot: a blocker on an
+    # optional reddit milestone or on a milestone the other platform satisfies
+    # must not flag attention.
+    blocker = d.get("current_blocker")
+    if blocker:
+        bmid = blocker.get("milestone")
+        if bmid in ("reddit_connected", "reddit_verified"):
+            blocker = None
+        elif bmid in MILESTONES and _satisfied(bmid):
+            blocker = None
     return {
         "complete": complete,
         "milestones": milestones,
-        "current_blocker": d.get("current_blocker"),
+        "current_blocker": blocker,
     }
 
 
@@ -209,15 +251,6 @@ def runtime_ready() -> bool:
     return bool(py and os.path.exists(py))
 
 
-def _launchctl_list() -> str:
-    try:
-        return subprocess.run(
-            ["launchctl", "list"], capture_output=True, text=True, timeout=10
-        ).stdout
-    except Exception:
-        return ""
-
-
 def autopilot_loaded() -> bool:
     # Autopilot is now the Claude Desktop scheduled task, not the legacy launchd job.
     cfg = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.join(str(Path.home()), ".claude")
@@ -456,23 +489,6 @@ def snapshot():
     return out
 
 
-def stats_7d():
-    """7-day post stats; loopback only (the DB read needs the owned runtime)."""
-    res = loopback_tool("get_stats", {"days": 7})
-    if not isinstance(res, dict):
-        return None
-    projects = res.get("projects")
-    proj = projects[0] if isinstance(projects, list) and projects else None
-    p = (proj or {}).get("posts")
-    if not p:
-        return None
-    return {
-        "posts": p.get("total", 0),
-        "views": p.get("views_period_total", p.get("views", 0)),
-        "replies": p.get("comments_period_total", p.get("comments", 0)),
-    }
-
-
 # set_autopilot() (the launchd toggle) was removed: the autopilot is now the Claude
 # Desktop scheduled task `social-autoposter-autopilot`, managed in the Scheduled tab,
 # so the menu bar no longer toggles a launchd job (it mirrors the dashboard instead).
@@ -498,51 +514,6 @@ def accessibility_trusted() -> bool:
         return False
 
 
-def request_accessibility() -> bool:
-    """Pop the system Accessibility prompt for THIS process (registers it in the
-    list so the user can toggle it on) and open the Settings pane. Returns the
-    current trust state. Safe to call when already trusted (no prompt shown)."""
-    trusted = False
-    try:
-        import ctypes
-        import ctypes.util
-
-        cf = ctypes.cdll.LoadLibrary(ctypes.util.find_library("CoreFoundation"))
-        ap = ctypes.cdll.LoadLibrary(ctypes.util.find_library("ApplicationServices"))
-        prompt_key = ctypes.c_void_p.in_dll(ap, "kAXTrustedCheckOptionPrompt")
-        cf_true = ctypes.c_void_p.in_dll(cf, "kCFBooleanTrue")
-        cf.CFDictionaryCreate.restype = ctypes.c_void_p
-        cf.CFDictionaryCreate.argtypes = [
-            ctypes.c_void_p,
-            ctypes.POINTER(ctypes.c_void_p),
-            ctypes.POINTER(ctypes.c_void_p),
-            ctypes.c_long,
-            ctypes.c_void_p,
-            ctypes.c_void_p,
-        ]
-        keys = (ctypes.c_void_p * 1)(prompt_key)
-        vals = (ctypes.c_void_p * 1)(cf_true)
-        d = cf.CFDictionaryCreate(None, keys, vals, 1, None, None)
-        ap.AXIsProcessTrustedWithOptions.restype = ctypes.c_bool
-        ap.AXIsProcessTrustedWithOptions.argtypes = [ctypes.c_void_p]
-        trusted = bool(ap.AXIsProcessTrustedWithOptions(d))
-    except Exception:
-        pass
-    try:
-        subprocess.run(
-            [
-                "open",
-                "x-apple.systempreferences:com.apple.preference.security"
-                "?Privacy_Accessibility",
-            ],
-            capture_output=True,
-            timeout=10,
-        )
-    except Exception:
-        pass
-    return trusted
-
-
 # ---- draft review (pop-up cards) ------------------------------------------
 # draft_cycle writes review-request.json when a fresh batch is ready; we read
 # the linked plan file (the /tmp/twitter_cycle_plan_<batch>.json the pipeline
@@ -1028,8 +999,9 @@ def review_drafts(plan, batch="review-queue"):
     must never be re-presented for review (approved ones proceed to post).
 
     Also excludes cards with ANY durable decision (approved, edited, rejected, or a
-    decided-but-failed post) via review_settled_ns(). approve/reject/edit are now
-    IDENTICAL: each writes a durable local record the INSTANT the user clicks, so a
+    decided-but-failed post) via _ledger_items_for_plan() below. approve/reject/edit
+    each write a durable local record via store_stamp_decision() the INSTANT the
+    user clicks (see s4l_menubar.py::_on_card_decision), so a
     decided card never re-presents even if the loopback (Claude Desktop) is down
     when the decision's plan-flag write is attempted. The main plan's
     `approved`/`terminal`/`posted` flags are only stamped once the loopback write
@@ -1055,6 +1027,10 @@ def review_drafts(plan, batch="review-queue"):
         out.append(
             {
                 "n": i + 1,  # 1-based, matches post_drafts numbering
+                # Platform tag (reddit cards, 2026-07-14): absent/None means
+                # twitter (every plan written before the field shipped). The
+                # card renders the platform mark and profile link from this.
+                "platform": c.get("platform"),
                 "thread_author": c.get("thread_author"),
                 "thread_text": c.get("thread_text"),
                 "reply_text": c.get("reply_text") or "",
@@ -1183,13 +1159,6 @@ def read_flags():
     return dict(_DEFAULT_FLAGS)
 
 
-def read_mode():
-    """Derived legacy single-mode string (personal_brand wins when on). Kept so
-    older menu-bar callers that expect one value keep working."""
-    f = read_flags()
-    return MODE_PERSONAL_BRAND if f.get("personal_brand") else MODE_PROMOTION
-
-
 def write_flags(personal_brand, promotion):
     """Persist both lane flags atomically (plus the derived legacy `mode`).
 
@@ -1363,16 +1332,6 @@ def write_posting_mode(mode):
     return stored
 
 
-def write_mode(mode):
-    """Legacy single-mode setter: named lane ON, the other OFF (compat)."""
-    if mode not in _VALID_MODES:
-        return read_flags()
-    return write_flags(
-        personal_brand=(mode == MODE_PERSONAL_BRAND),
-        promotion=(mode == MODE_PROMOTION),
-    )
-
-
 def toggle_lane(lane):
     """Flip ONE lane (personal_brand|promotion) and return the new flags."""
     if lane not in _VALID_MODES:
@@ -1382,75 +1341,6 @@ def toggle_lane(lane):
     return write_flags(f["personal_brand"], f["promotion"])
 
 
-def toggle_mode():
-    """Legacy whole-mode flip (mutually exclusive). Kept for old callers."""
-    new = (
-        MODE_PROMOTION
-        if read_mode() == MODE_PERSONAL_BRAND
-        else MODE_PERSONAL_BRAND
-    )
-    return write_mode(new)
-
-
-def review_reject_add(batch, n, candidate_id=None):
-    """Record a REJECT the INSTANT the user clicks, mirroring approved_queue_add.
-    Reject and approve are now IDENTICAL: both write a durable local record before
-    any loopback call, so review_drafts() suppresses the card even if the loopback
-    (Claude Desktop) is down when the reject's plan `terminal` write is attempted.
-    Dedups on (batch, n) within the CURRENT plan generation (a stale item's n
-    refers to a dead plan and must not absorb this decision); a reject is FINAL
-    and overrides any earlier status."""
-    with _approved_lock:
-        gen = _plan_generation(batch)
-        d = read_approved_queue()
-        for it in d["items"]:
-            if it.get("batch") == batch and it.get("n") == n and not _stale_for_plan(it, gen):
-                if it.get("status") != "rejected":
-                    it.update(status="rejected", error=None, ts=time_iso())
-                    _write_approved_queue(d)
-                return
-        d["items"].append({
-            "batch": batch, "n": n, "candidate_id": candidate_id,
-            "text": "", "edited": False,
-            "drop_link": False, "candidate_url": "", "status": "rejected",
-            "error": None, "ts": time_iso(),
-        })
-        _write_approved_queue(d)
-
-
-def approved_queue_add(batch, n, text="", edited=False, candidate_url="", drop_link=False,
-                       candidate_id=None):
-    """Record an approval the INSTANT the user clicks, before any posting. Dedups
-    on (batch, n) within the CURRENT plan generation: re-approving a card that's
-    still queued/posting/posted is a no-op; a previously FAILED card is reset to
-    queued so it retries. A stale item (previous plan generation, same n) must
-    not absorb the approval or the fresh card would silently never post.
-
-    candidate_id is the durable identity of the decision (twitter_candidates
-    row); n is only meaningful within one plan generation.
-
-    drop_link carries the user's "I deleted the link while editing" intent so a
-    restart-resumed post honors it too (else the poster re-appends the link)."""
-    with _approved_lock:
-        gen = _plan_generation(batch)
-        d = read_approved_queue()
-        for it in d["items"]:
-            if it.get("batch") == batch and it.get("n") == n and not _stale_for_plan(it, gen):
-                if it.get("status") == "failed":
-                    it.update(status="queued", text=text, edited=bool(edited),
-                              drop_link=bool(drop_link), error=None, ts=time_iso())
-                    _write_approved_queue(d)
-                return
-        d["items"].append({
-            "batch": batch, "n": n, "candidate_id": candidate_id,
-            "text": text, "edited": bool(edited),
-            "drop_link": bool(drop_link),
-            "candidate_url": candidate_url, "status": "queued",
-            "error": None, "ts": time_iso(),
-        })
-        _write_approved_queue(d)
-
-
 def approved_queue_set_status(batch, n, status, error=None):
     with _approved_lock:
         d = read_approved_queue()
@@ -1470,29 +1360,6 @@ def approved_queue_pending():
             if it.get("status") in ("queued", "posting")]
 
 
-def approved_queue_active_ns(batch):
-    """Plan indices the user has already approved for this batch — review_drafts()
-    excludes these so an approved card is never re-shown. Covers queued/posting
-    (in flight) AND posted: relying on the plan's posted flag alone leaves a window
-    (and breaks if the plan is regenerated), so the durable queue excludes posted
-    cards independently. `failed` is intentionally NOT excluded, so a failed post
-    falls back to manual review rather than silently vanishing."""
-    gen = _plan_generation(batch)
-    return {it.get("n") for it in read_approved_queue()["items"]
-            if it.get("batch") == batch and it.get("status") in ("queued", "posting", "posted")
-            and not _stale_for_plan(it, gen)}
-
-
-def review_settled_ns(batch):
-    """Plan indices with ANY durable user DECISION for this batch — review_drafts()
-    excludes these so approve, edit, and reject behave IDENTICALLY: a decided card
-    never re-presents for review. Covers queued/posting/posted (approved, in flight
-    or landed), `rejected`, AND `failed` (a decided-but-failed post is surfaced via
-    the failure notification + dashboard, NOT by re-showing it as a fresh review
-    card — that re-show was the "I already decided these came back" bug)."""
-    return {it.get("n") for it in _ledger_items_for_plan(batch, _plan_generation(batch))}
-
-
 def post_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, timeout=900, activity_label=None):
     """Post / reject drafts via the loopback tool. `post` = 1-based numbers to post
     as-is; `edits` = [{n, text}] to rewrite then post; `reject` = numbers to mark

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.5-rc.2",
+  "version": "1.7.5-rc.21",
   "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/mcp/shared/onboarding-ledger.cjs

@@ -16,8 +16,38 @@ const MILESTONES = [
   "project_ready",
   "topics_seeded",
   "tasks_scheduled",
+  // Optional platform add-ons (see OPTIONAL_MILESTONES below). Listed here so
+  // assertMilestone/appendEvent accept them, but they never gate `complete`.
+  "reddit_connected",
+  "reddit_verified",
 ];
 
+// Milestones that are offered but NOT required for onboarding completion.
+// Reddit is an optional platform: most installs never connect it, and adding
+// these ids must never regress an already-complete (or fresh X-only) box back
+// to "Setting up". publicSnapshot() therefore (a) excludes these from the
+// `complete` computation and (b) omits them from the milestones array while
+// they are still pristine "pending" (so progress bars and step lists are
+// unchanged for installs that never touch reddit); the same
+// never-regress-legacy-ledgers principle as the mode_chosen backfill.
+const OPTIONAL_MILESTONES = ["reddit_connected", "reddit_verified"];
+
+// Any-of platform completion (2026-07-15, user requirement): onboarding is
+// complete with AT LEAST ONE platform connected. X stays the default first
+// suggestion, but a Reddit-only install must read complete. A required
+// X milestone therefore also counts as satisfied when its Reddit counterpart
+// is complete; profile_scanned (an X-account scan) is required only while X is
+// the connected platform. Same never-regress principle as the mode_chosen
+// backfill: X-only and fresh ledgers evaluate exactly as before.
+function milestoneSatisfied(ledger, id) {
+  const done = (m) => ledger.milestones[m] && ledger.milestones[m].status === "complete";
+  if (done(id)) return true;
+  if (id === "x_connected") return done("reddit_connected");
+  if (id === "x_verified") return done("reddit_verified");
+  if (id === "profile_scanned") return !done("x_connected") && done("reddit_connected");
+  return false;
+}
+
 function stateDir(opts = {}) {
   return (
     opts.stateDir ||
@@ -283,14 +313,42 @@ function publicSnapshot(opts = {}) {
     schema_version: ledger.schema_version,
     started_at: ledger.started_at,
     updated_at: ledger.updated_at,
-    complete: MILESTONES.every(
-      (id) => ledger.milestones[id].status === "complete"
+    // Optional milestones (reddit) never gate completion, and required X
+    // milestones count as satisfied via their Reddit counterpart (any-of
+    // platform completion; see milestoneSatisfied above).
+    complete: MILESTONES.filter((id) => !OPTIONAL_MILESTONES.includes(id)).every(
+      (id) => milestoneSatisfied(ledger, id)
     ),
-    milestones: MILESTONES.map((id) => ({
+    // Row filtering, two rules with one goal (the step list shows only steps
+    // that apply to THIS install):
+    //   - optional milestones appear only once touched (attempted/completed/
+    //     blocked); a pristine pending optional row would read as an
+    //     unfinished setup step on installs that never opted in.
+    //   - a required milestone that is still pristine-pending but satisfied
+    //     via the other platform (reddit-only install: x_connected,
+    //     x_verified, profile_scanned) is omitted as not-applicable. A
+    //     blocked/in_progress row stays visible: the user actually tried it.
+    milestones: MILESTONES.filter((id) => {
+      const status = ledger.milestones[id].status;
+      if (OPTIONAL_MILESTONES.includes(id)) return status !== "pending";
+      if (status === "pending" && milestoneSatisfied(ledger, id)) return false;
+      return true;
+    }).map((id) => ({
       id,
       ...ledger.milestones[id],
+      ...(OPTIONAL_MILESTONES.includes(id) ? { optional: true } : {}),
     })),
-    current_blocker: ledger.current_blocker,
+    // Blocker suppression: a blocker on an OPTIONAL milestone (a failed
+    // reddit connect attempt on an X box) or on a milestone satisfied via the
+    // other platform (a failed X attempt on a reddit-only box) must not flag
+    // the setup as needing attention. The raw blocker stays in the ledger for
+    // history; only the reported snapshot hides it.
+    current_blocker:
+      ledger.current_blocker &&
+      (OPTIONAL_MILESTONES.includes(ledger.current_blocker.milestone) ||
+        milestoneSatisfied(ledger, ledger.current_blocker.milestone))
+        ? null
+        : ledger.current_blocker,
     doctor: ledger.doctor.latest
       ? {
           phase: ledger.doctor.latest.phase,
@@ -311,6 +369,7 @@ function publicSnapshot(opts = {}) {
 
 module.exports = {
   MILESTONES,
+  OPTIONAL_MILESTONES,
   blockMilestone,
   completeMilestone,
   ledgerPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.5-rc.2",
+  "version": "1.7.5-rc.21",
   "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

@@ -281,8 +281,8 @@ def _oldest_running_age() -> float | None:
     """Seconds since the oldest CLAIMED-but-unfinished job was written, or None if
     nothing is in flight. A worker claims by moving a job pending/ -> running/ and
     only removes it on result, so a job lingering in running/ far past any real
-    drafting turn means the worker claimed it and then wedged mid-run (dead/never-
-    spawned claude -p child). This is the ONLY signal for that case: pending-age is
+    drafting turn means the worker claimed it and then wedged mid-run.
+    This is the ONLY signal for that case: pending-age is
     silent (the job left pending/) and the producer's drain latch hasn't fired yet
     (it's still inside its own timeout). running/ is flat (see claude_job.py)."""
     run_root = os.path.join(_queue_root(), "running")
@@ -521,10 +521,7 @@ def main() -> int:
                 sentry = _sentry()
                 sentry.init()
                 if wedged_inflight:
-                    cause = (
-                        "a worker claimed a draft job and then died mid-run (claude -p child "
-                        "never came up / crashed)"
-                    )
+                    cause = "a worker claimed a draft job and then died mid-run"
                     stall_shape = "inflight_wedged"
                 elif batches_stuck:
                     cause = (