@m13v/s4l 1.7.7 → 1.7.8-rc.2

package/mcp/dist/index.js

@@ -3599,6 +3599,25 @@ function runtimeSnapshot() {
 // host tool create_scheduled_task. Calling it also eagerly pre-approves the
 // worker tools, so the tasks never stall on a permission prompt. Read-only +
 // idempotent.
+// ---- host + draft-provider plumbing (2026-08-06) ---------------------------
+// Which app is hosting this MCP server. Stamped at registration time via the
+// S4L_HOST env on the host's server entry (the codex `mcp add` sets
+// S4L_HOST=codex; Claude registrations set nothing). Deliberately an env var
+// we control, not MCP clientInfo sniffing: deterministic across host versions.
+function s4lHost() {
+    return (process.env.S4L_HOST || "").trim().toLowerCase() === "codex" ? "codex" : "claude";
+}
+// Stamp <state_dir>/draft-provider.json, the single source of truth read at the
+// run_claude.sh seam (scripts/draft_provider.py / claude_job.py) for which
+// engine answers the pipeline's pure text->JSON drafting turns. Last setup
+// wins: re-running queue_setup on either host takes ownership cleanly, which
+// is the single-driver guarantee (never two engines answering one queue).
+function writeDraftProvider(provider, setBy) {
+    const p = path.join(s4lStateDir(), "draft-provider.json");
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ provider, set_at: new Date().toISOString(), set_by: setBy }, null, 2), "utf-8");
+    console.error(`[draft-provider] ${provider} (${setBy})`);
+}
 tool("queue_setup", {
     title: "Get autopilot scheduled-task specs",
     description: "Returns the scheduled task that runs the hands-free draft autopilot on this machine " +
@@ -3610,6 +3629,35 @@ tool("queue_setup", {
         "installs. Use this as the final onboarding step instead of the old per-type worker tasks.",
     inputSchema: {},
 }, async () => {
+    // Codex/ChatGPT host: there is no scheduled-task worker at all. Drafting
+    // runs INLINE in the launchd cycle through the ChatGPT-app-bundled
+    // `codex exec` (headless, subscription-authenticated), so the entire
+    // Claude-Desktop worker apparatus below (allow-rules, SKILL.md, folder
+    // trust, create_scheduled_task) is skipped. Stamping the provider is the
+    // whole setup.
+    if (s4lHost() === "codex") {
+        clearMenubarStop();
+        void ensureMenubar();
+        writeDraftProvider("codex-exec", "queue_setup(codex)");
+        return jsonContent({
+            tasks: [],
+            provider: "codex-exec",
+            expectations: [
+                "What happens next (relay these lines to the user, in their words):",
+                "- About every 5 minutes a background draft cycle scans X for posts that match your search topics and drafts replies in your voice, using this app's engine directly. No scheduled task and no open app window is required.",
+                "- Drafts show up as review cards. The first one usually lands within a few minutes when there is matching supply on X; quiet topics mean fewer or no cards until something relevant is posted.",
+                "- Nothing is posted automatically. You approve each draft yourself (from the dashboard or the menu bar); posting autopilot stays OFF until you explicitly turn it on. Today it only drafts.",
+                "- You can edit your voice, topics, or the drafts themselves at any time, and check status on the dashboard.",
+            ],
+            next_step: "Nothing to schedule on this host: drafting is wired to run inline via the ChatGPT app's " +
+                "engine, driven by the background cycle this server installs. Do NOT create any scheduled " +
+                "task or automation. Relay the `expectations` lines to the user; setup of the draft " +
+                "autopilot is complete.",
+        });
+    }
+    // Claude host: take (or retake) ownership for the Desktop queue worker.
+    // Last setup wins — this is the single-driver guard's other half.
+    writeDraftProvider("claude-desktop-queue", "queue_setup(claude)");
     ensureQueueWorkerToolsAllowed();
     // Re-arming the autopilot is an explicit "start S4L" action: lift a prior
     // tray Quit so the review cards have a surface again. Best-effort and

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.7",
-  "installedAt": "2026-08-04T18:33:55.672Z"
+  "version": "1.7.8-rc.2",
+  "installedAt": "2026-08-07T01:31:32.984Z"
 }

package/mcp/manifest.json

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

@@ -174,9 +174,20 @@ class _Worker(threading.Thread):
         try:
             from AppKit import NSRunningApplication
 
+            hid = refocused = False
             ra = NSRunningApplication.runningApplicationWithProcessIdentifier_(pid)
             if ra is not None:
-                ra.hide()  # order the harness window out
+                # hide() can race the in-flight activation and return False
+                # (observed 2026-08-06: hid=False while refocus succeeded, so
+                # the window stayed visible behind the refocused app — the
+                # "I still saw it" reports). Retry briefly and trust
+                # isHidden() as the verdict, not hide()'s return value.
+                for _ in range(4):
+                    ra.hide()
+                    time.sleep(0.15)
+                    if ra.isHidden():
+                        break
+                hid = bool(ra.isHidden())
             # hide() alone does NOT reliably return focus here: all three
             # harnesses share the "Google Chrome Beta" bundle, so hiding one
             # process can leave the app-level active state on a sibling. Force
@@ -187,9 +198,23 @@ class _Worker(threading.Thread):
                 )
                 # NSApplicationActivateIgnoringOtherApps = 1 << 1
                 if prev is not None and not prev.isTerminated():
-                    prev.activateWithOptions_(1 << 1)
-        except Exception:
-            pass
+                    refocused = bool(prev.activateWithOptions_(1 << 1))
+            # Action log (2026-08-06): "did the guard actually hide it" was
+            # unanswerable for every popup report — the guard acted silently.
+            # One line per suppression, same relay as the telemetry.
+            s4l_log_relay.emit(
+                f"[browser-foreground] guard hide pid={pid} hid={hid} "
+                f"refocused={refocused} prev={self._prev_app or '?'}",
+                context="browser-foreground",
+            )
+        except Exception as e:
+            try:
+                s4l_log_relay.emit(
+                    f"[browser-foreground] guard hide FAILED pid={pid} err={type(e).__name__}: {e}",
+                    context="browser-foreground",
+                )
+            except Exception:
+                pass
 
     def run(self):
         while True:

package/mcp/package.json

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

@@ -97,6 +97,12 @@ def background_new_page(browser, context, url: str = "about:blank", timeout_ms:
         try:
             with context.expect_page(timeout=timeout_ms) as pg_info:
                 cdp.send("Target.createTarget", {"url": url, "background": True})
+            # Log SUCCESS too (2026-08-05): the residual focus-steal hunt hit
+            # same-second orphan blank creates that no log claimed. Success
+            # was silent by design, which made "our background create fired
+            # and coincided" indistinguishable from "an unknown foreground
+            # creator". One line per create closes that ambiguity.
+            _activity_log("bg_new_page", f"url={url[:60]}")
             return pg_info.value
         finally:
             try:
@@ -113,18 +119,26 @@ def background_new_page(browser, context, url: str = "about:blank", timeout_ms:
                f"({type(e).__name__}: {str(e)[:120]}); falling back to "
                f"FOREGROUND new_page (focus steal likely)")
         print(msg, file=sys.stderr)
-        try:
-            _p = os.path.expanduser("~/.claude/browser-profiles/browser-activity.log")
-            with open(_p, "a") as _f:
-                import time as _t
-                _f.write(f"[{_t.strftime('%Y-%m-%d %H:%M:%S')}] pycdp "
-                         f"script=browser_lifecycle.py action=fg_fallback "
-                         f"pid={os.getpid()} detail={type(e).__name__}\n")
-        except Exception:
-            pass
+        _activity_log("fg_fallback", f"detail={type(e).__name__}")
         return context.new_page()
 
 
+def _activity_log(action: str, detail: str = "") -> None:
+    """One line into the universal browser-activity.log (same file the
+    Python-CDP attach logging uses). Best-effort; never raises."""
+    try:
+        import time as _t
+
+        _p = os.path.expanduser("~/.claude/browser-profiles/browser-activity.log")
+        with open(_p, "a") as _f:
+            _f.write(f"[{_t.strftime('%Y-%m-%d %H:%M:%S')}] pycdp "
+                     f"script=browser_lifecycle.py action={action} "
+                     f"pid={os.getpid()} argv0={os.path.basename(sys.argv[0] or '?')} "
+                     f"{detail}\n")
+    except Exception:
+        pass
+
+
 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/claude_job.py

@@ -50,6 +50,11 @@ import s4l_env  # noqa: E402  (lives next to this file in scripts/)
 
 s4l_env.mirror()
 
+# Draft-provider selection (2026-08-06): <state_dir>/draft-provider.json decides
+# which engine answers queue-eligible tags. Stamped once at setup, read here at
+# the seam; no env-var fallback layering. See scripts/draft_provider.py.
+import draft_provider  # noqa: E402  (lives next to this file in scripts/)
+
 # Best-effort menu-bar activity narration. Importable because this script's own
 # directory (scripts/) is on sys.path[0] when run as `python3 .../claude_job.py`.
 # A failure to import (or to write) must NEVER affect the queue's real work.
@@ -702,6 +707,174 @@ def _plog(msg: str) -> None:
         pass
 
 
+def _emit_envelope(obj) -> None:
+    """Print the claude `--output-format json` shaped envelope the pipeline's
+    raw_decode + structured_output/result parsers expect, byte-compatible with
+    both the queue path and a real claude run."""
+    envelope = {
+        "type": "result",
+        "subtype": "success",
+        "is_error": False,
+        "structured_output": obj,
+        "result": json.dumps(obj) if not isinstance(obj, str) else obj,
+    }
+    sys.stdout.write(json.dumps(envelope))
+    sys.stdout.flush()
+
+
+def _run_codex_exec(ns, qtype: str, prompt: str, schema_text: str | None) -> int:
+    """codex-exec provider: answer the turn inline via the ChatGPT-app-bundled
+    `codex exec` (headless, subscription-authenticated). No queue, no worker,
+    no app-open requirement. Same envelope, same 0/1/79 exit semantics as the
+    queue path, so run_claude.sh callers can't tell the difference.
+
+    No fallback to the queue on failure, by design: a broken codex login must
+    fail loudly (rc=1) so the stall/deadman rails surface it, not silently
+    strand jobs in a queue no worker drains.
+    """
+    import tempfile
+
+    codex = draft_provider.codex_bin()
+    if not codex:
+        _plog(f"codex-exec provider active but no codex binary found; failing {qtype}")
+        return 1
+
+    batch = (os.environ.get("BATCH_ID") or os.environ.get("SA_CYCLE_ID") or "-").strip() or "-"
+    job_id = uuid.uuid4().hex
+    _arm_deathwatch(job_id, qtype, batch)
+    _act_write(qtype)
+
+    schema_path = None
+    out_path = None
+    try:
+        out_fd, out_path = tempfile.mkstemp(prefix="s4l_codex_out_", suffix=".txt")
+        os.close(out_fd)
+        cmd = [
+            codex, "exec", "-",
+            "-C", state_dir(),
+            "-s", "read-only",
+            "--skip-git-repo-check",
+            "-o", out_path,
+        ]
+        # Deliberately NOT --output-schema: OpenAI's strict structured-output
+        # mode rejects our lenient claude-style schemas (400 invalid_json_schema
+        # unless additionalProperties:false + all-required everywhere). The
+        # schema rides the prompt as guidance instead, mirroring the worker
+        # rail, and _validate_against_schema stays the lenient gate.
+        if schema_text:
+            prompt = (
+                f"{prompt}\n\n"
+                "FINAL ANSWER FORMAT: reply with ONLY a JSON value matching this "
+                "JSON Schema. No prose, no markdown fences, nothing else:\n"
+                f"{schema_text}"
+            )
+        # Model default: gpt-5.6-sol (best 5.6 tier; user call 2026-08-06), env
+        # override via S4L_CODEX_MODEL. Sol availability is plan-gated and the
+        # app's models_cache.json under-reports it, so truth is probe-by-use:
+        # on the specific "model not supported" 400 we retry ONCE with no -m
+        # (the account's config default, e.g. gpt-5.6-terra) and log the
+        # downgrade loudly. Any other failure stays loud with no retry.
+        model = os.environ.get("S4L_CODEX_MODEL", "").strip() or "gpt-5.6-sol"
+        # The user's global config may pin xhigh reasoning (fine for coding,
+        # slow and token-hungry for a drafting turn). Default these turns to
+        # medium; S4L_CODEX_REASONING overrides.
+        effort = os.environ.get("S4L_CODEX_REASONING", "medium").strip() or "medium"
+        cmd += ["-c", f'model_reasoning_effort="{effort}"']
+
+        budget = max(60, ns.timeout - 60)
+        _plog(f"codex-exec start {qtype} job {job_id} batch={batch} bin={codex} model={model} effort={effort} timeout={budget}s")
+        started = time.time()
+        proc = None
+        for attempt_model in (model, None):
+            attempt_cmd = cmd + (["-m", attempt_model] if attempt_model else [])
+            try:
+                proc = subprocess.run(
+                    attempt_cmd,
+                    input=prompt,
+                    capture_output=True,
+                    text=True,
+                    timeout=max(60, budget - int(time.time() - started)),
+                )
+            except subprocess.TimeoutExpired:
+                _act_clear()
+                _plog(f"codex-exec timed out after {budget}s on job {job_id} ({qtype})")
+                return 79  # mirror the queue path's "blocked, skip cleanly"
+            err_blob = f"{proc.stderr or ''}{proc.stdout or ''}"
+            if (
+                attempt_model
+                and "not supported when using Codex" in err_blob
+            ):
+                _plog(
+                    f"codex-exec model {attempt_model} unavailable on this account; "
+                    f"retrying job {job_id} with the config default model"
+                )
+                continue
+            break
+
+        # Token usage rides stderr as "tokens used\nN"; best-effort log only.
+        m = re.search(r"tokens used\s*\n?\s*([\d,]+)", proc.stderr or "")
+        tokens = m.group(1) if m else "?"
+        if proc.returncode != 0:
+            tail = (proc.stderr or proc.stdout or "").strip()[-400:]
+            _act_clear()
+            _plog(f"codex-exec rc={proc.returncode} on job {job_id} ({qtype}); tail: {tail}")
+            return 1
+
+        try:
+            with open(out_path) as f:
+                text = f.read().strip()
+        except Exception as e:
+            _act_clear()
+            _plog(f"codex-exec produced no last-message file for job {job_id}: {e}")
+            return 1
+        if not text:
+            _act_clear()
+            _plog(f"codex-exec empty answer on job {job_id} ({qtype})")
+            return 1
+
+        # Parse the answer the same leniently the worker rail does: JSON when
+        # it parses (objects for schema'd jobs, bare strings for link-tail),
+        # fenced JSON unwrapped, otherwise the raw text as a plain string.
+        obj = None
+        parsed = False
+        for candidate in (text, re.sub(r"^```(?:json)?\s*|\s*```$", "", text).strip()):
+            try:
+                obj = json.loads(candidate)
+                parsed = True
+                break
+            except Exception:
+                continue
+        if not parsed:
+            obj = text
+
+        err = _validate_against_schema(obj, schema_text)
+        if err:
+            _act_clear()
+            _plog(f"codex-exec result rejected for job {job_id} ({qtype}): {err}")
+            return 1
+
+        _emit_envelope(obj)
+        _mark_drain_success()
+        _stamp_heartbeat("codex-exec", qtype)
+        try:
+            _ncand = len(obj.get("candidates")) if isinstance(obj, dict) and isinstance(obj.get("candidates"), list) else "?"
+        except Exception:
+            _ncand = "?"
+        _plog(
+            f"codex-exec done job {job_id} batch={batch} ({qtype}) in {int(time.time() - started)}s "
+            f"tokens={tokens}; {_ncand} candidates -> producer assembles the plan"
+        )
+        return 0
+    finally:
+        for p in (schema_path, out_path):
+            if p:
+                try:
+                    os.remove(p)
+                except OSError:
+                    pass
+        _disarm_deathwatch(job_id)
+
+
 def cmd_provider(ns) -> int:
     _apply_state_dir_override(ns)
     qtype = TAG_TO_TYPE.get(ns.tag)
@@ -748,10 +921,16 @@ def cmd_provider(ns) -> int:
     # S4L paused: refuse to enqueue at all. Workers won't claim while paused, so
     # an enqueued job would just sit in pending/ while this producer burns its
     # whole wait window "drafting" and then dies to its external timeout.
+    # Applies to every provider: paused means no drafting, period.
     if _is_paused():
         _plog(f"S4L paused; refusing to enqueue {qtype} job")
         return 1
 
+    # Provider branch (2026-08-06). codex-exec answers inline; claude-p never
+    # reaches here (eligible already said no); anything else is the queue.
+    if draft_provider.get() == "codex-exec":
+        return _run_codex_exec(ns, qtype, prompt, schema_text)
+
     job_id = uuid.uuid4().hex
     created = time.time()
     # Cycle batch id (run-twitter-cycle.sh exports BATCH_ID) so every provider.log
@@ -1203,8 +1382,18 @@ def cmd_result(ns) -> int:
 
 def cmd_eligible(ns: argparse.Namespace) -> int:
     """Routing probe for run_claude.sh: exit 0 when the tag is queue-mapped,
-    1 otherwise. TAG_TO_TYPE is the single routing truth — no env var."""
-    return 0 if ns.tag in TAG_TO_TYPE else 1
+    1 otherwise. TAG_TO_TYPE is the single routing truth — no env var.
+
+    Provider layer (2026-08-06): when the box's draft provider is `claude-p`,
+    every tag reports NOT eligible, so run_claude.sh's existing fall-through
+    runs the real `claude -p` directly. That IS the claude-p implementation:
+    zero new execution paths, the locked wrapper stays untouched.
+    """
+    if ns.tag not in TAG_TO_TYPE:
+        return 1
+    if draft_provider.get() == "claude-p":
+        return 1
+    return 0
 
 
 def main() -> int:

package/scripts/draft_provider.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""draft_provider.py: which engine answers the pipeline's pure text->JSON turns.
+
+One file in the state dir (<state_dir>/draft-provider.json) records the choice,
+stamped once at setup time and read at the run_claude.sh seam (via
+claude_job.py). No env-var fallback layering: the file is the single source of
+truth, matching the experiments stamp-at-source rule.
+
+Providers:
+  claude-desktop-queue  (default) enqueue for the Claude Desktop s4l-worker
+                        scheduled task; the only option on boxes whose sole
+                        authenticated engine is Claude Desktop itself.
+  claude-p              skip the queue entirely; claude_job.py `eligible`
+                        returns 1 so run_claude.sh falls through to the real
+                        `claude -p` it already knows how to run. Requires the
+                        Claude Code CLI, logged in.
+  codex-exec            answer inline via the ChatGPT-app-bundled `codex exec`
+                        (headless, subscription-authenticated). Requires the
+                        ChatGPT app installed and logged in. No queue, no
+                        worker, no app-open requirement.
+
+CLI:
+  python3 scripts/draft_provider.py get            -> prints the active provider
+  python3 scripts/draft_provider.py set <name>     -> records the choice
+  python3 scripts/draft_provider.py codex-bin      -> prints resolved codex path
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+
+VALID_PROVIDERS = ("claude-desktop-queue", "claude-p", "codex-exec")
+DEFAULT_PROVIDER = "claude-desktop-queue"
+
+# The npm @openai/codex install is unreliable on macOS (XProtect false-positives
+# trash its native binary, openai/codex #31377), so the ChatGPT-app-bundled
+# binary is the only path we trust. S4L_CODEX_BIN exists for tests and for
+# machines that keep the binary elsewhere.
+CODEX_APP_BIN = "/Applications/ChatGPT.app/Contents/Resources/codex"
+
+
+def state_dir() -> str:
+    return os.environ.get("S4L_STATE_DIR") or os.path.join(
+        os.path.expanduser("~"), ".social-autoposter-mcp"
+    )
+
+
+def provider_path() -> str:
+    return os.path.join(state_dir(), "draft-provider.json")
+
+
+def get() -> str:
+    try:
+        with open(provider_path()) as f:
+            v = json.load(f).get("provider", "")
+    except Exception:
+        return DEFAULT_PROVIDER
+    return v if v in VALID_PROVIDERS else DEFAULT_PROVIDER
+
+
+def set_provider(name: str, set_by: str = "cli") -> None:
+    if name not in VALID_PROVIDERS:
+        raise ValueError(f"unknown provider {name!r}; valid: {VALID_PROVIDERS}")
+    os.makedirs(state_dir(), exist_ok=True)
+    tmp = provider_path() + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(
+            {
+                "provider": name,
+                "set_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "set_by": set_by,
+            },
+            f,
+            indent=2,
+        )
+    os.replace(tmp, provider_path())
+
+
+def codex_bin() -> str | None:
+    """Resolved codex binary path, or None when nothing usable exists."""
+    override = os.environ.get("S4L_CODEX_BIN", "").strip()
+    if override and os.access(override, os.X_OK):
+        return override
+    if os.access(CODEX_APP_BIN, os.X_OK):
+        return CODEX_APP_BIN
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) < 2 or sys.argv[1] not in ("get", "set", "codex-bin"):
+        print(__doc__, file=sys.stderr)
+        return 2
+    cmd = sys.argv[1]
+    if cmd == "get":
+        print(get())
+        return 0
+    if cmd == "codex-bin":
+        b = codex_bin()
+        if not b:
+            print("codex binary not found (is the ChatGPT app installed?)", file=sys.stderr)
+            return 1
+        print(b)
+        return 0
+    if len(sys.argv) < 3:
+        print("usage: draft_provider.py set <name>", file=sys.stderr)
+        return 2
+    try:
+        set_provider(sys.argv[2])
+    except ValueError as e:
+        print(str(e), file=sys.stderr)
+        return 2
+    print(f"draft provider set to {sys.argv[2]}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/foreground_event_capture.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Diagnosis-window capture (2026-08-06): on every harness focus-steal event,
+# snapshot the system state THAT SECOND — transient CDP clients, process ages,
+# frontmost app, and the AppleEvents debug log (enabled via `sudo log config`)
+# which names the PROCESS that requested Chrome's activation. Everything we
+# could never reconstruct minutes later.
+#
+# Run under nohup during the diagnosis window; not a pipeline component.
+# Output: skill/logs/foreground-captures.log
+LOG="$HOME/.social-autoposter-mcp/menubar/menubar.err.log"
+OUT="$HOME/social-autoposter/skill/logs/foreground-captures.log"
+
+tail -F -n0 "$LOG" 2>/dev/null | while IFS= read -r line; do
+    case "$line" in
+        *harness_browser_foregrounded*) ;;
+        *) continue ;;
+    esac
+    {
+        echo "===================================================================="
+        echo "CAPTURE $(date -u +%FT%T.%3NZ 2>/dev/null || date -u +%FT%TZ)"
+        echo "TRIGGER: $line"
+        echo "--- cdp clients 9557/9555/9556 ---"
+        lsof -nP -i :9557 -i :9555 -i :9556 2>/dev/null | grep -v 'Google Chrome' | grep -v COMMAND | \
+        while read -r c p rest; do
+            echo "$c $p started=$(ps -p "$p" -o lstart= 2>/dev/null | tr -s ' ') cmd=$(ps -p "$p" -o command= 2>/dev/null | cut -c1-140)"
+        done
+        echo "--- frontmost ---"
+        osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true' 2>/dev/null
+        echo "--- appleevents debug (last 30s, chrome-related) ---"
+        log show --last 30s --predicate 'subsystem == "com.apple.appleevents"' --style compact 2>/dev/null | \
+            grep -iE 'chrome|activate|reopen|open' | head -20
+        echo "--- launchservices (last 30s, chrome-related) ---"
+        log show --last 30s --predicate 'subsystem == "com.apple.launchservices"' --style compact 2>/dev/null | \
+            grep -iE 'chrome|front|activate' | head -12
+        echo "--- fresh short-lived python (started last 3 min) ---"
+        for p in $(pgrep -f python 2>/dev/null); do
+            et=$(ps -p "$p" -o etime= 2>/dev/null | tr -d ' ')
+            case "$et" in
+                0[0-2]:*|[0-9]:[0-9][0-9]) echo "$p etime=$et $(ps -p "$p" -o command= 2>/dev/null | cut -c1-120)" ;;
+            esac
+        done
+        echo ""
+    } >> "$OUT" 2>&1
+done