@m13v/s4l 1.7.4-rc.4 → 1.7.4

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

@@ -0,0 +1,118 @@
+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..de51934 100644
+--- a/src/browser_harness/daemon.py
++++ b/src/browser_harness/daemon.py
+@@ -5,8 +5,22 @@ from collections import deque
+ from pathlib import Path
+ 
+ from . import _ipc as ipc
++from .admin import cdp_urlopen
+ from cdp_use.client import CDPClient
+ 
++# s4l_no_proxy_ws: the daemon's CDP traffic is loopback; never let ANY client
++# in this process route it through a proxy. websockets>=14 autodetects proxies
++# at dial time via urllib.request.proxy_bypass()/getproxies() (which on macOS
++# include SYSTEM proxy settings from scutil --proxy), so a box-wide forwarder
++# turns the CDP WS dial into a proxied CONNECT that fails ("proxy rejected
++# connection: HTTP 503") — same failure class as the urllib 403 that
++# cdp_urlopen fixes for the HTTP lookup. Neutralize resolution process-wide:
++# the daemon's only non-loopback traffic (browser-use cloud API) works direct.
++# Both lookups happen at call time via module attributes, so this holds
++# regardless of import order.
++urllib.request.getproxies = lambda: {}  # type: ignore[assignment]
++urllib.request.proxy_bypass = lambda host: 1  # type: ignore[assignment]
++
+ 
+ def _load_env():
+     repo_root = Path(__file__).resolve().parents[2]
+@@ -113,7 +127,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 +153,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 +167,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

package/scripts/recent_self_posts.py

@@ -95,6 +95,12 @@ def build_block(platform, limit):
             "order_by": "posted_at",
             "order_dir": "desc",
             "limit": str(limit),
+            # Scope to THIS install's own posts (server filters on the
+            # authenticated X-Installation identity). Without this the
+            # default read returns the whole fleet's posts and the block
+            # would claim another account's replies as "yours"
+            # (found 2026-07-10: 8 of 20 rows were another install's).
+            "own_install": "true",
         },
     )
     rows = ((resp or {}).get("data") or {}).get("posts") or []

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:
@@ -1704,7 +1750,7 @@ def _log_dm_outbound(chat_url, content, dm_id=None, minted_codes=None):
         return False
 
 
-def send_dm(chat_url, message, dm_id=None):
+def send_dm(chat_url, message, dm_id=None, apply_campaigns=True):
     """Send a message in a Reddit chat or PM thread.
 
     For chat URLs (reddit.com/chat/...), navigates to the chat room and
@@ -1746,8 +1792,12 @@ def send_dm(chat_url, message, dm_id=None):
         minted_link_codes = wrap_res.get("minted_codes", [])
 
     # Tool-level campaign suffix injection (guaranteed delivery of literal text).
+    # apply_campaigns=False (via S4L_SKIP_CAMPAIGN_SUFFIX on the send-dm CLI)
+    # opts this DM out — set ONLY for human-drafted escalation replies
+    # (engage-dm-replies Phase 0); see twitter_browser.py send_dm for the
+    # incident rationale. The autopilot never sets it.
     applied_campaigns = []
-    for cid, suffix, sample_rate in _load_active_reddit_campaigns_for_dm():
+    for cid, suffix, sample_rate in (_load_active_reddit_campaigns_for_dm() if apply_campaigns else []):
         if random.random() < sample_rate:
             message = message + suffix
             applied_campaigns.append(cid)
@@ -2461,7 +2511,11 @@ def main():
                 dm_id_arg = int(sys.argv[4])
             except ValueError:
                 print(f"[send-dm] ignoring non-int dm_id arg: {sys.argv[4]!r}", file=sys.stderr)
-        result = send_dm(sys.argv[2], sys.argv[3], dm_id=dm_id_arg)
+        # S4L_SKIP_CAMPAIGN_SUFFIX=1 opts this DM out of campaign suffixes.
+        # Set ONLY by engage-dm-replies Phase 0 when delivering a human-drafted
+        # escalation reply — see send_dm's apply_campaigns comment.
+        _skip_camp = os.environ.get("S4L_SKIP_CAMPAIGN_SUFFIX", "").strip().lower() in ("1", "true", "yes")
+        result = send_dm(sys.argv[2], sys.argv[3], dm_id=dm_id_arg, apply_campaigns=not _skip_camp)
         print(json.dumps(result, indent=2))
 
     elif cmd == "compose-dm":

package/scripts/s4l_box_update.sh

@@ -61,7 +61,7 @@ esac
 # four space-separated tokens: "<channel> <tag> <version> <mcpb_url>".
 STATE_DIR="${S4L_STATE_DIR:-$HOME/.social-autoposter-mcp}"
 RESOLVED="$(S4L_STATE_DIR="$STATE_DIR" "$PY" - <<'PYEOF' 2>/dev/null || true
-import json, os, re, subprocess
+import json, os, re, subprocess, time
 
 state = os.environ.get("S4L_STATE_DIR") or os.path.join(os.path.expanduser("~"), ".social-autoposter-mcp")
 try:
@@ -113,6 +113,25 @@ if best is None:
     print("unresolved")
     raise SystemExit(0)
 tag = best[1]
+# Deposit the freshly resolved release into the SHARED cross-process cache
+# (<state dir>/latest-release.json) that version.ts and snapshot.py read, so
+# this probe also feeds the menu bar / MCP for the next TTL window instead of
+# them re-spending quota. etag stays null (this resolver does not capture one);
+# the next conditional probe simply pays one 200 and re-seeds it. Best effort:
+# a failed write never blocks the update itself. NOTE: staging resolves here
+# from the same LIST endpoint the other surfaces use, but stable picks newest
+# non-prerelease from the LIST while they use releases/latest — same result,
+# so the cache stays consistent either way.
+try:
+    os.makedirs(state, exist_ok=True)
+    _p = os.path.join(state, "latest-release.json")
+    _tmp = "%s.tmp.%d" % (_p, os.getpid())
+    with open(_tmp, "w") as _f:
+        json.dump({"at": time.time(), "channel": channel,
+                   "version": tag.lstrip("v"), "tag": tag, "etag": None}, _f)
+    os.replace(_tmp, _p)
+except Exception:
+    pass
 print("%s %s %s %s" % (channel, tag, tag.lstrip("v"), TAG_DL % (REPO, tag)))
 PYEOF
 )"

package/scripts/s4l_mode.py

@@ -70,9 +70,8 @@ toggle): this CLI and mode.json are the only way to flip it.
 `env` additionally exports S4L_CYCLE_LANE=<lane> for both lanes so the wrapper
 knows which lane this cycle is without re-deriving it.
 
-Before the 2026-07-06 SAPS->S4L rename this file lived at scripts/saps_mode.py;
-a thin shim keeps that old path alive for the chflags-locked
-run-twitter-cycle.sh. Do not reference the old name in new code.
+The pre-2026-07-06 helper filename is retired. Current code must import or
+invoke this module directly.
 """
 
 import json
@@ -101,7 +100,7 @@ DEFAULT_PERSONAL_BRAND_SHARE = 0.5
 
 
 def state_dir() -> Path:
-    # Mirrors mcp/src/index.ts sapsStateDir() and menubar/s4l_state.py state_dir().
+    # Mirrors mcp/src/index.ts s4lStateDir() and menubar/s4l_state.py state_dir().
     return Path(
         os.environ.get("S4L_STATE_DIR")
         or (Path.home() / ".social-autoposter-mcp")

package/scripts/scan_x_profile.py

@@ -324,13 +324,31 @@ def _own_posted_ids() -> set:
         from http_api import api_get  # noqa: PLC0415
         import re
         ids: set = set()
-        resp = api_get("/api/v1/posts", {"platform": "twitter",
-                                         "has_our_url": "true", "limit": 2000})
-        rows = ((resp or {}).get("data") or {}).get("posts") or []
-        for r in rows:
-            m = re.search(r"/status/(\d+)", str(r.get("our_url") or ""))
-            if m:
-                ids.add(m.group(1))
+        # The route caps limit at 500, so walk the FULL posting history with a
+        # forward posted_at cursor (order_dir=asc + since>=). On prolific
+        # accounts a single newest-500 page misses older S4L posts that the
+        # profile scan still reaches (bit the operator account: 12.8k posted
+        # statuses, 2 of 5 picked exemplars were S4L's own). The since filter
+        # is inclusive, so overlap rows dedupe via the set; a page whose max
+        # posted_at equals the cursor would loop and breaks instead.
+        cursor = None
+        for _ in range(80):  # hard cap 40k statuses
+            q = {"platform": "twitter", "has_our_url": "true", "limit": 500,
+                 "order_by": "posted_at", "order_dir": "asc"}
+            if cursor:
+                q["since"] = cursor
+            resp = api_get("/api/v1/posts", q)
+            rows = ((resp or {}).get("data") or {}).get("posts") or []
+            for r in rows:
+                m = re.search(r"/status/(\d+)", str(r.get("our_url") or ""))
+                if m:
+                    ids.add(m.group(1))
+            if len(rows) < 500:
+                break
+            page_max = max((r.get("posted_at") or "" for r in rows), default="")
+            if not page_max or page_max == cursor:
+                break
+            cursor = page_max
         return ids
     except Exception as e:
         print(f"[scan_x_profile] own-posts exclusion unavailable: {e}", file=sys.stderr)

package/scripts/schedule_state.py

@@ -94,6 +94,29 @@ def _registry_worker_recs(by_id):
 # false "not scheduled".
 FIRING_WINDOW = 420
 
+# --- Stall thresholds (single source of truth) --------------------------------
+# The longest a fully healthy drain can take end to end: a draft job can wait
+# minutes for a worker slot (per-minute scheduler cadence, workers busy on other
+# jobs) and the drafting turn itself runs multiple minutes. Observed healthy
+# episodes reach 8-10 min (2026-07-13); alarm at 20 min for margin. Every stall
+# detector derives from this ONE number so they can't drift apart again (99e695bf
+# retuned the two per-state timers to 1200s but left the end-to-end DRAFT_STUCK
+# check at 300s, which then false-alarmed on healthy 8-minute drains). The Node
+# server can't import this module — mcp/src/index.ts::AUTOPILOT_STALL_MS must be
+# kept in sync by hand.
+HEALTHY_DRAIN_MAX_SECONDS = 1200
+
+# A pending draft job unclaimed this long: no routine is draining the queue
+# (an idle queue has no pending job at all, so a quiet pipeline never trips it).
+STALL_SECONDS = HEALTHY_DRAIN_MAX_SECONDS
+# A job claimed but still sitting in running/ this long: the worker picked it up
+# and then wedged mid-run (the claude -p drafting child died / never spawned).
+RUNNING_STALL_SECONDS = HEALTHY_DRAIN_MAX_SECONDS
+# The producer's "drafting Nm" label alive this long: the end-to-end clock. This
+# is the only timer that spans claim→die→requeue churn loops, which reset the two
+# per-state timers above on every transition while nothing ever completes.
+DRAFT_STUCK_SECONDS = HEALTHY_DRAIN_MAX_SECONDS
+
 # Grace for a JUST-scheduled task that hasn't fired yet. When the user runs
 # "Set up draft schedule", create_scheduled_task registers both worker tasks
 # (cron "* * * * *", enabled) but lastRunAt is null until the host fires them the

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/setup_twitter_auth.py

@@ -199,7 +199,12 @@ def _launch_chrome() -> bool:
         cmd += ["--window-position=80,80", "--window-size=1100,900"]
     cmd.append("about:blank")
     PROFILE_DIR.mkdir(parents=True, exist_ok=True)
-    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    # start_new_session: Chrome must not inherit this process's group. When the
+    # caller is a transient launchd job, launchd SIGKILLs the job's whole
+    # process group on exit, reaping Chrome with it; the next lane's relaunch
+    # then steals the user's focus (2026-07-12, same fix as *-backend.sh).
+    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                            start_new_session=True)
     try:
         PID_FILE.write_text(str(proc.pid))
     except OSError: