social-autoposter 1.6.176 → 1.6.178

package/mcp/dist/index.js

@@ -1184,6 +1184,17 @@ tool("engagement_mode", {
         personaTopicsSeeded = true;
     }
     completeOnboardingMilestone("mode_chosen", { personal_brand: personalBrand, promotion, persona: personaName });
+    // Personal-brand-only is a first-class setup path: the persona is the draftable
+    // project, so seeding its topics IS the topics_seeded milestone. Without this the
+    // product path (project_config) is the only place that completes it, leaving a
+    // persona-only checklist stuck at "topics pending" even though topics are live.
+    if (personalBrand && personaTopicsSeeded) {
+        completeOnboardingMilestone("topics_seeded", {
+            project: personaName,
+            topic_count: personaTopicCount,
+            persona: true,
+        });
+    }
     // Install/refresh the launchd kicker NOW. For a personal-brand-only setup the
     // persona is the only draftable project (no managed product), so nothing else
     // would trigger the install until a later queue-worker boot — leaving the user

package/mcp/dist/setup.js

@@ -36,6 +36,20 @@ export const REQUIRED_FIELDS = [
     // project is NOT ready until it has at least one topic to seed. (2026-06-02)
     "search_topics",
 ];
+// Required fields for a personal-brand PERSONA project (persona:true). A persona
+// is a person's voice, NOT a product: it has no `website` and no target `icp` by
+// design. Validating a persona against the product REQUIRED_FIELDS therefore ALWAYS
+// reports it "missing website + icp" -> personaReady() could never be true, which
+// silently defeated the persona-aware kicker gate (a personal-brand-only setup then
+// never scheduled the autopilot and drafted nothing). So a persona is "ready" once
+// it has the fields the cycle actually consumes: a name, a voice, and at least one
+// seedable search topic. (2026-06-30, completing the 1.6.173 persona path)
+export const PERSONA_REQUIRED_FIELDS = [
+    "name",
+    "description",
+    "voice",
+    "search_topics",
+];
 export const RECOMMENDED_FIELDS = [
     "differentiator",
     "get_started_link",
@@ -422,14 +436,14 @@ export function ensureShortLinksDefault() {
 // ---------------------------------------------------------------------------
 // Which required fields are missing on the persisted project in config.json.
 // Returns null when the named project can't be found/read.
-export function missingForProject(name) {
+export function missingForProject(name, fields = REQUIRED_FIELDS) {
     if (!name)
         return null;
     try {
         const proj = (readConfig().projects || []).find((p) => p.name === name);
         if (!proj)
             return null;
-        return REQUIRED_FIELDS.filter((f) => {
+        return fields.filter((f) => {
             const v = proj[f];
             if (v == null)
                 return true;
@@ -471,7 +485,9 @@ export function personaReady() {
     const persona = findPersonaProject();
     if (!persona)
         return false;
-    const missing = missingForProject(persona.name);
+    // Validate against PERSONA_REQUIRED_FIELDS, NOT the product REQUIRED_FIELDS: a
+    // persona has no website/icp by design, so the product set would never pass.
+    const missing = missingForProject(persona.name, PERSONA_REQUIRED_FIELDS);
     return missing !== null && missing.length === 0;
 }
 const SETUP_REQUIRED_MESSAGE = "No project is set up yet. Run the `project_config` tool first: collect from the user their website " +

package/mcp/dist/telemetry.js

@@ -148,8 +148,6 @@ const LOG_FLUSH_MS = 3000; // otherwise flush on this cadence
 let logNoiseRe = null;
 try {
     const extra = (process.env.SAPS_LOG_NOISE_RE || "").trim();
-    // Default signatures: a bare `ps`/`launchctl`-style table dump row is rare in
-    // pipeline output but floods when an agent shells one in. Keep this tight.
     const sources = [
         extra,
     ].filter(Boolean);
@@ -158,9 +156,20 @@ try {
 catch {
     logNoiseRe = null;
 }
+// The X-Installation header (identity.py `header` output) is a single long base64
+// blob printed on stdout. Every heartbeat + every log flush shells identity.py to
+// mint it, and that stdout was being tee'd straight back into the log stream, which
+// re-triggered a flush — a self-referential loop that flooded Cloud Logging with
+// ~21k identical base64 lines/hour and buried real pipeline output. Karol's box was
+// impossible to read through it. Drop any line that is nothing but a long run of
+// base64 chars (no spaces): real pipeline output is never shaped like this, so the
+// filter is safe. Kept separate from logNoiseRe so an env override can't disable it.
+const BASE64_BLOB_RE = /^[A-Za-z0-9+/=_-]{120,}$/;
 function isNoise(line) {
     if (!line || !line.trim())
         return true; // blank / whitespace-only
+    if (BASE64_BLOB_RE.test(line.trim()))
+        return true; // X-Installation header echo
     if (logNoiseRe && logNoiseRe.test(line))
         return true;
     return false;

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.176",
-  "installedAt": "2026-07-01T00:50:21.138Z"
+  "version": "1.6.178",
+  "installedAt": "2026-07-01T02:07:11.872Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.176",
+  "version": "1.6.178",
   "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

@@ -79,6 +79,28 @@ except Exception as _import_err:
 
 import s4l_state as st  # noqa: E402
 
+# AppKit is available in the owned venv (PyObjC is a rumps dependency). We use it
+# only to pull the accessory (LSUIElement) app to the front before showing an
+# NSAlert: an agent app that isn't the active app has its rumps.alert appear
+# BEHIND the frontmost window ("modal doesn't show on top"), because runModal
+# doesn't activate the app for us. Guarded so a missing AppKit never breaks the
+# menu bar — the alert still shows, just possibly not front-most.
+try:
+    from AppKit import NSApplication  # noqa: E402
+except Exception:
+    NSApplication = None
+
+
+def _activate_front():
+    """Bring this accessory app to the front so the next NSAlert (rumps.alert)
+    opens on top of whatever was frontmost, instead of behind it. Best-effort."""
+    try:
+        if NSApplication is not None:
+            NSApplication.sharedApplication().activateIgnoringOtherApps_(True)
+    except Exception:
+        pass
+
+
 CLAUDE_APP = "Claude"
 POLL_SECONDS = 5
 
@@ -349,6 +371,7 @@ class S4LMenuBar(rumps.App):
         else:
             msg = "Click OK, then open Claude and ask it to " + action_desc + "."
         try:
+            _activate_front()
             rumps.alert(title=title, message=msg, ok="OK")
         except Exception:
             self._notify("S4L · prompt copied" if copied else "S4L",
@@ -598,6 +621,7 @@ class S4LMenuBar(rumps.App):
             return
         # ok=1 (plugin reset, keeps X login + browser layer), other=-1 (deep wipe),
         # cancel=0. See rumps.alert: default=1, alternate=0, other=-1.
+        _activate_front()
         choice = rumps.alert(
             title="Reset test machine?",
             message=(
@@ -638,6 +662,7 @@ class S4LMenuBar(rumps.App):
 
     def _alert(self, title, message):
         try:
+            _activate_front()
             rumps.alert(title=title, message=message, ok="OK")
         except Exception:
             pass
@@ -670,6 +695,7 @@ class S4LMenuBar(rumps.App):
         disable them is to quit Claude, strip the tasks while it's down, then
         relaunch. We warn the user with a modal FIRST that Claude Desktop will
         restart, since the app window will close and reopen under them."""
+        _activate_front()
         choice = rumps.alert(
             title="Quit the S4L autoposter?",
             message=(
@@ -946,6 +972,7 @@ class S4LMenuBar(rumps.App):
             self._reloc_needed = False
             self._cwd_healed = True
             return
+        _activate_front()
         choice = rumps.alert(
             title="Tidy the autopilot history?",
             message=(

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.176",
+  "version": "1.6.178",
   "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": "social-autoposter",
-  "version": "1.6.176",
+  "version": "1.6.178",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js"

package/scripts/identity.py

@@ -168,6 +168,35 @@ def _app_version():
     return None
 
 
+def _claude_desktop_version():
+    """CFBundleShortVersionString of the Claude Desktop app (macOS), or None.
+
+    Stamped into the install identity (and thus the X-Installation header on every
+    heartbeat) so the install-lane digest can correlate leaks/regressions with the
+    Desktop version. This is the variable we could not answer for Karol's box. Reads
+    Info.plist directly via plistlib; best-effort, never raises."""
+    if (platform.system() or "").lower() != "darwin":
+        return None
+    candidates = [
+        Path("/Applications/Claude.app/Contents/Info.plist"),
+        Path.home() / "Applications" / "Claude.app" / "Contents" / "Info.plist",
+    ]
+    for plist in candidates:
+        try:
+            if not plist.exists():
+                continue
+            import plistlib
+
+            with plist.open("rb") as f:
+                data = plistlib.load(f)
+            v = data.get("CFBundleShortVersionString") or data.get("CFBundleVersion")
+            if v:
+                return str(v).strip() or None
+        except Exception:
+            continue
+    return None
+
+
 def _tz():
     try:
         from datetime import datetime
@@ -192,6 +221,7 @@ def _build_fresh_identity():
         "python_version": platform.python_version() or None,
         "node_version": _node_version(),
         "app_version": _app_version(),
+        "claude_desktop_version": _claude_desktop_version(),
         "git_email": _git_email(),
         "tz": _tz(),
         "first_seen_at": int(time.time()),

package/scripts/memory_snapshot.py

@@ -16,6 +16,7 @@ import re
 import socket
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Any
 
@@ -595,6 +596,8 @@ def build_snapshot(top_n: int) -> dict[str, Any]:
         "ts": dt.datetime.now(dt.timezone.utc).astimezone().isoformat(timespec="seconds"),
         "hostname": socket.gethostname(),
         "repo_dir": str(REPO_DIR),
+        "claude_desktop_version": claude_desktop_version(),
+        "reaper": reaper_status(),
         "memory": parse_vm_stat(),
         "process_count": len(rows),
         "top_rss": [
@@ -685,6 +688,8 @@ def build_summary() -> dict[str, Any]:
         "ts": dt.datetime.now(dt.timezone.utc).astimezone().isoformat(timespec="seconds"),
         "hostname": socket.gethostname(),
         "app_version": _app_version(),
+        "claude_desktop_version": claude_desktop_version(),
+        "reaper": reaper_status(),
         "process_count": len(rows),
         "mem": {
             "total_mb": total,
@@ -724,6 +729,188 @@ def _app_version() -> str | None:
     return None
 
 
+def claude_desktop_version() -> str | None:
+    """CFBundleShortVersionString of the Claude Desktop app, or None if not found.
+
+    This is the ONE variable we could not answer for Karol: the reaper's blind spot
+    (a newer Claude Code changed the session-path shape so UUID_RE stopped matching)
+    is version-correlated, so we now stamp the Desktop version on every heartbeat +
+    snapshot. Reading Info.plist via plistlib is more robust than shelling `defaults`
+    (works headless, no user-defaults cache). Checks both the system-wide and the
+    per-user install locations. Best-effort: never raises."""
+    candidates = [
+        Path("/Applications/Claude.app/Contents/Info.plist"),
+        Path.home() / "Applications" / "Claude.app" / "Contents" / "Info.plist",
+    ]
+    for plist in candidates:
+        try:
+            if not plist.exists():
+                continue
+            import plistlib
+
+            with plist.open("rb") as f:
+                data = plistlib.load(f)
+            v = data.get("CFBundleShortVersionString") or data.get("CFBundleVersion")
+            if v:
+                return str(v).strip() or None
+        except Exception:
+            continue
+    return None
+
+
+def reaper_status() -> dict[str, Any] | None:
+    """Last cycle written by reap_stale_claude_sessions.py::write_status(), or None.
+
+    The reaper is a SEPARATE launchd job (com.m13v.social-claude-reaper) whose stderr
+    only lands in a local file, so its outcome was invisible centrally. It now drops a
+    reaper-status.json each cycle; we carry it on the heartbeat so a stuck/blind reaper
+    (e.g. ps_timed_out, or unparsed_worker_procs climbing while it kills nothing — the
+    Karol failure mode) is visible in installation_resource_samples. Also surfaces
+    staleness: if the file has not been touched recently the reaper itself may be dead."""
+    path = (
+        Path(os.environ.get("SAPS_STATE_DIR", str(Path.home() / ".social-autoposter-mcp")))
+        / "claude-queue"
+        / "reaper-status.json"
+    )
+    try:
+        if not path.exists():
+            return None
+        ds = json.loads(path.read_text())
+        age = None
+        try:
+            age = round(time.time() - path.stat().st_mtime, 1)
+        except OSError:
+            pass
+        return {
+            "ts": ds.get("ts"),
+            "age_sec": age,  # seconds since the reaper last wrote — >120s hints it is dead
+            "mode": ds.get("mode"),
+            "claude_killed": ds.get("claude_killed"),
+            "macos_mcp_killed": ds.get("macos_mcp_killed"),
+            "worker_probe_seen": ds.get("worker_probe_seen"),
+            "reapable_workers": ds.get("reapable_workers"),
+            "unparsed_worker_procs": ds.get("unparsed_worker_procs"),
+            "macos_mcp_seen": ds.get("macos_mcp_seen"),
+            "leaked_groups": ds.get("leaked_groups"),
+            "ps_timed_out": ds.get("ps_timed_out"),
+            "snapshot_empty": ds.get("snapshot_empty"),
+        }
+    except (OSError, ValueError, TypeError):
+        return None
+
+
+def _tail_lines(path: Path, n: int, approx_line_bytes: int = 4096) -> list[str]:
+    """Return the last `n` lines of a possibly-large file without reading it all.
+    Reads a bounded tail window (n * approx_line_bytes) from the end. Best-effort."""
+    try:
+        size = path.stat().st_size
+        want = min(size, n * approx_line_bytes)
+        with path.open("rb") as f:
+            f.seek(size - want)
+            data = f.read()
+        text = data.decode("utf-8", "replace")
+        lines = text.splitlines()
+        # Drop a possibly-truncated first line when we did not start at byte 0.
+        if want < size and lines:
+            lines = lines[1:]
+        return lines[-n:]
+    except Exception:
+        return []
+
+
+def _maybe_leak_alert(output: Path, current: dict[str, Any]) -> None:
+    """Fire a Sentry event when a monitored process group climbs monotonically for
+    N consecutive snapshots — the leak SHAPE that took down Karol's box (claude
+    workers + remote-macos-use MCP servers ratcheting up unbounded). This catches a
+    leak while it is GROWING, hours before the box freezes, instead of us finding out
+    from a support ticket. Best-effort + rate-limited by a cooldown file so a genuine
+    ongoing leak pages once per window, not every minute.
+
+    Runs on the JSONL path (every ~minute), reading its own recent history from the
+    file just written, so it needs no extra state beyond a small cooldown marker."""
+    groups_to_watch = ("claude_cli", "remote_macos_mcp_servers")
+    samples = _env_int("SAPS_LEAK_ALERT_SAMPLES", 5)      # consecutive climbs required
+    floor = _env_int("SAPS_LEAK_ALERT_FLOOR", 20)          # ignore below this count
+    climb_min = _env_int("SAPS_LEAK_ALERT_CLIMB_MIN", 12)  # min first->last growth
+    cooldown_s = _env_int("SAPS_LEAK_ALERT_COOLDOWN", 1800)
+    if samples < 3:
+        samples = 3
+
+    tail = _tail_lines(output, samples)
+    series: list[dict[str, Any]] = []
+    for line in tail:
+        try:
+            series.append(json.loads(line))
+        except Exception:
+            continue
+    if len(series) < samples:
+        return
+
+    def counts(name: str) -> list[int]:
+        vals = []
+        for snap in series[-samples:]:
+            g = (snap.get("groups") or {}).get(name) or {}
+            c = g.get("count")
+            vals.append(int(c) if isinstance(c, (int, float)) else 0)
+        return vals
+
+    leaking: list[str] = []
+    for name in groups_to_watch:
+        vals = counts(name)
+        if len(vals) < samples:
+            continue
+        monotonic = all(vals[i] <= vals[i + 1] for i in range(len(vals) - 1))
+        grew = (vals[-1] - vals[0]) >= climb_min
+        if monotonic and grew and vals[-1] >= floor:
+            leaking.append(f"{name} {vals[0]}->{vals[-1]} over {samples} samples")
+
+    if not leaking:
+        return
+
+    # Cooldown: one page per window even if the leak persists for hours.
+    state = Path(os.environ.get("SAPS_STATE_DIR", str(Path.home() / ".social-autoposter-mcp"))) / "claude-queue"
+    cooldown = state / "leak-alert.cooldown"
+    now = time.time()
+    try:
+        if cooldown.exists() and (now - cooldown.stat().st_mtime) < cooldown_s:
+            return
+    except OSError:
+        pass
+
+    reason = "; ".join(leaking)
+    # Always emit the stderr marker (parsed into the dashboard even without Sentry).
+    print(f"LEAK_ALERT {reason}", file=sys.stderr)
+    try:
+        import sentry_init
+
+        sentry_init.init()
+        sentry_init.capture_message(
+            f"process-group leak climbing: {reason}",
+            level="warning",
+            tags={
+                "component": "leak_detector",
+                "hostname": socket.gethostname(),
+                "claude_desktop_version": claude_desktop_version() or "unknown",
+                "app_version": _app_version() or "unknown",
+            },
+        )
+        sentry_init.flush(3.0)
+    except Exception:
+        pass
+    try:
+        state.mkdir(parents=True, exist_ok=True)
+        cooldown.write_text(str(now))
+    except Exception:
+        pass
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--output", default=os.environ.get("SAPS_MEMORY_SNAPSHOT_LOG", str(DEFAULT_OUTPUT)))
@@ -748,6 +935,10 @@ def main() -> int:
     with output.open("a", encoding="utf-8") as fh:
         fh.write(json.dumps(snapshot, sort_keys=True, separators=(",", ":")) + "\n")
 
+    # Proactive leak page: reads the tail of the JSONL we just appended to, so no
+    # extra state. Best-effort; never blocks the snapshot write.
+    _maybe_leak_alert(output, snapshot)
+
     groups = snapshot.get("groups", {})
     queues = snapshot.get("queues", {})
     claude_queue = queues.get("claude_queue", {}) if isinstance(queues, dict) else {}

package/scripts/reap_stale_claude_sessions.py

@@ -40,6 +40,7 @@ even before the owned runtime is provisioned.
 
 from __future__ import annotations
 
+import datetime as dt
 import json
 import os
 import re
@@ -102,6 +103,16 @@ SIG_REQUIRED = (
 DISCLAIMER_HINT = "Helpers/disclaimer"
 SIG_EXCLUDED = (DISCLAIMER_HINT,)
 
+# A LOOSER probe used purely for telemetry (never for killing): any process that
+# looks like a bundled claude-code agent-mode worker, even if it does NOT satisfy
+# the full SIG_REQUIRED tuple or its session path fails UUID_RE. This is the exact
+# blind spot that let Karol's box leak undetected: a newer Claude Code changed the
+# session-path shape so UUID_RE stopped matching, the worker fell out of `procs`,
+# and the reaper saw "nothing to do" while ~289 workers piled up. We count these
+# separately (`unparsed_worker_procs`) so a future regression is VISIBLE centrally
+# instead of silent.
+WORKER_PROBE = ("claude-code/", "--input-format stream-json")
+
 UUID_RE = re.compile(r"local-agent-mode-sessions/([0-9a-fA-F-]{36})")
 
 # The paired leak: every leaked `claude` worker spawns a `mcp-server-macos-use`
@@ -157,15 +168,39 @@ def parse_etime(etime: str) -> int:
 def snapshot():
     """Snapshot the process table once.
 
-    Returns (procs, by_pid, macos_mcp, meta):
+    Returns (procs, by_pid, macos_mcp, meta, stats):
       * procs     — claude agent-mode worker-signature processes (the primary target).
       * by_pid    — {pid: cmd} for every process (used to pair the disclaimer stub).
       * macos_mcp — {pid, ppid, age, cmd} for every `mcp-server-macos-use` node server
                     (the paired leak, reaped in main()).
       * meta      — {pid: {ppid, age}} for every process, so main() can tell whether an
                     MCP server's parent is still alive (orphan detection).
+      * stats     — {ps_timed_out, snapshot_empty, worker_probe_seen, reapable_workers,
+                    unparsed_worker_procs, macos_mcp_seen, total_procs}. Pure telemetry
+                    so a future regression (e.g. UUID_RE stops matching a newer Claude
+                    Code, the exact blind spot on Karol's box) is VISIBLE centrally
+                    instead of silently piling up.
     """
-    out = _run_ps()
+    stats = {
+        "ps_timed_out": False,
+        "snapshot_empty": False,
+        "worker_probe_seen": 0,     # procs that look like a claude-code agent worker
+        "reapable_workers": 0,      # of those, ones that satisfy SIG + UUID (=len(procs))
+        "unparsed_worker_procs": 0, # probe-positive but NOT reapable (regex/sig miss)
+        "macos_mcp_seen": 0,
+        "total_procs": 0,
+    }
+    try:
+        out = _run_ps()
+    except subprocess.TimeoutExpired:
+        # ps timed out even after the retry (box is at load 75 / 90% sys under a
+        # runaway leak). Surface it: a blind reaper cycle is a first-class datapoint,
+        # not a swallowed exception.
+        stats["ps_timed_out"] = True
+        stats["snapshot_empty"] = True
+        return [], {}, [], {}, stats
+    if not out.strip():
+        stats["snapshot_empty"] = True
     me = os.getpid()
     procs = []
     macos_mcp = []
@@ -177,6 +212,7 @@ def snapshot():
             continue
         pid, ppid, etime, cmd = int(m.group(1)), int(m.group(2)), m.group(3), m.group(4)
         by_pid[pid] = cmd
+        stats["total_procs"] += 1
         try:
             age = parse_etime(etime)
         except Exception:
@@ -188,17 +224,34 @@ def snapshot():
         # claude worker signature; these are separate node procs the workers spawn.
         if MACOS_MCP_RE.search(cmd) and not _SSH_RE.match(cmd):
             macos_mcp.append({"pid": pid, "ppid": ppid, "age": age, "cmd": cmd})
+            stats["macos_mcp_seen"] += 1
             continue
-        # (b) claude agent-mode worker sessions.
+        # Telemetry probe: does this look like a claude-code agent worker at all?
+        # Deliberately looser than SIG_REQUIRED, and it EXCLUDES the disclaimer stub
+        # so we don't double-count the launcher parent.
+        is_probe = (
+            all(tok in cmd for tok in WORKER_PROBE)
+            and not any(tok in cmd for tok in SIG_EXCLUDED)
+        )
+        if is_probe:
+            stats["worker_probe_seen"] += 1
+        # (b) claude agent-mode worker sessions — the REAPABLE set.
         if not all(tok in cmd for tok in SIG_REQUIRED):
+            if is_probe:
+                stats["unparsed_worker_procs"] += 1  # looks like a worker, sig miss
             continue
         if any(tok in cmd for tok in SIG_EXCLUDED):
             continue
         u = UUID_RE.search(cmd)
         if not u:
+            # Full signature but the session path shape defeated UUID_RE — THE Karol
+            # blind spot. Count it so the leak is never invisible again.
+            if is_probe:
+                stats["unparsed_worker_procs"] += 1
             continue
         procs.append({"pid": pid, "ppid": ppid, "age": age, "uuid": u.group(1), "cmd": cmd})
-    return procs, by_pid, macos_mcp, meta
+    stats["reapable_workers"] = len(procs)
+    return procs, by_pid, macos_mcp, meta, stats
 
 
 def kill(pid: int) -> bool:
@@ -231,6 +284,24 @@ def _state_dir() -> str:
     )
 
 
+def write_status(status: dict) -> None:
+    """Persist the last reaper cycle to <state_dir>/claude-queue/reaper-status.json
+    (atomic write). memory_snapshot.py reads this file and carries it on the heartbeat,
+    so the reaper — a SEPARATE launchd job whose stderr only lands in a local file — is
+    finally observable centrally. Mirrors the drain_status.json pattern. Best-effort:
+    the reaper's real work must never fail because telemetry could not be written."""
+    try:
+        d = os.path.join(_state_dir(), "claude-queue")
+        os.makedirs(d, exist_ok=True)
+        path = os.path.join(d, "reaper-status.json")
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump(status, f)
+        os.replace(tmp, path)
+    except Exception:
+        pass
+
+
 def count_running_jobs():
     """Number of IN-FLIGHT claimed jobs, or None if the queue dir is unreadable.
 
@@ -320,7 +391,7 @@ def main() -> int:
     inflight = count_running_jobs()  # None => queue unreadable => age-gate fallback
     claim_pids = running_claim_pids()  # agent-session pids actively holding a claim
 
-    procs, by_pid, macos_mcp, meta = snapshot()
+    procs, by_pid, macos_mcp, meta, stats = snapshot()
 
     # Group by session uuid.
     groups: dict[str, list[dict]] = {}
@@ -416,18 +487,47 @@ def main() -> int:
         if dry or kill(mp["pid"]):
             macos_killed += 1
 
-    if not killed and not disclaimers and not macos_killed:
-        # Nothing reapable this run (common no-leak path).
-        return 0
-
     mode = "queue" if inflight is not None else "age-fallback"
+    leaked_groups = sum(1 for g in groups.values() if len(g) > 1)
+
+    # Always persist the cycle outcome + always emit ONE structured marker, even on
+    # the common no-leak path. Two reasons this replaced the old silent early-return:
+    #   * The reaper is a separate launchd job; without a per-cycle heartbeat there is
+    #     no way to tell "reaper ran and found nothing" from "reaper is dead/stuck".
+    #   * `unparsed_worker_procs > 0` on a quiet cycle is the EARLY WARNING that the
+    #     worker signature has drifted (Karol's blind spot) — it must be visible even
+    #     when we killed nothing, precisely because we killed nothing.
+    status = {
+        "ts": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "dry_run": bool(dry),
+        "mode": mode,
+        "inflight": inflight,
+        "ceiling_sec": max_age,
+        "max_group": max_group,
+        "leaked_groups": leaked_groups,
+        "claude_killed": killed,
+        "disclaimer_killed": disclaimers,
+        "macos_mcp_killed": macos_killed,
+        "spared_claim_pids": sorted(claim_pids),
+        "worker_probe_seen": stats["worker_probe_seen"],
+        "reapable_workers": stats["reapable_workers"],
+        "unparsed_worker_procs": stats["unparsed_worker_procs"],
+        "macos_mcp_seen": stats["macos_mcp_seen"],
+        "total_procs": stats["total_procs"],
+        "ps_timed_out": stats["ps_timed_out"],
+        "snapshot_empty": stats["snapshot_empty"],
+    }
+    write_status(status)
+
     prefix = "[claude-reaper]" + (" DRY-RUN" if dry else "")
     print(
-        f"{prefix} reaped {killed} stale agent-mode claude session(s)"
-        f" + {disclaimers} disclaimer stub(s) + {macos_killed} remote-macos-mcp server(s)"
-        f" across {sum(1 for g in groups.values() if len(g) > 1)}"
-        f" leaked uuid group(s); mode={mode} inflight={inflight} ceiling={max_age}s"
-        f" spared_claim_pids={sorted(claim_pids)} max_group={max_group}",
+        f"{prefix} cycle mode={mode} inflight={inflight} ceiling={max_age}s"
+        f" worker_seen={stats['worker_probe_seen']} reapable={stats['reapable_workers']}"
+        f" unparsed={stats['unparsed_worker_procs']} leaked_groups={leaked_groups}"
+        f" mcp_seen={stats['macos_mcp_seen']} killed={killed}"
+        f" disclaimer_killed={disclaimers} mcp_killed={macos_killed}"
+        f" ps_timeout={int(stats['ps_timed_out'])} empty={int(stats['snapshot_empty'])}"
+        f" max_group={max_group}",
         file=sys.stderr,
     )
     return 0

package/scripts/schedule_state.py

@@ -40,6 +40,19 @@ WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
 # false "not scheduled".
 FIRING_WINDOW = 420
 
+# 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
+# first time — up to a minute or two later, longer if the launchd kicker is still
+# installing. Without this grace, compute() saw newest_epoch=None and returned
+# "missing", so the menu bar kept flashing ⚠ right after the user successfully
+# scheduled. If a freshly-created, enabled task hasn't fired yet but was created
+# within this window, treat it as "ok" (waiting for first fire, not orphaned).
+# 15 min comfortably covers a slow first fire; a genuinely dead schedule still
+# flips to ⚠ once the grace lapses. Orphaned tasks from an old account carry a
+# stale createdAt, so they never fall inside this window.
+CREATED_GRACE = 900
+
 SCHED_REGISTRY_GLOB = os.path.join(
     os.path.expanduser("~"), "Library", "Application Support", "Claude",
     "claude-code-sessions", "*", "*", "scheduled-tasks.json",
@@ -58,9 +71,21 @@ def _iso_to_epoch(s):
         return None
 
 
+def _ms_to_epoch(ms):
+    """createdAt is epoch MILLISECONDS in the registry; return epoch seconds."""
+    try:
+        return float(ms) / 1000.0
+    except (TypeError, ValueError):
+        return None
+
+
 def compute(glob_pattern: str = SCHED_REGISTRY_GLOB) -> str:
     """Return 'ok' | 'disabled' | 'missing' for the live account's draft schedule."""
     newest_epoch, newest_enabled = None, False
+    # Track the freshest just-created, enabled, never-yet-fired task so a schedule
+    # the user only moments ago set up doesn't read as "missing" before its first
+    # fire lands (see CREATED_GRACE).
+    newest_fresh_created = None
     any_present, any_enabled = False, False
     for f in glob.glob(glob_pattern):
         try:
@@ -79,9 +104,19 @@ def compute(glob_pattern: str = SCHED_REGISTRY_GLOB) -> str:
         e = max([x for x in epochs if x is not None], default=None)
         if e is not None and (newest_epoch is None or e > newest_epoch):
             newest_epoch, newest_enabled = e, enabled
+        # Freshly scheduled + enabled + not yet fired anywhere in this registry.
+        if enabled and e is None:
+            created = [_ms_to_epoch(r.get("createdAt")) for r in recs]
+            c = min([x for x in created if x is not None], default=None)
+            if c is not None and (newest_fresh_created is None or c > newest_fresh_created):
+                newest_fresh_created = c
     # Firing recently => the live account's schedule is active and healthy.
     if newest_epoch is not None and (time.time() - newest_epoch) <= FIRING_WINDOW:
         return "ok" if newest_enabled else "disabled"
+    # Just scheduled, enabled, waiting for its first fire => "ok" (not orphaned).
+    # Suppresses the false ⚠ right after the user sets up the draft schedule.
+    if newest_fresh_created is not None and (time.time() - newest_fresh_created) <= CREATED_GRACE:
+        return "ok"
     # Not firing anywhere. Registered-but-disabled => disabled; else missing.
     if any_present and not any_enabled:
         return "disabled"

package/scripts/snapshot.py

@@ -50,6 +50,12 @@ def _config_path() -> str:
 # Keep in sync with REQUIRED_FIELDS (mcp/src/setup.ts), QUEUE_WORKERS / UPDATER_LABEL
 # / AUTOPILOT_STALL_MS (mcp/src/index.ts).
 REQUIRED_FIELDS = ["name", "website", "description", "icp", "voice", "search_topics"]
+# Keep in sync with PERSONA_REQUIRED_FIELDS (mcp/src/setup.ts). A personal-brand
+# persona has no product website/icp by design; it is "ready" once it has the fields
+# the cycle consumes (name, voice, seedable topics). Without this, a personal-brand-
+# only setup can NEVER report setup_complete (any_ready requires a managed product),
+# leaving the menu bar stuck on "project not set up". (2026-06-30)
+PERSONA_REQUIRED_FIELDS = ["name", "description", "voice", "search_topics"]
 WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
 UPDATER_LABEL = "com.m13v.social-autoposter-update"
 AUTOPILOT_STALL_MS = 180_000
@@ -97,6 +103,35 @@ def _projects():
     return [_project_status(n, cfg_projects) for n in _managed_projects()]
 
 
+def _persona_status():
+    """The personal-brand persona (config.json persona:true) as a project-status
+    dict, or None when there's no persona. Validated against PERSONA_REQUIRED_FIELDS
+    (a persona has no product website/icp). The persona is excluded from the managed
+    scope (_managed_projects) by design, but IS what the cycle drafts in
+    personal_brand mode, so it must count toward readiness."""
+    cfg = _read_json(_config_path()) or {}
+    persona = next((p for p in (cfg.get("projects") or []) if p.get("persona")), None)
+    if persona is None:
+        return None
+    missing = []
+    for f in PERSONA_REQUIRED_FIELDS:
+        v = persona.get(f)
+        if v is None:
+            missing.append(f)
+        elif isinstance(v, str) and not v.strip():
+            missing.append(f)
+        elif isinstance(v, (list, tuple)) and len(v) == 0:
+            missing.append(f)
+        elif isinstance(v, dict) and len(v) == 0:
+            missing.append(f)
+    return {
+        "name": persona.get("name") or "PersonalBrand",
+        "ready": len(missing) == 0,
+        "missing_required": missing,
+        "persona": True,
+    }
+
+
 # ---- runtime / mode / autopilot (all file/launchctl) -----------------------
 def _runtime_ready() -> bool:
     rt = _read_json(os.path.join(_state_dir(), "runtime.json")) or {}
@@ -304,7 +339,15 @@ def compute() -> dict:
     rt_ready = _runtime_ready()
     x = _x_status()
     mode = _mode()
+    flags = _flags()
     schedule_state = _schedule_state()
+    # Personal-brand-only setups have NO managed product project; the persona IS the
+    # draftable "project" for the self-promo lane. Surface it as a project row when
+    # that lane is on so projects_ready / setup_complete / project_ready reflect a
+    # persona-only setup instead of forever reading "not set up". (2026-06-30)
+    persona = _persona_status()
+    if persona is not None and flags.get("personal_brand"):
+        projects = projects + [persona]
     any_ready = any(p["ready"] for p in projects)
     setup_complete = rt_ready and any_ready and bool(x["connected"])