@m13v/s4l 1.7.4-rc.4 → 1.7.4

package/scripts/invent_styles.py

@@ -15,12 +15,26 @@ This job runs OUTSIDE any drafting context, on the operator Mac only:
     style), so invention must NOT fan out per install the way topic
     invention does. One central daily run is the correct scope; that is
     the deliberate difference from invent_topics.py's per-install kicker.
-  - The prompt carries the existing style universe and explicitly forbids
-    the dominant structural family; the ask is a style from an
-    UNREPRESENTED family, not a riff on the champion.
+  - VERBALIZED SAMPLING (2026-07-10, arXiv 2510.01171): a single "invent
+    one style" ask reliably returns the modal answer (typicality bias from
+    preference training), which is why 653 of ~950 registered styles
+    cluster at 53-98 target_chars and one rhetorical family. Instead the
+    prompt asks for N_CANDIDATES candidate styles WITH a verbalized
+    typicality probability each, and selection takes the LOWEST-probability
+    candidate that survives dedup: we sample the tail of the distribution,
+    not the mode. This is the principled fix; the family blocklist below is
+    only a backstop.
+  - The existing registry is framed as OCCUPIED NICHES to stay out of
+    (quality-diversity framing, arXiv 2310.13032), NOT as reference
+    inspiration; showing top performers as exemplars is what anchored the
+    retired inline path to the champion family.
+  - target_chars DIVERSITY: the prompt shows live length-band occupancy
+    and requires candidates to spread across bands, biased to the
+    least-occupied ones, so invention stops minting 80-char styles.
   - Post-hoc semantic dedup (token-Jaccard on description+example, plus a
-    reframe-family heuristic) rejects near-clones; a rejection re-prompts
-    with a grown avoid-list, at most DUPE_RETRIES times.
+    reframe-family heuristic) rejects near-clones; when every candidate is
+    rejected we re-prompt with a grown avoid-list, at most DUPE_RETRIES
+    times.
   - Accepted styles are registered via engagement_styles.register_style
     (kind='model_invented'), same as the retired inline path, so pickers
     see them on their next tick with zero other wiring.
@@ -52,6 +66,12 @@ SCRIPT_TAG = "invent-styles"
 CALL_TIMEOUT_SEC = 420
 DUPE_RETRIES = 3
 SIMILARITY_THRESHOLD = 0.5  # Jaccard on description+example tokens
+N_CANDIDATES = 5            # verbalized-sampling fan-out per call
+
+# Length bands for target_chars diversity. Occupancy is computed live from
+# the registry and shown in the prompt; candidates must spread across bands
+# and bias toward the least-occupied ones.
+LENGTH_BANDS = [(30, 60), (60, 100), (100, 150), (150, 200), (200, 250)]
 
 # Heuristic markers of the saturated agree-then-relocate/reframe family.
 # A proposal whose description/example leans on these is a clone of the
@@ -98,6 +118,23 @@ def _find_near_dupe(proposal, universe):
     return None
 
 
+def band_occupancy(universe):
+    """[(lo, hi, count), ...] for LENGTH_BANDS over the registry's
+    target_chars. The live histogram the prompt shows so candidates can
+    claim underrepresented bands."""
+    counts = [0] * len(LENGTH_BANDS)
+    for e in universe.values():
+        try:
+            tc = int(e.get("target_chars") or 0)
+        except (TypeError, ValueError):
+            continue
+        for i, (lo, hi) in enumerate(LENGTH_BANDS):
+            if lo <= tc < hi:
+                counts[i] += 1
+                break
+    return [(lo, hi, counts[i]) for i, (lo, hi) in enumerate(LENGTH_BANDS)]
+
+
 def build_prompt(universe, avoid):
     names = sorted(universe.keys())
     # Detail only a bounded sample (prompt-size guard): the seeds plus the
@@ -117,25 +154,42 @@ def build_prompt(universe, avoid):
             "\nAlready proposed and REJECTED this run (do not resubmit or "
             "paraphrase): " + ", ".join(avoid) + "\n"
         )
+    bands = band_occupancy(universe)
+    band_lines = "\n".join(
+        f"- {lo}-{hi} chars: {count} existing styles"
+        f"{'  <- UNDERREPRESENTED, prefer this band' if count == min(c for _, _, c in bands) else ''}"
+        for lo, hi, count in bands
+    )
     return f"""You maintain the engagement-style registry for a social reply system. A style is a named rhetorical TEMPLATE (description + one example reply) that drafters follow when writing short replies on X/Twitter and Reddit.
 
-PROBLEM: the registry is saturated with ONE structural family: agree-then-relocate (concede the surface point, move the spotlight to the hidden/harder/unmeasured part, often "X is easy, Y is the real work" or "X was never the point, Y is"). Do NOT invent another member of that family, however disguised.
+The registry below is OCCUPIED TERRITORY, not inspiration. Your job is to find empty niches: structural families and length bands that no existing style covers. Do not riff on what is already there.
+
+The registry is saturated with ONE structural family: agree-then-relocate (concede the surface point, move the spotlight to the hidden/harder/unmeasured part, often "X is easy, Y is the real work" or "X was never the point, Y is"). Do NOT propose any member of that family, however disguised.
 
 EXISTING STYLE NAMES ({len(names)} total):
 {", ".join(names)}
 
-REPRESENTATIVE DETAILS (sample):
+REPRESENTATIVE DETAILS (occupied niches, sample):
 {chr(10).join(detailed)}
+
+LENGTH-BAND OCCUPANCY (live registry histogram of target_chars):
+{band_lines}
 {avoid_block}
-TASK: invent exactly ONE genuinely new style from a structural family that is missing or rare above. Families worth mining (pick ONE, or another you identify): direct answer with zero framing; first-person confession of a specific failure; pure curious question with no thesis; dry understatement one-liner; enthusiastic cosign with one concrete addition; flat disagreement stated plainly without conceding anything first; a tiny numbered checklist; a vivid analogy that does NOT end in a lesson; deadpan humor riffing on the thread's wording.
+TASK (verbalized sampling): generate {N_CANDIDATES} CANDIDATE styles. For each, verbalize a `probability`: how likely this exact style would be as a language model's single first answer to "invent a new reply style" (0.0-1.0, honest, they need not sum to 1). Deliberately include tail candidates: at least 3 of the {N_CANDIDATES} must have probability under 0.10, meaning genuinely atypical moves a model would almost never produce first. We will programmatically select from the LOW-probability tail, so the obvious candidates are effectively discards; put your creativity into the tail.
+
+Diversity requirements across the {N_CANDIDATES} candidates:
+- Each from a DIFFERENT structural family. Families worth mining (or others you identify): direct answer with zero framing; first-person confession of a specific failure; pure curious question with no thesis; dry understatement one-liner; enthusiastic cosign with one concrete addition; flat disagreement stated plainly without conceding anything first; a tiny numbered checklist; a vivid analogy that does NOT end in a lesson; deadpan humor riffing on the thread's wording.
+- Each in a DIFFERENT length band from the histogram above, biased toward the least-occupied bands. `target_chars` must be the actual length of your example, and the example must genuinely inhabit its band (a 200-char style is narrative, not a padded one-liner).
 
-Rules:
-- The example must read like a real human reply (lowercase ok), 40-220 chars, NO links, NO product names.
+Per-candidate rules:
+- `description` must state the style's DEFINING MOVE (the one thing every draft in this style must contain) and its OPENING (how the first words enter: e.g. lowercase noun, a number, the question itself). A future model reading only the description must know exactly what shape to write.
+- `note` states when to use / when not to, and how a product mention would enter this style if ever (one clause; the link/CTA layer is downstream, so no URLs or link mechanics).
+- The example must read like a real human reply (lowercase ok), NO links, NO product names.
 - The style must be usable across many products and threads, not thread-specific.
-- Your answer will be dedup-checked by token similarity against every existing style's description+example; if you cannot find a genuinely different move, return the saturation envelope instead of forcing a paraphrase.
+- Every candidate is dedup-checked by token similarity against every existing style's description+example; if you cannot field {N_CANDIDATES} genuinely different moves, return the saturation envelope instead of forcing paraphrases.
 
 Answer with ONLY one JSON object, no prose, in one of these two shapes:
-{{"name": "snake_case_name", "description": "...", "example": "...", "why_existing_didnt_fit": "...", "target_chars": <int, the length the example is>}}
+{{"candidates": [{{"name": "snake_case_name", "description": "...", "example": "...", "note": "...", "why_existing_didnt_fit": "...", "target_chars": <int>, "probability": <float>}}, ...]}}
 {{"saturated": true, "reason": "..."}}"""
 
 
@@ -202,21 +256,43 @@ def main():
                 print(f"[invent_styles] slot={slot} model reports saturation: "
                       f"{obj.get('reason', '')[:200]}", file=sys.stderr)
                 break
-            name = str(obj.get("name") or "").strip()
-            if not re.fullmatch(r"[a-z0-9_]{3,60}", name):
-                print(f"[invent_styles] slot={slot} bad name {name!r}; retrying",
-                      file=sys.stderr)
-                avoid.append(name or "(unnamed)")
-                continue
-            dupe = _find_near_dupe({**obj, "name": name}, universe)
-            if dupe:
-                reason, existing = dupe
-                print(f"[invent_styles] slot={slot} rejected {name!r}: {reason} "
-                      f"vs {existing}", file=sys.stderr)
-                avoid.append(name)
+            candidates = obj.get("candidates")
+            if not isinstance(candidates, list) or not candidates:
+                print(f"[invent_styles] slot={slot} attempt={attempt} no "
+                      f"candidates array in output", file=sys.stderr)
                 continue
-            accepted = {**obj, "name": name}
-            break
+            # Verbalized-sampling selection: walk the tail first (ascending
+            # verbalized probability = least typical candidate first) and
+            # take the first that survives dedup. The modal candidates at
+            # the top of the distribution only get a chance if every tail
+            # candidate is a clone.
+            def _prob(c):
+                try:
+                    return float(c.get("probability"))
+                except (TypeError, ValueError):
+                    return 1.0  # unparseable prob sorts as maximally typical
+            for cand in sorted(candidates, key=_prob):
+                name = str(cand.get("name") or "").strip()
+                if not re.fullmatch(r"[a-z0-9_]{3,60}", name):
+                    print(f"[invent_styles] slot={slot} bad name {name!r}; "
+                          f"skipping candidate", file=sys.stderr)
+                    avoid.append(name or "(unnamed)")
+                    continue
+                dupe = _find_near_dupe({**cand, "name": name}, universe)
+                if dupe:
+                    reason, existing = dupe
+                    print(f"[invent_styles] slot={slot} rejected {name!r} "
+                          f"(p={_prob(cand):.2f}): {reason} vs {existing}",
+                          file=sys.stderr)
+                    avoid.append(name)
+                    continue
+                accepted = {**cand, "name": name}
+                print(f"[invent_styles] slot={slot} selected tail candidate "
+                      f"{name!r} (p={_prob(cand):.2f}) from "
+                      f"{len(candidates)} candidates", file=sys.stderr)
+                break
+            if accepted:
+                break
         if not accepted:
             continue
         if args.dry_run:
@@ -227,6 +303,7 @@ def main():
             {
                 "description": accepted.get("description", ""),
                 "example": accepted.get("example", ""),
+                "note": accepted.get("note", ""),
                 "why_existing_didnt_fit": accepted.get("why_existing_didnt_fit", ""),
                 "target_chars": accepted.get("target_chars"),
             },

package/scripts/linkedin_cadence.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""LinkedIn posting cadence: 4 active days, then a mandatory 2-day break.
+
+Per user instruction (2026-07-11): LinkedIn activity should not run more than
+four days at a time before taking a two-day break. "Active day" is counted
+only when real posting/engagement activity actually happened that day (an
+outage day does not count toward the four), and the break pauses ALL LinkedIn
+traffic, including the passive presence-check job, not just posting.
+
+Every LinkedIn entrypoint (skill/run-linkedin.sh, engage-linkedin.sh,
+engage-dm-replies.sh, dm-outreach-linkedin.sh, audit-linkedin.sh,
+linkedin-presence.sh) already gates on the existence of ONE file:
+    ~/.claude/social-autoposter/linkedin.killswitch
+That file is scripts/linkedin_killswitch.py's antibot killswitch. This module
+reuses the SAME file for a scheduled break (signal="scheduled_break") so every
+entrypoint pauses automatically, with zero edits to the locked entrypoint
+scripts. It never overwrites a REAL antibot signal, and linkedin_killswitch.py
+is patched (recover-check) to never try to auto-recover a scheduled_break.
+
+State lives at ~/.claude/social-autoposter/linkedin_cadence.json:
+    {
+      "phase": "active" | "break",
+      "phase_started": "2026-07-11T20:00:00Z",
+      "active_days": ["2026-07-13", "2026-07-14", ...]   # UTC dates with
+                                                          # confirmed posts,
+                                                          # only meaningful
+                                                          # while phase=active
+    }
+
+CLI:
+    python3 scripts/linkedin_cadence.py enforce   # one tick; called every 15m
+    python3 scripts/linkedin_cadence.py status    # print state (json)
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import http_api  # noqa: E402
+import linkedin_killswitch as ks  # noqa: E402
+
+STATE_DIR = os.path.expanduser(
+    os.environ.get("LINKEDIN_KILLSWITCH_DIR", "~/.claude/social-autoposter")
+)
+STATE_FILE = os.path.expanduser(
+    os.environ.get("LINKEDIN_CADENCE_FILE", os.path.join(STATE_DIR, "linkedin_cadence.json"))
+)
+
+ACTIVE_DAYS_TARGET = int(os.environ.get("LINKEDIN_CADENCE_ACTIVE_DAYS", "4"))
+BREAK_DAYS = int(os.environ.get("LINKEDIN_CADENCE_BREAK_DAYS", "2"))
+
+SCHEDULED_BREAK_SIGNAL = "scheduled_break"
+
+
+def _now():
+    return datetime.now(timezone.utc)
+
+
+def _now_iso():
+    return _now().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _today_str():
+    return _now().date().isoformat()
+
+
+def _parse_ts(ts):
+    return datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+
+
+def _ensure_dir():
+    os.makedirs(STATE_DIR, exist_ok=True)
+
+
+def load_state():
+    try:
+        with open(STATE_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def save_state(state):
+    _ensure_dir()
+    tmp = STATE_FILE + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(state, f, indent=2)
+        f.write("\n")
+    os.replace(tmp, STATE_FILE)
+
+
+def _default_state_starting_break():
+    # First-ever run: user asked to start immediately with a two-day break.
+    return {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+
+
+def _today_post_count():
+    """LinkedIn posts made today (UTC), via the same API the dashboard uses.
+
+    Best-effort: returns None on any failure so callers can skip counting
+    this tick rather than wrongly recording 0 activity."""
+    try:
+        resp = http_api.api_get(
+            "/api/v1/dashboard/posts-per-day", {"days": 1, "platform": "linkedin"}
+        )
+        rows = (resp or {}).get("data", {}).get("rows", [])
+        today = _today_str()
+        for row in rows:
+            if row.get("day") == today:
+                return int(row.get("posts_made") or 0)
+        return 0
+    except Exception as exc:
+        print(f"[linkedin_cadence] WARN: posts-per-day query failed: {exc}", file=sys.stderr)
+        return None
+
+
+def _pause_marker_set():
+    """Set the shared killswitch file for a scheduled break, unless a REAL
+    antibot signal is already in charge (never stomp a genuine block)."""
+    payload = ks.read()
+    if payload is None:
+        ks.engage(
+            signal=SCHEDULED_BREAK_SIGNAL,
+            detail="cadence: scheduled 2-day pause after 4 active days",
+            send_email=False,
+        )
+        print("[linkedin_cadence] pause marker set (scheduled_break)", file=sys.stderr)
+    elif payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        pass  # already set by us; idempotent, no trail spam
+    else:
+        print(
+            f"[linkedin_cadence] real killswitch already active (signal="
+            f"{payload.get('signal')!r}); deferring to it, not overwriting",
+            file=sys.stderr,
+        )
+
+
+def _pause_marker_clear_if_ours():
+    payload = ks.read()
+    if payload is not None and payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        ks.clear()
+        print("[linkedin_cadence] pause marker cleared (break ended)", file=sys.stderr)
+
+
+def enforce():
+    state = load_state() or _default_state_starting_break()
+    if load_state() is None:
+        save_state(state)
+        print(
+            f"[linkedin_cadence] no prior state; starting BREAK phase now "
+            f"({BREAK_DAYS}d)",
+            file=sys.stderr,
+        )
+
+    now = _now()
+    phase = state["phase"]
+
+    if phase == "break":
+        started = _parse_ts(state["phase_started"])
+        elapsed = now - started
+        if elapsed >= timedelta(days=BREAK_DAYS):
+            state = {"phase": "active", "phase_started": _now_iso(), "active_days": []}
+            save_state(state)
+            _pause_marker_clear_if_ours()
+            print(
+                f"[linkedin_cadence] break ended after {elapsed}; switching to ACTIVE",
+                file=sys.stderr,
+            )
+            phase = "active"
+        else:
+            remaining = timedelta(days=BREAK_DAYS) - elapsed
+            _pause_marker_set()
+            print(
+                f"[linkedin_cadence] BREAK phase: {remaining} remaining",
+                file=sys.stderr,
+            )
+            return
+
+    # phase == "active"
+    real_block = ks.read()
+    if real_block is not None and real_block.get("signal") != SCHEDULED_BREAK_SIGNAL:
+        print(
+            f"[linkedin_cadence] account down for a real reason (signal="
+            f"{real_block.get('signal')!r}); not counting today, not pausing",
+            file=sys.stderr,
+        )
+        return
+
+    count = _today_post_count()
+    today = _today_str()
+    if count is not None and count > 0 and today not in state["active_days"]:
+        state["active_days"].append(today)
+        save_state(state)
+        print(
+            f"[linkedin_cadence] activity confirmed today ({count} posts); "
+            f"active_days={len(state['active_days'])}/{ACTIVE_DAYS_TARGET} "
+            f"{state['active_days']}",
+            file=sys.stderr,
+        )
+
+    if len(state["active_days"]) >= ACTIVE_DAYS_TARGET:
+        state = {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+        save_state(state)
+        _pause_marker_set()
+        print(
+            f"[linkedin_cadence] {ACTIVE_DAYS_TARGET} active days reached; "
+            f"switching to BREAK for {BREAK_DAYS}d",
+            file=sys.stderr,
+        )
+    else:
+        print(
+            f"[linkedin_cadence] ACTIVE phase: "
+            f"{len(state['active_days'])}/{ACTIVE_DAYS_TARGET} active days so far",
+            file=sys.stderr,
+        )
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in ("enforce", "status"):
+        print("usage: linkedin_cadence.py [enforce|status]", file=sys.stderr)
+        sys.exit(2)
+    if sys.argv[1] == "status":
+        state = load_state()
+        print(json.dumps(state if state is not None else {"phase": None}, indent=2))
+        sys.exit(0)
+    enforce()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/linkedin_killswitch.py

@@ -145,6 +145,10 @@ VALID_SIGNALS = {
     "session_invalid_marker",
     "captcha_detected",
     "manual",
+    # Deliberate pause from scripts/linkedin_cadence.py (4-active-days /
+    # 2-day-break schedule). Not an incident: recover-check must never try to
+    # auto-recover it, and engage() should never email on it.
+    "scheduled_break",
 }
 
 
@@ -880,6 +884,29 @@ def _hold_check_due_seconds():
     return (datetime.now(timezone.utc) - due).total_seconds()
 
 
+def _cadence_break_active():
+    """True while scripts/linkedin_cadence.py has us in a scheduled break.
+
+    Reads the cadence state file directly (no import of linkedin_cadence, to
+    avoid a circular import — linkedin_cadence imports this module). Recovery
+    must never attempt a real login or hold-check re-probe during a break,
+    REGARDLESS of which signal put the killswitch file in place: an
+    already-active real block (e.g. login_redirect) at the moment a break
+    starts must NOT get its 24h auto-recovery clock honored mid-break. The
+    2026-07-12 incident (a real hard_block login attempt fired during an
+    active cadence break) is exactly what this guards against."""
+    path = os.path.expanduser(
+        os.environ.get(
+            "LINKEDIN_CADENCE_FILE", os.path.join(STATE_DIR, "linkedin_cadence.json")
+        )
+    )
+    try:
+        with open(path, "r") as f:
+            return json.load(f).get("phase") == "break"
+    except Exception:
+        return False
+
+
 def _cmd_recover_check(args):
     """Gate for the hourly recovery job. Exits 0 when there is work to do and
     prints the MODE on stdout so the shell knows which path to drive:
@@ -894,6 +921,22 @@ def _cmd_recover_check(args):
     if not is_active():
         print("recover-check: killswitch not active, nothing to recover", file=sys.stderr)
         sys.exit(1)
+    if _cadence_break_active():
+        print(
+            "recover-check: cadence break active (scripts/linkedin_cadence.py); "
+            "suppressing ALL real recovery action (login/hold) regardless of "
+            "signal until the break ends, per 'stop all activity for 2 days'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    payload = read() or {}
+    if payload.get("signal") == "scheduled_break":
+        print(
+            "recover-check: scheduled_break active (cadence pause, not a real "
+            "incident); deferring to scripts/linkedin_cadence.py, not probing",
+            file=sys.stderr,
+        )
+        sys.exit(1)
     if is_terminal():
         print(
             "recover-check: TERMINAL (auto-recovery gave up); "

package/scripts/memory_snapshot.py

@@ -700,6 +700,8 @@ def build_summary() -> dict[str, Any]:
         "menubar": menubar_status(),
         "twitter_cycle": twitter_cycle_status(),
         "draft_publish": draft_publish_wrapper_status(),
+        "chrome_relaunches": chrome_relaunch_status(),
+        "cdp_health": cdp_health_status(),
         "process_count": len(rows),
         "mem": {
             "total_mb": total,
@@ -845,6 +847,25 @@ def reaper_status() -> dict[str, Any] | None:
         return None
 
 
+def cdp_health_status() -> dict[str, Any] | None:
+    """Last CDP readiness verdict, carried on the heartbeat.
+
+    Written by skill/lib/twitter-backend.sh on every
+    ensure_twitter_browser_for_backend call: whether the harness Chrome
+    completed a REAL connect_over_cdp handshake (not just /json/version),
+    plus the action taken (ok / wedge_restart / relaunched / relaunch_failed /
+    external_wedged). Makes a wedged-Chrome episode (S4L-4H, 2026-07-11) a
+    one-query answer in installation_resource_samples instead of a Sentry +
+    local-log archaeology session. Best-effort."""
+    try:
+        p = REPO_DIR / "skill" / "logs" / "cdp-health.json"
+        data = json.loads(p.read_text())
+        data["age_sec"] = round(time.time() - p.stat().st_mtime, 1)
+        return data
+    except Exception:
+        return None
+
+
 def twitter_cycle_status() -> dict[str, Any] | None:
     """Tail of the newest twitter-cycle log, carried on the heartbeat.
 
@@ -898,6 +919,42 @@ def draft_publish_wrapper_status() -> dict[str, Any] | None:
         return None
 
 
+def chrome_relaunch_status() -> dict[str, Any] | None:
+    """Harness-Chrome relaunch rate from skill/logs/chrome-relaunch-events.log.
+
+    The skill/lib/*-backend.sh launchers append one dated line per Chrome
+    launch. A healthy box launches Chrome rarely (boot, user quit, crash); a
+    high 24h count is the signature of the 2026-07-12 kill-respawn loop
+    (launchd reaping the kicker job's process group took Chrome with it every
+    cycle, and each relaunch stole the user's focus). Carried on the heartbeat
+    so the rate is queryable per-install WITHOUT the menubar foreground
+    observer, which only reports while the menubar process is alive."""
+    try:
+        p = REPO_DIR / "skill" / "logs" / "chrome-relaunch-events.log"
+        if not p.exists():
+            return None
+        now = time.time()
+        counts = {"1h": 0, "24h": 0}
+        last_line = None
+        for ln in _tail_lines(p, 400, approx_line_bytes=64):
+            ln = ln.strip()
+            if not ln:
+                continue
+            try:
+                ts = dt.datetime.strptime(ln.split()[0], "%Y-%m-%dT%H:%M:%SZ")
+                age = now - ts.replace(tzinfo=dt.timezone.utc).timestamp()
+            except (ValueError, IndexError):
+                continue
+            if age <= 3600:
+                counts["1h"] += 1
+            if age <= 86400:
+                counts["24h"] += 1
+            last_line = ln
+        return {"count_1h": counts["1h"], "count_24h": counts["24h"], "last": last_line}
+    except Exception:
+        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."""