v0.14: regional_risk_agent — FEMA NRI multi-hazard at county level

Broadens FlutIQ from flood-only to multi-hazard. Every county in the US
now gets a calibrated risk profile across 18 hazards (wildfire, hurricane,
tornado, earthquake, drought, heat wave, etc.) at the neighborhood level
from FEMA's National Risk Index — the canonical source.

The win that matters: NRI's data was previously gated behind FEMA's
click-through CSV download. Found the exposed ArcGIS REST endpoint
behind RAPT (Resilience Analysis and Planning Tool):

https://services.arcgis.com/XG15cJAlne2vxtgt/arcgis/rest/services/
National_Risk_Index_Counties/FeatureServer/0/query

Free, no auth, point queries, 467 fields per county, full national
coverage. Verified live across 6 geographies with very different
hazard fingerprints:

Chicago: Cold wave + Winter weather + Tornado + Inland flood
LA: Earthquake + Wildfire + Inland flood (Community
Resilience: Very Low — interesting demo signal)
Houston: Hurricane + Tornado + Inland flood + Lightning
Miami: Hurricane + Coastal flood + Lightning
Boulder: Wildfire + Lightning + Hail (Front Range fingerprint)
Anchorage: Avalanche + Earthquake + Volcanic activity

Gemma 4 ran on Chicago and produced authentically Chicago-specific
headline-hazard explanations:
'extreme Great Lakes winter cycles' (Winter Weather)
'Midwest corridor susceptibility' (Tornadoes)
'Urban heat island effect in Chicago' (Heat Waves)

Backend:
+ backend/app/tools/nri_county.py — Free ArcGIS point query against
FEMA's NRI Counties FeatureServer. Curates the 467-field response
down to: composite risk score+rating, top 5 hazards by NRI rating
tier, social vulnerability, community resilience, total EAL.
Field-name nuance documented (NRI's _RISKR is rating string,
_RISKS is numeric score — opposite of how the schema aliases
read).
+ backend/app/agents/regional_risk_agent.py — wraps the tool, asks
Gemma 4 to:
1. Pick 2-4 hazards that GENUINELY matter for THIS county
(not just 'all are very high' — that's a population-scale
artifact for big counties)
2. Note what the county-level NRI flood score adds vs the
property-level FEMA zone
3. Interpret SoVI + Community Resilience as recovery context
+ orchestrator: 'regional' added to the parallel data-agent pack.
~ risk_agent: prompt now includes a 'Regional Multi-Hazard Profile'
section so the synthesis can cross-reference county-level NRI with
property-level FEMA / 311 / satellite findings.

Frontend:
+ AGENTS list gets 'Regional risk analyst' (and 'Satellite surveyor'
which was previously missing from the agents-screen even though
it ran).
+ New §05 dossier section 'Wider neighborhood — beyond just flooding'
— purple-accented, only renders when NRI data is available. Shows
the composite badge, EAL, SoVI/Resilience chips, top hazards as a
numbered list with severity colors, plus Gemma's flood-misses
callout and resilience-context callout, sourced from RAPT.
+ Section numbering refactored to a useMemo helper (_sectionNums)
that walks through conditional sections counting up — cleaner
than the nested-conditional approach we had.

Version: chrome wordmark v0.13 → v0.14, app version 0.13.0 → 0.14.0.

app/agents/orchestrator.py

@@ -21,6 +21,7 @@ from app.agents.archive_agent import run_archive_agent
 from app.agents.fema_agent import run_fema_agent
 from app.agents.local_agent import run_local_agent
 from app.agents.news_agent import run_news_agent
+from app.agents.regional_risk_agent import run_regional_risk_agent
 from app.agents.risk_agent import run_risk_agent
 from app.agents.satellite_agent import run_satellite_agent
 from app.agents.streetview_agent import run_streetview_agent
@@ -78,10 +79,19 @@ def _make_satellite(language: str) -> AgentFn:
     return _run
 
 
+def _make_regional(language: str) -> AgentFn:
+    async def _run(ctx: GeoCtx) -> dict:
+        return await run_regional_risk_agent(
+            ctx["lat"], ctx["lon"], ctx.get("display_name", ""),
+            language=language,
+        )
+    return _run
+
+
 # Order here is the order the frontend renders agent rows in.
 # The two vision agents (streetview eye-level + satellite bird's-eye)
-# are placed last in the data row so users see the slower vision
-# calls finishing after the cheap text-API calls.
+# are placed last so users see the slower vision calls finishing after
+# the cheap text-API calls.
 def _data_agents_for(language: str) -> dict[str, AgentFn]:
     return {
         "fema": _fema,
@@ -89,6 +99,7 @@ def _data_agents_for(language: str) -> dict[str, AgentFn]:
         "weather": _weather,
         "news": _news,
         "archive": _archive,
+        "regional": _make_regional(language),
         "satellite": _make_satellite(language),
         "streetview": _make_streetview(language),
     }
@@ -260,6 +271,7 @@ def _compile_dossier(geo: GeoCtx, results: dict) -> dict:
         "archive": results.get("archive", {}),
         "streetview": results.get("streetview", {}),
         "satellite": results.get("satellite", {}),
+        "regional": results.get("regional", {}),
         "risk": results.get("risk", {}),
         "advisor": results.get("advisor", {}),
     }

app/agents/regional_risk_agent.py

@@ -0,0 +1,130 @@
+"""
+Regional risk agent — area-level multi-hazard context.
+
+Wraps the FEMA NRI county lookup. Asks Gemma 4 to:
+  1. Identify which 2-3 hazards genuinely matter for THIS county
+     (not just "all are very high" — that's true for any big-population
+     county on a national-percentile-ranked index)
+  2. Frame the result against the property-level flood signals the
+     other agents already produced
+  3. Note social vulnerability + community resilience as risk-context
+     modulators, not extra hazards
+
+The point of this agent is to broaden FlutIQ from flood-only to
+"here's the multi-hazard picture of your neighborhood." Wildfire,
+hurricane, earthquake, tornado are all surfaced in plain English at
+the COUNTY (not address) level — exactly the resolution of FEMA's NRI.
+"""
+import json
+
+from app.data.languages import prompt_directive
+from app.llm.client import call_gemma4, extract_text, parse_json_response
+from app.tools.nri_county import lookup_nri_county
+
+
+SYSTEM_PROMPT = """You are a regional natural-hazard analyst. You read FEMA's National Risk Index (NRI) county-level data and explain in plain language which hazards meaningfully affect a specific neighborhood.
+
+Critical guidance:
+- NRI scores are NATIONAL PERCENTILES. A county at the 99th percentile for tornado risk is in the top 1% of the country for tornado risk — that's meaningful. But large-population counties tend to score Very High on many hazards just because more people + property = more expected loss; rating alone is not enough, look at the SCORES too.
+- Distinguish "this county is genuinely high-risk for hazard X" (high score AND meaningful expected annual loss vs population) from "this county hits Very High because of population scale, not unusual hazard exposure."
+- Cross-reference with property-level flood signals provided by other agents. NRI's Inland Flooding score is COUNTY-LEVEL; the property's actual FEMA Zone designation and 311 record are more precise.
+- Social Vulnerability and Community Resilience are POPULATION-level — they describe how well the surrounding community can respond to and recover from a disaster. Note them; don't conflate with hazard exposure.
+- Plain English. Avoid hazard-jargon (e.g. say "tornadoes" not "convective windstorm events").
+
+Always respond with valid JSON only."""
+
+
+async def run_regional_risk_agent(
+    lat: float,
+    lon: float,
+    address: str,
+    fema_findings: dict | None = None,
+    language: str = "en",
+) -> dict:
+    nri = await lookup_nri_county(lat, lon)
+
+    if not nri.get("available"):
+        return {
+            "available": False,
+            "summary": (
+                f"FEMA National Risk Index lookup unavailable: "
+                f"{nri.get('error', 'unknown reason')}"
+            ),
+            "raw": nri,
+        }
+
+    # Trim the raw NRI for the prompt — keep top hazards + ratings only,
+    # drop the long all-18-hazards array since the model already gets
+    # the top 5 ranked.
+    nri_for_prompt = {
+        "county": nri["county"],
+        "state": nri["state"],
+        "population": nri.get("population"),
+        "composite_risk_score": nri["composite_risk_score"],
+        "composite_risk_rating": nri["composite_risk_rating"],
+        "expected_annual_loss_usd": nri["expected_annual_loss_usd"],
+        "social_vulnerability_rating": nri["social_vulnerability_rating"],
+        "community_resilience_rating": nri["community_resilience_rating"],
+        "top_hazards": nri["top_hazards"],
+    }
+
+    fema_for_prompt = (
+        {k: v for k, v in (fema_findings or {}).items() if k != "raw"}
+        if fema_findings else None
+    )
+
+    user_prompt = f"""Analyze the FEMA National Risk Index profile for the property's COUNTY.
+
+Address: {address}
+
+## NRI county-level signal
+{json.dumps(nri_for_prompt, indent=2, default=str)}
+
+## Property-level FEMA flood designation (from the property-specific FEMA agent)
+{json.dumps(fema_for_prompt, indent=2, default=str) if fema_for_prompt else "(not available)"}
+
+Return a JSON object:
+
+{{
+  "headline_hazards": [
+    {{
+      "name": "<short hazard name, e.g. 'Hurricane', 'Wildfire'>",
+      "rating": "<copy from top_hazards above>",
+      "score": <copy from top_hazards above>,
+      "matters_because": "<1 sentence explaining why this hazard genuinely affects THIS county — geography, climate, history. Do not just restate the rating.>"
+    }}
+  ],
+  "what_property_level_flood_misses": "<1-2 sentences on what the county-level NRI flood score adds vs. the property's specific FEMA Zone designation. If the FEMA agent already showed this is a SFHA property, say so. If FEMA says minimal but NRI inland-flooding is Very High, that's a meaningful gap to call out.>",
+  "resilience_context": "<1-2 sentences interpreting Social Vulnerability + Community Resilience for this area, in plain English. Examples: 'Highly resilient community: well-resourced response infrastructure.' / 'Lower community resilience means a similar storm here would take longer to recover from than in a higher-resilience county.'>",
+  "summary": "<1 sentence for the status feed>"
+}}
+
+CONSTRAINTS:
+- headline_hazards: pick 2 to 4 hazards. Skip anything with rating "No Rating" / "Insufficient Data" / "Not Applicable".
+- Don't pad with non-meaningful hazards just to fill 4 slots.
+- If the county is genuinely low-risk overall (composite < 50), say so honestly.
+- Return ONLY the JSON object."""
+
+    response = await call_gemma4(
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT + prompt_directive(language)},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=0.2,
+        max_tokens=2000,
+    )
+
+    text = extract_text(response)
+    parsed = parse_json_response(text) or {}
+
+    # Always pass through the structured NRI data so the dossier UI can
+    # render the full top-hazards table even if the model's interpretation
+    # truncated to 2.
+    parsed["available"] = True
+    parsed["nri"] = nri
+    if "summary" not in parsed:
+        parsed["summary"] = (
+            f"County composite risk: {nri['composite_risk_rating']} "
+            f"({nri['composite_risk_score']}/100)"
+        )
+    return parsed

app/agents/risk_agent.py

@@ -110,6 +110,15 @@ Here is all the data collected by our investigation team:
 ## Satellite Visual Analysis (from the satellite agent)
 {json.dumps({k: v for k, v in (all_data.get('satellite') or {}).items() if k != 'image_data_url'}, indent=2, default=str)}
 
+## Regional Multi-Hazard Profile (FEMA NRI, county-level — from the regional_risk agent)
+This is the COUNTY-level National Risk Index profile — wider than the
+property-specific signals above, narrower than national. Use it to widen
+the risk story beyond flooding (wildfire, hurricane, tornado, earthquake,
+etc. as applicable to this geography). Don't double-count: NRI's Inland
+Flooding score is county-level; the FEMA flood zone above is the
+authoritative property-level designation.
+{json.dumps({k: v for k, v in (all_data.get('regional') or {}).items() if k != 'nri'}, indent=2, default=str)}
+
 ## Weather & Hydrology Findings
 {json.dumps(all_data.get('weather', {}), indent=2, default=str)}
 

app/main.py

@@ -8,7 +8,7 @@ from fastapi.staticfiles import StaticFiles
 from app.api.assess import router as assess_router
 from app.api.health import router as health_router
 
-app = FastAPI(title="FlutIQ", version="0.13.0")
+app = FastAPI(title="FlutIQ", version="0.14.0")
 
 # CORS still permissive for split-deployment scenarios. With the
 # bundled deploy (frontend served from FastAPI) it's a no-op because

app/tools/nri_county.py

@@ -0,0 +1,201 @@
+"""
+FEMA National Risk Index — county-level multi-hazard scores.
+
+Why this matters: every other agent in FlutIQ is flood-focused. NRI gives
+us the calibrated, neighborhood-level "everything else" — wildfire,
+hurricane, tornado, earthquake, drought, heat wave, lightning, etc., plus
+Social Vulnerability and Community Resilience indices.
+
+Source: FEMA's Resilience Analysis and Planning Tool (RAPT) hosts the
+NRI Counties dataset on its public ArcGIS Online org. The FeatureServer
+accepts point queries without auth — exactly what we need.
+
+  https://services.arcgis.com/XG15cJAlne2vxtgt/arcgis/rest/services/
+    National_Risk_Index_Counties/FeatureServer/0/query?...
+
+Coverage: all 3,143 US counties + county-equivalents. Updated annually.
+
+Each county record has 467 fields. We surface a curated subset:
+  - Composite risk score + rating + percentile
+  - Per-hazard score + rating for the 18 NRI hazards
+  - Social Vulnerability + Community Resilience
+  - Total expected annual loss in dollars
+
+We DROP all the per-asset breakdown fields (building / population /
+agriculture EAL split out across 18 hazards = 100+ columns) because
+the dossier doesn't need them and they bloat the prompt budget.
+"""
+import json
+
+import httpx
+
+
+SERVICE_URL = (
+    "https://services.arcgis.com/XG15cJAlne2vxtgt/arcgis/rest/services/"
+    "National_Risk_Index_Counties/FeatureServer/0/query"
+)
+
+# 18 NRI hazards — codes used in field names + display labels.
+# Order matters: most common-to-explain hazards first so any "top N"
+# truncation surfaces the most-recognizable ones.
+HAZARDS: list[tuple[str, str]] = [
+    ("IFLD", "Inland flooding"),
+    ("CFLD", "Coastal flooding"),
+    ("HRCN", "Hurricane"),
+    ("WFIR", "Wildfire"),
+    ("ERQK", "Earthquake"),
+    ("TRND", "Tornado"),
+    ("HAIL", "Hail"),
+    ("HWAV", "Heat wave"),
+    ("CWAV", "Cold wave"),
+    ("DRGT", "Drought"),
+    ("WNTW", "Winter weather"),
+    ("ISTM", "Ice storm"),
+    ("SWND", "Strong wind"),
+    ("LTNG", "Lightning"),
+    ("LNDS", "Landslide"),
+    ("TSUN", "Tsunami"),
+    ("VLCN", "Volcanic activity"),
+    ("AVLN", "Avalanche"),
+]
+
+# Order from FEMA's NRI rating bins, low → high. Used to bucket-rank.
+_RATING_ORDER = (
+    "Very Low",
+    "Relatively Low",
+    "Relatively Moderate",
+    "Relatively High",
+    "Very High",
+    "No Rating",
+    "Insufficient Data",
+    "Not Applicable",
+)
+
+
+def _is_meaningful_rating(s: str | None) -> bool:
+    if not s:
+        return False
+    s = s.strip()
+    return s not in ("No Rating", "Insufficient Data", "Not Applicable", "")
+
+
+def _rating_rank(s: str | None) -> int:
+    """Rank a rating from 0 (very low) to 4 (very high). Non-rated → -1."""
+    try:
+        idx = _RATING_ORDER.index((s or "").strip())
+        return idx if idx <= 4 else -1
+    except ValueError:
+        return -1
+
+
+async def lookup_nri_county(lat: float, lon: float) -> dict:
+    """Point query the NRI Counties FeatureServer for (lat, lon).
+
+    Returns a dict with:
+      - county / state / fips
+      - composite risk: score (0-100) + rating
+      - expected_annual_loss_usd
+      - hazards: list of {code, name, score, rating, rank} sorted by rank desc
+      - top_hazards: top 5 by rating rank (only meaningfully-rated ones)
+      - social_vulnerability: rating + score
+      - community_resilience: rating + score
+    """
+    params = {
+        "geometry": json.dumps({
+            "x": lon, "y": lat,
+            "spatialReference": {"wkid": 4326},
+        }),
+        "geometryType": "esriGeometryPoint",
+        "inSR": "4326",
+        "outFields": "*",
+        "returnGeometry": "false",
+        "f": "json",
+    }
+
+    async with httpx.AsyncClient(timeout=20, follow_redirects=True) as client:
+        resp = await client.get(SERVICE_URL, params=params)
+
+    if resp.status_code != 200:
+        return {"available": False, "error": f"HTTP {resp.status_code}"}
+
+    try:
+        data = resp.json()
+    except ValueError:
+        return {"available": False, "error": "non-JSON response"}
+
+    if isinstance(data, dict) and "error" in data:
+        return {
+            "available": False,
+            "error": (data["error"].get("message") or "ArcGIS error"),
+        }
+
+    features = data.get("features") or []
+    if not features:
+        return {
+            "available": False,
+            "error": "No NRI county polygon at this point (out of US?)",
+        }
+
+    a = features[0].get("attributes") or {}
+
+    hazards = []
+    for code, name in HAZARDS:
+        # NRI field naming, verified against live response 2026-05-06:
+        #   _RISKR = Rating (string like "Very High")
+        #   _RISKS = Score (numeric 0-100)
+        #   _RISKV = Value (dollar expected loss) — not used here
+        rating = a.get(f"{code}_RISKR")
+        score = a.get(f"{code}_RISKS")
+        if score is None and not _is_meaningful_rating(rating):
+            continue
+        hazards.append({
+            "code": code,
+            "name": name,
+            "score": (
+                round(float(score), 2)
+                if isinstance(score, (int, float))
+                else None
+            ),
+            "rating": rating if _is_meaningful_rating(rating) else None,
+            "rank": _rating_rank(rating),
+        })
+
+    hazards_meaningful = [h for h in hazards if h["rank"] >= 0]
+    hazards_meaningful.sort(
+        key=lambda h: (-h["rank"], -(h["score"] or 0)),
+    )
+    top_hazards = hazards_meaningful[:5]
+
+    return {
+        "available": True,
+        "county": a.get("COUNTY"),
+        "state": a.get("STATEABBRV"),
+        "state_full": a.get("STATE"),
+        "fips": a.get("STCOFIPS"),
+        "population": a.get("POPULATION"),
+        "composite_risk_score": (
+            round(float(a["RISK_SCORE"]), 2)
+            if isinstance(a.get("RISK_SCORE"), (int, float)) else None
+        ),
+        "composite_risk_rating": a.get("RISK_RATNG"),
+        "expected_annual_loss_usd": (
+            int(a["EAL_VALT"])
+            if isinstance(a.get("EAL_VALT"), (int, float)) else None
+        ),
+        "social_vulnerability_rating": a.get("SOVI_RATNG"),
+        "social_vulnerability_score": (
+            round(float(a["SOVI_SCORE"]), 2)
+            if isinstance(a.get("SOVI_SCORE"), (int, float)) else None
+        ),
+        "community_resilience_rating": a.get("RESL_RATNG"),
+        "community_resilience_score": (
+            round(float(a["RESL_SCORE"]), 2)
+            if isinstance(a.get("RESL_SCORE"), (int, float)) else None
+        ),
+        "hazards": hazards_meaningful,
+        "top_hazards": top_hazards,
+        "source": (
+            "FEMA National Risk Index, county level. Hosted via FEMA's "
+            "Resilience Analysis and Planning Tool (RAPT)."
+        ),
+    }

static/index.html

@@ -540,6 +540,12 @@ const AGENTS = [
   { id: "archive", name: "Archivist",
     finding: "Cook County: 11 NOAA flood events in 10yr, 4 FEMA disaster declarations. 2008, 2013, 2020, 2023 caused widespread basement flooding.",
     pin: { x: 62, y: 70, label: "11 events / 10y", tone: "amber" }, delay: 1100 },
+  { id: "regional", name: "Regional risk analyst",
+    finding: "FEMA NRI county-level multi-hazard profile — wildfire, hurricane, tornado, earthquake, etc. — for the wider neighborhood.",
+    pin: null, delay: 1300 },
+  { id: "satellite", name: "Satellite surveyor",
+    finding: "Multimodal: bird's-eye Mapbox imagery → Gemma 4 vision → impervious-surface and catchment analysis.",
+    pin: null, delay: 1700 },
   { id: "streetview", name: "Streetview surveyor",
     finding: "Multimodal: feeding Google Street View imagery to Gemma 4 vision to spot ground-floor flood-risk indicators.",
     pin: null, delay: 1800 },
@@ -1117,12 +1123,29 @@ const mapDossier = (raw) => {
     streetview: raw.streetview || {},
     satellite: raw.satellite || {},
     local: raw.local || {},
+    regional: raw.regional || {},
   };
 };
 
 const DossierScreen = ({ onBack, dossier }) => {
   const D = useMemo(() => mapDossier(dossier), [dossier]);
   const [showReasoning, setShowReasoning] = useState(false);
+
+  // Section numbers depend on which conditional sections render. We
+  // precompute them so the rendering JSX stays readable.
+  const _sectionNums = useMemo(() => {
+    const hasImages   = D.streetview?.available || D.satellite?.available;
+    const hasRegional = D.regional?.available;
+    let n = 2;  // §01 actions, §02 insurance fixed
+    const fmt = () => "§" + String(++n).padStart(2, "0");
+    return {
+      images:   hasImages   ? fmt() : null,
+      gap:      fmt(),
+      regional: hasRegional ? fmt() : null,
+      signals:  fmt(),
+      news:     fmt(),
+    };
+  }, [D]);
   const [showBoxes, setShowBoxes] = useState(true);
   const [imageTab, setImageTab] = useState("streetview");  // "streetview" | "satellite" | "topo"
   return (
@@ -1228,7 +1251,7 @@ const DossierScreen = ({ onBack, dossier }) => {
           const showOverlay = showBoxes && indicatorsWithBoxes.length > 0;
         return (
           <Section
-            num="§03"
+            num={_sectionNums.images || "§03"}
             icon={<Icon name="pin" color="var(--accent)" size={16}/>}
             iconBg="var(--accent-soft)"
             title="What we saw at the property"
@@ -1406,7 +1429,7 @@ const DossierScreen = ({ onBack, dossier }) => {
         })()}
 
         <Section
-          num={(D.streetview?.available || D.satellite?.available) ? "§04" : "§03"}
+          num={_sectionNums.gap}
           icon={<Icon name="warn" color="var(--coral)" size={16}/>}
           iconBg="var(--coral-soft)"
           title="Why FEMA's flood map isn't the whole story"
@@ -1544,8 +1567,90 @@ const DossierScreen = ({ onBack, dossier }) => {
           )}
         </Section>
 
+        {D.regional?.available && (
+          <Section
+            num={_sectionNums.regional}
+            icon={<Icon name="warn" color="var(--purple)" size={16}/>}
+            iconBg="var(--purple-soft)"
+            title="Wider neighborhood — beyond just flooding"
+            badge={<span className="risk-tag purple">FEMA NRI · county-level</span>}>
+            <p style={{color:"var(--ink-2)", marginTop:0}}>
+              FlutIQ is flood-focused, but your county faces other hazards too. This is FEMA's
+              National Risk Index for {D.regional.nri?.county} {D.regional.nri?.state}
+              {D.regional.nri?.population ? ` (pop. ${D.regional.nri.population.toLocaleString()})` : ""},
+              calibrated against every other US county.
+            </p>
+            <div style={{display:"flex", gap:8, flexWrap:"wrap", margin:"12px 0", fontSize:12}}>
+              {D.regional.nri?.composite_risk_rating && (
+                <span className={`risk-tag ${
+                  D.regional.nri.composite_risk_rating.includes("Very High") ? "coral"
+                  : D.regional.nri.composite_risk_rating.includes("High") ? "amber"
+                  : D.regional.nri.composite_risk_rating.includes("Moderate") ? "amber"
+                  : "teal"
+                }`}>
+                  Composite: {D.regional.nri.composite_risk_rating} ({D.regional.nri.composite_risk_score}/100)
+                </span>
+              )}
+              {D.regional.nri?.expected_annual_loss_usd != null && (
+                <span className="risk-tag neutral">
+                  Expected annual loss: ${(D.regional.nri.expected_annual_loss_usd / 1_000_000).toFixed(0)}M
+                </span>
+              )}
+              {D.regional.nri?.social_vulnerability_rating && (
+                <span className="risk-tag neutral">SoVI: {D.regional.nri.social_vulnerability_rating}</span>
+              )}
+              {D.regional.nri?.community_resilience_rating && (
+                <span className="risk-tag neutral">Resilience: {D.regional.nri.community_resilience_rating}</span>
+              )}
+            </div>
+            {Array.isArray(D.regional.headline_hazards) && D.regional.headline_hazards.length > 0 && (
+              <div style={{marginBottom:12}}>
+                <div className="stat-label" style={{marginBottom:8}}>Headline hazards for this county</div>
+                <ol style={{margin:0, paddingLeft:0, listStyle:"none", fontSize:13, color:"var(--ink-2)", lineHeight:1.55}}>
+                  {D.regional.headline_hazards.map((h, i) => {
+                    const r = (h.rating || "").toLowerCase();
+                    const color = r.includes("very high") ? "var(--coral)"
+                                : r.includes("high") ? "var(--amber)"
+                                : r.includes("moderate") ? "var(--amber)"
+                                : "var(--teal)";
+                    return (
+                      <li key={i} style={{marginBottom:10, display:"flex", gap:10}}>
+                        <span style={{
+                          flexShrink:0, width:22, height:22, borderRadius:4,
+                          background:color, color:"white", fontSize:12, fontWeight:600,
+                          fontFamily:"'JetBrains Mono', monospace",
+                          display:"flex", alignItems:"center", justifyContent:"center",
+                        }}>{i+1}</span>
+                        <div>
+                          <strong>{h.name}</strong>
+                          {h.rating && <span className="small" style={{marginLeft:6}}> · {h.rating}</span>}
+                          {h.score != null && <span className="small" style={{marginLeft:6, color:"var(--ink-4)"}}> · score {h.score}</span>}
+                          <div style={{color:"var(--ink-3)", fontSize:12, marginTop:2}}>{h.matters_because}</div>
+                        </div>
+                      </li>
+                    );
+                  })}
+                </ol>
+              </div>
+            )}
+            {D.regional.what_property_level_flood_misses && (
+              <p style={{margin:"10px 0", padding:"10px 12px", background:"var(--bg)", borderLeft:"3px solid var(--accent)", borderRadius:4, fontSize:13, color:"var(--ink-2)", lineHeight:1.55}}>
+                <strong style={{color:"var(--accent)"}}>vs property-level FEMA · </strong>{D.regional.what_property_level_flood_misses}
+              </p>
+            )}
+            {D.regional.resilience_context && (
+              <p style={{margin:"10px 0", padding:"10px 12px", background:"var(--bg)", borderLeft:"3px solid var(--teal)", borderRadius:4, fontSize:13, color:"var(--ink-2)", lineHeight:1.55}}>
+                <strong style={{color:"var(--teal)"}}>Community resilience · </strong>{D.regional.resilience_context}
+              </p>
+            )}
+            <div style={{fontSize:11, color:"var(--ink-4)", marginTop:10, fontFamily:"'JetBrains Mono', monospace"}}>
+              source · FEMA National Risk Index via the Resilience Analysis and Planning Tool (RAPT)
+            </div>
+          </Section>
+        )}
+
         <Section
-          num={(D.streetview?.available || D.satellite?.available) ? "§05" : "§04"}
+          num={_sectionNums.signals}
           icon={<Icon name="drop" color="var(--accent)" size={16}/>}
           iconBg="var(--accent-soft)"
           title="The raw signals we looked at"
@@ -1559,7 +1664,7 @@ const DossierScreen = ({ onBack, dossier }) => {
         </Section>
 
         <Section
-          num={(D.streetview?.available || D.satellite?.available) ? "§06" : "§05"}
+          num={_sectionNums.news}
           icon={<Icon name="news" color="var(--amber)" size={16}/>}
           iconBg="var(--amber-soft)"
           title="Recent local flood news">
@@ -1594,7 +1699,7 @@ const Chrome = ({ screen, onJump, dark, onToggleDark, language, onLanguageChange
     <div className="wordmark" onClick={()=>onJump("search")} style={{cursor:"pointer"}}>
       <span className="glyph">F</span>
       <span>FlutIQ</span>
-      <span style={{color:"var(--ink-4)",fontSize:12,marginLeft:8,fontFamily:"JetBrains Mono"}}>v0.13 · beta</span>
+      <span style={{color:"var(--ink-4)",fontSize:12,marginLeft:8,fontFamily:"JetBrains Mono"}}>v0.14 · beta</span>
     </div>
     <div className="chrome-meta">
       <span className="pill static"><span className="dot"/>gemma-4 · OpenRouter</span>