@m13v/s4l 1.7.7-rc.6 → 1.7.7-rc.7

package/mcp/dist/repo.js

@@ -211,7 +211,9 @@ export function readPlan(batchId) {
     }
 }
 export function writePlan(batchId, plan) {
-    fs.writeFileSync(planPath(batchId), JSON.stringify(plan, null, 2), "utf-8");
+    // Compact (no indent): the review store reached 65 MB with pretty-printing
+    // (2026-08-02 lag incident) and every reader pays the parse.
+    fs.writeFileSync(planPath(batchId), JSON.stringify(plan), "utf-8");
 }
 // Find the newest plan file when no batch id is supplied.
 export function latestBatchId() {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.7-rc.6",
-  "installedAt": "2026-07-31T23:52:05.555Z"
+  "version": "1.7.7-rc.7",
+  "installedAt": "2026-08-02T22:02:14.223Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.7-rc.6",
+  "version": "1.7.7-rc.7",
   "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_menubar.py

@@ -27,6 +27,20 @@ import sys
 import tempfile
 import threading
 import time
+import warnings
+
+# PyObjC emits an ObjCPointerWarning for every CGColor() handed to a CALayer
+# (s4l_card's tile styling). The message embeds the pointer address, so the
+# warnings module's once-per-location dedup never matches and a single card
+# render sprayed ~100 lines/sec into menubar.err.log (13k+ lines by the
+# 2026-08-02 lag incident). The pointers are handled correctly; silence the
+# category before any card module loads.
+try:
+    import objc
+
+    warnings.filterwarnings("ignore", category=objc.ObjCPointerWarning)
+except Exception:
+    pass
 
 # --- stderr timestamp wrapper -------------------------------------------------
 # menubar.err.log (this process's stderr, redirected by the launchd plist) has
@@ -715,8 +729,28 @@ class S4LMenuBar(rumps.App):
         self._tick_stats_at = 0.0
         self._reloc_timer = rumps.Timer(self._maybe_relocate_tasks, 90)
         self._reloc_timer.start()
+        # Store compaction: archive heavy fields off settled candidates so the
+        # review-queue file (and every 1s/5s poll that parses it) stays small.
+        # Boot pass runs off the main thread — the first pass after an
+        # un-compacted stretch can chew through tens of MB.
+        self._compacted_at = 0.0
+        self._compact_store_async()
         self._tick(None)
 
+    def _compact_store_async(self):
+        self._compacted_at = time.time()
+
+        def run():
+            try:
+                n = st.compact_store()
+                if n:
+                    sys.stderr.write(f"[s4l-menubar] store compaction archived {n} candidate(s)\n")
+                    sys.stderr.flush()
+            except Exception:
+                pass
+
+        threading.Thread(target=run, daemon=True, name="s4l-compact-store").start()
+
     # ---- side effects -----------------------------------------------------
     def _open_claude(self, _=None):
         subprocess.run(["open", "-a", CLAUDE_APP], capture_output=True,
@@ -3009,6 +3043,10 @@ class S4LMenuBar(rumps.App):
                     sys.stderr.flush()
             except Exception:
                 pass
+        # Hourly store compaction keeps the review-queue file small as posts
+        # settle (boot already ran one pass; see _compact_store_async).
+        if now_rc - self._compacted_at >= 3600:
+            self._compact_store_async()
 
     # ---- draft review pop-ups ---------------------------------------------
     def _posting_activity_label_locked(self):

package/mcp/menubar/s4l_state.py

@@ -721,7 +721,9 @@ def _store_update(mutate):
                         data = {"candidates": []}
                     rv = mutate(data)
                     tmp = f"{sp}.tmp.{os.getpid()}"
-                    Path(tmp).write_text(json.dumps(data, indent=2))
+                    # Compact separators: this file reached 65 MB with indent=2
+                    # (2026-08-02 lag incident) and every reader pays the parse.
+                    Path(tmp).write_text(json.dumps(data, separators=(",", ":")))
                     os.replace(tmp, sp)
                     return rv
                 finally:
@@ -779,6 +781,97 @@ def candidate_state(c):
     return "awaiting_review"
 
 
+# Draft-time payloads that are only needed while a candidate can still POST
+# (awaiting_review: card rendering; approved/post_failed: the drain path
+# rebuilds a mini-plan from reddit_decision/reddit_plan_meta). Once a candidate
+# is posted or terminal these blobs are dead weight — and they dominated the
+# 65 MB store that caused the 2026-08-02 UI lag (single reddit candidates
+# carried ~180 KB). Compaction moves them to an append-only sidecar so the
+# append-forever ledger keeps every byte while the hot file stays small.
+HEAVY_ARCHIVE_FIELDS = ("reddit_plan_meta", "reddit_decision", "thread_selftext")
+
+# Audit-only blobs inside reddit_plan_meta.style_assignment, stamped by
+# engagement_styles.pick_style_for_post "for audit" and copied onto EVERY
+# reddit candidate by merge_review_queue. distribution_snapshot alone was
+# ~107 KB per candidate (7.6 MB across one pending backlog). Nothing on the
+# card-render or posting path reads them (post_reddit.py --phase post uses
+# only .style/.mode; index.ts forwards the dict opaquely), so they are safe
+# to archive off candidates in ANY state, pending included.
+STYLE_AUDIT_FIELDS = ("distribution_snapshot", "reference_styles")
+
+ARCHIVE_STORE = "review-queue-archive.jsonl"
+
+
+def compact_store():
+    """Archive heavy payloads out of the hot store into review-queue-archive
+    .jsonl, then rewrite the store compactly. Two passes over the candidates:
+    HEAVY_ARCHIVE_FIELDS come off SETTLED (posted/terminal) candidates only —
+    approved/post_failed rows still need reddit_decision/reddit_plan_meta for
+    a (re-)approval drain — while STYLE_AUDIT_FIELDS come off every candidate.
+    Runs under the same store lock as every other python writer. The archive
+    lines land (flush+fsync) BEFORE any field is stripped, so no data is ever
+    lost — a crash in between only risks a duplicate archive line, never a
+    missing one. Returns the number of candidates compacted (0 when there was
+    nothing to do), None on failure."""
+
+    ap = str(Path(state_dir()) / ARCHIVE_STORE)
+
+    def mutate(data):
+        records = []  # (candidate, archived-fields dict, strip callback)
+        for c in data.get("candidates") or []:
+            fields = {}
+            settled = candidate_state(c) in ("posted", "terminal")
+            if settled:
+                fields.update(
+                    {k: c[k] for k in HEAVY_ARCHIVE_FIELDS if c.get(k)}
+                )
+            sa = (c.get("reddit_plan_meta") or {}).get("style_assignment")
+            audit = (
+                {}
+                if (settled and "reddit_plan_meta" in fields) or not isinstance(sa, dict)
+                else {k: sa[k] for k in STYLE_AUDIT_FIELDS if sa.get(k)}
+            )
+            if audit:
+                fields["style_assignment_audit"] = audit
+
+            def strip(c=c, settled=settled, sa=sa, audit=audit):
+                if settled:
+                    for k in HEAVY_ARCHIVE_FIELDS:
+                        c.pop(k, None)
+                for k in audit:
+                    sa.pop(k, None)
+
+            if fields:
+                records.append((c, fields, strip))
+        if not records:
+            return 0
+        with open(ap, "a") as f:
+            for c, fields, _ in records:
+                f.write(
+                    json.dumps(
+                        {
+                            "candidate_id": c.get("candidate_id"),
+                            "our_url": c.get("our_url"),
+                            "thread_url": c.get("thread_url"),
+                            "archived_at": time_iso(),
+                            "fields": fields,
+                        },
+                        separators=(",", ":"),
+                    )
+                    + "\n"
+                )
+            f.flush()
+            os.fsync(f.fileno())
+        for c, fields, strip in records:
+            strip()
+            c["archived_fields"] = sorted(
+                set(c.get("archived_fields") or []) | set(fields)
+            )
+        return len(records)
+
+    return _store_update(mutate)
+
+
 def store_stamp_decision(batch, decision):
     """Write a card decision INTO the store the instant the user clicks. This is
     the durable record (the old approved-queue.json ledger is no longer
@@ -1001,13 +1094,22 @@ def store_reconcile_decisions(batch, decisions):
     return fixed
 
 
+# (path, mtime_ns, size) -> posted count. review_queue_posted_count() is on the
+# menubar's 1-second activity poll; without this cache that poll re-parsed the
+# whole store every tick, which saturated the AppKit main thread once the file
+# grew (2026-08-02: 65 MB, 98% CPU, multi-second card lag).
+_posted_count_cache = {"key": None, "count": None}
+
+
 def review_queue_posted_count():
     """Posts that have LANDED in the review-queue plan — the durable, cross-process
     truth. Independent of the menu bar's in-memory burst queue (which dies on a
     restart) and of WHICH process is posting (the menu bar worker, the autopilot,
     or a host agent draining via approve_drafts). Returns the posted count, or None
     when the plan can't be read. Drives the menu-bar posting indicator so progress
-    stays visible regardless of how the drain is driven."""
+    stays visible regardless of how the drain is driven. Cached on the plan
+    file's (mtime, size): the caller polls every second, the file changes only
+    when a writer lands."""
     plan_path = None
     req = read_review_request()
     if req:
@@ -1016,11 +1118,22 @@ def review_queue_posted_count():
         plan_path = store_path()
     if not Path(plan_path).exists():
         plan_path = "/tmp/twitter_cycle_plan_review-queue.json"
+    try:
+        stt = os.stat(plan_path)
+        cache_key = (os.path.realpath(plan_path), stt.st_mtime_ns, stt.st_size)
+    except OSError:
+        cache_key = None
+    if cache_key is not None and _posted_count_cache["key"] == cache_key:
+        return _posted_count_cache["count"]
     plan = read_plan(plan_path)
     cands = (plan or {}).get("candidates")
-    if not cands:
-        return None
-    return sum(1 for c in cands if candidate_state(c) == "posted")
+    count = None if not cands else sum(
+        1 for c in cands if candidate_state(c) == "posted"
+    )
+    if cache_key is not None:
+        _posted_count_cache["key"] = cache_key
+        _posted_count_cache["count"] = count
+    return count
 
 
 def review_drafts(plan, batch="review-queue"):

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.7-rc.6",
+  "version": "1.7.7-rc.7",
   "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.7.7-rc.6",
+  "version": "1.7.7-rc.7",
   "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/context_mining.py

@@ -304,13 +304,20 @@ SCHEMA = {
             "type": "array",
             "items": {
                 "type": "object",
-                "required": ["action", "text", "why", "source_session", "source_date"],
+                "required": [
+                    "action",
+                    "title",
+                    "story",
+                    "conclusion",
+                    "source_session",
+                    "source_date",
+                ],
                 "properties": {
                     "action": {"type": "string", "enum": ["add", "revise"]},
                     "revises_line": {"type": ["integer", "null"]},
-                    "text": {"type": "string"},
-                    "why": {"type": "string"},
-                    "quote": {"type": "string"},
+                    "title": {"type": "string"},
+                    "story": {"type": "string"},
+                    "conclusion": {"type": "string"},
                     "source_session": {"type": "string"},
                     "source_date": {"type": "string"},
                 },
@@ -320,6 +327,15 @@ SCHEMA = {
 }
 
 
+def corpus_entry(p: dict) -> str:
+    """Render one approved proposal as a single corpus line (numbering is
+    line-based, so the entry must not contain newlines)."""
+    story = " ".join((p.get("story") or "").split())
+    concl = " ".join((p.get("conclusion") or "").split())
+    title = " ".join((p.get("title") or "").split())
+    return f"{title}: {story} Conclusion: {concl}"
+
+
 def build_prompt(sessions: list[dict], pending_props: list[dict] | None = None) -> str:
     corpus_lines = read_corpus_lines()
     corpus_block = (
@@ -327,11 +343,15 @@ def build_prompt(sessions: list[dict], pending_props: list[dict] | None = None)
         if corpus_lines
         else "(the corpus is currently empty)"
     )
+    def _gist(r: dict) -> str:
+        # works for both the old one-line shape (text) and the story shape
+        return r.get("text") or f"{r.get('title', '')}: {r.get('conclusion', '')}"
+
     considered = [
-        {"status": r.get("status"), "text": r.get("text", "")} for r in read_ledger()[-60:]
-    ] + [{"status": "pending", "text": p.get("text", "")} for p in (pending_props or [])]
+        {"status": r.get("status"), "gist": _gist(r)} for r in read_ledger()[-60:]
+    ] + [{"status": "pending", "gist": _gist(p)} for p in (pending_props or [])]
     considered_block = (
-        "\n".join(f"- ({r['status']}) {r['text'][:200]}" for r in considered)
+        "\n".join(f"- ({r['status']}) {r['gist'][:200]}" for r in considered)
         if considered
         else "(nothing has been considered yet)"
     )
@@ -346,7 +366,7 @@ def build_prompt(sessions: list[dict], pending_props: list[dict] | None = None)
 
 # Role
 
-You are the daily context miner for a personal "context corpus": a numbered list of durable, one-line memories distilled from the user's own Claude conversations. Each line is an insight worth keeping and potentially worth sharing with the world: a specific experience, a hard-won conclusion, a non-obvious observation, or a concrete data point.
+You are the daily context miner for a personal "context corpus": a numbered list of durable memories distilled from the user's own Claude conversations. Each entry is a short STORY plus a CONCLUSION: what actually happened (with its credible specifics) and the transferable lesson it taught. Entries are worth keeping and potentially worth sharing with the world: a specific experience, a hard-won conclusion, a non-obvious observation, or a concrete data point.
 
 The user is Matthew, a solo founder building S4L (a social-media autoposting agent), Fazm, Mediar, and related products, and doing everything else through Claude sessions: fundraising, debugging, ops, legal, marketing.
 
@@ -389,11 +409,12 @@ The user is Matthew, a solo founder building S4L (a social-media autoposting age
 # Your task
 
 Propose 0-3 corpus changes, and only what clears EVERY bar above; most days the
-right answer is 0 or 1. An empty proposals list is a valid, common answer. For each proposal:
-- action: "add" for a new line, or "revise" when a new learning supersedes an existing corpus line (set revises_line to that line's number).
-- text: the corpus line itself. One sentence, self-contained, max ~300 chars, written in the user's plainspoken voice. No hashtags, no em dashes.
-- why: one sentence on why this is worth keeping (what makes it non-obvious or shareable).
-- quote: a short supporting excerpt from the transcript (redact any secrets).
+right answer is 0 or 1. An empty proposals list is a valid, common answer. Each
+proposal is a small STORY with a CONCLUSION, not a bare aphorism:
+- action: "add" for a new entry, or "revise" when a new learning supersedes an existing corpus entry (set revises_line to that entry's number).
+- title: a short, specific handle for the insight (max ~70 chars, not clickbait).
+- story: 2-5 sentences telling what actually happened, in the user's plainspoken first-person voice. Keep the concrete specifics that make it credible and vivid (the numbers, the timeline, the failure mode, what was tried), but generalize or omit anything only an insider would care about. Anonymize people, redact secrets. No hashtags, no em dashes.
+- conclusion: 1-2 sentences stating the transferable lesson a stranger could apply to their own work. This is the part that must stand on its own.
 - source_session: the 8-char session id from the transcript header.
 - source_date: the session date (YYYY-MM-DD).
 
@@ -457,9 +478,8 @@ def _run_one_batch(sessions: list[dict], pending_props: list[dict], ns) -> list[
 
     stamped = []
     for p in obj.get("proposals") or []:
-        pid = "cm-" + hashlib.sha1(
-            (p.get("text", "") + p.get("source_session", "")).encode()
-        ).hexdigest()[:8]
+        key = (p.get("title") or p.get("text") or "") + p.get("source_session", "")
+        pid = "cm-" + hashlib.sha1(key.encode()).hexdigest()[:8]
         p["id"] = pid
         p["mined_at"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
         stamped.append(p)
@@ -549,10 +569,13 @@ def cmd_review(_ns) -> int:
         else:
             head += "  ADD"
         print(head)
-        print(f"  text : {p.get('text', '')}")
-        print(f"  why  : {p.get('why', '')}")
-        if p.get("quote"):
-            print(f"  quote: {p['quote'][:220]}")
+        if p.get("title"):
+            print(f"  title: {p['title']}")
+            print(f"  story: {p.get('story', '')}")
+            print(f"  concl: {p.get('conclusion', '')}")
+        else:  # legacy one-line shape
+            print(f"  text : {p.get('text', '')}")
+            print(f"  why  : {p.get('why', '')}")
         print(f"  src  : {p.get('source_session', '?')} @ {p.get('source_date', '?')}")
     print("=" * 72)
     print(f"{len(props)} pending. approve/skip with: context_mining.py approve <id...>")
@@ -575,18 +598,21 @@ def _decide(ids: list[str], status: str) -> int:
             print(f"unknown id: {pid}")
             continue
         if status == "approved":
+            entry = corpus_entry(p) if p.get("title") else p.get("text", "")
             if p.get("action") == "revise" and p.get("revises_line"):
                 n = p["revises_line"]
                 if 0 < n <= len(corpus_lines):
-                    corpus_lines[n - 1] = p["text"]
+                    corpus_lines[n - 1] = entry
                 else:
-                    corpus_lines.append(p["text"])
+                    corpus_lines.append(entry)
             else:
-                corpus_lines.append(p["text"])
+                corpus_lines.append(entry)
         append_ledger(
             {
                 "id": pid,
                 "status": status,
+                "title": p.get("title", ""),
+                "conclusion": p.get("conclusion", ""),
                 "text": p.get("text", ""),
                 "source_session": p.get("source_session"),
                 "decided_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),

package/scripts/merge_review_queue.py

@@ -101,7 +101,9 @@ def _atomic_write(path: str, obj) -> None:
     os.makedirs(os.path.dirname(path), exist_ok=True)
     tmp = f"{path}.tmp.{os.getpid()}"
     with open(tmp, "w") as f:
-        json.dump(obj, f, indent=2)
+        # Compact separators: the review store reached 65 MB with indent=2
+        # (2026-08-02 lag incident) and every reader pays the parse.
+        json.dump(obj, f, separators=(",", ":"))
     os.replace(tmp, path)