#172: three more owner-notice conditions: no-browser-route, sidecar-down, adapter-broken

FaultsFrom judges three more faults at the shared twelve-hour OwnerWindow:
a no-browser-route Site's refusing run (browser-backed Sites excluded), a
sidecar no Lane has reached (one site-wide fault), and a Site where more
than half of Series hold an old no-chapter failure row. recordPass fills
the inputs from three new store reads (RefusingSince, SidecarOK,
NoChapterShare), each failing independently and never failing a pass, and
the clear loop forgets the empty-Site row too so a lifted sidecar-down
fires again on return.

backend/internal/store/store.go

@@ -1227,6 +1227,101 @@ func (s *Store) LanePassOutcomes(since int64) ([]SiteOutcomes, error) {
 	return out, rows.Err()
 }
 
+// RefusingSince reports, per Site, when that Site's current unbroken run of
+// refusing passes began: a pass refuses when the Lane gate returned early
+// (skip = 'refusing') or the pass loop counted refusals (refused > 0), so a
+// Site parked in refusal backoff keeps its run unbroken. A Site whose
+// latest pass did not refuse is absent. The run is bounded by the pass
+// log's retention — a run older than the log answers with the oldest row
+// present — and nothing after now counts: the cutoff is the caller's clock.
+func (s *Store) RefusingSince(now int64) (map[string]int64, error) {
+	rows, err := s.db.Query(`
+		SELECT site, MIN(ran_at)
+		FROM poll_passes p
+		WHERE ran_at <= $1
+		  AND (refused > 0 OR skip = 'refusing')
+		  AND ran_at > COALESCE((
+		      SELECT MAX(q.ran_at) FROM poll_passes q
+		      WHERE q.site = p.site AND q.ran_at <= $1
+		        AND NOT (q.refused > 0 OR q.skip = 'refusing')
+		  ), 0)
+		GROUP BY site`, now)
+	if err != nil {
+		return nil, fmt.Errorf("query refusing since: %w", err)
+	}
+	defer rows.Close()
+
+	out := map[string]int64{}
+	for rows.Next() {
+		var site string
+		var since int64
+		if err := rows.Scan(&site, &since); err != nil {
+			return nil, fmt.Errorf("scan refusing since: %w", err)
+		}
+		out[site] = since
+	}
+	return out, rows.Err()
+}
+
+// SidecarOK reports, per Site in sites, the unix ms of that Site's most
+// recent pass that actually reached the sidecar: the pass ran its loop
+// (skip = '') and no Series read lost Chrome (unreachable = 0) — a
+// challenge answer still reached the sidecar, a lost sidecar did not. A
+// Site with no such pass is absent: an asleep Lane never reached it, so it
+// is absent too and cannot age into a sidecar-down alarm by itself.
+func (s *Store) SidecarOK(sites []string) (map[string]int64, error) {
+	rows, err := s.db.Query(`
+		SELECT DISTINCT ON (site) site, ran_at
+		FROM poll_passes
+		WHERE site = ANY($1) AND skip = '' AND unreachable = 0
+		ORDER BY site, ran_at DESC`, sites)
+	if err != nil {
+		return nil, fmt.Errorf("query sidecar ok: %w", err)
+	}
+	defer rows.Close()
+
+	out := map[string]int64{}
+	for rows.Next() {
+		var site string
+		var ranAt int64
+		if err := rows.Scan(&site, &ranAt); err != nil {
+			return nil, fmt.Errorf("scan sidecar ok: %w", err)
+		}
+		out[site] = ranAt
+	}
+	return out, rows.Err()
+}
+
+// NoChapterShare reports, per Site, the share of that Site's Series holding
+// a no-chapter failure row older than cutoff: old rows over the Site's
+// whole Series count, so a four-Series Site and a 200-Series Site are
+// judged on the same scale. A Site with no Series has no share and is
+// absent.
+func (s *Store) NoChapterShare(cutoff int64) (map[string]float64, error) {
+	rows, err := s.db.Query(`
+		SELECT s.site,
+		       (COUNT(*) FILTER (WHERE f.outcome = 'no_chapter' AND f.failing_since < $1))::float8
+		         / (COUNT(*)::float8)
+		FROM series s
+		LEFT JOIN poll_failures f ON f.site = s.site AND f.series_id = s.series_id
+		GROUP BY s.site
+		ORDER BY s.site`, cutoff)
+	if err != nil {
+		return nil, fmt.Errorf("query no-chapter share: %w", err)
+	}
+	defer rows.Close()
+
+	out := map[string]float64{}
+	for rows.Next() {
+		var site string
+		var share float64
+		if err := rows.Scan(&site, &share); err != nil {
+			return nil, fmt.Errorf("scan no-chapter share: %w", err)
+		}
+		out[site] = share
+	}
+	return out, rows.Err()
+}
 // SetLaneRefusal persists a Site's refusal backoff stamp without touching its
 // pause. until is supplied by the caller's clock.
 func (s *Store) SetLaneRefusal(site string, until int64) error {