@m13v/s4l 1.7.1-rc.26 → 1.7.1-rc.28

package/mcp/dist/index.js

@@ -885,11 +885,24 @@ async function postApproved(batchId, plan) {
     {
         const gateDeadline = Date.now() + 8 * 60_000;
         let waited = false;
+        let waitStartedAt = 0;
         while ((postingActive || isPeerDrainActive()) && Date.now() < gateDeadline) {
+            if (!waited) {
+                waitStartedAt = Date.now();
+                // This loop was previously silent end-to-end (2026-07-08 forensics: a
+                // ~1:45 gap in a user's approval batch had zero trace anywhere). Log
+                // once on entry (not per 5s tick, to avoid spamming the file) so a
+                // later "why did card N take so long" question has a starting point.
+                logPostEvent(`postApproved_wait_start batch=${batchId} blocked_by=${describePostingBlocker()}`);
+            }
             waited = true;
             await sleepMs(5000);
         }
-        if (postingActive || isPeerDrainActive()) {
+        const timedOut = postingActive || isPeerDrainActive();
+        if (waited) {
+            logPostEvent(`postApproved_wait_end batch=${batchId} waited_ms=${Date.now() - waitStartedAt} timed_out=${timedOut}`);
+        }
+        if (timedOut) {
             return {
                 attempted: 0,
                 exit_code: 0,
@@ -3858,8 +3871,8 @@ async function ensureUpdaterInstalled() {
 //   'disabled' — present but a worker task is disabled.
 //   'missing'  — not firing anywhere (orphaned / not registered for the live
 //                account) -> dashboard offers "Set up draft schedule".
-// The algorithm (live-account detection by freshest lastRunAt, firing window,
-// etc.) lives in ONE place: scripts/schedule_state.py. The Python menu bar imports
+// The algorithm (live-account detection via config.json's lastKnownAccountUuid,
+// firing window, etc.) lives in ONE place: scripts/schedule_state.py. The Python menu bar imports
 // that module in-process; we shell out to it here. Keeping a single implementation
 // is the whole point — the two surfaces can no longer drift. The script is
 // stdlib-only and resolvePython() falls back to system python3, so this works even
@@ -4155,8 +4168,12 @@ function writePanelUrl(url) {
             // and fully usable via `url` for anything that already has it (e.g. this
             // process's own Code side-panel proxy); we just don't publish ourselves
             // as THE shared menu-bar target.
+            logPanelEvent(`panel_cede existing_pid=${existing.pid}`);
             return;
         }
+        logPanelEvent(existing?.pid
+            ? `panel_takeover dead_pid=${existing.pid}`
+            : `panel_claim previous=none`);
         fs.writeFileSync(panelEndpointPath(), JSON.stringify({ url, pid: process.pid, version: VERSION, started_at: new Date().toISOString() }, null, 2) + "\n", "utf-8");
     }
     catch (e) {
@@ -4307,6 +4324,25 @@ function isPeerDrainActive() {
         return false;
     }
 }
+// Human-readable reason for the postApproved wait gate, used only for the
+// wait_start log line — distinguishes "our own drain hasn't hit its grace
+// release yet" from "a peer MCP instance (different pid, e.g. a separate
+// Claude session/queue-worker) is mid-drain," and names the peer pid + how
+// much longer its flag has left so a log reader doesn't have to guess.
+function describePostingBlocker() {
+    if (postingActive)
+        return "own_in_process_flag";
+    try {
+        const j = JSON.parse(fs.readFileSync(postingFlagPath(), "utf-8"));
+        if (typeof j?.expires_at === "number" && j.expires_at > Date.now() && typeof j?.pid === "number") {
+            return `peer_pid=${j.pid} expires_in_ms=${j.expires_at - Date.now()}`;
+        }
+    }
+    catch {
+        /* best effort */
+    }
+    return "unknown";
+}
 // activity.json: a tiny "what's running right now" signal the menu bar reads to
 // show a loading spinner + label (scanning / drafting / posting / …). Written by
 // long-running tools, cleared when they finish. Best-effort; absence == idle.
@@ -4491,6 +4527,25 @@ function logPostEvent(msg) {
         /* best effort */
     }
 }
+// Timestamped on-disk trail of panel-endpoint.json ownership handoffs. Mirrors
+// logPostEvent's rationale (per-process console.error is hard to even locate
+// across ephemeral, per-host-session MCP instances), for the panel-election
+// side instead of the posting side. writePanelUrl() runs on every process's
+// eager startup, so this also captures the mundane "claimed with nothing
+// registered" and "ceded to an already-alive owner" cases, not just handoffs
+// — that's what makes it possible to tell "a fresh instance took over from a
+// dead registrant" apart from "an approve click found nothing registered at
+// all" after the fact, instead of inferring it from timing alone.
+function logPanelEvent(msg) {
+    try {
+        const dir = path.join(repoDir(), "skill", "logs");
+        fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(path.join(dir, "panel-events.log"), `${new Date().toISOString()} pid=${process.pid} ${msg}\n`);
+    }
+    catch {
+        /* best effort */
+    }
+}
 function sigkillScanTree(pid) {
     logPostEvent(`sigkill_scan_tree target=${pid}`);
     try {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.1-rc.26",
-  "installedAt": "2026-07-08T21:06:17.945Z"
+  "version": "1.7.1-rc.28",
+  "installedAt": "2026-07-08T23:19:54.168Z"
 }

package/mcp/manifest.json

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

@@ -28,6 +28,50 @@ import tempfile
 import threading
 import time
 
+# --- stderr timestamp wrapper -------------------------------------------------
+# menubar.err.log (this process's stderr, redirected by the launchd plist) has
+# never carried timestamps, so correlating a line like "[s4l-card] approved at
+# level 1" with the UTC-stamped logs elsewhere (post-*.log, post-preempt-
+# events.log, panel-events.log) meant guessing from file position alone
+# (2026-07-08 forensics). Wrap sys.stderr once, here, before any other module
+# gets a chance to print, so every line written to stderr for the rest of the
+# process gets a leading UTC timestamp in the same format those other logs
+# use — zero changes needed at any individual print()/write() call site
+# (s4l_card._log, the many sys.stderr.write(...) calls in this file, rumps'/
+# PyObjC's own warnings, …).
+class _TimestampedStderr:
+    def __init__(self, stream):
+        self._stream = stream
+        self._newline_pending = True  # True at the start of a fresh line
+
+    def write(self, data):
+        if not data:
+            return 0
+        ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        lines = data.split("\n")
+        out = []
+        for i, line in enumerate(lines):
+            if i > 0:
+                out.append("\n")
+            starts_new_line = i > 0 or self._newline_pending
+            if starts_new_line and line:
+                out.append(f"[{ts}] ")
+            out.append(line)
+        self._newline_pending = data.endswith("\n")
+        return self._stream.write("".join(out))
+
+    def flush(self):
+        self._stream.flush()
+
+    def isatty(self):
+        try:
+            return self._stream.isatty()
+        except Exception:
+            return False
+
+
+sys.stderr = _TimestampedStderr(sys.stderr)
+
 # --- Sentry bootstrap --------------------------------------------------------
 # The menu bar runs as a standalone KeepAlive LaunchAgent off the owned venv,
 # a separate process from the MCP server, so it was a Sentry blind spot: a crash
@@ -2269,10 +2313,14 @@ class S4LMenuBar(rumps.App):
         # never nag the user mid-onboarding — only the value is now always honest.
         schedule_state = self._schedule_state()
         self._schedule_state_cache = schedule_state
-        # 'stalled' (task present + enabled, host scheduler stopped launching it:
-        # the Desktop warm-session wedge or an account-switch orphan) needs
-        # attention just like missing/disabled, but its primary fix is a Claude
-        # Desktop restart, not re-arm (Karol, 2026-07-06).
+        # 'stalled' (task present + enabled FOR THE ACTIVE ACCOUNT, host
+        # scheduler stopped launching it: the Desktop warm-session wedge,
+        # Karol 2026-07-06) needs attention just like missing/disabled.
+        # schedule_state.py is account-scoped (2026-07-08): an account switch
+        # now correctly resolves to 'missing' (the active account genuinely
+        # has no registration), not 'stalled' — a stale OTHER account's
+        # registry is never consulted for the active account's health, so
+        # 'stalled' can no longer be misdiagnosed here.
         attention = setup_complete and schedule_state in ("missing", "disabled", "stalled")
         # Routines-lane rate limit (429): the draft tasks ARE registered and firing
         # for this account, but every run dies on a Claude rate limit, so nothing
@@ -2304,13 +2352,12 @@ class S4LMenuBar(rumps.App):
         # draft_stuck shadowed the missing/disabled branch in _build_menu — the user
         # saw "worker keeps getting killed" with NO Re-arm button instead of "Draft
         # tasks aren't scheduled on this account" + the one-click fix (Karol,
-        # 2026-07-06). "stalled" is deliberately included (2026-07-08): that branch's
-        # only offered fix is "Restart Claude Desktop", but a job that has sat this
-        # long — claimed-and-hung, OR never claimed at all (see the ⧖ prefix check
-        # below) — means a restart was either already tried and didn't help, or
-        # isn't the right first move; Diagnose is the more useful single action once
-        # we have DRAFT_STUCK_SECONDS of direct evidence from the queue itself,
-        # which is a more reliable signal than the host's lastRunAt staleness.
+        # 2026-07-06). "stalled" is deliberately included (2026-07-08): that
+        # branch's fix (Set up draft schedule / re-arm) works for it too, but a
+        # job that has sat this long — claimed-and-hung, OR never claimed at all
+        # (see the ⧖ prefix check below) — is more specific, direct evidence
+        # from the queue itself than the host's lastRunAt staleness, so it's
+        # worth surfacing as its own reason even under "stalled".
         if (
             setup_complete
             and schedule_state in ("ok", "stalled")
@@ -2965,16 +3012,20 @@ class S4LMenuBar(rumps.App):
                 items.append(self._label("⚠ Draft tasks are scheduled but disabled"))
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             elif schedule_state == "stalled":
-                # Task registered + enabled but the host stopped launching it: the
-                # Claude Desktop warm-session wedge (finished worker sessions never
-                # exit; the overlap guard skips every fire) or an account-switch
-                # orphan. Re-arm goes through the same real create_scheduled_task
+                # Task registered + enabled FOR THE ACTIVE ACCOUNT (schedule_state.py
+                # is account-scoped, 2026-07-08 — see its module docstring) but the
+                # host stopped launching it: the Claude Desktop warm-session wedge
+                # (finished worker sessions never exit; the overlap guard skips
+                # every fire). Re-arm goes through the same real create_scheduled_task
                 # path as onboarding — a verified fix the user has seen work —
                 # rather than a silent Claude Desktop quit/relaunch with no visible
                 # feedback, which field evidence (2026-07-08) showed doesn't
-                # reliably clear the underlying stall. Distinct label from the
-                # "aren't scheduled" case below since the task DOES exist here;
-                # same one-click remedy either way.
+                # reliably clear the underlying stall (that field incident turned
+                # out to be a DIFFERENT bug: schedule_state.py was reading a stale,
+                # no-longer-active account's registry — now fixed, so "stalled"
+                # here means what it says: same account, task present, just not
+                # firing). Distinct label from the "aren't scheduled" case below
+                # since the task DOES exist here; same one-click remedy either way.
                 items.append(self._label("⚠ Drafts stopped — Claude’s scheduler is stuck"))
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             else:

package/mcp/menubar/s4l_state.py

@@ -1317,8 +1317,18 @@ def review_event_add(event):
             p.parent.mkdir(parents=True, exist_ok=True)
             with open(p, "a") as f:
                 f.write(json.dumps(ev) + "\n")
-    except Exception:
-        pass
+    except Exception as err:
+        # Was a silent `pass` — a card's approve/reject decision could vanish
+        # with zero trace anywhere (2026-07-08: two approved-and-posted cards
+        # had no review_events row at all, and this was one of the candidate
+        # causes with nothing to confirm or rule it out). Never never write to
+        # the outbox again for THIS event, so it's worth saying loudly.
+        sys.stderr.write(
+            f"[s4l-state] review_event_add: failed to append to outbox ({type(err).__name__}: {err}); "
+            f"event DROPPED event_uuid={ev.get('event_uuid')} decision={ev.get('decision')} "
+            f"candidate_id={ev.get('candidate_id')}\n"
+        )
+        sys.stderr.flush()
     flush_review_events_async()
 
 
@@ -1339,16 +1349,29 @@ def flush_review_events():
                 if not p.exists():
                     return
                 lines = [ln for ln in p.read_text().splitlines() if ln.strip()]
-        except Exception:
+        except Exception as err:
+            sys.stderr.write(f"[s4l-state] flush_review_events: failed to read outbox: {type(err).__name__}: {err}\n")
+            sys.stderr.flush()
             return
         events = []
         for ln in lines:
             try:
                 ev = json.loads(ln)
-                if isinstance(ev, dict) and ev.get("event_uuid"):
-                    events.append(ev)
-            except Exception:
+            except Exception as err:
+                sys.stderr.write(
+                    f"[s4l-state] flush_review_events: dropping unparseable outbox line "
+                    f"({type(err).__name__}: {err}): {ln[:200]!r}\n"
+                )
+                sys.stderr.flush()
                 continue  # corrupt line: dropped on the next rewrite
+            if isinstance(ev, dict) and ev.get("event_uuid"):
+                events.append(ev)
+            else:
+                sys.stderr.write(
+                    f"[s4l-state] flush_review_events: dropping malformed outbox line "
+                    f"(not a dict, or missing event_uuid): {ln[:200]!r}\n"
+                )
+                sys.stderr.flush()
         if not events:
             if lines:  # only corrupt lines left — clear the file
                 _outbox_remove(set())
@@ -1357,7 +1380,12 @@ def flush_review_events():
         # import lazily so a missing pipeline repo degrades to buffer-only.
         try:
             from http_api import api_post
-        except Exception:
+        except Exception as err:
+            sys.stderr.write(
+                f"[s4l-state] flush_review_events: http_api unavailable ({type(err).__name__}: {err}); "
+                f"{len(events)} event(s) staying buffered in the outbox\n"
+            )
+            sys.stderr.flush()
             return
         shipped = set()
         for i in range(0, len(events), 100):
@@ -1365,7 +1393,12 @@ def flush_review_events():
             try:
                 api_post("/api/v1/review-events", {"events": batch})
                 shipped.update(e["event_uuid"] for e in batch)
-            except Exception:
+            except Exception as err:
+                sys.stderr.write(
+                    f"[s4l-state] flush_review_events: POST failed ({type(err).__name__}: {err}); "
+                    f"{len(batch)} event(s) in this batch (and any after it) staying buffered for the next kick\n"
+                )
+                sys.stderr.flush()
                 break  # network/API down: keep the rest for the next kick
         _outbox_remove(shipped, keep_only_valid=True)
     finally:

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.1-rc.26",
+  "version": "1.7.1-rc.28",
   "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.1-rc.26",
+  "version": "1.7.1-rc.28",
   "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/schedule_state.py

@@ -104,16 +104,66 @@ CREATED_GRACE = 900
 # "Claude*" (not "Claude"): the host app can run with a custom --user-data-dir
 # (per-account dirs like "Claude-mediar" on multi-account machines), and the
 # registry lands under THAT dir while plain "Claude/" has no claude-code-sessions
-# at all. The freshest-lastRunAt selection in compute() already picks the live
-# registry among however many dirs match, so widening the glob is safe; the
-# plain-"Claude" glob read a hard "missing" forever on such machines even while
-# both worker tasks fired every minute (found 2026-07-02 during onboarding).
+# at all. UNSCOPED across every account under each root — deliberately, this is
+# also imported by callers that need to see EVERY account's registries (e.g. the
+# menu bar's relocation/legacy-consolidation sweep, which must find and clean up
+# old accounts' leftover tasks, not just the live one). compute()/_detail() do
+# NOT use this directly by default any more — see _active_registry_glob_patterns.
 SCHED_REGISTRY_GLOB = os.path.join(
     os.path.expanduser("~"), "Library", "Application Support", "Claude*",
     "claude-code-sessions", "*", "*", "scheduled-tasks.json",
 )
 
 
+def _config_json_paths():
+    """One config.json per Claude* root (multi-account machines can run
+    several distinct --user-data-dir roots, e.g. Claude-mediar, each a
+    separate host app instance with its own logged-in account)."""
+    return glob.glob(os.path.join(
+        os.path.expanduser("~"), "Library", "Application Support", "Claude*",
+        "config.json",
+    ))
+
+
+def _active_account_uuid(config_path):
+    """The account currently logged into the Claude* root config_path lives
+    under, or None if config.json is missing/unreadable/predates this field."""
+    try:
+        with open(config_path) as fh:
+            d = json.load(fh)
+        u = d.get("lastKnownAccountUuid")
+        return u if isinstance(u, str) and u else None
+    except Exception:
+        return None
+
+
+def _active_registry_glob_patterns():
+    """One glob pattern per Claude* root, scoped to ONLY the account that root
+    is currently logged into (verified 2026-07-08: claude-code-sessions/<uuid>/
+    is keyed by account — lastKnownAccountUuid in that root's config.json
+    matches the top-level directory local-agent-mode-sessions/<uuid>/ actually
+    running under, and a different, no-longer-active account's own <uuid>/
+    directory sits untouched alongside it). Falls back to the OLD
+    every-account-under-this-root pattern for a root whose config.json doesn't
+    resolve an account, so an unusual/older install never regresses to a blind
+    'missing' just because this field happens to be absent."""
+    patterns = []
+    for cfg in _config_json_paths():
+        root = os.path.dirname(cfg)
+        uuid = _active_account_uuid(cfg)
+        if uuid:
+            patterns.append(os.path.join(
+                root, "claude-code-sessions", uuid, "*", "scheduled-tasks.json"
+            ))
+        else:
+            patterns.append(os.path.join(
+                root, "claude-code-sessions", "*", "*", "scheduled-tasks.json"
+            ))
+    # No Claude* root found at all (host app never launched here) -> fall back
+    # to the unscoped glob so callers still see SOMETHING rather than nothing.
+    return patterns or [SCHED_REGISTRY_GLOB]
+
+
 def _iso_to_epoch(s):
     if not s:
         return None
@@ -134,37 +184,45 @@ def _ms_to_epoch(ms):
         return None
 
 
-def compute(glob_pattern: str = SCHED_REGISTRY_GLOB) -> str:
-    """Return 'ok' | 'disabled' | 'stalled' | 'missing' for the draft schedule."""
+def compute(glob_pattern: str | None = None) -> str:
+    """Return 'ok' | 'disabled' | 'stalled' | 'missing' for the draft schedule.
+
+    With no argument (every real caller), scans ONLY the active account's
+    registries via _active_registry_glob_patterns() — see its docstring and
+    the module docstring for why. Pass an explicit glob_pattern to scan a
+    literal pattern instead (e.g. a test fixture dir); this bypasses account
+    scoping entirely, matching the old unconditional behavior."""
+    patterns = [glob_pattern] if glob_pattern is not None else _active_registry_glob_patterns()
     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:
-            with open(f) as fh:
-                d = json.load(fh)
-        except Exception:
-            continue
-        by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
-        recs = _registry_worker_recs(by_id)
-        if recs is None:
-            continue
-        any_present = True
-        enabled = all(r.get("enabled") for r in recs)
-        any_enabled = any_enabled or enabled
-        epochs = [_iso_to_epoch(r.get("lastRunAt")) for r in recs]
-        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
+    for pattern in patterns:
+        for f in glob.glob(pattern):
+            try:
+                with open(f) as fh:
+                    d = json.load(fh)
+            except Exception:
+                continue
+            by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
+            recs = _registry_worker_recs(by_id)
+            if recs is None:
+                continue
+            any_present = True
+            enabled = all(r.get("enabled") for r in recs)
+            any_enabled = any_enabled or enabled
+            epochs = [_iso_to_epoch(r.get("lastRunAt")) for r in recs]
+            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"
@@ -172,9 +230,11 @@ def compute(glob_pattern: str = SCHED_REGISTRY_GLOB) -> str:
     # 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; registered and
-    # enabled but the host stopped launching it => stalled (Desktop scheduler
-    # wedge or account-switch orphan); absent everywhere => missing.
+    # Not firing anywhere for the active account. Registered-but-disabled =>
+    # disabled; registered and enabled but the host stopped launching it =>
+    # stalled (Desktop scheduler wedge, SAME account); absent for the active
+    # account entirely (never scheduled, or orphaned by an account switch) =>
+    # missing.
     if any_present and not any_enabled:
         return "disabled"
     if any_present and any_enabled:
@@ -182,29 +242,32 @@ def compute(glob_pattern: str = SCHED_REGISTRY_GLOB) -> str:
     return "missing"
 
 
-def _detail(glob_pattern: str = SCHED_REGISTRY_GLOB) -> dict:
-    """Cheap diagnostics for the JSON output: which registries the glob saw and
-    which contain both worker tasks, with each one's freshest lastRunAt age.
-    This is what makes a 'missing' verdict debuggable from a log line instead of
-    requiring filesystem forensics (the 2026-07-02 rotated-dir bug hid here)."""
+def _detail(glob_pattern: str | None = None) -> dict:
+    """Cheap diagnostics for the JSON output: which registries the glob(s) saw
+    and which contain both worker tasks, with each one's freshest lastRunAt
+    age. This is what makes a 'missing' verdict debuggable from a log line
+    instead of requiring filesystem forensics (the 2026-07-02 rotated-dir bug,
+    and the 2026-07-08 wrong-account bug, both hid here)."""
+    patterns = [glob_pattern] if glob_pattern is not None else _active_registry_glob_patterns()
     regs = []
-    for f in glob.glob(glob_pattern):
-        entry = {"path": f, "has_workers": False, "last_run_age_s": None}
-        try:
-            with open(f) as fh:
-                d = json.load(fh)
-            by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
-            recs = _registry_worker_recs(by_id)
-            if recs is not None:
-                entry["has_workers"] = True
-                epochs = [_iso_to_epoch(r.get("lastRunAt")) for r in recs]
-                e = max([x for x in epochs if x is not None], default=None)
-                if e is not None:
-                    entry["last_run_age_s"] = int(time.time() - e)
-        except Exception as exc:
-            entry["error"] = str(exc)
-        regs.append(entry)
-    return {"glob": glob_pattern, "registries": regs}
+    for pattern in patterns:
+        for f in glob.glob(pattern):
+            entry = {"path": f, "has_workers": False, "last_run_age_s": None}
+            try:
+                with open(f) as fh:
+                    d = json.load(fh)
+                by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
+                recs = _registry_worker_recs(by_id)
+                if recs is not None:
+                    entry["has_workers"] = True
+                    epochs = [_iso_to_epoch(r.get("lastRunAt")) for r in recs]
+                    e = max([x for x in epochs if x is not None], default=None)
+                    if e is not None:
+                        entry["last_run_age_s"] = int(time.time() - e)
+            except Exception as exc:
+                entry["error"] = str(exc)
+            regs.append(entry)
+    return {"glob": patterns, "registries": regs}
 
 
 def main() -> int: