@m13v/s4l 1.7.2 → 1.7.4-rc.1

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";
@@ -1023,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
@@ -1389,6 +1394,31 @@ async function seedSearchQueriesForProject(project, rawQueries) {
         return { note: ` (Search-query seeding skipped — ${e.message}.)`, queries };
     }
 }
+// After a project save, persist the profile scan's engagement-ranked top
+// replies into that project's voice.examples (and the persona_corpus.txt
+// exemplar section when the project is the persona). Every drafting prompt on
+// every platform already mirrors voice.examples, so this ONE write feeds them
+// all. scripts/voice_exemplars.py reads the last_profile_scan.json sidecar
+// scan_x_profile.py wrote and only quotes the user's own public replies
+// verbatim (mechanical ranking, no synthesis). Best-effort by design: no scan
+// yet, no usable replies, or hand-written voice.examples (exit 3, respected)
+// all return null and never block the save.
+async function applyScannedVoiceExamples(project) {
+    try {
+        const res = await runPython("scripts/voice_exemplars.py", ["apply", "--project", project], {
+            timeoutMs: 30_000,
+        });
+        const last = res.stdout.trim().split("\n").slice(-1)[0] || "";
+        const parsed = JSON.parse(last);
+        if (parsed.ok && parsed.voice_examples_written) {
+            return `Stored ${parsed.voice_examples_written} of their top-performing real replies (ranked by engagement, with the threads they answered) as voice.examples — every drafter now mirrors them.`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // ---- engagement_mode: choose personal-brand vs product (setup-time) --------
 // Part of onboarding: AFTER X connect + profile_scan, BEFORE product config, the
 // agent asks the user which mode they want and calls this. It persists the mode
@@ -1598,6 +1628,10 @@ tool("engagement_mode", {
         return textContent(`Mode saved as ${mode}, but provisioning the persona project failed: ${e?.message || e}. ` +
             `Retry engagement_mode action:'set'.`);
     }
+    // Persist the profile scan's top-performing real replies as the persona's
+    // voice.examples + the persona_corpus.txt exemplar section (best-effort;
+    // see applyScannedVoiceExamples).
+    const personaExemplarNote = await applyScannedVoiceExamples(personaName);
     // Seed the persona's topics into the DB universe the cycle reads (best-effort;
     // the cycle's own fail-loud path still reports if topics are missing).
     let personaTopicsSeeded = false;
@@ -1682,6 +1716,7 @@ tool("engagement_mode", {
         persona_topic_count: personaTopicCount,
         persona_query_count: personaQueryCount,
         persona_query_note: personaQueryNote || null,
+        persona_voice_examples: personaExemplarNote,
         kicker_installed: kickerInstall ? kickerInstall.ok : null,
         kicker_detail: kickerInstall ? kickerInstall.detail : null,
         onboarding: onboardingSnapshot(),
@@ -1961,12 +1996,17 @@ tool("project_config", {
             counts: scan.counts,
             posts: scan.posts,
             comments: scan.comments,
+            top_posts: scan.top_posts,
+            top_replies: scan.top_replies,
             grounding_instructions: scan.grounding_instructions,
             website_research_instructions: WEBSITE_RESEARCH_INSTRUCTIONS,
             onboarding: onboardingSnapshot(),
             next_step: "FOUR steps, in order. FIRST (VOICE, from this scan): read the bio, posts, and comments " +
                 "as GROUND TRUTH and, per grounding_instructions, extract their profession/identity, " +
-                "voice & vibe (tone, phrasing, casing, tics), 2-4 verbatim golden-rule example replies, " +
+                "voice & vibe (tone, phrasing, casing, tics), verbatim golden-rule example replies (the " +
+                "scan pre-ranks these by real engagement in top_replies/top_posts, with stats, parent " +
+                "tweets, and thread continuations; persist them into the project's voice.examples so " +
+                "every drafter mirrors them), " +
                 "a phrase bank + things they avoid, and their icp. The scan is BACKWARD-LOOKING (only what " +
                 "they already posted) so it is the source for VOICE, not the primary source for topics. " +
                 "SECOND (the DICTATION interview — this is where TOPICS + grounding corpus come from, do NOT " +
@@ -2079,6 +2119,13 @@ tool("project_config", {
             });
         }
         const result = applySetup(args);
+        // Persist the profile scan's engagement-ranked exemplars into this
+        // project's voice.examples (+ the persona corpus section when the target
+        // is the persona). Reads the last_profile_scan.json sidecar the scanner
+        // wrote; verbatim quotes of the user's own public replies, so no
+        // synthesis happens here. Best-effort: no scan yet or hand-written
+        // examples present (exit 3) are both fine, and never block the save.
+        const exemplarNote = await applyScannedVoiceExamples(result.project);
         if (result.persona) {
             // no-op on the onboarding ledger; readiness is reported below as usual.
         }
@@ -2176,6 +2223,7 @@ tool("project_config", {
             kicker_detail: kickerInstall ? kickerInstall.detail : null,
             fields_set: result.fields_set,
             fields_removed: result.fields_removed,
+            voice_examples: exemplarNote,
             config_path: configPath(),
             onboarding: onboardingSnapshot(),
             note: (result.persona
@@ -2192,7 +2240,8 @@ tool("project_config", {
                     : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
                         `First derive those fields from existing context, profile_scan, and website research, then ` +
                         `call project_config again with name='${result.project}'. Ask only if a required field is genuinely unknowable.`) +
-                advancedNote,
+                advancedNote +
+                (exemplarNote ? ` ${exemplarNote}` : ""),
         });
     }
     catch (e) {
@@ -2418,19 +2467,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);
@@ -5247,6 +5310,28 @@ async function main() {
     void sendStateSnapshot("startup");
     const ss = setInterval(() => void sendStateSnapshot("interval"), 15 * 60_000);
     ss.unref();
+    // One-shot voice-exemplar catch-up for installs onboarded BEFORE the
+    // exemplar feature: if the persona has no voice.examples_scanned_at, rescan
+    // the connected X profile and store the top-performing replies as
+    // voice.examples + the persona_corpus.txt exemplar section. Additive only
+    // (regenerates just its own marked corpus section; respects hand-written
+    // examples) and self-limiting (marker file rate-limits scan attempts;
+    // BAIL-ON-BUSY on the twitter-browser lock, so it never contends with a
+    // running cycle — it just retries on a later boot). Delayed so boot-time
+    // work (runtime provision, kicker install) settles first.
+    const backfill = setTimeout(() => {
+        if (isPaused())
+            return;
+        void runPython("scripts/voice_exemplars.py", ["backfill"], { timeoutMs: 420_000 })
+            .then((r) => {
+            const last = r.stdout.trim().split("\n").slice(-1)[0] || "";
+            console.error(`[social-autoposter-mcp] voice-exemplars backfill: ${last}`);
+        })
+            .catch((e) => {
+            console.error("[social-autoposter-mcp] voice-exemplars backfill failed:", e?.message || e);
+        });
+    }, 3 * 60_000);
+    backfill.unref();
 }
 main().catch(async (err) => {
     console.error("[social-autoposter-mcp] fatal:", err);

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/twitterAuth.js

@@ -60,8 +60,9 @@ export async function xScanProfile(opts) {
         args.push("--handle", opts.handle);
     args.push("--posts", String(opts?.posts ?? 20));
     args.push("--comments", String(opts?.comments ?? 50));
-    // The scan scrolls two timelines; give it room but keep it bounded.
-    const res = await runPython("scripts/scan_x_profile.py", args, { timeoutMs: 180_000 });
+    // The scan scrolls two timelines plus visits the top posts' permalinks for
+    // thread expansion; give it room but keep it bounded.
+    const res = await runPython("scripts/scan_x_profile.py", args, { timeoutMs: 240_000 });
     try {
         return JSON.parse(res.stdout.trim().split("\n").slice(-1).join("\n"));
     }

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2",
-  "installedAt": "2026-07-10T15:25:23.017Z"
+  "version": "1.7.4-rc.1",
+  "installedAt": "2026-07-10T22:41:18.186Z"
 }

package/mcp/manifest.json

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