fix(programs): trigger scope-watch immediately when user searches a program

Closes the gap where Ryan-BBP's new scope wasn't alerting on Discord even after the
user could see it in HackerOne: the warmer was rate-limiting on that program, so its
cached row stayed stale, and the passive watch only fires on warmer refresh — so a
stale row that never gets re-fetched can't trigger an alert.

Fix: when the Programs page on-search debounce force-fetches a program's scope
(POST /api/scope/program-summaries with force=true), the server now also feeds the
fresh summary into ProgramWatchCheckProgram(p). If its latest_target_updated_at is
newer than the watermark, Discord alert fires immediately and the watermark advances
(so the next warmer refresh doesn't re-alert on the same update).

Net effect: searching "ryan-bbp" in the Programs page = wake the watch up for it.
Force-fetches reach H1 directly (no internal 15-min cache to keep masking the new
scope), so a real new asset shows up in Discord within seconds of the search.

Bypasses the boot intro and per-cycle cap so a single force-fetch can fire exactly
one alert per program. No-op when watch disabled or no watermark yet (lets the
warmer establish baseline first).

Verified: go build/vet clean.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: h0tak88r

internal/api/program_watch.go

@@ -142,6 +142,35 @@ func ProgramWatchOnRefresh(programs []ProgramSummary) {
 	_ = db.SetSetting(programWatchWatermarkKey, freshest.LatestTargetUpdatedAt)
 }
 
+// ProgramWatchCheckProgram fires the watch for a SINGLE program — used when a
+// force-refreshed scope summary comes back (e.g. user searched the Programs page
+// for "ryan-bbp"). If the program's latest_target_updated_at is newer than the
+// persisted watermark, alert immediately and advance the watermark so the next
+// warmer refresh doesn't re-alert. No-op when watch is disabled or the program
+// can't be checked. Bypasses the boot intro and the per-cycle cap.
+func ProgramWatchCheckProgram(p ProgramSummary) {
+	if !programWatchEnabled() || !programWatchPlatformAllowed(p.Platform) {
+		return
+	}
+	if p.LatestTargetUpdatedAt == "" {
+		return
+	}
+	programWatchMu.Lock()
+	defer programWatchMu.Unlock()
+	watermark, _ := db.GetSetting(programWatchWatermarkKey)
+	if watermark == "" {
+		// No baseline yet — let the regular refresh path establish it silently
+		// (otherwise the first search after a fresh install would alert on
+		// whatever happened to be cached).
+		return
+	}
+	if !isNewerProgramTime(p.LatestTargetUpdatedAt, watermark) {
+		return
+	}
+	sendProgramUpdateDiscord(p)
+	_ = db.SetSetting(programWatchWatermarkKey, p.LatestTargetUpdatedAt)
+}
+
 func sendProgramIntroDiscord(p ProgramSummary) {
 	msg := fmt.Sprintf("📌 **Scope watch ready** — most recent update: **%s** (`%s` · %s)\n• Latest asset: `%s`\n• Updated: %s",
 		programWatchName(p), p.Handle, strings.ToUpper(p.Platform),

internal/api/programs_api.go

@@ -307,6 +307,13 @@ func apiProgramScopeSummaries(c *gin.Context) {
 			// hide the program's real scope until the TTL expires.
 			if fetched {
 				setCachedProgramScope(cacheKey, summary)
+				// User-initiated force-fetch (Programs page search) → also feed the
+				// scope-update watch so a genuinely-newer-than-watermark program
+				// alerts Discord immediately, instead of waiting for the next
+				// warmer refresh that might re-rate-limit it.
+				if req.Force {
+					ProgramWatchCheckProgram(summary)
+				}
 			}
 			mu.Lock()
 			summaries[cacheKey] = summary