@m13v/s4l 1.7.12-rc.3 → 1.7.12-rc.6

package/mcp/dist/index.js

@@ -5271,6 +5271,43 @@ function readPanelEndpoint() {
         return null;
     }
 }
+// A live pid is not enough to trust panel-endpoint.json: the exit-hook unlink
+// never runs on SIGKILL, so the file can point at a dead pid that the OS later
+// RECYCLES for an unrelated process — kill(pid, 0) then reports "alive" and
+// every instance would cede forever (no panel owner, no heartbeat/relay owner)
+// until the squatter happens to exit. Accept the registration only when the
+// pid's command line actually looks like an S4L MCP server; on ps failure fall
+// back to liveness alone rather than stealing a possibly-valid slot.
+function isS4lServerPid(pid) {
+    if (!isPidAlive(pid))
+        return false;
+    try {
+        const cmd = execFileSync("ps", ["-o", "command=", "-p", String(pid)], {
+            encoding: "utf-8",
+            timeout: 4000,
+        });
+        return cmd.includes("dist/index.js") || cmd.includes("@m13v/s4l-mcp");
+    }
+    catch {
+        return true;
+    }
+}
+// True when this process should run per-INSTALL periodic work (heartbeat,
+// transcript/provider relays, state snapshots). Several server instances are
+// routinely alive at once (Desktop, Code side-panel, per-minute queue workers —
+// each boots its own copy via the ~/.claude.json registration), and before this
+// gate every one of them ran every timer: 16 concurrent instances meant 48
+// heartbeat python spawns per 15 min and a measured ~11k fs-events/sec from
+// duplicate relay scans. Reuse the panel-endpoint election writePanelUrl already
+// maintains: the registered live S4L-server pid is the designated worker; when
+// the file is absent, stale, or squatted, anyone may run the work (the 120s
+// reclaim tick will elect a new owner shortly).
+function isInstallTickOwner() {
+    const existing = readPanelEndpoint();
+    if (!existing?.pid || existing.pid === process.pid)
+        return true;
+    return !isS4lServerPid(existing.pid);
+}
 // Publish the loopback URL to stable files so out-of-process readers can find
 // the ephemeral port without scraping `lsof`:
 //   - panel-url            plain text, for the Claude Code side-panel reverse proxy.
@@ -5295,7 +5332,7 @@ function writePanelUrl(url) {
         fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(path.join(dir, "panel-url"), url, "utf-8");
         const existing = readPanelEndpoint();
-        if (existing?.pid && existing.pid !== process.pid && isPidAlive(existing.pid)) {
+        if (existing?.pid && existing.pid !== process.pid && isS4lServerPid(existing.pid)) {
             // Someone else already holds a live registration (most likely a longer-
             // lived session than us) — don't clobber it. Our own panel is still up
             // and fully usable via `url` for anything that already has it (e.g. this
@@ -6212,6 +6249,67 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`[social-autoposter-mcp] connected. v=${VERSION} repo=${repoDir()}`);
+    // Exit when the client goes away. The SDK's StdioServerTransport listens only
+    // for stdin 'data'/'error' — never 'end'/'close' — so client death is invisible
+    // to it, and the eagerly-started panel HTTP listener below holds the event loop
+    // open forever. That combination orphaned 16 servers (33 GB RSS, duplicate
+    // autopilot timers) on 2026-09-18: every client exit (clean close OR SIGKILL,
+    // which just closes our stdin pipe) left a full server behind, reparented to
+    // launchd. Handle EOF ourselves, plus signals, plus a ppid backstop for the
+    // rare case where an inherited fd keeps the stdin pipe open past client death.
+    let shutdownStarted = false;
+    const exitNow = (reason) => {
+        console.error(`[social-autoposter-mcp] client gone (${reason}); exiting`);
+        try {
+            localPanel?.server.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        process.exit(0);
+    };
+    const shutdown = (reason, force = false) => {
+        if (shutdownStarted) {
+            // A second signal while we wait out a drain means "stop now".
+            if (force)
+                exitNow(`${reason}, forced`);
+            return;
+        }
+        shutdownStarted = true;
+        if (!postingActive) {
+            exitNow(reason);
+            return;
+        }
+        // A posting drain is in flight: this process holds the shared
+        // twitter-browser shell lock under its OWN pid while a python poster child
+        // drives Chrome. Exiting now (a) lets the next per-minute cycle
+        // stale-reclaim the lock mid-post and (b) crashes the poster on EPIPE
+        // between a landed reply and its bookkeeping — the idempotent redrain then
+        // double-posts. Wait for the drain to finish (the interval is deliberately
+        // ref'd so it keeps the process alive), capped at the approve_drafts
+        // worst-case timeout.
+        console.error(`[social-autoposter-mcp] client gone (${reason}); waiting for in-flight posting drain before exit`);
+        const started = Date.now();
+        const wait = setInterval(() => {
+            if (!postingActive || Date.now() - started > 2 * 3600_000) {
+                clearInterval(wait);
+                exitNow(`${reason}, drain done`);
+            }
+        }, 5_000);
+    };
+    process.stdin.on("end", () => shutdown("stdin end"));
+    process.stdin.on("close", () => shutdown("stdin close"));
+    process.on("SIGTERM", () => shutdown("SIGTERM", true));
+    process.on("SIGINT", () => shutdown("SIGINT", true));
+    // Skip the backstop when we were BORN with ppid 1 (a launchd-managed server is
+    // legitimately parented to launchd; only a reparent-after-birth means orphaned).
+    if (process.ppid !== 1) {
+        const ppidWatch = setInterval(() => {
+            if (process.ppid === 1)
+                shutdown("orphaned (ppid=1)");
+        }, 30_000);
+        ppidWatch.unref();
+    }
     // Eagerly start the loopback panel server so the Claude Code side panel (and any
     // reverse proxy in front of it) always has a backend to hit, without waiting for
     // a first `dashboard` call. Best-effort: a bind failure must never block boot.
@@ -6245,8 +6343,16 @@ async function main() {
     // (parity with the npx launchd heartbeat). Once on startup, then every 15m
     // while the desktop app keeps the server alive. unref() so it never holds the
     // process open past a normal exit.
+    // Heartbeat + the relays + snapshots below are per-INSTALL work: gate every
+    // tick on the panel-endpoint election (isInstallTickOwner) so N concurrent
+    // instances produce 1x the spawns, not Nx. The startup heartbeat stays
+    // unconditional — a fresh install must phone home before it ever wins an
+    // election.
     void sendHeartbeat("startup");
-    const hb = setInterval(() => void sendHeartbeat("interval"), 15 * 60_000);
+    const hb = setInterval(() => {
+        if (isInstallTickOwner())
+            void sendHeartbeat("interval");
+    }, 15 * 60_000);
     hb.unref();
     // Ship Claude session transcripts (scheduled queue-worker runs + s4l repo
     // sessions) to the Cloud Logging relay so a user's session can be
@@ -6257,7 +6363,7 @@ async function main() {
     if ((process.env.S4L_TRANSCRIPT_RELAY ?? "1") !== "0") {
         let transcriptRelayRunning = false;
         const relayTranscripts = () => {
-            if (transcriptRelayRunning)
+            if (transcriptRelayRunning || !isInstallTickOwner())
                 return;
             transcriptRelayRunning = true;
             runPython("scripts/relay_session_transcripts.py", ["--max-lines", "600"], {
@@ -6283,7 +6389,7 @@ async function main() {
     if ((process.env.S4L_PROVIDER_LOG_RELAY ?? "1") !== "0") {
         let providerRelayRunning = false;
         const relayProviderLog = () => {
-            if (providerRelayRunning)
+            if (providerRelayRunning || !isInstallTickOwner())
                 return;
             providerRelayRunning = true;
             runPython("scripts/relay_provider_log.py", ["--max-lines", "500"], {
@@ -6306,7 +6412,10 @@ async function main() {
     // the recurring tick only POSTs when something actually changed; setup.ts
     // additionally fires it right after every config write.
     void sendStateSnapshot("startup");
-    const ss = setInterval(() => void sendStateSnapshot("interval"), 15 * 60_000);
+    const ss = setInterval(() => {
+        if (isInstallTickOwner())
+            void sendStateSnapshot("interval");
+    }, 15 * 60_000);
     ss.unref();
     // Voice-exemplar catch-up + periodic refresh, checked on every boot
     // (2026-07-16, extended from the original one-shot-for-legacy-installs

package/mcp/dist/repo.js

@@ -85,6 +85,21 @@ export function run(cmd, args, opts = {}) {
         }
         let stdout = "";
         let stderr = "";
+        // Cap captured output to a tail. run() used to accumulate a child's full
+        // stdout+stderr unbounded for the child's lifetime; long-lived spawns (the
+        // 13h voice backfill) and stuck children pinned those strings and were the
+        // main driver of multi-GB server heaps. Callers that parse output read
+        // either whole small payloads or the LAST line, so keeping the tail
+        // preserves semantics. 8 MB per stream is far above any legitimate payload.
+        const MAX_CAPTURE_BYTES = 8 * 1024 * 1024;
+        const capTail = (s) => s.length > MAX_CAPTURE_BYTES ? s.slice(s.length - (MAX_CAPTURE_BYTES >> 1)) : s;
+        // The line-splitter buffers below only shed at '\n', so a child emitting
+        // long newline-free output (carriage-return progress bars, one huge line)
+        // would grow them unbounded for its lifetime — the same heap pathology the
+        // capture cap exists for. Keep only a tail of an oversized partial line
+        // (telemetry truncates lines to 8KB anyway).
+        const MAX_LINEBUF_BYTES = 1024 * 1024;
+        const capLineBuf = (buf) => buf.length > MAX_LINEBUF_BYTES ? buf.slice(-8192) : buf;
         // Per-stream partial-line buffers so onLine fires on whole lines only,
         // regardless of how the OS chunks the pipe reads.
         let outBuf = "";
@@ -104,7 +119,7 @@ export function run(cmd, args, opts = {}) {
                     /* a progress sink must never break the wrapped command */
                 }
             }
-            return buf;
+            return capLineBuf(buf);
         };
         // Parallel whole-line splitter that tees to the telemetry sink (if any),
         // kept separate from the onLine pump so neither path can affect the other.
@@ -127,29 +142,56 @@ export function run(cmd, args, opts = {}) {
                     /* the telemetry sink must never break the wrapped command */
                 }
             }
-            return buf;
+            return capLineBuf(buf);
         };
+        let settled = false;
         let timer;
+        let killTimer;
         if (opts.timeoutMs) {
             timer = setTimeout(() => {
                 child.kill("SIGTERM");
+                // A child that ignores SIGTERM used to live (and hold its pipes and our
+                // buffers) forever. Escalate — but GENEROUSLY: children trap SIGTERM on
+                // purpose to finish critical bookkeeping (twitter_post_plan.py finishes
+                // the current candidate's post + recording, which can take minutes, so a
+                // fast SIGKILL would reopen the posted-but-unrecorded double-post
+                // window). 15 min covers every graceful path; only a truly wedged child
+                // gets hard-killed.
+                killTimer = setTimeout(() => {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        /* already gone */
+                    }
+                }, 15 * 60_000);
+                killTimer.unref();
             }, opts.timeoutMs);
         }
         child.stdout.on("data", (d) => {
+            if (settled)
+                return;
             const s = d.toString();
-            stdout += s;
+            stdout = capTail(stdout + s);
             outBuf = pump(s, "stdout", outBuf);
             sinkOutBuf = sinkPump(s, "stdout", sinkOutBuf);
         });
         child.stderr.on("data", (d) => {
+            if (settled)
+                return;
             const s = d.toString();
-            stderr += s;
+            stderr = capTail(stderr + s);
             errBuf = pump(s, "stderr", errBuf);
             sinkErrBuf = sinkPump(s, "stderr", sinkErrBuf);
         });
-        child.on("close", (code) => {
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
             if (timer)
                 clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
             // Flush any trailing partial line (output with no terminating newline).
             if (opts.onLine) {
                 if (outBuf)
@@ -185,10 +227,28 @@ export function run(cmd, args, opts = {}) {
                     }
             }
             resolve({ code: code ?? -1, stdout, stderr });
+        };
+        child.on("close", (code) => finish(code));
+        child.on("exit", (code) => {
+            // 'close' waits for the stdio pipes to drain, which never happens when a
+            // grandchild inherited them and outlives the child — the promise (and the
+            // captured output) then leaked for the grandchild's lifetime. After the
+            // child itself exits, give the pipes a grace to flush, then settle. The
+            // setImmediate hop matters: if the event loop was stalled past the grace
+            // by sync work, timers fire BEFORE the poll phase reads the data already
+            // sitting in the kernel buffer — hopping to the check phase lets those
+            // reads land first instead of truncating a successful child's output.
+            const drain = setTimeout(() => setImmediate(() => finish(code)), 10_000);
+            drain.unref();
         });
         child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
             if (timer)
                 clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
             resolve({ code: -1, stdout, stderr: stderr + String(err) });
         });
     });

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.12-rc.3",
-  "installedAt": "2026-08-21T17:20:57.824Z"
+  "version": "1.7.12-rc.6",
+  "installedAt": "2026-09-24T20:11:16.353Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.12-rc.3",
+  "version": "1.7.12-rc.6",
   "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.12-rc.3",
+  "version": "1.7.12-rc.6",
   "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.12-rc.3",
+  "version": "1.7.12-rc.6",
   "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/cdp_drive.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Minimal CDP driver for the harness Chrome on port 9556.
+Usage:
+  cdp_drive.py nav <url>            -> navigate active page tab, print final href
+  cdp_drive.py href                 -> print current href of active page tab
+  cdp_drive.py shot <path>          -> screenshot active page tab to path
+  cdp_drive.py click <x> <y>        -> dispatch mouse click at viewport coords
+  cdp_drive.py eval <expr>          -> evaluate JS expression, print JSON result
+"""
+import sys, json, time, base64
+import urllib.request
+import websocket  # websocket-client
+
+PORT = 9556
+BASE = f"http://localhost:{PORT}"
+
+
+def list_tabs():
+    with urllib.request.urlopen(f"{BASE}/json/list", timeout=10) as r:
+        return json.load(r)
+
+
+def active_page():
+    tabs = list_tabs()
+    pages = [t for t in tabs if t.get("type") == "page" and t.get("webSocketDebuggerUrl")]
+    # prefer a linkedin tab, else first page
+    for t in pages:
+        if "linkedin.com" in (t.get("url") or ""):
+            return t
+    if pages:
+        return pages[0]
+    raise RuntimeError("no page tab")
+
+
+class CDP:
+    def __init__(self, ws_url):
+        self.ws = websocket.create_connection(
+            ws_url, max_size=None, timeout=60, suppress_origin=True
+        )
+        self._id = 0
+
+    def cmd(self, method, **params):
+        self._id += 1
+        mid = self._id
+        self.ws.send(json.dumps({"id": mid, "method": method, "params": params}))
+        while True:
+            msg = json.loads(self.ws.recv())
+            if msg.get("id") == mid:
+                if "error" in msg:
+                    raise RuntimeError(msg["error"])
+                return msg.get("result", {})
+
+    def close(self):
+        try:
+            self.ws.close()
+        except Exception:
+            pass
+
+
+def get_href(c):
+    r = c.cmd("Runtime.evaluate", expression="location.href", returnByValue=True)
+    return r.get("result", {}).get("value")
+
+
+def main():
+    action = sys.argv[1]
+    tab = active_page()
+    c = CDP(tab["webSocketDebuggerUrl"])
+    try:
+        if action in ("nav", "click"):
+            c.cmd("Page.enable")
+        if action == "nav":
+            url = sys.argv[2]
+            c.cmd("Page.navigate", url=url)
+            time.sleep(6)
+            print(get_href(c))
+        elif action == "href":
+            print(get_href(c))
+        elif action == "shot":
+            path = sys.argv[2]
+            r = c.cmd("Page.captureScreenshot", format="png")
+            with open(path, "wb") as f:
+                f.write(base64.b64decode(r["data"]))
+            print(path)
+        elif action == "click":
+            x = float(sys.argv[2]); y = float(sys.argv[3])
+            c.cmd("Input.dispatchMouseEvent", type="mousePressed", x=x, y=y, button="left", clickCount=1)
+            c.cmd("Input.dispatchMouseEvent", type="mouseReleased", x=x, y=y, button="left", clickCount=1)
+            time.sleep(4)
+            print(get_href(c))
+        elif action == "eval":
+            expr = sys.argv[2]
+            r = c.cmd("Runtime.evaluate", expression=expr, returnByValue=True, awaitPromise=True)
+            print(json.dumps(r.get("result", {}).get("value")))
+        else:
+            print("unknown action", file=sys.stderr); sys.exit(2)
+    finally:
+        c.close()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/cdp_ready_check.py

@@ -24,6 +24,18 @@ crashed ("Aw, Snap") keeps its title/url in every listing while sitting dead;
 probe each page with a trivial Runtime.evaluate and reload it IN PLACE on
 failure — fresh renderer, no kill, no new window, no focus change.
 
+DEAD SESSION DISPATCH (2026-08-20, recurred 2026-09-01): a parked tab whose
+DevTools SESSION dispatch is dead never replies to any per-tab command, so the
+in-place Page.reload hangs too and cannot revive it — while the browser-level
+ws stays healthy and this probe used to report ready anyway (Playwright then
+hung at connect for every posting attempt; on 09-01 that burned all 5 drain
+retries on two human-approved drafts). The reload is therefore RE-VERIFIED
+with a second Runtime.evaluate; a tab that still doesn't answer gets REPLACED
+via browser-level Target.createTarget(background=True) + Target.closeTarget
+(the proven fix both incidents — no Chrome restart, no focus steal, session
+cookies intact). Only if replacement itself fails does the verdict flip to
+ready=false, so hc_ensure_browser's two-strike reap finally has a real signal.
+
 Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
 
 Prints a one-line JSON verdict to stdout (same shape/keys as before; mode is
@@ -84,9 +96,13 @@ def main() -> int:
         info = _get_json(f"{url}/json/version", timeout=3)
         _ws_call(info["webSocketDebuggerUrl"], "Browser.getVersion", timeout_s)
 
-        # Renderer-liveness sweep: revive crashed tabs in place, best-effort;
-        # revival must never fail the readiness verdict the wedge gate uses.
+        # Renderer-liveness sweep. A crashed renderer revives with an in-place
+        # reload; a tab with dead session dispatch (reload hangs too) gets
+        # REPLACED via browser-level commands. Only an unfixable page tab
+        # fails the verdict — see DEAD SESSION DISPATCH in the docstring.
         revived = 0
+        replaced = 0
+        dead = 0
         pages = []
         try:
             pages = [t for t in _get_json(f"{url}/json/list", timeout=3)
@@ -95,23 +111,54 @@ def main() -> int:
                 try:
                     _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
                              4.0, expression="1")
+                    continue
+                except Exception:
+                    pass
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
+                except Exception:
+                    pass
+                # Re-verify: a reload that went through proves dispatch is
+                # alive again; one that hung proves it never will be.
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
+                             4.0, expression="1")
+                    revived += 1
+                    continue
+                except Exception:
+                    pass
+                # Dead session dispatch: replace the TAB, keep Chrome. Only
+                # http(s) tabs are recreated (the harness daemon's
+                # is_real_page refuses about:/chrome: tabs); the dead one is
+                # closed only after its replacement exists so the browser is
+                # never left tabless.
+                page_url = t.get("url") or ""
+                try:
+                    if not page_url.startswith("http"):
+                        raise ValueError(f"unreplaceable url {page_url[:40]!r}")
+                    _ws_call(info["webSocketDebuggerUrl"], "Target.createTarget",
+                             8.0, url=page_url, background=True)
+                    _ws_call(info["webSocketDebuggerUrl"], "Target.closeTarget",
+                             8.0, targetId=t["id"])
+                    replaced += 1
                 except Exception:
-                    try:
-                        _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
-                        revived += 1
-                    except Exception:
-                        pass
+                    dead += 1
         except Exception:
             pass
 
         out = {
-            "ready": True, "mode": "raw_ws", "contexts": len(pages),
+            "ready": dead == 0, "mode": "raw_ws", "contexts": len(pages),
             "elapsed_s": round(time.time() - t0, 2),
         }
         if revived:
             out["revived"] = revived
+        if replaced:
+            out["replaced"] = replaced
+        if dead:
+            out["dead_pages"] = dead
+            out["error"] = "page_session_dead_unreplaceable"
         print(json.dumps(out))
-        return 0
+        return 0 if dead == 0 else 1
     except Exception as e:
         print(json.dumps({
             "ready": False, "mode": "raw_ws",

package/scripts/draft_prompt_core.py

@@ -301,10 +301,19 @@ def _load_config():
 def projects_json(lane=None, only_project=None):
     """The ALL_PROJECTS_JSON block: per-project drafting config as a JSON
     string. lane='personal_brand' emits ONLY the persona project through the
-    whitelist; otherwise every project through the ops denylist.
+    whitelist; otherwise every ROUTABLE project through the ops denylist.
     only_project (reddit lane: one project per draft call) narrows the
     promotion output to that single project's entry. Returns '{}' on any
-    failure, mirroring the shell's `|| echo "{}"`."""
+    failure, mirroring the shell's `|| echo "{}"`.
+
+    Routable (2026-09-23): the promotion roster excludes persona entries and
+    archived projects (enabled: false). ALL_PROJECTS_JSON doubles as the prep
+    step's PROJECT ROUTING target list ("...unless the thread content clearly
+    better fits another project"), so an unfiltered roster let a promotion
+    cycle re-route a candidate onto the persona while the personal_brand lane
+    was switched OFF (observed 2026-09-23: a promotion-lane card posted as
+    PersonalBrand), or onto an archived project. The persona is reachable
+    ONLY via the personal_brand lane's whitelist branch above."""
     lane = lane if lane is not None else os.environ.get("S4L_ACTIVE_LANE", "")
     try:
         config = _load_config()
@@ -319,6 +328,10 @@ def projects_json(lane=None, only_project=None):
         for p in projects:
             if only_project and p.get("name") != only_project:
                 continue
+            if not only_project and (
+                p.get("persona") is True or p.get("enabled", True) is False
+            ):
+                continue
             out[p["name"]] = {k: v for k, v in p.items() if k not in _OPS_KEYS}
         return json.dumps(out, indent=2)
     except Exception:

package/scripts/dump_visitor_history.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Dump a visitor's cross-thread history as JSON for prompt injection.
+
+Gives the web-chat agent memory of a returning visitor across ALL their
+threads, so it never goes cold ("nothing like that on our side") on a known
+user just because they opened a fresh thread. Reads:
+
+    GET /api/v1/web-chat/visitor?email=<email>&exclude=<thread>&limit=N
+
+Used by skill/check-web-chats.sh alongside dump_web_chat_history.py:
+
+    $(python3 scripts/dump_visitor_history.py --email "$EMAIL" --exclude "$THREAD_ID")
+
+Returns:
+  {
+    "visitor_email": ..., "thread_count": N, "excluded_thread": ...,
+    "threads": [{ thread_id, project, page_url, created_at, last_message_at }, ...],
+    "recent_messages": [{ thread_id, sender, sender_name, text, created_at }, ...]
+  }
+
+On any error (no email, thread-only visitor, endpoint 404) it prints an empty
+skeleton and exits 0, so the caller can always inline the output safely.
+"""
+
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get
+
+EMPTY = {"visitor_email": "", "thread_count": 0, "threads": [], "recent_messages": []}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--email", required=True)
+    parser.add_argument("--exclude", default="", help="thread_id to leave out (the current one)")
+    parser.add_argument("--project", default="")
+    parser.add_argument("--limit", type=int, default=120)
+    args = parser.parse_args()
+
+    email = (args.email or "").strip()
+    if not email or "@" not in email:
+        print(json.dumps(EMPTY))
+        return
+
+    query = {"email": email, "limit": args.limit}
+    if args.exclude:
+        query["exclude"] = args.exclude
+    if args.project:
+        query["project"] = args.project
+
+    try:
+        resp = api_get("/api/v1/web-chat/visitor", query=query, ok_on_404=True)
+    except Exception as e:  # never let a memory lookup crash the spawn
+        print(json.dumps({**EMPTY, "visitor_email": email, "_error": str(e)}))
+        return
+
+    if resp.get("_not_found"):
+        print(json.dumps({**EMPTY, "visitor_email": email}))
+        return
+
+    out = resp.get("data") or {}
+    if not out:
+        out = {**EMPTY, "visitor_email": email}
+    print(json.dumps(out, indent=2))
+
+
+if __name__ == "__main__":
+    main()