@m13v/s4l 1.7.2-rc.9 → 1.7.3

package/mcp/dist/index.js

@@ -20,7 +20,7 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
 import { repoDir, runPython, run, readPlan, writePlan, planPath, } from "./repo.js";
-import { applySetup, resolveProject, personaReady, listManagedProjectStatus, listProjectSettings, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, normalizeStringList, } from "./setup.js";
+import { applySetup, resolveProject, hasReadyProject, personaReady, listManagedProjectStatus, listProjectSettings, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, normalizeStringList, } from "./setup.js";
 import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from "./twitterAuth.js";
 import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, menubarRunning, clearMenubarStop, ensurePipelineCurrent, ensureRuntimeProvisioned, retryProvisionIfStalled, } from "./runtime.js";
 import { blockOnboardingMilestone, completeOnboardingMilestone, ensureDoctorPhase, onboardingLedger, onboardingSnapshot, recordOnboardingAttempt, runDoctorPhase, } from "./onboarding.js";
@@ -870,6 +870,18 @@ async function ensureTwitterBrowserForPost() {
         },
     });
 }
+// A terminal stamp written by merge_review_queue.py's backend sync for a row the
+// freshness gate merely EXPIRED (not posted, not skipped) records "nobody decided
+// this in time" — an explicit human approval outranks it. The poster's own
+// at-post-time tweet_unavailable check remains the real gate on whether the
+// thread still exists. Without this override, a card approved while (or just
+// before) the sync stamped it is refused as already-decided and the approval
+// silently no-ops (2 of 3 approvals lost on 2026-07-10).
+function expiredStampOverridable(c) {
+    return (c.terminal === true &&
+        c.posted !== true &&
+        c.discard_reason === "backend_status_expired");
+}
 async function postApproved(batchId, plan) {
     // Drain serialization (2026-07-06 incident). Every call drains the WHOLE
     // approved backlog, so overlapping drains are pure waste and actively harmful:
@@ -922,7 +934,18 @@ async function postApproved(batchId, plan) {
     // drains the not-yet-posted approved backlog (e.g. a card a restart interrupted),
     // never re-posts a done one. This is what lets the startup backlog-drain and the
     // per-card menu-bar calls share one code path safely.
-    const approved = (plan.candidates || []).filter((c) => c.approved === true && c.posted !== true && c.terminal !== true);
+    // An approved card whose only blocker is an overridable backend-expiry stamp is
+    // included: approval outranks the freshness gate (see expiredStampOverridable),
+    // and the stamp is cleared so every downstream terminal check agrees it's live.
+    const approved = (plan.candidates || []).filter((c) => c.approved === true &&
+        c.posted !== true &&
+        (c.terminal !== true || expiredStampOverridable(c)));
+    for (const c of approved) {
+        if (c.terminal === true) {
+            c.terminal = false;
+            delete c.discard_reason;
+        }
+    }
     if (approved.length === 0)
         return { attempted: 0, exit_code: 0, summary: "nothing approved" };
     // PREFLIGHT: posting needs a configured @handle, or twitter_browser.py refuses
@@ -1000,7 +1023,12 @@ async function postApproved(batchId, plan) {
                 };
             }
             return await runPython("scripts/twitter_post_plan.py", ["--plan", planPath(approvedBatch)], {
-                timeoutMs: 900_000,
+                // Scale with batch size: a mass-approval drain runs ~15-20s per card,
+                // so a fixed 15min ceiling SIGTERMed any batch over ~50 cards mid-post
+                // (Karol 2026-07-09: 0/131 posted, exit=-1). 60s/card headroom covers
+                // slow candidates; the 2h cap bounds a hung poster (the browser-lock
+                // expiry and per-reply subprocess timeouts still fire underneath).
+                timeoutMs: Math.min(7_200_000, Math.max(900_000, approved.length * 60_000)),
                 env: ({
                     S4L_SKIP_CAMPAIGN_SUFFIX: "1",
                     // Manual approval is an EXCEPTION to the tail-link A/B. The cron pipeline
@@ -2316,9 +2344,17 @@ tool("post_drafts", {
     });
     // Cross-surface de-dup: chat and the menu-bar pop-ups can both approve, so
     // never re-post a candidate the other surface already posted OR ruled out.
+    // Exception: an overridable backend-expiry stamp yields to this explicit
+    // approval (see expiredStampOverridable) — clear it and post.
     const alreadyDone = [];
     for (const n of Array.from(approve)) {
-        if (candidates[n - 1]?.posted === true || candidates[n - 1]?.terminal === true) {
+        const c = candidates[n - 1];
+        if (c && expiredStampOverridable(c)) {
+            c.terminal = false;
+            delete c.discard_reason;
+            continue;
+        }
+        if (c?.posted === true || c?.terminal === true) {
             approve.delete(n);
             alreadyDone.push(n);
         }
@@ -2387,19 +2423,33 @@ tool("get_stats", {
     title: "Get X/Twitter stats",
     description: "Read-only post + engagement stats for the X/Twitter rail over the last N days. " +
         "Wraps project_stats_json.py. Use to show the user how their posts are performing. " +
+        "With no `project` it reports EVERY configured lane, including the personal-brand " +
+        "persona (which usually carries most of the volume) — prefer that default. " +
         "After returning the numbers, call the `dashboard` tool so the user sees them rendered.",
     inputSchema: {
         days: z.number().int().min(1).max(90).default(7),
         project: z
             .string()
             .optional()
-            .describe("Which configured project to report on. Optional when only one project is set up; required when several are."),
+            .describe("Scope to one configured project (the persona lane's name works too). " +
+            "Omit to report all lanes — products AND the personal-brand persona."),
     },
 }, async ({ days, project }) => {
-    const r = resolveProject(project);
-    if (!r.ok)
+    // Explicit project: validate it (projectStatus is persona-aware, so the
+    // persona lane resolves). No project: report EVERY lane rather than
+    // resolving to a single product — the old single-project resolution made
+    // the persona lane (often 90% of activity) invisible in stats.
+    let proj;
+    if (project) {
+        const r = resolveProject(project);
+        if (!r.ok)
+            return textContent(r.message);
+        proj = r.project;
+    }
+    else if (!hasReadyProject() && !personaReady()) {
+        const r = resolveProject();
         return textContent(r.message);
-    const proj = r.project;
+    }
     const args = ["--posts-only", "--platform", "twitter", "--days", String(days)];
     if (proj)
         args.push("--project", proj);
@@ -4963,7 +5013,9 @@ async function drainApprovedBacklog() {
     try {
         const plan = readPlan(REVIEW_QUEUE_ID);
         const cands = plan?.candidates || [];
-        const backlog = cands.filter((c) => c.approved === true && c.posted !== true && c.terminal !== true);
+        const backlog = cands.filter((c) => c.approved === true &&
+            c.posted !== true &&
+            (c.terminal !== true || expiredStampOverridable(c)));
         if (!backlog.length)
             return;
         console.error(`[post] draining ${backlog.length} approved-but-unposted card(s) left from before`);

package/mcp/dist/screencast.js

@@ -18,6 +18,20 @@
  */
 import { execFile } from "node:child_process";
 import { createRequire } from "node:module";
+import { logLine } from "./telemetry.js";
+// One structured relay line (context "browser-foreground", the same lane the
+// menubar's NSWorkspace observer emits on) every time THIS module raises the
+// managed Chrome. The observer records THAT the window came to the front;
+// these lines record WHY (screencast attach vs explicit front action), so the
+// two join on timestamp in Cloud Logging.
+function logBringToFront(source, extra) {
+    try {
+        logLine("stdout", JSON.stringify({ ev: "browser_bring_to_front", source, ...extra }), "browser-foreground");
+    }
+    catch {
+        /* telemetry must never break the screencast */
+    }
+}
 // Untyped indirection: Node ships a global WebSocket at runtime (>=21) but
 // @types/node doesn't always declare it as a value, and MessageEvent isn't typed
 // without the DOM lib. Reach for it dynamically and keep the event handlers `any`.
@@ -123,6 +137,14 @@ class Screencast {
             this.port = chosenPort;
             this.targetTitle = target.title || "";
             this.targetUrl = target.url || "";
+            // connect() just sent Page.bringToFront (Chrome won't stream frames for a
+            // background tab), which raises the harness window — record each raise.
+            // Reconnects happen silently on every frame poll after the attached tab
+            // dies, so this line is the ONLY attribution for reconnect-storm raises.
+            logBringToFront("screencast_attach", {
+                port: chosenPort,
+                url: (target.url || "").slice(0, 200),
+            });
             return { ok: true };
         }
         catch (e) {
@@ -333,5 +355,10 @@ export async function bringBrowserToFront(port) {
     if (process.platform === "darwin") {
         await raiseMacWindow(chosenPort);
     }
+    logBringToFront("front_action", {
+        port: chosenPort,
+        url: (target.url || "").slice(0, 200),
+        raised_os_window: process.platform === "darwin",
+    });
     return { ok: true, port: chosenPort };
 }

package/mcp/dist/setup.js

@@ -486,9 +486,15 @@ export function missingForProject(name, fields = REQUIRED_FIELDS) {
     }
 }
 export function projectStatus(name) {
-    const missing = missingForProject(name);
+    // The persona lane (persona:true) has no website/icp by design — validate it
+    // against PERSONA_REQUIRED_FIELDS like every other status surface, or an
+    // explicit request for it (e.g. get_stats project:'PersonalBrand') gets the
+    // misleading "still needs: website, icp" refusal.
+    const persona = findPersonaProject()?.name === name;
+    const required = persona ? PERSONA_REQUIRED_FIELDS : REQUIRED_FIELDS;
+    const missing = missingForProject(name, required);
     if (missing === null) {
-        return { name, in_config: false, ready: false, missing_required: [...REQUIRED_FIELDS] };
+        return { name, in_config: false, ready: false, missing_required: [...required] };
     }
     return { name, in_config: true, ready: missing.length === 0, missing_required: missing };
 }

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2-rc.9",
-  "installedAt": "2026-07-09T04:41:50.762Z"
+  "version": "1.7.3",
+  "installedAt": "2026-07-10T18:26:15.755Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.2-rc.9",
+  "version": "1.7.3",
   "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_browser_foreground.py

@@ -0,0 +1,188 @@
+"""Ground-truth "the harness browser just went foreground" telemetry.
+
+Customers reported the managed Chrome popping over their work (1.7.x made the
+launchd kicker keep a harness Chrome alive all day, the screencast reconnect
+sends Page.bringToFront, and single-display Macs clamp the off-screen
+--window-position back on-screen). None of those moments were recorded
+anywhere: the causing sites had no logs and nothing observed the OS z-order.
+
+This module is the cause-agnostic observer. It subscribes to NSWorkspace
+activate/launch notifications and, whenever the app coming to the front is a
+Chrome/Chromium whose command line carries a MANAGED profile
+(~/.claude/browser-profiles/browser-harness*), emits one structured JSON line
+via s4l_log_relay.emit(..., context="browser-foreground"). The relay POSTs it
+to /api/v1/installations/logs under the install's X-Installation identity, so
+in Cloud Logging (project s4l-app-prod) the events are:
+
+    jsonPayload.context="browser-foreground"
+    AND jsonPayload.install_id="<uuid>"
+
+Payload fields: cause ("activated" fires on every raise, "launched" only on a
+fresh Chrome process = the launch-activation steal), pid, profile + CDP port +
+--window-position (parsed from the process command line; window-position
+80,80 = setup_twitter_auth's on-screen login, 3042,-1032 = the pipeline
+default), interrupted_app (the frontmost app the user lost), and
+suppressed_since_last (burst dedupe counter, so a bringToFront storm is
+countable without flooding the relay).
+
+Design constraints:
+  - The notification handler must never block the main run loop: it only
+    enqueues; a daemon worker does the `ps` classification + emit.
+  - Only harness-Chrome events are emitted. The user's own Chrome, and every
+    other app switch, produce zero relay traffic (we keep the last non-harness
+    app name in memory as interrupted_app context, nothing more).
+  - Strictly best-effort: install() returning False just means no telemetry.
+"""
+
+import json
+import os
+import queue
+import re
+import subprocess
+import threading
+import time
+
+import s4l_log_relay
+
+# A managed harness Chrome is one launched on a profile under this marker
+# (browser-harness = twitter 9555, browser-harness-linkedin = 9556, ...).
+_PROFILE_MARKER = os.path.join(".claude", "browser-profiles", "browser-harness")
+
+# Within this window, repeats of the same (cause, pid) are counted, not emitted.
+# A screencast-reconnect storm raises Chrome every few seconds; one line per
+# 30s with suppressed_since_last preserves the frequency without the flood.
+_DEDUPE_SECONDS = 30.0
+
+_events = queue.Queue()
+_started = False
+
+
+def _cmdline(pid):
+    try:
+        out = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "command="],
+            capture_output=True, text=True, timeout=3,
+        )
+        return (out.stdout or "").strip()
+    except Exception:
+        return ""
+
+
+class _Worker(threading.Thread):
+    def __init__(self):
+        super().__init__(daemon=True, name="s4l-browser-foreground")
+        self._pid_cache = {}  # pid -> (is_harness, details dict)
+        self._prev_app = None  # last non-harness frontmost app name
+        self._last_key = None  # (cause, pid) of last emitted event
+        self._last_emit_at = 0.0
+        self._suppressed = 0
+
+    def _classify(self, pid):
+        cached = self._pid_cache.get(pid)
+        if cached is not None:
+            return cached
+        cmd = _cmdline(pid)
+        is_harness = _PROFILE_MARKER in cmd and "--remote-debugging-port=" in cmd
+        details = {}
+        if is_harness:
+            m = re.search(r"--user-data-dir=(\S+)", cmd)
+            details["profile"] = os.path.basename(m.group(1).rstrip("/")) if m else ""
+            m = re.search(r"--remote-debugging-port=(\d+)", cmd)
+            details["port"] = int(m.group(1)) if m else None
+            m = re.search(r"--window-position=(\S+)", cmd)
+            details["window_position"] = m.group(1) if m else None
+        result = (is_harness, details)
+        # pids recycle rarely; a tiny bounded cache is enough and self-clears.
+        if len(self._pid_cache) > 64:
+            self._pid_cache.clear()
+        self._pid_cache[pid] = result
+        return result
+
+    def _handle(self, cause, pid, name, low):
+        if "chrome" not in low and "chromium" not in low:
+            if cause == "activated" and name:
+                self._prev_app = name
+            return
+        is_harness, details = self._classify(pid)
+        if not is_harness:
+            # The user's own Chrome counts as their workspace too.
+            if cause == "activated" and name:
+                self._prev_app = name
+            return
+        now = time.time()
+        key = (cause, pid)
+        if key == self._last_key and now - self._last_emit_at < _DEDUPE_SECONDS:
+            self._suppressed += 1
+            return
+        payload = {
+            "ev": "harness_browser_foregrounded",
+            "cause": cause,  # "activated" | "launched"
+            "app": name,
+            "pid": pid,
+            "interrupted_app": self._prev_app,
+            "suppressed_since_last": self._suppressed,
+        }
+        payload.update(details)
+        self._last_key = key
+        self._last_emit_at = now
+        self._suppressed = 0
+        s4l_log_relay.emit(
+            "[browser-foreground] " + json.dumps(payload, ensure_ascii=False),
+            context="browser-foreground",
+        )
+
+    def run(self):
+        while True:
+            try:
+                cause, pid, name, low = _events.get()
+                self._handle(cause, pid, name, low)
+            except Exception:
+                # Never die: a bad event must not end foreground telemetry.
+                time.sleep(0.5)
+
+
+def install():
+    """Subscribe to NSWorkspace activate/launch notifications and start the
+    classifier worker. Call once at menubar boot (the AppKit run loop rumps
+    starts delivers the notifications). Returns True on success; never raises."""
+    global _started
+    if _started:
+        return True
+    try:
+        from AppKit import NSWorkspace
+
+        nc = NSWorkspace.sharedWorkspace().notificationCenter()
+
+        def _make(cause):
+            def _handler(note):
+                try:
+                    app = note.userInfo().objectForKey_("NSWorkspaceApplicationKey")
+                    if app is None:
+                        return
+                    name = str(app.localizedName() or "")
+                    bid = str(app.bundleIdentifier() or "")
+                    pid = int(app.processIdentifier())
+                    _events.put((cause, pid, name, (name + " " + bid).lower()))
+                except Exception:
+                    pass
+            return _handler
+
+        # Keep the block handlers referenced for the process lifetime: PyObjC
+        # does retain the blocks it wraps, but the observer tokens returned
+        # here are our only handle if we ever need to removeObserver_.
+        tokens = [
+            nc.addObserverForName_object_queue_usingBlock_(
+                "NSWorkspaceDidActivateApplicationNotification", None, None,
+                _make("activated"),
+            ),
+            nc.addObserverForName_object_queue_usingBlock_(
+                "NSWorkspaceDidLaunchApplicationNotification", None, None,
+                _make("launched"),
+            ),
+        ]
+        install._tokens = tokens  # noqa: SLF001 (lifetime anchor)
+        _Worker().start()
+        _started = True
+        return True
+    except Exception:
+        return False