koala73
diff --git a/‎server/worldmonitor/news/v1/_classifier.ts‎
Lines changed: 112 additions & 3 deletions b/‎server/worldmonitor/news/v1/_classifier.ts‎
Lines changed: 112 additions & 3 deletions
diff --git a/‎server/worldmonitor/news/v1/list-feed-digest.ts‎
Lines changed: 70 additions & 8 deletions b/‎server/worldmonitor/news/v1/list-feed-digest.ts‎
Lines changed: 70 additions & 8 deletions
@@ -17,7 +17,14 @@ export interface ClassificationResult {
   level: ThreatLevel;
   category: EventCategory;
   confidence: number;
-  source: 'keyword';
+  // 'keyword' = pure keyword match (CRITICAL/HIGH/MEDIUM/LOW lists or
+  // info-level no-match fallback). 'keyword-historical-downgrade' = a
+  // CRITICAL/HIGH keyword matched, but the headline contained a historical
+  // retrospective marker (e.g. "Science history:", "April 26, 1986",
+  // "5 years ago"), so the level was forced to info. Distinct source tag
+  // lets downstream consumers + telemetry distinguish "no-match info"
+  // from "downgraded-from-critical info".
+  source: 'keyword' | 'keyword-historical-downgrade';
 }
 
 type KeywordMap = Record<string, EventCategory>;
@@ -212,6 +219,91 @@ function matchKeywords(
   return null;
 }
 
+/**
+ * Headline-shape patterns that flip a CRITICAL/HIGH keyword classification
+ * into a historical retrospective. Triggered ONLY after a critical/high
+ * keyword has already matched — i.e. these patterns alone don't downgrade
+ * unrelated content; they downgrade content where the trigger word
+ * (`meltdown`, `invasion`, `genocide`, …) appears in a historically-framed
+ * headline. Examples that tripped the prior classifier:
+ *   - "Science history: Chernobyl nuclear power plant melts down — April 26, 1986"
+ *   - "On this day: Iraq invasion 5 years ago"
+ * Both contain a CRITICAL keyword AND an unmistakable retrospective marker.
+ */
+// Highly-specific retrospective prefixes — bare "Today in" / "This day in"
+// were intentionally REMOVED after PR #3429 review (round 2). Both have
+// legitimate current-event uses ("Today in Ukraine: Russian missile strikes
+// Kyiv") that would have falsely downgraded real critical alerts. Only
+// patterns whose retrospective intent is unambiguous remain:
+//   - "Science history:" — Live Science series tag, never current.
+//   - "Throwback" / "Flashback" — always retrospective by definition.
+const HISTORICAL_PREFIX_RE = /^(?:science history|throwback|flashback)\s*:?/i;
+
+// "On this day in YYYY" requires a YEAR after the prefix — narrows out
+// "On this day, Iran fires missile" (current event) while keeping
+// "On this day in 1986, Chernobyl..." (retrospective).
+const HISTORICAL_PREFIX_WITH_YEAR_RE = /^on this day in\s+(?:19|20)\d{2}\b/i;
+
+// "This day in history" — specific phrasing, not the bare "This day in"
+// (which could prefix a current-event headline).
+const THIS_DAY_IN_HISTORY_RE = /^this day in history\b/i;
+
+const HISTORICAL_PHRASE_RE =
+  /\b(?:\d+\s+(?:years?|decades?|months?)\s+(?:ago|after|later)|anniversary|in memoriam|remembering|remembered|commemorat(?:e|es|ed|ion)|retrospective)\b/i;
+
+// Full date in the headline. The year must be ≥ 2 years in the past for
+// the date to count as retrospective — "April 26, 2026" (current year) or
+// "April 26, 2025" (last year) appear in plenty of current-event headlines
+// (court rulings, regulatory deadlines, scheduled events). Only dates from
+// 2024-and-earlier (in 2026) are unambiguously retrospective.
+const FULL_DATE_RE =
+  /\b(?:january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{1,2},?\s+((?:19|20)\d{2})\b/i;
+
+const ISO_DATE_RE = /\b((?:19|20)\d{2})-\d{1,2}-\d{1,2}\b/;
+
+/**
+ * Year is "past" for retrospective purposes when it's at least 2 years
+ * older than the current calendar year. Conservative cutoff: a 1-year-old
+ * date is often current-context (last year's court ruling, last year's
+ * outbreak) and we don't want to falsely downgrade those.
+ */
+function isPastRetrospectiveYear(year: number, nowMs: number): boolean {
+  const currentYear = new Date(nowMs).getUTCFullYear();
+  return year < currentYear - 1;
+}
+
+/**
+ * Returns true if the title looks like a historical retrospective.
+ * Used by classifyByKeyword to downgrade CRITICAL/HIGH keyword matches
+ * (e.g. "meltdown") that appear in a backward-looking headline, AND by
+ * enrichWithAiCache as a defense-in-depth check on LLM-promoted levels.
+ *
+ * The `nowMs` parameter is exposed for unit testability (so tests can pin
+ * the "current year" without depending on wall-clock time). Production
+ * callers omit it and get `Date.now()`.
+ *
+ * Exported for test coverage — DO NOT call from production code paths
+ * other than classifyByKeyword and enrichWithAiCache.
+ */
+export function hasHistoricalMarker(title: string, nowMs: number = Date.now()): boolean {
+  if (HISTORICAL_PREFIX_RE.test(title)) return true;
+  if (HISTORICAL_PREFIX_WITH_YEAR_RE.test(title)) return true;
+  if (THIS_DAY_IN_HISTORY_RE.test(title)) return true;
+  if (HISTORICAL_PHRASE_RE.test(title)) return true;
+
+  const fullDateMatch = title.match(FULL_DATE_RE);
+  if (fullDateMatch && isPastRetrospectiveYear(parseInt(fullDateMatch[1]!, 10), nowMs)) {
+    return true;
+  }
+
+  const isoDateMatch = title.match(ISO_DATE_RE);
+  if (isoDateMatch && isPastRetrospectiveYear(parseInt(isoDateMatch[1]!, 10), nowMs)) {
+    return true;
+  }
+
+  return false;
+}
+
 export function classifyByKeyword(title: string, variant?: string): ClassificationResult {
   const lower = title.toLowerCase();
 
@@ -220,12 +312,29 @@ export function classifyByKeyword(title: string, variant?: string): Classificati
   }
 
   const isTech = variant === 'tech';
+  // Historical-retrospective downgrade applies only to CRITICAL/HIGH
+  // keyword matches — those are the levels that score high enough to
+  // ship in briefs, and those are where the false-positive cost is
+  // highest (an anniversary listicle ranking like a current crisis).
+  // LOW/MEDIUM matches are left alone since they don't clear thresholds
+  // anyway, and the downgrade-to-info would be over-aggressive there.
+  const isRetrospective = hasHistoricalMarker(title);
 
   let match = matchKeywords(lower, CRITICAL_KEYWORDS);
-  if (match) return { level: 'critical', category: match.category, confidence: 0.9, source: 'keyword' };
+  if (match) {
+    if (isRetrospective) {
+      return { level: 'info', category: 'general', confidence: 0.85, source: 'keyword-historical-downgrade' };
+    }
+    return { level: 'critical', category: match.category, confidence: 0.9, source: 'keyword' };
+  }
 
   match = matchKeywords(lower, HIGH_KEYWORDS);
-  if (match) return { level: 'high', category: match.category, confidence: 0.8, source: 'keyword' };
+  if (match) {
+    if (isRetrospective) {
+      return { level: 'info', category: 'general', confidence: 0.85, source: 'keyword-historical-downgrade' };
+    }
+    return { level: 'high', category: match.category, confidence: 0.8, source: 'keyword' };
+  }
 
   if (isTech) {
     match = matchKeywords(lower, TECH_HIGH_KEYWORDS);
 
@@ -13,7 +13,7 @@ import { markNoCacheResponse } from '../../../_shared/response-headers';
 import { sha256Hex } from '../../../_shared/hash';
 import { CHROME_UA } from '../../../_shared/constants';
 import { VARIANT_FEEDS, INTEL_SOURCES, type ServerFeed } from './_feeds';
-import { classifyByKeyword, type ThreatLevel } from './_classifier';
+import { classifyByKeyword, hasHistoricalMarker, type ThreatLevel } from './_classifier';
 import { buildClassifyCacheKey } from '../../intelligence/v1/_shared';
 import { getSourceTier } from '../../../_shared/source-tiers';
 import {
@@ -129,7 +129,7 @@ interface ParsedItem {
   level: ThreatLevel;
   category: string;
   confidence: number;
-  classSource: 'keyword' | 'llm';
+  classSource: 'keyword' | 'keyword-historical-downgrade' | 'llm';
   importanceScore: number;
   corroborationCount: number;
   titleHash?: string;
@@ -348,7 +348,7 @@ function parseRssXml(xml: string, feed: ServerFeed, variant: string): ParseResul
       level: threat.level,
       category: threat.category,
       confidence: threat.confidence,
-      classSource: 'keyword',
+      classSource: threat.source,
       importanceScore: 0,
       corroborationCount: 1,
       lang: feed.lang ?? 'en',
@@ -498,7 +498,13 @@ function decodeXmlEntities(s: string): string {
 }
 
 async function enrichWithAiCache(items: ParsedItem[]): Promise<void> {
-  const candidates = items.filter(i => i.classSource === 'keyword');
+  // Apply the LLM cache to BOTH 'keyword' and 'keyword-historical-downgrade'
+  // sources. The historical-downgrade path forced an info level based on a
+  // headline-shape heuristic; the LLM cache (when warmed) is a stronger
+  // signal and should be allowed to either confirm or override.
+  const candidates = items.filter(
+    i => i.classSource === 'keyword' || i.classSource === 'keyword-historical-downgrade',
+  );
   if (candidates.length === 0) return;
 
   // Use the canonical buildClassifyCacheKey from intelligence/v1/_shared
@@ -521,14 +527,70 @@ async function enrichWithAiCache(items: ParsedItem[]): Promise<void> {
     if (!hit || hit.level === '_skip' || !hit.level || !hit.category) continue;
 
     for (const item of relatedItems) {
+      // L3 defense-in-depth runs FIRST, BEFORE capLlmUpgrade. If the
+      // title carries a historical-retrospective marker, force info
+      // regardless of what the LLM cache claimed — retrospective content
+      // should never ship at any non-info level.
+      //
+      // Why before the cap (P1 fix on PR #3429 round 3): when keyword=info
+      // and hit=critical, capLlmUpgrade returns medium (info+2=medium).
+      // A post-cap check on `cappedLevel === 'critical' || === 'high'`
+      // would miss this — `medium` doesn't match — so the brief 2026-04-
+      // 26-1302 Chernobyl-style title would have shipped at MEDIUM (which
+      // still passes 'all' sensitivity briefs). Running the marker check
+      // on the original hit and forcing info — not on cappedLevel — closes
+      // that gap.
+      //
+      // Why force info unconditionally (not just critical/high): retro-
+      // spective markers should suppress the LLM verdict at every non-info
+      // level, including medium and low. A medium-level retrospective would
+      // still ship in 'all'-sensitivity briefs; the goal of this guard is
+      // "retrospective content NEVER ships, regardless of LLM verdict."
+      if (hasHistoricalMarker(item.title)) {
+        console.warn(
+          `[classify] LLM hit forced to info by historical marker: ` +
+            `keyword=${item.level} llm=${hit.level} title="${item.title.slice(0, 60)}"`,
+        );
+        item.level = 'info';
+        item.category = hit.category;
+        item.confidence = 0.9;
+        item.classSource = 'llm';
+        item.isAlert = false;
+        continue;
+      }
+
+      // Skip the LLM cache for high-confidence keyword=critical matches
+      // (confidence 0.9). Without this skip, capLlmUpgrade is a Math.min
+      // — a stale or wrong LLM cache entry saying 'info' would silently
+      // demote a genuine current critical event to info via min(critical,
+      // info) = info, with no remaining safeguard.
+      //
+      // The retrospective case the prior PR #3424 wanted to handle here
+      // is already handled UPSTREAM: a keyword=critical title with a
+      // historical marker becomes classSource='keyword-historical-
+      // downgrade' (confidence 0.85, level=info) inside classifyByKeyword
+      // BEFORE reaching this function, so the L3 marker check above
+      // catches it via the historical-downgrade source. Items reaching
+      // here at confidence 0.9 are by construction items where the
+      // keyword classifier saw a critical match AND saw no marker —
+      // the safer default for those is to trust the keyword verdict.
+      //
+      // The L3 marker check above intentionally runs BEFORE this skip so
+      // that keyword=info (confidence 0.3, no-match) titles with a
+      // marker — the brief 2026-04-26-1302 "Science history: melts
+      // down…" shape — still get forced to info via the cache hit.
+      // Belt-and-suspenders for substring-keyword-miss contamination.
+      //
+      // P1 fix on PR #3429 round 4 (Greptile review on commit 96d3c12d7).
       if (0.9 <= item.confidence) continue;
+
+      //
       // Cap the LLM upgrade at +2 tiers above the keyword classification
       // so a poisoned cache entry (e.g., "About Section 508" → high) can't
       // promote an info-keyword item past medium (info+2=medium). Legitimate
-      // medium→critical upgrades (medium+2=critical) remain reachable; the
-      // bounded loss is keyword=low → LLM=critical, which caps at high
-      // (low+2=high) and is logged below. See LEVEL_RANK doc + R4 for the
-      // full per-keyword cap table.
+      // medium→critical upgrades (medium+2=critical) remain reachable.
+      // capLlmUpgrade is a Math.min so downgrades pass through freely.
+      // See LEVEL_RANK doc + R4 for the full per-keyword cap table.
       const cappedLevel = capLlmUpgrade(item.level, hit.level);
       if (cappedLevel !== hit.level) {
         console.warn(