@m13v/s4l 1.7.4-rc.25 → 1.7.4-rc.26

package/bin/cli.js

@@ -427,6 +427,29 @@ function installBrowserHarness() {
     if (reset.status !== 0) {
       console.warn('    WARNING: could not reset browser-harness clone to pinned commit; using existing checkout.');
     }
+    // Vendored fix on top of the pin (keep in sync with runtime.ts): loopback
+    // CDP requests must never route through a proxy — macOS system proxy
+    // settings leak into urllib's default opener and a box-wide forwarder
+    // 403s every 127.0.0.1 probe (2026-07-13). Applied at install time since
+    // we don't control the upstream repo. If it stops applying, upstream has
+    // either merged the fix (detected; fine) or refactored (warn); never fail
+    // the install over it.
+    const harnessPatch = path.join(PKG_ROOT, 'scripts', 'patches', 'browser-harness-loopback-cdp-proxy.patch');
+    if (fs.existsSync(harnessPatch)) {
+      const chk = spawnSync('git', ['-C', harnessDir, 'apply', '--check', harnessPatch], { stdio: 'pipe' });
+      if (chk.status === 0) {
+        spawnSync('git', ['-C', harnessDir, 'apply', harnessPatch], { stdio: 'inherit' });
+        console.log('    applied loopback-proxy patch to browser-harness');
+      } else {
+        let fixedUpstream = false;
+        try {
+          fixedUpstream = fs.readFileSync(path.join(harnessDir, 'src', 'browser_harness', 'admin.py'), 'utf-8').includes('cdp_urlopen');
+        } catch { /* file moved — fall through to the warning */ }
+        if (!fixedUpstream) {
+          console.warn('    WARNING: browser-harness loopback-proxy patch no longer applies and the fix is absent upstream; CDP probes may 403 behind a system proxy.');
+        }
+      }
+    }
   };
   if (!fs.existsSync(harnessDir)) {
     fs.mkdirSync(path.dirname(harnessDir), { recursive: true });

package/mcp/dist/runtime.js

@@ -828,6 +828,37 @@ async function provision(progress) {
             timeoutMs: 120000,
         });
         await sh("git", ["-C", HARNESS_DIR, "reset", "--hard", "FETCH_HEAD"], { timeoutMs: 60000 });
+        // Vendored fix on top of the pin: loopback CDP requests must never route
+        // through a proxy. macOS system proxy settings leak into urllib's default
+        // opener, and a box-wide forwarder 403s every 127.0.0.1 probe, so Chrome
+        // reads as "wedged"/logged-out while it is actually fine (2026-07-13).
+        // Upstream doesn't carry the fix and we don't control that repo, so apply
+        // our patch at install time, on every machine. If it stops applying
+        // cleanly, upstream has either merged the fix (detected below; fine) or
+        // refactored the files (warn); never fail the install over it.
+        const harnessPatch = path.join(MATERIALIZED_REPO, "scripts", "patches", "browser-harness-loopback-cdp-proxy.patch");
+        if (fs.existsSync(harnessPatch)) {
+            const chk = await sh("git", ["-C", HARNESS_DIR, "apply", "--check", harnessPatch], {
+                timeoutMs: 30000,
+            });
+            if (chk.code === 0) {
+                await sh("git", ["-C", HARNESS_DIR, "apply", harnessPatch], { timeoutMs: 30000 });
+            }
+            else {
+                let fixedUpstream = false;
+                try {
+                    fixedUpstream = fs
+                        .readFileSync(path.join(HARNESS_DIR, "src", "browser_harness", "admin.py"), "utf-8")
+                        .includes("cdp_urlopen");
+                }
+                catch {
+                    /* file moved — fall through to the warning */
+                }
+                if (!fixedUpstream) {
+                    console.error("[runtime] browser-harness loopback-proxy patch no longer applies and the fix is absent upstream; CDP probes may 403 behind a system proxy");
+                }
+            }
+        }
         // Install the CLI via uv tool (lands at ~/.local/bin/browser-harness).
         // --force so a refreshed source / changed entry point is reinstalled.
         const inst = await sh(uv, ["tool", "install", "--force", "-e", HARNESS_DIR], {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.25",
-  "installedAt": "2026-07-13T15:58:56.002Z"
+  "version": "1.7.4-rc.26",
+  "installedAt": "2026-07-13T16:27:04.389Z"
 }

package/mcp/manifest.json

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

@@ -337,9 +337,9 @@ UPDATE_PROMPT = "Update the S4L plugin to the latest version."
 # Re-arm goes through the HOST create_scheduled_task path (the same one onboarding
 # uses) — it registers the routines under whatever account is logged in and shows
 # up in Routines. The host tool only runs inside an agent chat, so the menu bar
-# hands Claude this prompt (auto-typed, clipboard+paste fallback). We do NOT write
-# scheduled-tasks.json directly — that can't reliably target a just-switched-into
-# account, which is exactly the bug it caused.
+# hands Claude this prompt (auto-typed, clipboard+paste fallback). The automatic
+# fix can now direct-write after resolving lastActiveOrg; keep this host path for
+# Keychain denial, missing/stale cookie, and other resolution failures.
 REARM_PROMPT = (
     "Set up the S4L draft autopilot schedule for this Claude account. "
     "If queue_setup is available, call it; then for s4l-worker call the host tool "
@@ -786,8 +786,8 @@ class S4LMenuBar(rumps.App):
         bridge is panel-only), so the reliable path here is: copy the prompt to the
         clipboard, open Claude, and tell the user to paste it. (The dashboard
         widget's button does this in one click via app.sendMessage — no paste.) We
-        do NOT auto-type (focus/timing flaky) and do NOT write the registry directly
-        (can't reliably target a just-switched-into account).
+        do NOT auto-type (focus/timing flaky). This remains the fallback when the
+        automatic direct-write path cannot resolve/decrypt the active org cookie.
 
         The click itself is captured (mirroring _diagnose_fix) — previously this
         button had NO telemetry at all, so a past incident (Karol, 2026-07-07)
@@ -810,15 +810,15 @@ class S4LMenuBar(rumps.App):
 
     def _finish_schedule_setup(self, _=None):
         """One-click fix for schedule_state == 'missing' when
-        scheduled_task_selfheal.can_create_for_active_account() confirms a
-        session directory already exists for the active account (2026-07-08):
-        quit Claude, create the registration via a direct file write (the
-        same heal() the update flow uses — see its module docstring for why
-        this is equivalent to what create_scheduled_task would produce), then
-        relaunch. Primary action for this case now instead of re-arm: no
-        clipboard paste, no chat turn required. Re-arm remains the fallback
-        for the rarer case where no session directory exists yet for the
-        active account (see _build_menu) — fix 5 never fabricates one.
+        scheduled_task_selfheal.can_create_for_active_account() confirms an
+        existing session directory OR the active-org cookie needed to make
+        the exact account/org directory: quit Claude, create the registration
+        via a direct file write (the same heal() the update flow uses — see
+        its module docstring for why this is equivalent to what
+        create_scheduled_task would produce), then relaunch. Primary action
+        for this case now instead of re-arm: no clipboard paste or chat turn.
+        Re-arm remains the fallback when the cookie is unavailable or macOS
+        denies its Safe Storage Keychain read.
 
         No confirm dialog: the restart is already disclosed in the menu item
         label itself ("...(restarts Claude)", _build_menu) — a modal repeating
@@ -3331,13 +3331,12 @@ class S4LMenuBar(rumps.App):
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             else:
                 items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
-                # Prefer the automatic fix (2026-07-08): if the active account
-                # already has a session directory, _finish_schedule_setup can
-                # create the registration directly (heal() fix 5) with no
-                # clipboard paste needed. Fall back to re-arm only when fix 5
-                # has nowhere to write (no session dir yet for this account —
-                # it never fabricates one), since that's the one case where
-                # only the live create_scheduled_task host tool can help.
+                # Prefer the automatic fix: an existing session directory OR
+                # lastActiveOrg cookie lets _finish_schedule_setup target the
+                # active account exactly (heal() fix 5), with no clipboard
+                # paste. Fall back to the live create_scheduled_task host tool
+                # when neither source is available; decryption denial after a
+                # click is also caught by the post-restart verification.
                 can_selfheal = False
                 try:
                     import scheduled_task_selfheal

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.4-rc.25",
+  "version": "1.7.4-rc.26",
   "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.4-rc.25",
+  "version": "1.7.4-rc.26",
   "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",
@@ -17,6 +17,7 @@
     "!bin/server.js",
     "!bin/auth.js",
     "scripts/*.py",
+    "scripts/patches/",
     "!scripts/db_direct.py",
     "!scripts/sync_blocked_authors.py",
     "!scripts/backfill_real_clicks.py",

package/scripts/patches/browser-harness-loopback-cdp-proxy.patch

@@ -0,0 +1,126 @@
+From a97b7cdae960813f13af39ef99ce878426008dcc Mon Sep 17 00:00:00 2001
+From: m13v <i@m13v.com>
+Date: Mon, 13 Jul 2026 08:48:50 -0700
+Subject: [PATCH] Never route loopback CDP requests through a proxy
+
+urllib's default opener honors proxy env vars and macOS system proxy
+settings (scutil --proxy). On a machine with a system-wide proxy (e.g. a
+local gost/ISP forwarder), every 127.0.0.1 CDP probe is sent to the proxy
+and returns 403 Forbidden, so Chrome looks unreachable while curl (env
+proxies only) and Playwright (own websocket stack) work fine. Route all
+loopback CDP HTTP calls through a proxy-free opener; non-loopback CDP
+URLs keep default proxy behavior.
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
+---
+ src/browser_harness/admin.py  | 24 +++++++++++++++++++++++-
+ src/browser_harness/daemon.py |  7 ++++---
+ src/browser_harness/run.py    |  3 ++-
+ 3 files changed, 29 insertions(+), 5 deletions(-)
+
+diff --git a/src/browser_harness/admin.py b/src/browser_harness/admin.py
+index c72a8fb..64addee 100644
+--- a/src/browser_harness/admin.py
++++ b/src/browser_harness/admin.py
+@@ -5,6 +5,7 @@ import subprocess
+ import sys
+ import tempfile
+ import time
++import urllib.parse
+ import urllib.request
+ from pathlib import Path
+ 
+@@ -445,8 +446,29 @@ def _stop_cloud_browser(browser_id):
+         pass
+ 
+ 
++_NO_PROXY_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
++
++
++def cdp_urlopen(url, timeout=15):
++    """urlopen for CDP endpoints: never send loopback traffic through a proxy.
++
++    urllib's default opener honors proxy env vars AND macOS system proxy
++    settings (scutil --proxy). On a box with a system-wide proxy (e.g. a local
++    gost/ISP forwarder) every 127.0.0.1 CDP probe gets routed to the proxy and
++    comes back 403 Forbidden — Chrome then looks unreachable/"wedged" while
++    curl (env proxies only) and Playwright (own websocket stack) work fine.
++    Loopback must always connect direct; non-loopback CDP URLs keep the
++    default proxy behavior (a remote/cloud CDP endpoint may legitimately need
++    the proxy for reachability).
++    """
++    host = (urllib.parse.urlsplit(url).hostname or "").lower()
++    if host in ("127.0.0.1", "localhost", "::1"):
++        return _NO_PROXY_OPENER.open(url, timeout=timeout)
++    return urllib.request.urlopen(url, timeout=timeout)
++
++
+ def _cdp_ws_from_url(cdp_url):
+-    return json.loads(urllib.request.urlopen(f"{cdp_url}/json/version", timeout=15).read())["webSocketDebuggerUrl"]
++    return json.loads(cdp_urlopen(f"{cdp_url}/json/version", timeout=15).read())["webSocketDebuggerUrl"]
+ 
+ 
+ def _has_local_gui():
+diff --git a/src/browser_harness/daemon.py b/src/browser_harness/daemon.py
+index 0f0f255..ceb08b9 100644
+--- a/src/browser_harness/daemon.py
++++ b/src/browser_harness/daemon.py
+@@ -5,6 +5,7 @@ from collections import deque
+ from pathlib import Path
+ 
+ from . import _ipc as ipc
++from .admin import cdp_urlopen
+ from cdp_use.client import CDPClient
+ 
+ 
+@@ -113,7 +114,7 @@ def get_ws_url():
+         base_url = url.rstrip("/")
+         while time.time() < deadline:
+             try:
+-                return json.loads(urllib.request.urlopen(f"{base_url}/json/version", timeout=5).read())["webSocketDebuggerUrl"]
++                return json.loads(cdp_urlopen(f"{base_url}/json/version", timeout=5).read())["webSocketDebuggerUrl"]
+             except urllib.error.HTTPError as e:
+                 last_err = e
+                 if e.code == 404 and (ws := _ws_from_devtools_active_port(url)):
+@@ -139,7 +140,7 @@ def get_ws_url():
+         deadline = time.time() + 30
+         while time.time() < deadline:
+             try:
+-                return json.loads(urllib.request.urlopen(f"http://127.0.0.1:{port}/json/version", timeout=1).read())["webSocketDebuggerUrl"]
++                return json.loads(cdp_urlopen(f"http://127.0.0.1:{port}/json/version", timeout=1).read())["webSocketDebuggerUrl"]
+             except urllib.error.HTTPError as e:
+                 # Chrome 147+ disables /json/* HTTP discovery on the default user-data-dir;
+                 # the ws path Chrome wrote to DevToolsActivePort still works.
+@@ -153,7 +154,7 @@ def get_ws_url():
+         )
+     for probe_port in (9222, 9223):
+         try:
+-            with urllib.request.urlopen(f"http://127.0.0.1:{probe_port}/json/version", timeout=1) as r:
++            with cdp_urlopen(f"http://127.0.0.1:{probe_port}/json/version", timeout=1) as r:
+                 return json.loads(r.read())["webSocketDebuggerUrl"]
+         except (OSError, KeyError, ValueError):
+             continue
+diff --git a/src/browser_harness/run.py b/src/browser_harness/run.py
+index 8ab1f0f..cbd3835 100644
+--- a/src/browser_harness/run.py
++++ b/src/browser_harness/run.py
+@@ -9,6 +9,7 @@ if hasattr(sys.stdout, "reconfigure"):
+ 
+ from .admin import (
+     _version,
++    cdp_urlopen,
+     NAME,
+     daemon_alive,
+     ensure_daemon,
+@@ -59,7 +60,7 @@ USAGE = """Usage:
+ def _local_chrome_listening():
+     for port in (9222, 9223):
+         try:
+-            urllib.request.urlopen(f"http://127.0.0.1:{port}/json/version", timeout=0.3).close()
++            cdp_urlopen(f"http://127.0.0.1:{port}/json/version", timeout=0.3).close()
+             return True
+         except OSError: pass
+     return False
+-- 
+2.43.0
+

package/scripts/reddit_browser.py

@@ -347,7 +347,53 @@ def _refresh_browser_lock():
     _heartbeat_bash_lease()
 
 
+# --- L1/L2 browser-hang guards (2026-07-13, mirrors twitter_browser.py) ------
+# L1: default per-op/navigation timeouts so no Playwright call can hang forever.
+# L2: liveness heartbeat on the shell reddit-browser lock dir; lock held +
+# stale heartbeat = wedged holder, TERMed by watchdog_hung_runs.py in ~30 min
+# instead of the multi-hour age cap. See twitter_browser.py for the incident
+# writeup (2026-07-13 pid 1380 media-capture wedge during a network flap).
+BROWSER_OP_TIMEOUT_MS = 30_000
+BROWSER_NAV_TIMEOUT_MS = 60_000
+_BROWSER_LOCK_HEARTBEAT = "/tmp/social-autoposter-reddit-browser.lock/heartbeat"
+_HB_THROTTLE_S = 5
+_hb_last_touch = 0.0
+
+
+def _touch_browser_heartbeat(*_args):
+    global _hb_last_touch
+    now = time.time()
+    if now - _hb_last_touch < _HB_THROTTLE_S:
+        return
+    _hb_last_touch = now
+    try:
+        if os.path.isdir(os.path.dirname(_BROWSER_LOCK_HEARTBEAT)):
+            with open(_BROWSER_LOCK_HEARTBEAT, "w") as f:
+                f.write(str(int(now)))
+    except Exception:
+        pass
+
+
 def get_browser_and_page(playwright):
+    """Instrumented entry point: attach via _get_browser_and_page_raw, then
+    (L1) set default per-op/navigation timeouts so no page call can hang
+    forever, and (L2) wire the browser-lock liveness heartbeat. All new code
+    should use THIS, never the raw variant."""
+    browser, page, is_cdp = _get_browser_and_page_raw(playwright)
+    try:
+        page.set_default_timeout(BROWSER_OP_TIMEOUT_MS)
+        page.set_default_navigation_timeout(BROWSER_NAV_TIMEOUT_MS)
+    except Exception:
+        pass
+    _touch_browser_heartbeat()
+    try:
+        page.on("request", _touch_browser_heartbeat)
+    except Exception:
+        pass
+    return browser, page, is_cdp
+
+
+def _get_browser_and_page_raw(playwright):
     """Get a logged-in Reddit page, preferring CDP-attach over launch_persistent_context.
 
     Two paths:

package/scripts/scheduled_task_selfheal.py

@@ -29,12 +29,18 @@ Run as a script -> heals, then prints {"ok": true, ...} as JSON.
 from __future__ import annotations
 
 import glob
+import ctypes
+import ctypes.util
+import hashlib
 import json
 import os
 import shutil
+import sqlite3
+import subprocess
 import sys
 import tempfile
 import time
+import uuid as uuidlib
 
 import schedule_state  # noqa: E402  (lives next to this file in scripts/)
 
@@ -53,6 +59,180 @@ SCHED_REGISTRY_GLOB = os.path.join(
     "claude-code-sessions", "*", "*", "scheduled-tasks.json",
 )
 
+CLAUDE_COOKIE_HOST = ".claude.ai"
+CLAUDE_SAFE_STORAGE_SERVICE = "Claude Safe Storage"
+
+
+def _normalized_uuid(value) -> str | None:
+    """Return a canonical UUID string, or None for anything path-unsafe."""
+    if not isinstance(value, str):
+        return None
+    try:
+        return str(uuidlib.UUID(value.strip()))
+    except (ValueError, AttributeError):
+        return None
+
+
+def _last_active_org_cookie_row(root: str):
+    """Read only the lastActiveOrg row from this Claude profile's cookie DB.
+
+    Opening through SQLite (rather than copying/parsing the file ourselves)
+    also lets SQLite include a live WAL when Claude is still running. Cookie
+    values never leave this helper except as the one selected row.
+    """
+    db = os.path.join(root, "Cookies")
+    if not os.path.isfile(db):
+        return None
+    conn = None
+    try:
+        conn = sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=1)
+        return conn.execute(
+            """
+            SELECT host_key, value, encrypted_value
+              FROM cookies
+             WHERE name = 'lastActiveOrg'
+               AND (host_key = '.claude.ai' OR host_key = 'claude.ai')
+             ORDER BY last_access_utc DESC
+             LIMIT 1
+            """
+        ).fetchone()
+    except Exception:
+        return None
+    finally:
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+
+def _has_last_active_org_cookie(root: str) -> bool:
+    """Cheap capability probe that never reads Keychain or shows a prompt."""
+    row = _last_active_org_cookie_row(root)
+    if not row:
+        return False
+    _host, value, encrypted = row
+    if _normalized_uuid(value):
+        return True
+    return isinstance(encrypted, bytes) and encrypted.startswith(b"v10")
+
+
+def _claude_safe_storage_password() -> bytes | None:
+    """Read Electron's per-user cookie key from macOS Keychain.
+
+    There is deliberately no password field in S4L. macOS owns authorization:
+    the read commonly succeeds silently, but it may show its standard Keychain
+    dialog for the logged-in user. A denial, locked keychain, missing item, or
+    unanswered dialog simply makes this best-effort resolver return None.
+    """
+    if sys.platform != "darwin":
+        return None
+    try:
+        result = subprocess.run(
+            [
+                "/usr/bin/security",
+                "find-generic-password",
+                "-w",
+                "-s",
+                CLAUDE_SAFE_STORAGE_SERVICE,
+            ],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            timeout=20,
+            check=False,
+        )
+        if result.returncode != 0 or not result.stdout:
+            return None
+        password = result.stdout
+        if password.endswith(b"\r\n"):
+            password = password[:-2]
+        elif password.endswith(b"\n"):
+            password = password[:-1]
+        return password or None
+    except Exception:
+        return None
+
+
+def _aes_128_cbc_decrypt(ciphertext: bytes, key: bytes, iv: bytes) -> bytes | None:
+    """AES-CBC/PKCS7 via macOS CommonCrypto, available through libSystem.
+
+    Keeping this in-process avoids passing the derived cookie key on an
+    `openssl -K ...` command line, where another local process could see it.
+    """
+    if sys.platform != "darwin" or not ciphertext:
+        return None
+    try:
+        system_lib = ctypes.util.find_library("System") or "/usr/lib/libSystem.dylib"
+        common_crypto = ctypes.CDLL(system_lib)
+        cc_crypt = common_crypto.CCCrypt
+        cc_crypt.argtypes = [
+            ctypes.c_uint32,  # operation
+            ctypes.c_uint32,  # algorithm
+            ctypes.c_uint32,  # options
+            ctypes.c_void_p, ctypes.c_size_t,  # key, key length
+            ctypes.c_void_p,  # IV
+            ctypes.c_void_p, ctypes.c_size_t,  # input, input length
+            ctypes.c_void_p, ctypes.c_size_t,  # output, output capacity
+            ctypes.POINTER(ctypes.c_size_t),  # bytes written
+        ]
+        cc_crypt.restype = ctypes.c_int32
+
+        key_buf = ctypes.create_string_buffer(key, len(key))
+        iv_buf = ctypes.create_string_buffer(iv, len(iv))
+        input_buf = ctypes.create_string_buffer(ciphertext, len(ciphertext))
+        output_buf = ctypes.create_string_buffer(len(ciphertext) + 16)
+        output_len = ctypes.c_size_t()
+        status = cc_crypt(
+            1,  # kCCDecrypt
+            0,  # kCCAlgorithmAES
+            1,  # kCCOptionPKCS7Padding
+            key_buf, len(key),
+            iv_buf,
+            input_buf, len(ciphertext),
+            output_buf, len(output_buf),
+            ctypes.byref(output_len),
+        )
+        if status != 0:
+            return None
+        return output_buf.raw[:output_len.value]
+    except Exception:
+        return None
+
+
+def _active_org_uuid_from_cookie(root: str) -> str | None:
+    """Resolve the active org without any claude-code-sessions directory.
+
+    Chromium's macOS v10 cookie format uses a PBKDF2-derived AES key from the
+    app's Safe Storage item. Newer databases bind plaintext to the cookie host
+    by prepending SHA-256(host_key); older ones omit that prefix, so accept
+    both formats but only return a syntactically valid UUID.
+    """
+    row = _last_active_org_cookie_row(root)
+    if not row:
+        return None
+    host, value, encrypted = row
+    plain_uuid = _normalized_uuid(value)
+    if plain_uuid:
+        return plain_uuid
+    if not isinstance(encrypted, bytes) or not encrypted.startswith(b"v10"):
+        return None
+
+    password = _claude_safe_storage_password()
+    if not password:
+        return None
+    key = hashlib.pbkdf2_hmac("sha1", password, b"saltysalt", 1003, 16)
+    clear = _aes_128_cbc_decrypt(encrypted[3:], key, b" " * 16)
+    if clear is None:
+        return None
+    host_digest = hashlib.sha256(str(host).encode("utf-8")).digest()
+    if clear.startswith(host_digest):
+        clear = clear[len(host_digest):]
+    try:
+        return _normalized_uuid(clear.decode("utf-8"))
+    except UnicodeDecodeError:
+        return None
+
 
 def _ensure_worker_skill_md() -> bool:
     """Make sure ~/.claude/scheduled-tasks/s4l-worker/SKILL.md exists before we
@@ -110,9 +290,13 @@ def heal() -> dict:
          tree held zero registry files. Resolves the active account via
          schedule_state.py's config.json lookup (lastKnownAccountUuid,
          verified correct against real installs 2026-07-08) and writes a
-         fresh worker entry into its most-recently-touched EXISTING session
-         directory (never fabricates a new directory). Same user-intent and
-         worker_skill_ok guards as fix 4.
+         fresh worker entry into its most-recently-touched existing session
+         directory. If the account has no directory yet, decrypts Claude
+         Desktop's .claude.ai/lastActiveOrg cookie with the current user's
+         macOS `Claude Safe Storage` Keychain item and creates the exact
+         <account>/<organization> pair. Keychain denial/missing-cookie cases
+         fail closed and retain the live-host-tool fallback. Same user-intent
+         and worker_skill_ok guards as fix 4.
     Best-effort: never raises. Returns a small summary dict for logging."""
     summary = {"ok": True, "edited": [], "created": [], "error": None}
     try:
@@ -218,12 +402,25 @@ def heal() -> dict:
                     p for p in glob.glob(os.path.join(account_dir, "*"))
                     if os.path.isdir(p)
                 ]
-                if not session_dirs:
-                    continue  # Desktop has never created a session for this
-                              # account on this box -- nowhere safe to write
-                # Most-recently-touched session dir is the best available
-                # guess for "the one Desktop is actively using".
-                target_dir = max(session_dirs, key=lambda p: os.path.getmtime(p))
+                if session_dirs:
+                    # Most-recently-touched session dir is the best available
+                    # choice when Desktop has already materialized one.
+                    target_dir = max(session_dirs, key=lambda p: os.path.getmtime(p))
+                else:
+                    # A login creates lastActiveOrg before agent mode creates
+                    # claude-code-sessions. It is therefore the missing
+                    # server-assigned half of the exact account/org path.
+                    org_uuid = _active_org_uuid_from_cookie(root)
+                    if not org_uuid:
+                        continue
+                    target_dir = os.path.join(account_dir, org_uuid)
+                    try:
+                        # Private identity-scoped state. Do not chmod a path
+                        # Desktop already made; mode applies only when new.
+                        os.makedirs(account_dir, mode=0o700, exist_ok=True)
+                        os.makedirs(target_dir, mode=0o700, exist_ok=True)
+                    except Exception:
+                        continue
                 target_file = os.path.join(target_dir, "scheduled-tasks.json")
                 new_entry = {
                     "id": WORKER_TASK_ID,
@@ -268,12 +465,12 @@ def heal() -> dict:
 
 def can_create_for_active_account() -> bool:
     """Read-only: would fix 5 (see heal()) actually be able to create a fresh
-    registration right now? True only if the active account (resolved the same
-    way heal() does, via schedule_state's config.json lookup) has at least one
-    EXISTING session directory to write into — fix 5 never fabricates one.
-    Used by callers (the menu bar) to decide whether to offer an automatic
-    "restart to finish setup" action or fall back to the manual re-arm prompt,
-    BEFORE committing to a restart that would turn out to fix nothing."""
+    registration right now? True if the active account has either an existing
+    session directory or a plausible lastActiveOrg cookie. This passive menu/
+    status probe deliberately does NOT read Keychain (which could show an
+    authorization dialog); heal() performs and validates decryption only after
+    the user chooses the restart action. Any denial then fails closed and the
+    post-restart verification points the user to the manual re-arm fallback."""
     try:
         for cfg in schedule_state._config_json_paths():
             root = os.path.dirname(cfg)
@@ -285,7 +482,7 @@ def can_create_for_active_account() -> bool:
                 p for p in glob.glob(os.path.join(account_dir, "*"))
                 if os.path.isdir(p)
             ]
-            if session_dirs:
+            if session_dirs or _has_last_active_org_cookie(root):
                 return True
     except Exception:
         pass

package/scripts/test_scheduled_task_selfheal.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Focused tests for fresh-account scheduled-task registry creation."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(__file__))
+import scheduled_task_selfheal as selfheal  # noqa: E402
+
+
+ACCOUNT_UUID = "f598e7b5-55be-46e8-815e-e8ddb394fc73"
+ORG_UUID = "d03d2d69-12d0-45bf-9f67-ae085d6848e5"
+
+
+def _write_cookie_db(root: str, *, value: str = "", encrypted: bytes = b"v10fixture"):
+    db = os.path.join(root, "Cookies")
+    conn = sqlite3.connect(db)
+    try:
+        conn.execute(
+            """
+            CREATE TABLE cookies (
+                host_key TEXT,
+                name TEXT,
+                value TEXT,
+                encrypted_value BLOB,
+                last_access_utc INTEGER
+            )
+            """
+        )
+        conn.execute(
+            "INSERT INTO cookies VALUES (?, 'lastActiveOrg', ?, ?, 1)",
+            (selfheal.CLAUDE_COOKIE_HOST, value, encrypted),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
+class ScheduledTaskSelfhealTest(unittest.TestCase):
+    def test_decrypted_cookie_strips_chromium_host_digest(self):
+        with tempfile.TemporaryDirectory() as root:
+            _write_cookie_db(root)
+            clear = (
+                hashlib.sha256(selfheal.CLAUDE_COOKIE_HOST.encode()).digest()
+                + ORG_UUID.encode()
+            )
+            with (
+                mock.patch.object(
+                    selfheal, "_claude_safe_storage_password", return_value=b"fixture"
+                ),
+                mock.patch.object(selfheal, "_aes_128_cbc_decrypt", return_value=clear),
+            ):
+                self.assertEqual(selfheal._active_org_uuid_from_cookie(root), ORG_UUID)
+
+    def test_capability_probe_does_not_read_keychain(self):
+        with tempfile.TemporaryDirectory() as root:
+            os.makedirs(root, exist_ok=True)
+            config = os.path.join(root, "config.json")
+            with open(config, "w") as fh:
+                json.dump({"lastKnownAccountUuid": ACCOUNT_UUID}, fh)
+            _write_cookie_db(root)
+            with (
+                mock.patch.object(
+                    selfheal.schedule_state, "_config_json_paths", return_value=[config]
+                ),
+                mock.patch.object(
+                    selfheal,
+                    "_claude_safe_storage_password",
+                    side_effect=AssertionError("passive probe touched Keychain"),
+                ),
+            ):
+                self.assertTrue(selfheal.can_create_for_active_account())
+
+    def test_heal_creates_exact_account_org_registry_without_session_dir(self):
+        with tempfile.TemporaryDirectory() as root:
+            config = os.path.join(root, "config.json")
+            with open(config, "w") as fh:
+                json.dump({"lastKnownAccountUuid": ACCOUNT_UUID}, fh)
+            worker_cwd = os.path.join(root, "worker")
+            registry_glob = os.path.join(
+                root, "claude-code-sessions", "*", "*", "scheduled-tasks.json"
+            )
+            expected = os.path.join(
+                root,
+                "claude-code-sessions",
+                ACCOUNT_UUID,
+                ORG_UUID,
+                "scheduled-tasks.json",
+            )
+            with (
+                mock.patch.object(
+                    selfheal.schedule_state, "_config_json_paths", return_value=[config]
+                ),
+                mock.patch.object(
+                    selfheal, "_active_org_uuid_from_cookie", return_value=ORG_UUID
+                ),
+                mock.patch.object(selfheal, "_ensure_worker_skill_md", return_value=True),
+                mock.patch.object(selfheal, "WORKER_CWD", worker_cwd),
+                mock.patch.object(selfheal, "SCHED_REGISTRY_GLOB", registry_glob),
+                mock.patch.object(selfheal, "DEPRECATED_TASK_IDS", ()),
+                mock.patch.object(selfheal, "LEGACY_WORKER_TASK_IDS", ()),
+            ):
+                summary = selfheal.heal()
+
+            self.assertEqual(summary["created"], [expected])
+            with open(expected) as fh:
+                registry = json.load(fh)
+            self.assertEqual(registry["recordedSkips"], [])
+            self.assertEqual(registry["scheduledTasks"][0]["id"], selfheal.WORKER_TASK_ID)
+            self.assertEqual(registry["scheduledTasks"][0]["cwd"], worker_cwd)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/twitter_browser.py

@@ -610,7 +610,61 @@ def _cdp_diagnostics(cdp_url):
     return diag
 
 
+# --- L1/L2 browser-hang guards (2026-07-13) ----------------------------------
+# L1: no single Playwright operation may block forever. Until today NO script
+# set a default timeout, so any page op could hang indefinitely — a twitter
+# cycle wedged 60+ min in Phase 2b-prep media capture during a network flap
+# (2026-07-13 08:02, pid 1380) while holding the twitter-browser lock, blocking
+# every peer pipeline until the 180-min watchdog cap. Healthy ops here finish
+# in <10s; navigation on the x.com SPA gets extra slack. Callers all have
+# retry layers above, so failing fast is strictly better than hanging.
+BROWSER_OP_TIMEOUT_MS = 30_000
+BROWSER_NAV_TIMEOUT_MS = 60_000
+# L2: liveness heartbeat for the SHELL browser lock (the cross-pipeline mutex,
+# /tmp/social-autoposter-twitter-browser.lock). Touched on attach and on every
+# page network request (throttled), so "lock held + heartbeat stale" means the
+# holder is wedged, not just slow — a healthy 65-min phase2b-gen hold shows
+# constant traffic. watchdog_hung_runs.py reads this to TERM wedged holders in
+# ~30 min instead of the 180-min age cap. Best-effort: never fails the caller.
+_BROWSER_LOCK_HEARTBEAT = "/tmp/social-autoposter-twitter-browser.lock/heartbeat"
+_HB_THROTTLE_S = 5
+_hb_last_touch = 0.0
+
+
+def _touch_browser_heartbeat(*_args):
+    global _hb_last_touch
+    now = time.time()
+    if now - _hb_last_touch < _HB_THROTTLE_S:
+        return
+    _hb_last_touch = now
+    try:
+        if os.path.isdir(os.path.dirname(_BROWSER_LOCK_HEARTBEAT)):
+            with open(_BROWSER_LOCK_HEARTBEAT, "w") as f:
+                f.write(str(int(now)))
+    except Exception:
+        pass
+
+
 def get_browser_and_page(playwright):
+    """Instrumented entry point: attach via _get_browser_and_page_raw, then
+    (L1) set default per-op/navigation timeouts so no page call can hang
+    forever, and (L2) wire the browser-lock liveness heartbeat. All new code
+    should use THIS, never the raw variant."""
+    browser, page, is_cdp = _get_browser_and_page_raw(playwright)
+    try:
+        page.set_default_timeout(BROWSER_OP_TIMEOUT_MS)
+        page.set_default_navigation_timeout(BROWSER_NAV_TIMEOUT_MS)
+    except Exception:
+        pass
+    _touch_browser_heartbeat()
+    try:
+        page.on("request", _touch_browser_heartbeat)
+    except Exception:
+        pass
+    return browser, page, is_cdp
+
+
+def _get_browser_and_page_raw(playwright):
     """Connect to the running twitter-harness Chrome via CDP.
 
     Returns (browser, page, is_cdp=True). `page` is a reused existing Twitter

package/scripts/watchdog_hung_runs.py

@@ -19,6 +19,34 @@ REPO = Path("/Users/matthewdi/social-autoposter")
 LOG_RUN_PY = REPO / "scripts" / "log_run.py"
 SKILL_PATH_MARKER = "/social-autoposter/skill/"
 MAX_AGE_SEC = 45 * 60
+
+# --- L2: browser-lock liveness (2026-07-13) ----------------------------------
+# The age caps below are backstops sized ABOVE the worst-case duration of a
+# HEALTHY run, so they can't tell "90 min in and progressing" from "wedged
+# since minute 4". This check can: the shared browser libs (twitter_browser.py
+# / reddit_browser.py get_browser_and_page) touch <lock_dir>/heartbeat on every
+# attach and page network event, so a *-browser lock held by a LIVE process
+# whose heartbeat has gone stale means the holder is wedged mid-browser-work
+# (2026-07-13: pid 1380 hung 60+ min in Phase 2b-prep media capture during a
+# network flap, blocking every peer pipeline until the 180-min age cap).
+# Thresholds: WARN at 30 min stale (log-only). KILL at 90 min stale — above
+# the gen phase's documented 60-min worst-case ceiling, so a legit long hold
+# with no python browser invocations can't be false-killed — and ONLY when
+# peers are actually queued waiting (an unwanted lock harms nobody). The
+# 2026-07-12 lock.sh signal fix makes the TERM safe: the holder releases its
+# locks and exits instead of continuing lock-protected work.
+# ONLY the heartbeat-instrumented platforms. linkedin-browser holders write no
+# heartbeat (the linkedin pipeline drives Chrome via the bh harness, not a
+# shared python lib), so on pid-file age alone a healthy long linkedin run
+# would be indistinguishable from a wedge — add it here only once its driver
+# touches <lock_dir>/heartbeat too.
+BROWSER_LOCKS_WATCHED = (
+    "/tmp/social-autoposter-twitter-browser.lock",
+    "/tmp/social-autoposter-reddit-browser.lock",
+)
+HB_WARN_SEC = 30 * 60
+HB_KILL_SEC = 90 * 60
+HB_REWARN_SEC = 30 * 60  # re-log the warning at most this often per holder
 # Per-script cap overrides for pipelines that legitimately run longer than
 # the 45 min global (stats.py over ~4-5k posts + rate-limit sleeps).
 # Key is (script_file, platform_or_None). Lookup order: (script, platform),
@@ -317,6 +345,83 @@ def emit_job_log(label, elapsed_sec):
     )
 
 
+def _holder_cmdline(pid: int) -> str:
+    try:
+        out = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "command="],
+            capture_output=True, text=True, timeout=5,
+        ).stdout.strip()
+        return out[:200]
+    except Exception:
+        return ""
+
+
+def check_browser_lock_liveness() -> None:
+    """L2: TERM a live *-browser lock holder whose liveness heartbeat has gone
+    stale for HB_KILL_SEC while peers wait. See the constants block up top."""
+    now = time.time()
+    for lock_dir in BROWSER_LOCKS_WATCHED:
+        if not os.path.isdir(lock_dir):
+            continue
+        try:
+            with open(os.path.join(lock_dir, "pid")) as f:
+                holder = int((f.read().strip() or "0"))
+        except (OSError, ValueError):
+            continue
+        if holder <= 0:
+            continue
+        try:
+            os.kill(holder, 0)  # liveness probe only
+        except ProcessLookupError:
+            continue  # dead holder: acquire_lock's dead_pid reclaim owns this
+        except OSError:
+            continue
+        # Last liveness = freshest of the heartbeat (browser libs) and the pid
+        # file (stamped at acquire), so a just-acquired lock is never "stale".
+        marks = []
+        for name in ("heartbeat", "pid"):
+            try:
+                marks.append(os.path.getmtime(os.path.join(lock_dir, name)))
+            except OSError:
+                pass
+        if not marks:
+            continue
+        stale = now - max(marks)
+        if stale < HB_WARN_SEC:
+            continue
+        try:
+            waiters = len(os.listdir(f"{lock_dir}.queue"))
+        except OSError:
+            waiters = 0
+        lock_name = os.path.basename(lock_dir)
+        if stale >= HB_KILL_SEC and waiters >= 1:
+            cmd = _holder_cmdline(holder)
+            watchdog_log(
+                f"KILL-STALE-HOLDER {lock_name} pid={holder} heartbeat_stale={int(stale)}s "
+                f"waiters={waiters} cmd={cmd!r}"
+            )
+            killed = kill_tree(holder)
+            watchdog_log(f"  killed pids: {killed}")
+            continue
+        # Warn tier: log-only, rate-limited via a marker inside the lock dir
+        # (dies with the lock, so each hold re-warns independently).
+        marker = os.path.join(lock_dir, "hb-warned")
+        try:
+            if now - os.path.getmtime(marker) < HB_REWARN_SEC:
+                continue
+        except OSError:
+            pass
+        try:
+            with open(marker, "w") as f:
+                f.write(str(int(now)))
+        except OSError:
+            pass
+        watchdog_log(
+            f"WARN-STALE-HOLDER {lock_name} pid={holder} heartbeat_stale={int(stale)}s "
+            f"waiters={waiters} cmd={_holder_cmdline(holder)!r}"
+        )
+
+
 def main() -> None:
     procs = list_skill_shell_processes()
     for pid, ppid, etimes, script_file, platform in procs:
@@ -337,6 +442,7 @@ def main() -> None:
             watchdog_log(f"  script trap already logged {label} — skipping watchdog emit")
         else:
             emit_job_log(label, etimes)
+    check_browser_lock_liveness()
 
 
 if __name__ == "__main__":