@m13v/s4l 1.7.5-rc.2 → 1.7.5-rc.21

package/scripts/browser_mutex.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""browser_mutex.py — THE per-platform browser-session mutex (2026-07-14).
+
+A faithful, parameterized extraction of scripts/twitter_browser.py's
+battle-hardened file mutex, so every platform driver shares ONE implementation
+instead of three divergent ones (reddit_browser.py's old copy still had the
+check-then-write claim race AND the dead-holder starvation twitter fixed on
+2026-06-16). The twitter semantics are preserved bit-for-bit: same lockfile
+JSON shape ({session_id, timestamp, role}), same reclaim ladder, same
+"locked by session" give-up string downstream parsers grep for.
+
+This mutex serializes the PYTHON drivers of one harness Chrome. It deliberately
+does NOT share a path with the shell pipeline lock (skill/lock.sh's
+/tmp/social-autoposter-<name>.lock dirs): pipelines hold that lock around whole
+phases while their child python ops take THIS one per op — merging the two onto
+one path would deadlock that nesting (or need ancestor-walk inheritance in
+every acquire). Unification here means one LIBRARY, not one lock.
+
+Reclaim ladder (a holder we can PROVE dead is taken immediately, so a crashed
+peer can never starve the fleet):
+  1. holder == us            -> re-entrant; refresh and proceed.
+  1b. holder == $S4L_LOCK_OWNER (live) -> batch inherit: a poster parent holds
+      the lock across a whole approved batch; its child reply subprocesses
+      refresh instead of contending, and leave release to the parent.
+  2. UUID holder, pid gone   -> stale legacy (Claude session) lock, reclaim.
+  3. python:PID, pid gone    -> dead peer, reclaim.
+  4. age >= expiry           -> failsafe (role "post" holders get the shorter
+                                post_lock_expiry so a hung poster self-clears).
+  5. live UUID holder        -> inherit (parent Claude session).
+  5b. we are role "post", holder is a LIVE lower-priority python peer ->
+      PREEMPT it (SIGTERM, grace, SIGKILL) and claim: posting is the scarce
+      user-initiated action; the aborted scan re-runs next tick.
+  6. live python peer        -> wait, then give up after wait_max with the
+                                structured "locked by session" error.
+
+Do NOT "simplify" by letting shell pipelines rm -f the lockfile: that blind rm
+deleted LIVE peers' locks (defect b, removed 2026-06-16). See
+docs/twitter_browser_lock.md for the incident history behind every branch.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+
+_UUID_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I
+)
+
+
+class BrowserMutex:
+    def __init__(
+        self,
+        lock_file: str,
+        label: str,
+        lock_expiry: int = 300,
+        post_lock_expiry: int = 180,
+        wait_max: int = 45,
+        poll_interval: int = 2,
+        preempt_kill_wait: int = 5,
+        role: str | None = None,
+        on_touch=None,
+    ):
+        """label is the human prefix in error strings ("Twitter browser",
+        "Reddit browser") — downstream parsers grep "locked by session", keep
+        the shape. on_touch (optional callable) runs after every successful
+        acquire/refresh (reddit bumps its bash lease there); it must never
+        raise consequences: exceptions are swallowed."""
+        self.lock_file = os.path.expanduser(lock_file)
+        self.label = label
+        self.lock_expiry = lock_expiry
+        self.post_lock_expiry = post_lock_expiry
+        self.wait_max = wait_max
+        self.poll_interval = poll_interval
+        self.preempt_kill_wait = preempt_kill_wait
+        self.role = (role or os.environ.get("S4L_LOCK_ROLE") or "scan").strip() or "scan"
+        self.on_touch = on_touch
+        self.session_id = f"python:{os.getpid()}"
+        self.inherited = False
+        self.acquired_at: float | None = None
+
+    # ---- liveness probes ----------------------------------------------------
+    @staticmethod
+    def _is_uuid_holder_alive(holder: str) -> bool:
+        if not holder:
+            return False
+        try:
+            return (
+                subprocess.run(
+                    ["pgrep", "-f", f"claude.*--session-id {holder}"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    timeout=2,
+                ).returncode
+                == 0
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+            return True  # err on the side of NOT stealing
+
+    @staticmethod
+    def _is_python_holder_alive(holder: str) -> bool:
+        if not holder.startswith("python:"):
+            return True  # not a python holder; this probe makes no claim
+        try:
+            pid = int(holder.split(":", 1)[1])
+        except (ValueError, IndexError):
+            return True
+        try:
+            os.kill(pid, 0)
+            return True
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+        except OSError:
+            return True
+
+    # ---- claim / preempt ----------------------------------------------------
+    def _try_take(self) -> bool:
+        """O_CREAT|O_EXCL makes "is it free? then take it" one syscall, so two
+        cold-start acquirers can't both win (defect c)."""
+        try:
+            fd = os.open(self.lock_file, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+        except FileExistsError:
+            return False
+        except OSError:
+            return False
+        try:
+            os.write(fd, json.dumps(
+                {"session_id": self.session_id, "timestamp": int(time.time()), "role": self.role}
+            ).encode())
+        finally:
+            os.close(fd)
+        return True
+
+    def _preempt(self, pid: int) -> bool:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            return True
+        except OSError:
+            return False
+        deadline = time.time() + self.preempt_kill_wait
+        while time.time() < deadline:
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                return True
+            time.sleep(0.2)
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except OSError:
+            pass
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            return True
+        return False
+
+    def _touch(self):
+        if self.on_touch:
+            try:
+                self.on_touch()
+            except Exception:
+                pass
+
+    # ---- public API -----------------------------------------------------------
+    def acquire(self):
+        deadline = time.time() + self.wait_max
+        try:
+            os.makedirs(os.path.dirname(self.lock_file), exist_ok=True)
+        except OSError:
+            pass
+        while True:
+            if not os.path.exists(self.lock_file):
+                if self._try_take():
+                    break
+                if time.time() >= deadline:
+                    print(json.dumps({
+                        "success": False,
+                        "error": f"{self.label} lock contended on create; waited {self.wait_max}s, giving up."
+                    }))
+                    sys.exit(1)
+                time.sleep(self.poll_interval)
+                continue
+            try:
+                with open(self.lock_file) as f:
+                    lock = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                if self._try_take():
+                    break
+                if time.time() >= deadline:
+                    print(json.dumps({
+                        "success": False,
+                        "error": f"{self.label} lock unreadable; waited {self.wait_max}s, giving up."
+                    }))
+                    sys.exit(1)
+                time.sleep(self.poll_interval)
+                continue
+            age = time.time() - lock.get("timestamp", 0)
+            holder = lock.get("session_id", "")
+            holder_role = lock.get("role", "scan")  # legacy locks (no role) = preemptable
+
+            # 1. Re-entrant.
+            if holder == self.session_id and not self.inherited:
+                self.refresh()
+                break
+
+            # 1b. Batch-owner inherit (posting).
+            batch_owner = os.environ.get("S4L_LOCK_OWNER") or ""
+            if holder and holder == batch_owner and self._is_python_holder_alive(holder):
+                self.session_id = holder
+                self.inherited = True
+                self.refresh()
+                print(f"[browser_lock] inherited batch owner={holder} "
+                      f"role={holder_role} -> pid={os.getpid()}", file=sys.stderr)
+                break
+
+            # 2-4. Reclaim provably dead/expired holders.
+            reclaim_reason = ""
+            if _UUID_RE.match(holder or "") and not self._is_uuid_holder_alive(holder):
+                reclaim_reason = "dead_uuid"
+            elif holder.startswith("python:") and not self._is_python_holder_alive(holder):
+                reclaim_reason = "dead_python"
+            elif age >= (self.post_lock_expiry if holder_role == "post" else self.lock_expiry):
+                reclaim_reason = "expired"
+            if reclaim_reason:
+                try:
+                    os.remove(self.lock_file)
+                except OSError:
+                    pass
+                if self._try_take():
+                    print(f"[browser_lock] reclaimed holder={holder or '<none>'} "
+                          f"reason={reclaim_reason} age={int(age)}s -> pid={os.getpid()}",
+                          file=sys.stderr)
+                    break
+                time.sleep(self.poll_interval)
+                continue
+
+            # 5. Live UUID holder = parent Claude session -> inherit.
+            if _UUID_RE.match(holder or ""):
+                self.session_id = holder
+                self.inherited = True
+                break
+
+            # 5b. POSTING PRIORITY: preempt a live lower-priority python peer.
+            if (
+                self.role == "post"
+                and holder.startswith("python:")
+                and holder_role != "post"
+                and self._is_python_holder_alive(holder)
+            ):
+                try:
+                    victim_pid = int(holder.split(":", 1)[1])
+                except (ValueError, IndexError):
+                    victim_pid = 0
+                if victim_pid and self._preempt(victim_pid):
+                    try:
+                        os.remove(self.lock_file)
+                    except OSError:
+                        pass
+                    if self._try_take():
+                        print(
+                            f"[browser_lock] post preempted holder={holder} "
+                            f"role={holder_role} age={int(age)}s -> pid={os.getpid()}",
+                            file=sys.stderr,
+                        )
+                        break
+                time.sleep(self.poll_interval)
+                continue
+
+            # 6. Live python peer: wait, then give up (real contention).
+            if time.time() >= deadline:
+                print(json.dumps({
+                    "success": False,
+                    "error": f"{self.label} locked by session {holder} ({int(age)}s, peer alive); waited {self.wait_max}s, giving up."
+                }))
+                sys.exit(1)
+            time.sleep(self.poll_interval)
+            continue
+        self.acquired_at = time.time()
+        self._touch()
+
+    def refresh(self):
+        try:
+            with open(self.lock_file, "w") as f:
+                json.dump({"session_id": self.session_id, "timestamp": int(time.time()), "role": self.role}, f)
+        except OSError:
+            pass
+        self._touch()
+
+    def release(self):
+        """Inherited locks are the PARENT'S to release; never clobber them."""
+        if self.inherited:
+            return
+        try:
+            if os.path.exists(self.lock_file):
+                with open(self.lock_file) as f:
+                    lock = json.load(f)
+                if lock.get("session_id") == self.session_id:
+                    os.remove(self.lock_file)
+                    if self.acquired_at:
+                        held = time.time() - self.acquired_at
+                        if held >= 5:
+                            print(
+                                f"[browser-lock] held {held:.0f}s "
+                                f"(role={self.role}, pid={os.getpid()})",
+                                file=sys.stderr,
+                            )
+        except (json.JSONDecodeError, OSError):
+            pass

package/scripts/claude_job.py

@@ -71,6 +71,11 @@ TAG_TO_TYPE = {
     # twitter_gen_links.py's Phase 2b-gen step, which already tolerates the
     # queue worker's cadence — see scripts/link_tail.py).
     "twitter-link-tail": "twitter-link-tail",
+    # Reddit draft phase (queue-native since 2026-07-14): post_reddit.py's
+    # draft turn became pure text->JSON (thread content is pre-fetched in
+    # Python and inlined; no Bash tools), mirroring the twitter Phase 2b
+    # tool-free conversion, so it rides the same universal worker.
+    "post-reddit-draft": "reddit-draft",
 }
 
 # queue type -> (activity state, label) the menu bar shows while the job is in
@@ -83,6 +88,10 @@ TYPE_TO_ACTIVITY = {
     "invent-topic": ("learning", "new topic"),
     "invent-queries": ("learning", "new queries"),
     "twitter-link-tail": ("drafting", "link bridge"),
+    # Same bare "draft" label as twitter-prep ON PURPOSE: the menu bar title
+    # must stay concise (user rule 2026-07-14); the platform shows on the
+    # review card itself, not in the tray.
+    "reddit-draft": ("drafting", "draft"),
 }
 
 # queue type -> execution notes PREPENDED to the prompt sidecar at claim time.
@@ -114,6 +123,18 @@ TYPE_TO_WORKER_NOTES = {
         "and not wrapped in any other keys. The caller unwraps a plain string "
         "result directly; wrapping it in an object will corrupt the reply."
     ),
+    "reddit-draft": (
+        "WORKER EXECUTION NOTES (queue metadata; follow while executing the "
+        "prompt below): every Reddit thread's content is already inlined in "
+        "the prompt — do NOT fetch anything, do NOT run searches, no tools "
+        "are needed. Apply the prompt's SELECTION GATE to each candidate, "
+        "draft comments for the ones that pass, and submit ONE result object "
+        "matching the schema: {\"posts\": [...], \"rejects\": [...]}. A "
+        "candidate that fails the gate is simply absent from posts (add a "
+        "rejects entry only for the structural false-positive cases the "
+        "prompt describes). Batches are small; draft them in one pass and "
+        "submit promptly."
+    ),
 }
 
 

package/scripts/config.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""config.py — THE config.json loader. One repo-root resolution, one parser.
+
+Before this module (2026-07-14), ~120 call sites each rolled their own
+`json.load(open(.../config.json))` with at least nine different repo-root
+variable conventions (REPO_DIR, REPO_ROOT, ROOT, _REPO_ROOT, ...), and most
+hardcoded `~/social-autoposter`. That hardcode class runs code OUTSIDE the
+managed package on customer boxes (unreachable by auto-update) and silently
+no-ops where the directory doesn't exist — the exact bug that broke session
+restore and tab cleanup on customer installs (S4L-4H triage 2026-07-12).
+
+Usage:
+    from config import repo_dir, config_path, load_config, get
+
+    cfg = load_config()                      # dict, cached
+    projects = get("projects", [])           # top-level key
+    handle = get("accounts.twitter.handle")  # dotted path
+    cfg = load_config(fresh=True)            # bypass cache (long-lived procs)
+
+Resolution order for the repo root (single source of truth):
+  1. $S4L_REPO_DIR      — set by managed-install launchd plists and the MCP
+                          server, points at ~/.social-autoposter-mcp/repo/package
+  2. this file's parent — scripts/ lives one level under the repo root, so a
+                          direct checkout resolves to itself without any env
+  3. ~/social-autoposter — legacy operator-box fallback
+
+$S4L_CONFIG_PATH overrides the config file location outright (some installs
+pin the operator config, e.g. ~/s4l/config.json, independent of the code dir).
+
+Do NOT add write helpers here. Config writes go through the MCP server's
+project_config tool (it owns validation and the state snapshot); pipeline
+scripts are readers.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+_CACHE: dict | None = None
+_CACHE_PATH: str | None = None
+_CACHE_MTIME: float | None = None
+
+
+def repo_dir() -> str:
+    env = os.environ.get("S4L_REPO_DIR")
+    if env:
+        return os.path.expanduser(env)
+    here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if os.path.exists(os.path.join(here, "config.json")):
+        return here
+    return os.path.expanduser("~/social-autoposter")
+
+
+def config_path() -> str:
+    env = os.environ.get("S4L_CONFIG_PATH")
+    if env:
+        p = os.path.expanduser(env)
+    else:
+        sp = state_config_path()
+        p = sp if os.path.exists(sp) else os.path.join(repo_dir(), "config.json")
+    # Resolve symlinks to the real target. os.replace()-style atomic writers
+    # otherwise REPLACE a symlink with a plain file instead of writing through
+    # it, which is exactly how the operator Mac's config split in two on
+    # 2026-07-11 and again on 2026-07-13. realpath of a plain file is itself,
+    # so customer installs are unaffected.
+    return os.path.realpath(p) if os.path.exists(p) else p
+
+
+def state_config_path() -> str:
+    """Canonical home of config.json (2026-07-13): the state dir, which no
+    package update, re-materialize, or plist regeneration ever touches. The
+    MCP server migrates a legacy $S4L_REPO_DIR/config.json here on boot and
+    leaves a symlink behind for direct-path readers; config_path() prefers
+    this file whenever it exists."""
+    state_dir = os.environ.get("S4L_STATE_DIR") or "~/.social-autoposter-mcp"
+    return os.path.join(os.path.expanduser(state_dir), "config.json")
+
+
+def load_config(fresh: bool = False) -> dict:
+    """Parsed config.json. Cached per (path, mtime); pass fresh=True to force
+    a re-read regardless (e.g. long-lived processes reacting to edits)."""
+    global _CACHE, _CACHE_PATH, _CACHE_MTIME
+    path = config_path()
+    try:
+        mtime = os.path.getmtime(path)
+    except OSError:
+        return {}
+    if not fresh and _CACHE is not None and _CACHE_PATH == path and _CACHE_MTIME == mtime:
+        return _CACHE
+    try:
+        with open(path) as f:
+            _CACHE = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return _CACHE if (_CACHE is not None and _CACHE_PATH == path) else {}
+    _CACHE_PATH = path
+    _CACHE_MTIME = mtime
+    return _CACHE
+
+
+def get(path: str, default=None):
+    """Dotted-path lookup into config.json: get("accounts.twitter.handle").
+    A single-segment path reads a top-level key. Lists are not traversed;
+    fetch the list and iterate at the call site."""
+    node = load_config()
+    for part in path.split("."):
+        if not isinstance(node, dict) or part not in node:
+            return default
+        node = node[part]
+    return node
+
+
+def project(name: str) -> dict | None:
+    """The projects[] entry with this name (case-insensitive), else None."""
+    for p in load_config().get("projects") or []:
+        if isinstance(p, dict) and str(p.get("name", "")).lower() == name.lower():
+            return p
+    return None

package/scripts/counterparty_history.py

@@ -83,10 +83,25 @@ def _conversation_root(platform, post_id, their_comment_url):
     return f"url:{their_comment_url.rsplit('/', 1)[0]}"
 
 
+# Same-author reply cap advisory (2026-07-14): a run of near-identical
+# corrections to one person over a short window reads as one-note bot
+# behavior even when each individual reply was earned. This is a SOFT
+# nudge appended to the history block, not a hard skip, since a genuine
+# direct question from the author (see get_counterparty_history_block)
+# still earns a reply past the threshold; only a deterministic count-based
+# gate would wrongly suppress that case.
+RECENT_CAP_WINDOW_HOURS = 48
+RECENT_CAP_THRESHOLD = 3
+
+
 def _fetch_author_summary(platform, author, days=7):
     """Compute bot/loop-judgment stats for `author` in the last `days` window.
 
-    Returns a one-line summary string (or "" when there is no history).
+    Returns (summary_line, recent_replied_count). summary_line is "" when
+    there is no history. recent_replied_count is how many of our replies to
+    this author landed inside RECENT_CAP_WINDOW_HOURS, used for the same-
+    author cap advisory below.
+
     Signals: total candidates, our replied count, our skipped count,
     distinct conversation roots, our_replies / distinct_roots ratio (the
     "engagement-loop shape" metric — closer to 1.0 = farm-shaped), skip
@@ -94,7 +109,7 @@ def _fetch_author_summary(platform, author, days=7):
     clean), span_hours.
     """
     if not author:
-        return ""
+        return "", 0
     since_ts = (datetime.now(timezone.utc) - timedelta(days=int(days))).isoformat()
     try:
         resp = api_get(
@@ -114,11 +129,11 @@ def _fetch_author_summary(platform, author, days=7):
             f"{platform}/@{author}: {e}",
             file=sys.stderr,
         )
-        return ""
+        return "", 0
 
     total = len(rows)
     if total == 0:
-        return ""
+        return "", 0
 
     replied = sum(1 for r in rows if r.get("status") == "replied")
     skipped = sum(1 for r in rows if r.get("status") == "skipped")
@@ -142,13 +157,29 @@ def _fetch_author_summary(platform, author, days=7):
     if len(timestamps) >= 2:
         span_h = (max(timestamps) - min(timestamps)).total_seconds() / 3600.0
 
-    return (
+    recent_cutoff = datetime.now(timezone.utc) - timedelta(hours=RECENT_CAP_WINDOW_HOURS)
+    recent_replied = 0
+    for r in rows:
+        if r.get("status") != "replied":
+            continue
+        ts = r.get("replied_at") or r.get("discovered_at")
+        if not ts:
+            continue
+        try:
+            dt = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+        except Exception:
+            continue
+        if dt >= recent_cutoff:
+            recent_replied += 1
+
+    summary_line = (
         f"SUMMARY (last {days}d): {total} candidates, {replied} our_replies, "
         f"{skipped} skipped ({skip_pct:.1f}% skip_rate), "
         f"{distinct_roots} distinct conversation_roots "
         f"(replies/root={ratio:.2f}, closer to 1.0 = farm-shaped), "
         f"span={span_h:.1f}h"
     )
+    return summary_line, recent_replied
 
 
 def _fetch_dm_history(platform, author, post_id):
@@ -302,7 +333,7 @@ def get_counterparty_history_block(platform, author, current_post_id=None, curre
         sum_fut = ex.submit(_fetch_author_summary, platform, author, 7)
         same_post_disengage, dm_lines = dm_fut.result()
         pub_lines = pub_fut.result()
-        summary_line = sum_fut.result()
+        summary_line, recent_replied = sum_fut.result()
 
     if not dm_lines and not pub_lines and not summary_line:
         return same_post_disengage, ""
@@ -317,6 +348,13 @@ def get_counterparty_history_block(platform, author, current_post_id=None, curre
     if summary_line:
         parts.append("")
         parts.append(summary_line)
+    if recent_replied >= RECENT_CAP_THRESHOLD:
+        parts.append(
+            f"\nCAUTION: we've already replied to @{author} {recent_replied} times in the "
+            f"last {RECENT_CAP_WINDOW_HOURS}h. Repeating the same correction again reads as "
+            "one-note bot behavior. Only reply again if they asked a direct question or raised "
+            "a genuinely new point; otherwise let this one go or shift to a different angle."
+        )
     if dm_lines:
         parts.append("\n### DM threads on other posts")
         parts.append("\n".join(dm_lines))

package/scripts/engage_github.py

@@ -306,9 +306,13 @@ def run_claude(prompt, timeout=300, session_id=None):
     import time as _time
     import select
     usage = {"input_tokens": 0, "output_tokens": 0, "cache_read": 0, "cache_create": 0, "cost_usd": 0.0}
-    cmd = ["claude", "-p", "--output-format", "stream-json", "--verbose"]
-    if session_id:
-        cmd += ["--session-id", session_id]
+    # Route through run_claude.sh (2026-07-14) for session cost accounting +
+    # quota handling; tag engage-github is unmapped in TAG_TO_TYPE so this
+    # stays a direct claude -p. --session-id travels via the CLAUDE_SESSION_ID
+    # env (set below); the wrapper passes the flag itself, so adding it here
+    # too would hand claude a duplicate flag.
+    _run_claude_sh = os.path.join(os.path.dirname(os.path.abspath(__file__)), "run_claude.sh")
+    cmd = ["bash", _run_claude_sh, "engage-github", "-p", "--output-format", "stream-json", "--verbose"]
     cmd += ["--tools", "Read"]
     env = os.environ.copy()
     env.pop("ANTHROPIC_API_KEY", None)  # use OAuth, not API key

package/scripts/engage_reddit.py

@@ -583,9 +583,15 @@ def run_claude(prompt, timeout=300, session_id=None):
     import time as _time
     import select
     usage = {"input_tokens": 0, "output_tokens": 0, "cache_read": 0, "cache_create": 0, "cost_usd": 0.0}
-    cmd = ["claude", "-p", "--output-format", "stream-json", "--verbose"]
-    if session_id:
-        cmd += ["--session-id", session_id]
+    # Route through run_claude.sh (2026-07-14) for session cost accounting +
+    # the dead-man's-switch quota handling every shell pipeline already gets.
+    # Tag engage-reddit is NOT in claude_job.py TAG_TO_TYPE, so this stays a
+    # direct claude -p (stream-json passes through the wrapper's tee).
+    # --session-id must NOT be passed here: the wrapper adds the flag itself
+    # and honors a caller-set CLAUDE_SESSION_ID env (set below), so passing
+    # it here too would hand claude a duplicate flag.
+    _run_claude_sh = os.path.join(os.path.dirname(os.path.abspath(__file__)), "run_claude.sh")
+    cmd = ["bash", _run_claude_sh, "engage-reddit", "-p", "--output-format", "stream-json", "--verbose"]
     # --bare removed: it blocks OAuth auth which we need
     cmd += ["--tools", "Bash,Read"]
     env = os.environ.copy()