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

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.8",
+  "installedAt": "2026-08-03T22:41:58.148Z"
 }

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.8",
   "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

@@ -1964,7 +1964,12 @@ class _ReviewController(NSObject):
         """NSTimer target (2026-07-15): re-renders the header's age/expiry
         label every second so its countdown visibly counts down without
         needing hover. Not a python_method -- NSTimer invokes this through
-        the ObjC runtime."""
+        the ObjC runtime. No-op when the rendered text is unchanged: the
+        label usually shows a coarse "3h"-style value that only changes
+        every few minutes, and unconditionally re-styling it dirtied one
+        layer per tile per second -- with a 130-tile canvas that was a
+        constant CoreAnimation commit churn keeping the app at ~15% CPU
+        while idle (2026-08-02 lag incident)."""
         if self._age_expiry_label is None:
             return
         try:
@@ -1975,6 +1980,9 @@ class _ReviewController(NSObject):
             )
             if not text:
                 return
+            if (text, urgent) == getattr(self, "_age_expiry_last", None):
+                return
+            self._age_expiry_last = (text, urgent)
             self._age_expiry_label.setStringValue_(text)
             self._age_expiry_label.setFont_(_font(11, urgent))
             self._age_expiry_label.setTextColor_(

package/mcp/menubar/s4l_card_canvas.py

@@ -461,14 +461,13 @@ class _CanvasController(NSObject):
 
     @objc.python_method
     def _reflow_from(self, start_idx):
-        """Rebuild every slot's CONTENT from start_idx onward from the
-        current self._order -- slot POSITIONS never move, only which draft
-        occupies each one. Used after a decision removes one entry so
-        everything after it shifts into the vacated grid position ("snake"
-        reflow, 2026-07-16 user direction) instead of independently
-        refilling in place. In-progress edits on any rebuilt tile are lost
-        -- ranking order takes priority over preserving an edit on a card
-        the reviewer hadn't yet acted on."""
+        """Build every slot's CONTENT from start_idx onward from the current
+        self._order. Only two callers: the initial grid build (start 0) and
+        extend_drafts (start = old length, so only the NEW empty slots get
+        content). Decisions no longer come through here -- rebuilding ~130
+        full tile views per click was the dominant cost of an approval on a
+        big backlog (2026-08-02 lag incident, second act); _remove_and_reflow
+        now MOVES the surviving slot views instead."""
         for i in range(start_idx, len(self._slots)):
             slot = self._slots[i]
             for sv in list(slot["view"].subviews()):
@@ -476,8 +475,8 @@ class _CanvasController(NSObject):
             d = self._order[i]
             tile = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_focus_hostView_hostWindow_(
                 [d],
-                self._tile_decision_cb(i),
-                self._tile_complete_cb(i),
+                self._tile_decision_cb(slot),
+                self._tile_complete_cb(slot),
                 True,
                 slot["view"],
                 self._panel,
@@ -487,19 +486,23 @@ class _CanvasController(NSObject):
 
     @objc.python_method
     def _remove_and_reflow(self, n):
-        """Pop draft `n` out of self._order, drop one slot (the grid is one
-        shorter -- no spare capacity to backfill), and reflow every slot
-        from its old position onward so subsequent cards shift up into the
-        gap in rank order."""
+        """Pop draft `n` out of self._order, drop ITS slot (view and all),
+        and shift every later slot's VIEW up into the vacated grid position
+        ("snake" reflow, 2026-07-16 user direction). Positions move, content
+        doesn't: each surviving tile keeps its live view -- O(N) setFrame
+        calls instead of O(N) full tile rebuilds (2026-08-02 lag fix), and
+        an in-progress edit on a later card now survives earlier decisions
+        instead of being clobbered by the rebuild."""
         try:
             idx = next(i for i, d in enumerate(self._order) if d.get("n") == n)
         except StopIteration:
             return
         self._order.pop(idx)
-        if self._slots:
-            last = self._slots.pop()
-            last["view"].removeFromSuperview()
-        self._reflow_from(idx)
+        if idx < len(self._slots):
+            gone = self._slots.pop(idx)
+            gone["view"].removeFromSuperview()
+        for i in range(idx, len(self._slots)):
+            self._slots[i]["view"].setFrame_(self._slot_frame(i))
         self._resize_doc()
         self._refresh_header()
         # Last card decided -> nothing left to review, so close the canvas
@@ -535,7 +538,7 @@ class _CanvasController(NSObject):
             _log(f"canvas discard-all handler failed: {e}")
 
     @objc.python_method
-    def _tile_decision_cb(self, slot_idx):
+    def _tile_decision_cb(self, slot):
         def _cb(decision):
             self._decisions.append(decision)
             self._last_decision_at = time.time()
@@ -549,16 +552,16 @@ class _CanvasController(NSObject):
         return _cb
 
     @objc.python_method
-    def _tile_complete_cb(self, slot_idx):
+    def _tile_complete_cb(self, slot):
         def _cb(_tile_decisions):
             # The tile's own single-draft stack finished -- remove it from
             # the ranking and let everything after it shift up ("snake"
-            # reflow; see _remove_and_reflow). slot_idx is read lazily at
-            # call time (not captured as a fixed n) because a still-live
-            # tile ahead of it could have already shifted this slot's
-            # content since the closure was created.
-            slot = self._slots[slot_idx] if slot_idx < len(self._slots) else None
-            n = slot["n"] if slot else None
+            # reflow; see _remove_and_reflow). Closing over the SLOT DICT
+            # (not a positional index) keeps the lookup correct no matter
+            # how many earlier slots have been popped since this closure
+            # was created: a slot keeps its `n` for life now that reflow
+            # moves views instead of rebuilding content.
+            n = slot["n"]
             if n is not None:
                 self._remove_and_reflow(n)
 

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.8",
   "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.8",
   "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/browser_lifecycle.py

@@ -77,6 +77,36 @@ def park_tabs(cdp_base: str, host_markers, park_url: str, label: str) -> None:
         pass
 
 
+def background_new_page(browser, context, url: str = "about:blank", timeout_ms: int = 10_000):
+    """Create a Playwright page WITHOUT raising the Chrome window.
+
+    Playwright's context.new_page() maps to a FOREGROUND Target.createTarget,
+    which activates Chrome on macOS and steals app focus (the July 2026
+    focus-steal class; same call the bh helpers and the harness daemon were
+    already fixed to avoid). Playwright's public API has no background
+    option, so this creates the target via a browser-level CDP session with
+    background:true and returns the Page that `context` adopts for it.
+
+    ONE shared implementation for every attach path that previously called
+    context.new_page() on the harness (reddit_browser, twitter_browser,
+    reddit_browser_fetch). Falls back to context.new_page() if the CDP path
+    fails: a rare focus blip beats a dead pipeline.
+    """
+    try:
+        cdp = browser.new_browser_cdp_session()
+        try:
+            with context.expect_page(timeout=timeout_ms) as pg_info:
+                cdp.send("Target.createTarget", {"url": url, "background": True})
+            return pg_info.value
+        finally:
+            try:
+                cdp.detach()
+            except Exception:
+                pass
+    except Exception:
+        return context.new_page()
+
+
 def register_park_on_exit(cdp_base: str, host_markers, park_url: str, label: str) -> None:
     """Arm park_tabs to run at process exit, once per (endpoint, park_url).
     Call from a platform lib's get_browser_and_page so only processes that

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/harness_target_monitor.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Attribution monitor for harness-Chrome focus steals (2026-08-03).
+
+Connects to a harness Chrome's browser-level CDP websocket, enables target
+discovery, and appends one timestamped line per Target lifecycle event
+(created / destroyed / info-changed => navigations) to a log file. Correlate
+these against the `[browser-foreground]` activation lines in
+~/.social-autoposter-mcp/menubar/menubar.err.log to attribute WHICH tab
+operation coincided with an app activation, something none of the existing
+logs capture (the daemon log has no timestamps; python new_page sites have
+no logging at all; bh [bh_tab_event] covers only the bh lanes).
+
+Read-only: never creates, closes, or navigates anything.
+
+Usage:
+    harness_target_monitor.py [--port 9557] [--log PATH]
+
+Runs forever; reconnects with backoff when Chrome restarts. Intended to run
+under nohup during a diagnosis window. It is NOT part of the pipeline.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+
+
+def ts() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+def log_line(path: str, msg: str) -> None:
+    with open(path, "a") as f:
+        f.write(f"[{ts()}] {msg}\n")
+
+
+def monitor_once(port: int, log_path: str) -> None:
+    import urllib.request
+    import websocket
+
+    opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+    info = json.loads(opener.open(f"http://127.0.0.1:{port}/json/version", timeout=3).read())
+    ws = websocket.create_connection(
+        info["webSocketDebuggerUrl"], timeout=5, suppress_origin=True
+    )
+    try:
+        ws.send(json.dumps({"id": 1, "method": "Target.setDiscoverTargets",
+                            "params": {"discover": True}}))
+        log_line(log_path, f"monitor attached port={port} chrome={info.get('Browser','?')}")
+        ws.settimeout(60)
+        last_url = {}
+        while True:
+            try:
+                msg = json.loads(ws.recv())
+            except Exception as e:
+                if "timed out" in str(e).lower():
+                    # Idle is fine; poke the connection so a dead Chrome errors out.
+                    ws.send(json.dumps({"id": 2, "method": "Browser.getVersion"}))
+                    continue
+                raise
+            method = msg.get("method", "")
+            p = msg.get("params", {})
+            t = p.get("targetInfo", {})
+            if t.get("type") not in ("page", ""):
+                continue
+            tid = t.get("targetId") or p.get("targetId", "?")
+            url = t.get("url", "")
+            if method == "Target.targetCreated":
+                log_line(log_path, f"CREATED  {tid} url={url[:100]}")
+            elif method == "Target.targetDestroyed":
+                log_line(log_path, f"DESTROYED {tid} (last_url={last_url.get(tid, '?')[:100]})")
+            elif method == "Target.targetInfoChanged":
+                if url and url != last_url.get(tid):
+                    log_line(log_path, f"NAVIGATED {tid} url={url[:100]}")
+            if tid != "?" and url:
+                last_url[tid] = url
+    finally:
+        try:
+            ws.close()
+        except Exception:
+            pass
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=9557)
+    ap.add_argument("--log", default=os.path.expanduser(
+        "~/social-autoposter/skill/logs/harness-target-events-9557.log"))
+    args = ap.parse_args()
+    while True:
+        try:
+            monitor_once(args.port, args.log)
+        except KeyboardInterrupt:
+            return 0
+        except Exception as e:
+            try:
+                log_line(args.log, f"monitor disconnected ({type(e).__name__}: {str(e)[:120]}); retry in 15s")
+            except OSError:
+                pass
+            time.sleep(15)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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)
 
 

package/scripts/reddit_browser.py

@@ -441,7 +441,11 @@ def _get_browser_and_page_raw(playwright):
                         return cdp_browser, pg, True
                 if chosen.pages:
                     return cdp_browser, chosen.pages[0], True
-                page = chosen.new_page()
+                # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                # new_page() here is a foreground Target.createTarget, which
+                # activates Chrome and steals macOS app focus.
+                from browser_lifecycle import background_new_page
+                page = background_new_page(cdp_browser, chosen)
                 return cdp_browser, page, True
             # No usable context: do NOT close the CDP browser (would kill the
             # harness Chrome); just disconnect by falling through.
@@ -464,13 +468,15 @@ def _get_browser_and_page_raw(playwright):
                     for c in cookies
                 )
                 if has_session:
-                    # Reuse an existing tab (no focus-steal); only new_page if none.
+                    # Reuse an existing tab (no focus-steal); only create if none,
+                    # and then in the BACKGROUND (2026-08-03, see above).
                     for pg in ctx.pages:
                         if "reddit.com" in (pg.url or "") and "login" not in (pg.url or ""):
                             return cdp_browser, pg, True
                     if ctx.pages:
                         return cdp_browser, ctx.pages[0], True
-                    page = ctx.new_page()
+                    from browser_lifecycle import background_new_page
+                    page = background_new_page(cdp_browser, ctx)
                     return cdp_browser, page, True
             try:
                 cdp_browser.close()

package/scripts/reddit_browser_fetch.py

@@ -165,7 +165,11 @@ def browser_get_json(url, cdp_url=None, timeout_ms=25000):
                 if page is None and ctx.pages:
                     page = ctx.pages[0]
                 if page is None:
-                    page = ctx.new_page()
+                    # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                    # new_page() is a foreground Target.createTarget, which
+                    # activates Chrome and steals macOS app focus.
+                    from browser_lifecycle import background_new_page
+                    page = background_new_page(browser, ctx)
                 # Load the matching host root so the subsequent fetch() is same-origin
                 # (no CORS between www/old) and carries the logged-in session.
                 try:

package/scripts/reddit_tools.py

@@ -74,71 +74,61 @@ def _wait_if_needed():
 def _fetch_via_browser(url):
     """Fetch a Reddit URL through the reddit-harness logged-in Chrome.
 
-    Returns the raw response body (str) on HTTP 200, else None so the caller
-    falls back to urllib. This is the 2026-05-29 transport swap: Reddit began
-    403ing urllib/curl on *.json from residential IPs on 2026-05-28, but a
-    same-origin fetch() from inside the logged-in harness browser returns 200.
-
-    Gated by REDDIT_FETCH_BACKEND: default ("harness") uses the browser first;
-    set REDDIT_FETCH_BACKEND=urllib to force the legacy path (e.g. for debugging).
-    Also short-circuits to None when REDDIT_CDP_URL is unset AND no harness is
-    expected, so plain `urllib`-only environments are unaffected.
+    Browser-ONLY transport (2026-08-03, user decision: no urllib fallback).
+    Reddit's TLS-fingerprint wall (2026-05-28) 403s urllib/curl on *.json
+    unconditionally, so the old fallback could never succeed: it burned ~2s
+    per browser hiccup and then lost the query anyway. Transient failures
+    (Reddit 503s, harness contention) get ONE in-transport retry instead.
+    The REDDIT_FETCH_BACKEND=urllib debug knob is gone for the same reason:
+    forcing a transport that is guaranteed to 403 debugs nothing.
+
+    Returns the raw response body (str) on HTTP 200. Raises on final failure,
+    urllib.error.HTTPError for HTTP statuses and urllib.error.URLError for
+    transport-level failures, matching the exception shapes callers already
+    handle from the urllib era. 429 keeps the old inline-wait contract
+    (absorb a short wait, else RateLimitedError).
     """
-    if os.environ.get("REDDIT_FETCH_BACKEND", "harness").lower() == "urllib":
-        return None
-    try:
-        from reddit_browser_fetch import browser_get_json
-    except Exception as e:
-        sys.stderr.write(f"[reddit_tools] browser fetch unavailable ({e}); urllib fallback\n")
-        return None
-    try:
+    from reddit_browser_fetch import browser_get_json
+
+    last_status = 0
+    for attempt in (1, 2):
         body, status = browser_get_json(url)
         if status == 200 and body:
             return body
-        sys.stderr.write(f"[reddit_tools] browser fetch status={status} for {url[:80]}; urllib fallback\n")
-    except Exception as e:
-        sys.stderr.write(f"[reddit_tools] browser fetch error ({e}); urllib fallback\n")
-    return None
+        last_status = status
+        if status == 429:
+            # Browser transport exposes no X-Ratelimit-Reset header; assume
+            # Reddit's standard 60s window.
+            _write_ratelimit(0, 60)
+            if 60 > MAX_INLINE_WAIT_SECONDS:
+                raise RateLimitedError(60)
+            if attempt == 1:
+                print("Rate limited. Waiting 62s...", file=sys.stderr)
+                time.sleep(62)
+            continue
+        sys.stderr.write(
+            f"[reddit_tools] browser fetch status={status} for {url[:80]} (attempt {attempt}/2)\n"
+        )
+        if attempt == 1:
+            time.sleep(2.5)
+    if last_status == 429:
+        raise RateLimitedError(60)
+    if last_status:
+        raise urllib.error.HTTPError(
+            url, last_status,
+            f"reddit browser fetch failed (status={last_status})", None, None,
+        )
+    raise urllib.error.URLError(f"reddit browser transport failed for {url[:80]}")
 
 
 def _do_request(url):
-    """Make a Reddit API request with rate limit handling.
+    """Make a Reddit API request via the harness browser (sole transport).
 
-    Primary transport is the reddit-harness browser (see _fetch_via_browser);
-    urllib is the silent fallback. On 429 (urllib path): raises RateLimitedError
-    immediately if the reset would require a long wait, else absorbs short waits.
+    429 handling (inline wait / RateLimitedError) lives inside
+    _fetch_via_browser; HTTP and transport failures raise there too.
     """
     _wait_if_needed()
-    # Browser-first (bypasses Reddit's urllib 403 wall). Falls through to urllib
-    # if the harness is down or returns a non-200.
-    _body = _fetch_via_browser(url)
-    if _body is not None:
-        try:
-            return json.loads(_body)
-        except Exception:
-            sys.stderr.write(f"[reddit_tools] browser body not JSON for {url[:80]}; urllib fallback\n")
-    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
-    try:
-        resp = urllib.request.urlopen(req, timeout=20)
-        remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-        reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-        _write_ratelimit(remaining, reset)
-        return json.loads(resp.read())
-    except urllib.error.HTTPError as e:
-        if e.code == 429:
-            reset = float(e.headers.get("X-Ratelimit-Reset", 60))
-            _write_ratelimit(0, reset)
-            if reset > MAX_INLINE_WAIT_SECONDS:
-                raise RateLimitedError(reset)
-            print(f"Rate limited. Waiting {int(reset)+2}s...", file=sys.stderr)
-            time.sleep(int(reset) + 2)
-            # Retry once
-            resp = urllib.request.urlopen(req, timeout=20)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset2 = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset2)
-            return json.loads(resp.read())
-        raise
+    return json.loads(_fetch_via_browser(url))
 
 
 def batch_fetch_info(thing_ids, user_agent=USER_AGENT):
@@ -158,41 +148,9 @@ def batch_fetch_info(thing_ids, user_agent=USER_AGENT):
         ids_str = ",".join(chunk)
         url = f"https://old.reddit.com/api/info.json?id={ids_str}"
         _wait_if_needed()
-        # Browser-first transport (Reddit 403s urllib on *.json). urllib fallback.
-        _body = _fetch_via_browser(url)
-        if _body is not None:
-            try:
-                data = json.loads(_body)
-                for child in data.get("data", {}).get("children", []):
-                    cd = child.get("data", {})
-                    name = cd.get("name")
-                    if name:
-                        results[name] = cd
-                continue
-            except Exception:
-                sys.stderr.write("[reddit_tools] browser info.json not JSON; urllib fallback\n")
-        req = urllib.request.Request(url, headers={"User-Agent": user_agent})
-        try:
-            resp = urllib.request.urlopen(req, timeout=30)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset)
-            data = json.loads(resp.read())
-        except urllib.error.HTTPError as e:
-            if e.code == 429:
-                reset = float(e.headers.get("X-Ratelimit-Reset", 60))
-                _write_ratelimit(0, reset)
-                if reset > MAX_INLINE_WAIT_SECONDS:
-                    raise RateLimitedError(reset)
-                print(f"Rate limited. Waiting {int(reset)+2}s...", file=sys.stderr)
-                time.sleep(int(reset) + 2)
-                resp = urllib.request.urlopen(req, timeout=30)
-                remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-                reset2 = float(resp.headers.get("X-Ratelimit-Reset", 0))
-                _write_ratelimit(remaining, reset2)
-                data = json.loads(resp.read())
-            else:
-                raise
+        # Browser-only transport (see _fetch_via_browser; raises on failure,
+        # including the RateLimitedError this loop's callers already handle).
+        data = json.loads(_fetch_via_browser(url))
 
         for child in data.get("data", {}).get("children", []):
             d = child.get("data", {})
@@ -620,15 +578,9 @@ def _html_postable_check(thread_url):
     try:
         url = thread_url.replace("www.reddit.com", "old.reddit.com").rstrip("/") + "/"
         _wait_if_needed()
-        # Browser-first transport (Reddit 403s urllib). urllib fallback below.
+        # Browser-only transport (see _fetch_via_browser). Raises on failure;
+        # the outer except maps that to None ("network error") as before.
         html = _fetch_via_browser(url)
-        if html is None:
-            req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
-            resp = urllib.request.urlopen(req, timeout=15)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset)
-            html = resp.read().decode("utf-8", errors="ignore")
         # Scope the lock check to the post header only. r/Entrepreneur (and
         # similar subs) sticky an AutoMod comment that is itself locked,
         # rendering `<span class="locked-tagline">locked comment</span>`

package/scripts/stats.py

@@ -447,64 +447,37 @@ def fetch_reddit_json(url, user_agent, max_retries=2, timeout=15):
     (success AND error) into _reddit_rate_state so the caller can pace.
     On 429, honors Retry-After (capped to 120s) and retries.
     """
-    # 2026-07-14 transport fix: Reddit started 403-blocking plain urllib on
-    # *.json (2026-05-28), which silently killed this scan (every poll came
-    # back as an HTML block page -> 'empty'/'error', zero rows patched since).
-    # Route through the logged-in harness browser first, the same transport
-    # reddit_tools._do_request has used since 2026-05-29 (the replies pass in
-    # this file already goes through it via batch_fetch_info and kept working).
-    # urllib below stays as the fallback; REDDIT_FETCH_BACKEND=urllib forces it.
-    if os.environ.get("REDDIT_FETCH_BACKEND", "harness").lower() != "urllib":
-        try:
-            from reddit_browser_fetch import browser_get_json
-            body, code = browser_get_json(url)
-            if code == 200 and body:
-                try:
-                    return ("ok", json.loads(body))
-                except Exception:
-                    pass  # non-JSON body -> fall through to urllib
-            elif code == 404:
-                return ("not_found", None)
-        except Exception:
-            pass
-    req = urllib.request.Request(url, headers={"User-Agent": user_agent})
+    # Browser-ONLY transport (2026-08-03, user decision: no urllib fallback).
+    # Reddit's TLS-fingerprint wall (2026-05-28) 403s urllib/curl on *.json
+    # unconditionally, so the old urllib fallback below could never succeed;
+    # it burned retries on guaranteed 403s and returned 'error' anyway.
+    # Transient browser failures (Reddit 503s, harness contention) get the
+    # same retry budget the urllib path had. The browser transport exposes
+    # no rate-limit headers, so 429 waits assume Reddit's standard 60s
+    # window; `user_agent`/`timeout` stay in the signature for callers but
+    # are unused (the harness browser supplies its own identity).
+    from reddit_browser_fetch import browser_get_json
+
     for attempt in range(max_retries + 1):
         try:
-            with urllib.request.urlopen(req, timeout=timeout) as resp:
-                _update_reddit_rate_state(resp.headers)
-                body = resp.read()
-                if not body:
-                    return ("empty", None)
-                try:
-                    return ("ok", json.loads(body))
-                except Exception:
-                    return ("empty", None)
-        except urllib.error.HTTPError as e:
-            _update_reddit_rate_state(e.headers)
-            if e.code == 404:
-                return ("not_found", None)
-            if e.code == 429:
-                retry_after = None
-                if e.headers:
-                    ra = e.headers.get("Retry-After")
-                    if ra:
-                        try:
-                            retry_after = int(ra)
-                        except (TypeError, ValueError):
-                            retry_after = None
-                if retry_after is None:
-                    retry_after = int(_reddit_rate_state.get("reset_in") or 60)
-                retry_after = max(1, min(retry_after, 120))
-                if attempt < max_retries:
-                    time.sleep(retry_after)
-                    continue
-                return ("rate_limited", None)
-            return ("error", None)
+            body, code = browser_get_json(url)
         except Exception:
+            body, code = None, 0
+        if code == 200 and body:
+            try:
+                return ("ok", json.loads(body))
+            except Exception:
+                return ("empty", None)
+        if code == 404:
+            return ("not_found", None)
+        if code == 429:
             if attempt < max_retries:
-                time.sleep(5 * (attempt + 1))
+                time.sleep(60)
                 continue
-            return ("error", None)
+            return ("rate_limited", None)
+        if attempt < max_retries:
+            time.sleep(5 * (attempt + 1))
+            continue
     return ("error", None)
 
 

package/scripts/twitter_browser.py

@@ -515,7 +515,11 @@ def _get_browser_and_page_raw(playwright):
                 # Otherwise reuse the first page (caller will navigate it).
                 if context.pages:
                     return browser, context.pages[0], True
-                return browser, context.new_page(), True
+                # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                # new_page() is a foreground Target.createTarget, which
+                # activates Chrome and steals macOS app focus.
+                from browser_lifecycle import background_new_page
+                return browser, background_new_page(browser, context), True
             # No contexts present (unusual on a fresh harness Chrome) — create one.
             context = browser.new_context()
             return browser, context.new_page(), True
@@ -545,7 +549,9 @@ def _get_browser_and_page_raw(playwright):
                         return browser, pg, True
                 if context.pages:
                     return browser, context.pages[0], True
-                return browser, context.new_page(), True
+                # Zero pages: background create (2026-08-03, see above).
+                from browser_lifecycle import background_new_page
+                return browser, background_new_page(browser, context), True
         except Exception as e:
             _release_browser_lock()
             print(json.dumps({