sync: github 3e9a578

Dockerfile

@@ -15,19 +15,23 @@ COPY vendor/mcp-core /app/mcp-core
 RUN pip install /app/data-adapters /app/mcp-core "uvicorn[standard]>=0.30" \
     "huggingface_hub[hf_xet]>=0.24"
 
-# Pull the MARC PREVIMER atlases at build time. The dataset is private so we
-# need an HF token with read access. On HF Spaces, define the secret in
-# Settings -> Variables and secrets -> Secrets:
+# Pull the tidal atlas dataset at build time (MARC PREVIMER + SHOM Atlas C2D).
+# The dataset is private so we need an HF token with read access. On HF
+# Spaces, define the secret in Settings -> Variables and secrets -> Secrets:
 #   HF_TOKEN  (User Access Token with read scope on Qdonnars/openwind-tidal-atlas)
-# Runtime reads it back via MARC_ATLAS_DIR (set below). The fetch script falls
-# back gracefully (creates an empty MARC_ATLAS_DIR, runtime uses Open-Meteo
-# SMOC only) when the secret is absent.
+# Runtime reads MARC subdirs via MARC_ATLAS_DIR and the SHOM Parquet+JSON via
+# SHOM_C2D_DIR; both point at the same shared directory because the layout
+# inside the dataset places SHOM artefacts at root next to the per-atlas MARC
+# subdirs. The fetch script falls back gracefully (empty dir, runtime uses
+# Open-Meteo SMOC only) when the secret is absent.
 ENV HF_DATASET_ID=Qdonnars/openwind-tidal-atlas
-ENV MARC_ATLAS_DIR=/app/data/marc-atlas
-COPY fetch_marc_dataset.py /tmp/fetch_marc_dataset.py
+ENV ATLAS_DATA_DIR=/app/data/atlas
+ENV MARC_ATLAS_DIR=/app/data/atlas
+ENV SHOM_C2D_DIR=/app/data/atlas
+COPY fetch_atlases.py /tmp/fetch_atlases.py
 RUN --mount=type=secret,id=HF_TOKEN,required=false \
     sh -c 'if [ -f /run/secrets/HF_TOKEN ]; then export HF_TOKEN="$(cat /run/secrets/HF_TOKEN)"; fi; \
-           python /tmp/fetch_marc_dataset.py'
+           python /tmp/fetch_atlases.py'
 
 COPY app.py /app/app.py
 

fetch_atlases.py

@@ -0,0 +1,68 @@
+"""Pull tidal atlases from the HF Dataset at Docker build time.
+
+Reads ``HF_TOKEN`` (mounted as a build secret) and ``HF_DATASET_ID`` from
+the environment, snapshots the dataset under ``ATLAS_DATA_DIR`` (default
+``/app/data/atlas``), and reports what was fetched. Falls back gracefully
+(empty dir, runtime uses Open-Meteo SMOC only) when the token is absent
+so contributors can build the image without an HF account.
+
+The downloaded layout is expected to contain both:
+
+- MARC PREVIMER atlas tiles at ``<ATLAS_DATA_DIR>/<ATLAS>/`` (e.g. ``FINIS/``,
+  ``SUDBZH/``, ``MANGA/``), one per Ifremer atlas. Read at runtime by
+  ``MARC_ATLAS_DIR``.
+- SHOM Atlas C2D artefacts at the dataset root: ``shom_c2d_points.parquet``
+  + ``shom_c2d_ref_ports.json``. Read at runtime by ``SHOM_C2D_DIR``.
+
+Both env vars (``MARC_ATLAS_DIR`` and ``SHOM_C2D_DIR``) are set to the
+same directory by the Dockerfile, so the data-adapters loaders find
+their respective files side by side. Either source can be missing from
+the dataset and the runtime degrades the cascade accordingly:
+SHOM → MARC → SMOC.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    target = os.environ.get("ATLAS_DATA_DIR", "/app/data/atlas")
+    dataset_id = os.environ.get("HF_DATASET_ID", "Qdonnars/openwind-tidal-atlas")
+    token = os.environ.get("HF_TOKEN")
+
+    if not token:
+        print("WARNING: HF_TOKEN not set, skipping atlas dataset download")
+        print("plan_passage will fall back to Open-Meteo SMOC only")
+        os.makedirs(target, exist_ok=True)
+        return
+
+    from huggingface_hub import snapshot_download
+
+    print(f"Fetching {dataset_id} -> {target}")
+    snapshot_download(dataset_id, repo_type="dataset", local_dir=target, token=token)
+
+    target_path = Path(target)
+    marc_atlases = sorted(
+        p.name
+        for p in target_path.iterdir()
+        if p.is_dir() and (p / "metadata.json").exists()
+    )
+    shom_present = (
+        (target_path / "shom_c2d_points.parquet").exists()
+        and (target_path / "shom_c2d_ref_ports.json").exists()
+    )
+    print(f"Atlas dataset cached at {target}")
+    print(f"  MARC atlases: {marc_atlases or '<none>'}")
+    print(f"  SHOM Atlas C2D: {'present' if shom_present else '<absent>'}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as exc:
+        print(f"ERROR fetching atlas dataset: {exc}", file=sys.stderr)
+        # Don't fail the build — runtime will fall back as best it can.
+        os.makedirs(os.environ.get("ATLAS_DATA_DIR", "/app/data/atlas"), exist_ok=True)

fetch_marc_dataset.py

@@ -1,40 +0,0 @@
-"""Pull MARC PREVIMER atlases from the HF Dataset at Docker build time.
-
-Reads ``HF_TOKEN`` (mounted as a build secret), ``HF_DATASET_ID`` and
-``MARC_ATLAS_DIR`` from the environment. Falls back gracefully (no MARC
-data, runtime uses Open-Meteo SMOC) if the token is absent — this lets
-contributors build the image without an HF account.
-"""
-from __future__ import annotations
-
-import os
-import sys
-
-
-def main() -> None:
-    target = os.environ.get("MARC_ATLAS_DIR", "/app/data/marc-atlas")
-    dataset_id = os.environ.get("HF_DATASET_ID", "Qdonnars/openwind-tidal-atlas")
-    token = os.environ.get("HF_TOKEN")
-
-    if not token:
-        print("WARNING: HF_TOKEN not set, skipping MARC dataset download")
-        print("plan_passage will fall back to Open-Meteo SMOC only")
-        os.makedirs(target, exist_ok=True)
-        return
-
-    from huggingface_hub import snapshot_download
-
-    print(f"Fetching {dataset_id} -> {target}")
-    snapshot_download(dataset_id, repo_type="dataset", local_dir=target, token=token)
-    atlases = sorted(p for p in os.listdir(target) if not p.startswith("."))
-    print(f"MARC dataset cached at {target}")
-    print(f"Atlases: {atlases}")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception as exc:
-        print(f"ERROR fetching MARC dataset: {exc}", file=sys.stderr)
-        # Don't fail the build — runtime will fall back to Open-Meteo SMOC.
-        os.makedirs(os.environ.get("MARC_ATLAS_DIR", "/app/data/marc-atlas"), exist_ok=True)

vendor/data-adapters/src/openwind_data/currents/narrow_pass.py

@@ -0,0 +1,52 @@
+"""Per-point confidence labelling for current values.
+
+The qualitative tag (``"high"`` / ``"medium"`` / ``"low"`` / ``None``) sits
+beside ``current_source`` on each ``SegmentReport`` so the LLM and UI can
+qualify a current value without re-deriving the rules.
+
+The labelling is **source-based for now**. We previously shipped a
+hand-drawn list of named narrow-pass bboxes (Goulet de Brest, Raz de Sein,
+Goulet du Morbihan, etc.) to downgrade confidence inside known choke
+points. That approach was unprincipled — bboxes drawn by intuition rather
+than by physics — and has been removed. The data-driven replacement will
+land with the SHOM Atlas C2D ingestion: zones where C2D peak speeds
+exceed a threshold (e.g. ≥ 3 kt at vives-eaux) are exactly the zones
+where every freely-available product under-resolves the choke, so the
+confidence downgrade can be derived from the data instead of hand-drawn.
+
+Until that adapter is wired, ``confidence_for_point`` reflects only the
+source product's intrinsic resolution.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+ConfidenceLevel = Literal["high", "medium", "low"]
+
+
+def confidence_for_point(lat: float, lon: float, source: str | None) -> ConfidenceLevel | None:
+    """Confidence tag for the current value at (lat, lon) with given source.
+
+    - ``None`` source → ``None`` (no current data, nothing to qualify).
+    - SHOM Atlas C2D (``"shom_c2d_*"``) → ``"high"``: French navigation
+      reference, hand-placed points on flow features, validated against
+      in-situ measurements.
+    - MARC PREVIMER (``"marc_*"``) → ``"high"``: Ifremer harmonic atlas,
+      regular 250 m to 2 km grid depending on zone.
+    - Open-Meteo SMOC (``"openmeteo_smoc"``) → ``"medium"``: 8 km global
+      Mercator product, fine for open water but blunt near the coast.
+    - Anything else → ``"medium"`` (unknown source, stay conservative).
+
+    The ``lat`` and ``lon`` arguments are reserved for the data-driven
+    successor (SHOM-peak-based downgrade in choke points) and are
+    currently unused.
+    """
+    del lat, lon  # reserved for the data-driven successor
+    if source is None:
+        return None
+    if source.startswith("shom_c2d_") or source.startswith("marc_"):
+        return "high"
+    if source == "openmeteo_smoc":
+        return "medium"
+    return "medium"

vendor/data-adapters/src/openwind_data/currents/router.py

@@ -1,14 +1,27 @@
-"""Composite marine adapter — MARC where covered, Open-Meteo SMOC elsewhere.
+"""Composite marine adapter — SHOM > MARC > Open-Meteo cascade.
 
-Wraps an upstream ``MarineDataAdapter`` (typically ``OpenMeteoAdapter``) and
-a ``MarcAtlasRegistry``. Returns a ``ForecastBundle`` whose ``sea`` series
-has currents and tide heights overridden by MARC predictions when the query
-point falls inside a MARC emprise. Wave fields are always passed through
-from Open-Meteo (MARC has no wave atlases).
+Wraps an upstream ``MarineDataAdapter`` (typically ``OpenMeteoAdapter``)
+plus a ``MarcAtlasRegistry`` and a ``ShomC2dRegistry``. Returns a
+``ForecastBundle`` whose ``sea`` series has currents (and tide heights, for
+MARC only — SHOM C2D does not carry heights) overridden by the finest
+available source at each waypoint:
+
+1. **SHOM Atlas C2D** (top priority): the French navigation reference.
+   Hand-curated scattered points on flow features in coastal cartouches.
+   Used wherever a SHOM point sits within ~5 km of the query.
+2. **MARC PREVIMER** (mid priority): regular harmonic grid (250 m to
+   2 km). Fills the continuous coastal/shelf coverage that SHOM doesn't
+   sample.
+3. **Open-Meteo SMOC** (fallback): 8 km global Mercator. Used only when
+   neither SHOM nor MARC cover the waypoint.
+
+Wave fields are always passed through from Open-Meteo (no SHOM/MARC wave
+atlases). Tide heights come from MARC only when the waypoint falls
+inside a MARC emprise — SHOM C2D doesn't ship height series.
 
 Provenance is exposed on each ``SeaPoint`` via ``current_source``:
-``"marc_<atlas_lower>_<res>m"`` (e.g. ``"marc_finis_250m"``) inside MARC,
-``"openmeteo_smoc"`` outside.
+``"shom_c2d_<atlas_id>_<zone>"`` inside SHOM, ``"marc_<atlas>_<res>m"``
+inside MARC-only zones, ``"openmeteo_smoc"`` outside both.
 """
 
 from __future__ import annotations
@@ -23,6 +36,7 @@ from openwind_data.adapters.base import (
     SeaSeries,
 )
 from openwind_data.currents.marc_atlas import MarcAtlasRegistry
+from openwind_data.currents.shom_c2d_registry import ShomC2dRegistry
 
 
 def _marc_source_label(atlas_name: str, resolution_m: int) -> str:
@@ -31,14 +45,21 @@ def _marc_source_label(atlas_name: str, resolution_m: int) -> str:
 
 @dataclass
 class CompositeMarineAdapter:
-    """``MarineDataAdapter`` that overrides Open-Meteo currents/tide with MARC.
+    """``MarineDataAdapter`` that overrides Open-Meteo currents/tide via the
+    SHOM > MARC > SMOC cascade.
 
     Methods on the upstream adapter (e.g. ``aclose``) are not delegated;
     callers manage the lifecycle of the upstream they pass in.
+
+    ``shom`` is optional; when omitted (or empty), the cascade reduces to
+    MARC > SMOC and the adapter behaves identically to the previous
+    two-tier version. This lets callers skip SHOM in benches or in
+    deployments where the C2D artefacts aren't shipped.
     """
 
     upstream: MarineDataAdapter
     marc: MarcAtlasRegistry
+    shom: ShomC2dRegistry | None = None
 
     async def fetch(
         self,
@@ -49,9 +70,13 @@ class CompositeMarineAdapter:
         models: list[str] | None = None,
     ) -> ForecastBundle:
         bundle = await self.upstream.fetch(lat, lon, start, end, models=models)
+        # Try SHOM first (highest priority). When it covers, override the
+        # currents only — wave and tide fields stay on Open-Meteo / MARC.
+        if self.shom is not None and self.shom.covers(lat, lon):
+            return self._apply_shom(bundle, lat, lon)
         atlas = self.marc.covers(lat, lon)
         if atlas is None:
-            return bundle  # outside MARC, keep Open-Meteo
+            return bundle  # outside SHOM and MARC, keep Open-Meteo
 
         # Inside MARC: predict the full series in one shot (vectorised).
         times = [p.time for p in bundle.sea.points]
@@ -100,3 +125,47 @@ class CompositeMarineAdapter:
             sea=SeaSeries(points=tuple(new_points)),
             requested_at=bundle.requested_at,
         )
+
+    def _apply_shom(self, bundle: ForecastBundle, lat: float, lon: float) -> ForecastBundle:
+        """Override the bundle's currents with SHOM Atlas C2D predictions.
+
+        Wave fields stay on Open-Meteo. Tide height also stays on
+        Open-Meteo (or falls through to MARC if a separate MARC override
+        also applies — currently mutually exclusive in the cascade since
+        SHOM takes priority). The source label embeds atlas id + zone
+        name, e.g. ``"shom_c2d_558_morbihan"``.
+        """
+        if self.shom is None:  # narrows the Optional for type checkers
+            return bundle
+        times = [p.time for p in bundle.sea.points]
+        if not times:
+            return bundle
+        result = self.shom.predict_current_series(lat, lon, times)
+        if result is None:
+            return bundle
+        speeds_kn, dirs_to_deg, source_label = result
+        new_points: list[SeaPoint] = []
+        for i, p in enumerate(bundle.sea.points):
+            new_points.append(
+                SeaPoint(
+                    time=p.time,
+                    wave_height_m=p.wave_height_m,
+                    wave_period_s=p.wave_period_s,
+                    wave_direction_deg=p.wave_direction_deg,
+                    wind_wave_height_m=p.wind_wave_height_m,
+                    swell_wave_height_m=p.swell_wave_height_m,
+                    current_speed_kn=float(speeds_kn[i]),
+                    current_direction_to_deg=float(dirs_to_deg[i]),
+                    tide_height_m=p.tide_height_m,
+                    current_source=source_label,
+                )
+            )
+        return ForecastBundle(
+            lat=bundle.lat,
+            lon=bundle.lon,
+            start=bundle.start,
+            end=bundle.end,
+            wind_by_model=bundle.wind_by_model,
+            sea=SeaSeries(points=tuple(new_points)),
+            requested_at=bundle.requested_at,
+        )

vendor/data-adapters/src/openwind_data/currents/shom_c2d.py

@@ -0,0 +1,271 @@
+"""Parser for the SHOM "Courants de marée 2D" ASCII atlas (Édition 2005).
+
+This module loads the public-domain dataset distributed by SHOM under
+Licence Ouverte v2.0 (cf. ``data.gouv.fr/datasets/courants-de-maree-des-cotes-
+de-france-manche-atlantique-produit-numerique-1``). The product covers the
+French Manche and Atlantic coasts with hand-curated current vectors at
+discrete points, organised hour-by-hour relative to the high or low tide
+of a reference port.
+
+It is **not** wired into the runtime cascade — MARC PREVIMER (250 m on
+critical passes, 700 m on the shelf) is finer than every C2D zone except
+a few micro-cartouches (Bloscon 170 m, Roscoff 160 m). C2D's value lives
+elsewhere:
+
+1. As a **bench reference** for measuring MARC skill at named hotspots
+   (Goulet de Brest, Raz de Sein, Ouessant, Goulet du Morbihan,
+   Saint-Malo, Hague). C2D is built from a different model lineage
+   (TELEMAC-2D or SHOM finite-difference) with denser bathymetry and
+   has been validated against SHOM in-situ measurements, so divergence
+   between MARC and C2D at the same point is meaningful signal.
+2. As a **cross-check** for narrow-pass-zone definitions: where C2D and
+   MARC disagree by more than X%, the bbox is a candidate for the
+   ``narrow_pass`` registry.
+
+Format reference: ``DOCUMENTATION/NoticeCourants.pdf`` §8.2 inside the
+SHOM C2D distribution. Each zone file is ASCII Latin-1 encoded:
+
+- Line 1: reference port name. Suffix ``.BM`` (or ``BM``) means the
+  hourly index is referenced to **low** tide; otherwise high tide.
+- For each grid point, three lines:
+  1. Position WGS84 ``sDDMM.mmm sDDDMM.mmm`` (lat, lon, signed degrees +
+     decimal minutes; lat positive = N, lon positive = E).
+  2. Vives-eaux (coef 95) — 13 U values, ``*``, 13 V values.
+     Tenths of a knot. Hour offsets -6h, -5h, ..., 0h, +1h, ..., +6h
+     relative to the reference port's high (or low) tide.
+     Components positive toward east (U) and north (V).
+  3. Mortes-eaux (coef 45) — same layout.
+
+To predict the current at coefficient C, linearly interpolate:
+
+    V(C) = V_me + (C - 45) / 50 * (V_ve - V_me)
+
+Mediterranean coasts are not covered (per SHOM: tidal currents
+negligible there).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+# Hours sampled in each VE/ME line, relative to PM/BM at the reference port.
+HOUR_OFFSETS: tuple[int, ...] = tuple(range(-6, 7))  # -6, -5, ..., +6 → 13 values
+# m/s to knots: 1 m/s = 1.94384 kt. SHOM stores values in 1/10 kt so the file
+# integer 25 means 2.5 kt directly — no m/s round-trip needed.
+DECIKT_TO_KN = 0.1
+
+
+@dataclass(frozen=True, slots=True)
+class C2dPoint:
+    """A single SHOM C2D grid point with its 4 hourly time series.
+
+    All speeds are in knots (converted from the raw 1/10 kt integer storage).
+    Components ``u`` are positive toward east, ``v`` positive toward north.
+
+    The reference convention (``ref_tide``) tells callers whether the 13
+    samples are anchored to high tide (``"PM"``) or low tide (``"BM"``) at
+    the zone's reference port. Coefficient 45 ≈ mortes-eaux, 95 ≈ vives-eaux.
+    """
+
+    lat: float
+    lon: float
+    u_ve_kn: tuple[float, ...]  # length 13, coef 95
+    v_ve_kn: tuple[float, ...]
+    u_me_kn: tuple[float, ...]  # length 13, coef 45
+    v_me_kn: tuple[float, ...]
+
+    def speed_kn_at(self, hour_offset: int, coef: float) -> float:
+        """Speed (kt) at a given hour offset and tide coefficient.
+
+        ``hour_offset`` must be one of ``HOUR_OFFSETS`` (no time interpolation
+        here — keep this primitive small; callers do hour interpolation).
+        ``coef`` is linearly interpolated between 45 and 95 (extrapolation
+        allowed but flagged by the caller's domain knowledge).
+        """
+        idx = HOUR_OFFSETS.index(hour_offset)
+        u = self.u_me_kn[idx] + (coef - 45.0) / 50.0 * (self.u_ve_kn[idx] - self.u_me_kn[idx])
+        v = self.v_me_kn[idx] + (coef - 45.0) / 50.0 * (self.v_ve_kn[idx] - self.v_me_kn[idx])
+        return float(np.hypot(u, v))
+
+
+@dataclass(frozen=True, slots=True)
+class C2dZone:
+    """One SHOM C2D zone (one .UJA atlas planche).
+
+    Attributes:
+        atlas_id: SHOM atlas number (557..565).
+        name: zone short name from the filename (e.g. ``"MORBIHAN"``).
+        ref_port: reference port name as printed in the file header,
+            stripped of any ``.BM`` suffix.
+        ref_tide: ``"PM"`` (high tide) or ``"BM"`` (low tide); tells callers
+            which tide event the hourly samples are anchored to.
+        points: tuple of grid points. Order matches the file.
+    """
+
+    atlas_id: int
+    name: str
+    ref_port: str
+    ref_tide: str  # "PM" or "BM"
+    points: tuple[C2dPoint, ...]
+
+    @property
+    def bbox(self) -> tuple[float, float, float, float]:
+        """``(lat_min, lon_min, lat_max, lon_max)`` over the zone's points."""
+        lats = [p.lat for p in self.points]
+        lons = [p.lon for p in self.points]
+        return (min(lats), min(lons), max(lats), max(lons))
+
+
+def _parse_lat_lon_token(s: str) -> float:
+    """Parse a SHOM ``sDDMM.mmm`` token into signed decimal degrees.
+
+    The text is a numeric string where the integer part is degrees * 100
+    plus minutes and the fractional part is decimal minutes. So
+    ``"4737.420"`` means 47°37.420'N (= 47 + 37.420/60 ≈ 47.62367°). A
+    ``-`` sign on the whole token flips hemisphere.
+    """
+    val = float(s)
+    sign = 1.0 if val >= 0 else -1.0
+    val = abs(val)
+    degrees = int(val // 100)
+    minutes = val - degrees * 100
+    return sign * (degrees + minutes / 60.0)
+
+
+def _parse_hourly_line(line: str) -> tuple[tuple[float, ...], tuple[float, ...]]:
+    """Parse one VE or ME line into ``(u[13], v[13])`` arrays in knots.
+
+    The raw line is fixed-width and may have negative integers concatenated
+    without whitespace (e.g. ``-22-10  0``). We split each side of ``*`` on
+    a regex-equivalent walk: scan character-by-character, start a new field
+    on a sign or digit boundary, terminate on whitespace or sign change.
+    """
+    if "*" not in line:
+        raise ValueError(f"missing '*' separator in C2D line: {line!r}")
+    u_part, v_part = line.split("*", 1)
+    us = _split_packed_ints(u_part)
+    vs = _split_packed_ints(v_part)
+    if len(us) != 13 or len(vs) != 13:
+        raise ValueError(f"expected 13 U + 13 V values, got {len(us)} + {len(vs)} in {line!r}")
+    return (
+        tuple(x * DECIKT_TO_KN for x in us),
+        tuple(x * DECIKT_TO_KN for x in vs),
+    )
+
+
+def _split_packed_ints(s: str) -> list[int]:
+    """Split a SHOM-style packed integer field like ``"-22-10  0  4"``.
+
+    Whitespace separates fields; a ``-`` sign also starts a new field even
+    without preceding whitespace. Empty whitespace-only segments are
+    skipped.
+    """
+    out: list[int] = []
+    buf = ""
+    for ch in s:
+        if ch == "-":
+            if buf and buf != "-":
+                out.append(int(buf))
+            buf = "-"
+        elif ch.isspace():
+            if buf and buf != "-":
+                out.append(int(buf))
+            buf = ""
+        else:
+            buf += ch
+    if buf and buf != "-":
+        out.append(int(buf))
+    return out
+
+
+def parse_c2d_file(path: Path | str, atlas_id: int) -> C2dZone:
+    """Load one SHOM C2D zone file (e.g. ``DONNEES/558/MORBIHAN_558``).
+
+    The file is Latin-1 encoded (SHOM legacy). The ``atlas_id`` is the
+    SHOM atlas number (557..565); callers usually derive it from the
+    parent directory name.
+    """
+    p = Path(path)
+    text = p.read_text(encoding="latin-1")
+    # Some files use \r\n; splitlines handles both.
+    raw_lines = text.splitlines()
+    # Drop fully blank trailing lines but preserve interior structure.
+    lines = [line for line in raw_lines if line.strip() != ""]
+    if not lines:
+        raise ValueError(f"empty C2D file: {p}")
+
+    header = lines[0].strip()
+    # ".BM", " BM" or "_BM" suffix → reference is low tide. SHOM mixes the
+    # three across files (e.g. "Le Havre.BM" in atlas 561 vs
+    # "La_Rochelle_BM" in atlas 559). Otherwise high tide.
+    ref_tide = "PM"
+    ref_port = header
+    upper = header.upper()
+    if upper.endswith(".BM") or upper.endswith(" BM") or upper.endswith("_BM"):
+        ref_tide = "BM"
+        ref_port = header[:-3].strip().rstrip("_").strip()
+
+    # Each subsequent point is exactly 3 lines: position, VE, ME.
+    body = lines[1:]
+    if len(body) % 3 != 0:
+        raise ValueError(f"C2D body line count not divisible by 3 in {p}: got {len(body)} lines")
+
+    points: list[C2dPoint] = []
+    for i in range(0, len(body), 3):
+        pos_line = body[i]
+        ve_line = body[i + 1]
+        me_line = body[i + 2]
+        # Position line: two whitespace-separated tokens, possibly with a
+        # trailing tab/space artefact from the original CD-ROM export.
+        tokens = pos_line.split()
+        if len(tokens) < 2:
+            raise ValueError(f"bad C2D position line in {p}: {pos_line!r}")
+        lat = _parse_lat_lon_token(tokens[0])
+        lon = _parse_lat_lon_token(tokens[1])
+        u_ve, v_ve = _parse_hourly_line(ve_line)
+        u_me, v_me = _parse_hourly_line(me_line)
+        points.append(
+            C2dPoint(
+                lat=lat,
+                lon=lon,
+                u_ve_kn=u_ve,
+                v_ve_kn=v_ve,
+                u_me_kn=u_me,
+                v_me_kn=v_me,
+            )
+        )
+
+    return C2dZone(
+        atlas_id=atlas_id,
+        name=p.name.rsplit("_", 1)[0],
+        ref_port=ref_port,
+        ref_tide=ref_tide,
+        points=tuple(points),
+    )
+
+
+def load_c2d_directory(donnees_dir: Path | str) -> tuple[C2dZone, ...]:
+    """Load every zone file under a SHOM C2D ``DONNEES`` directory.
+
+    Walks ``DONNEES/<atlas_id>/<ZONE_NAME>_<atlas_id>`` files and skips
+    the ``_lisezmoi_*.txt`` documentation. Returns zones in deterministic
+    order (sorted by atlas id then zone name) so downstream code can rely
+    on a stable iteration.
+    """
+    root = Path(donnees_dir)
+    zones: list[C2dZone] = []
+    for atlas_dir in sorted(root.iterdir()):
+        if not atlas_dir.is_dir():
+            continue
+        try:
+            atlas_id = int(atlas_dir.name)
+        except ValueError:
+            continue
+        for zone_file in sorted(atlas_dir.iterdir()):
+            if zone_file.name.startswith("_") or not zone_file.is_file():
+                continue
+            zones.append(parse_c2d_file(zone_file, atlas_id))
+    return tuple(zones)

vendor/data-adapters/src/openwind_data/currents/shom_c2d_registry.py

@@ -0,0 +1,340 @@
+"""Runtime SHOM Atlas C2D registry: spatial index + tide-relative predictor.
+
+Loads the Parquet + JSON artefacts produced by ``scripts/build_shom_c2d.py``
+and exposes prediction at any ``(lat, lon, datetime)`` independently of MARC.
+
+Pipeline at query time:
+
+1. Test bbox membership (cheap rectangle test). Outside the SHOM bbox, the
+   caller falls back to MARC or SMOC.
+2. KDTree-nearest lookup over the ~13 k scattered points → returns the
+   point's 4 series (U/V at vives-eaux 95 and mortes-eaux 45) and its
+   reference port key.
+3. Harmonic prediction at the reference port's M2/S2/N2/K1/O1/M4 constants
+   to find the PM (or BM) event nearest to the query time. Yields the
+   ``hour_offset`` ∈ [-6, +6] used to linear-interp the 13-sample series.
+4. Linear interpolation in time over the 13-hour series, twice (coef 45
+   and coef 95), and finally a linear interpolation in coefficient based
+   on the predicted tide range at the reference port for that day.
+
+All harmonic constants live in the JSON file shipped alongside the
+Parquet, so this module never imports MARC at runtime — the MARC
+dependency is purely build-time. If MARC is dropped in a later iteration,
+SHOM C2D keeps working.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+import numpy as np
+import polars as pl
+
+from openwind_data.currents.harmonic import predict as harmonic_predict
+
+# Hour offsets covered by the SHOM 13-sample series, in hours relative to
+# PM/BM at the reference port.
+_HOUR_OFFSETS = np.arange(-6, 7, dtype=float)
+# Mean-equinox tidal range at Brest (m). SHOM defines coef 100 as
+# 100 x range / 6.1 m. Used here to normalise the day's predicted range
+# into a tidal coefficient.
+_BREST_MEAN_RANGE_M = 6.1
+# How wide a window to scan around the query time when locating a tide
+# event. Slightly wider than half the M2 period (12.42 h) so we always
+# bracket exactly one PM and one BM.
+_TIDE_SCAN_HALFWINDOW = timedelta(hours=7.0)
+# Sampling step inside the scan window (minutes). 5-min step gives < 1 min
+# of error on the located extremum, well below the harmonic resolution.
+_TIDE_SCAN_STEP_MIN = 5
+
+
+@dataclass(frozen=True, slots=True)
+class _RefPortMeta:
+    display_name: str
+    lat: float
+    lon: float
+    ref_tide: str  # "PM" or "BM"
+    constants: dict[str, tuple[float, float]]
+
+
+@dataclass(frozen=True, slots=True)
+class ShomC2dRegistry:
+    """All SHOM C2D points + reference-port constants, indexed for fast lookup.
+
+    Construct via :meth:`from_directory` once at server startup; callers
+    keep a long-lived instance and call :meth:`predict_current_series`
+    repeatedly. The struct holds ~5 MB of numpy arrays plus the KDTree.
+
+    Field semantics:
+
+    - ``lats`` / ``lons``: WGS84 in degrees, shape ``(N,)`` of float32.
+    - ``u_ve`` / ``v_ve`` / ``u_me`` / ``v_me``: shape ``(N, 13)`` float32,
+      hour offsets ``-6h..+6h``, in knots. ``ve`` = vives-eaux (coef 95),
+      ``me`` = mortes-eaux (coef 45).
+    - ``ref_port_keys``: per-point lookup key into ``ref_ports`` (object
+      dtype, shape ``(N,)``).
+    - ``zone_names``: per-point zone label, e.g. ``"MORBIHAN"``. Used in
+      ``current_source`` provenance strings.
+    - ``atlas_ids``: per-point SHOM atlas number (557..565), int16.
+    - ``ref_ports``: dict ``key → _RefPortMeta`` for tide-event prediction.
+    - ``bbox``: ``(lat_min, lon_min, lat_max, lon_max)`` for fast pre-filter.
+
+    Spatial nearest-neighbour is brute-force vectorised numpy: a single
+    query computes squared distance to all ~13 k points (~80 µs) and
+    returns the minimum index. A KDTree would be faster asymptotically
+    but adds a scipy dependency and saves microseconds we don't need at
+    this scale. The per-query cost is dominated by the harmonic
+    prediction at the reference port, not by the spatial lookup.
+    """
+
+    lats: np.ndarray  # shape (N,), float32
+    lons: np.ndarray
+    u_ve: np.ndarray  # shape (N, 13)
+    v_ve: np.ndarray
+    u_me: np.ndarray
+    v_me: np.ndarray
+    ref_port_keys: np.ndarray  # shape (N,), object
+    zone_names: np.ndarray
+    atlas_ids: np.ndarray  # shape (N,), int16
+    ref_ports: dict[str, _RefPortMeta]
+    bbox: tuple[float, float, float, float]
+    _cos_mean_lat: float  # cached for query-side projection
+
+    @classmethod
+    def from_directory(cls, root: Path | str) -> ShomC2dRegistry:
+        """Load the Parquet + JSON pair from a build artefact directory.
+
+        Returns an empty registry (zero points, ``bbox`` collapsed to
+        ``(0, 0, 0, 0)``, an empty tree) if the directory is missing or
+        the artefacts are absent. The runtime treats an empty registry as
+        "not covered anywhere", so the cascade falls back to MARC / SMOC.
+        """
+        root = Path(root)
+        points_path = root / "shom_c2d_points.parquet"
+        ports_path = root / "shom_c2d_ref_ports.json"
+        if not points_path.exists() or not ports_path.exists():
+            return cls._empty()
+
+        df = pl.read_parquet(points_path)
+        if df.height == 0:
+            return cls._empty()
+
+        lats = df["lat"].to_numpy().astype(np.float32, copy=False)
+        lons = df["lon"].to_numpy().astype(np.float32, copy=False)
+        u_ve = np.array(df["u_ve_kn"].to_list(), dtype=np.float32)
+        v_ve = np.array(df["v_ve_kn"].to_list(), dtype=np.float32)
+        u_me = np.array(df["u_me_kn"].to_list(), dtype=np.float32)
+        v_me = np.array(df["v_me_kn"].to_list(), dtype=np.float32)
+        ref_port_keys = df["ref_port_key"].to_numpy()
+        zone_names = df["zone"].to_numpy()
+        atlas_ids = df["atlas_id"].to_numpy().astype(np.int16, copy=False)
+
+        raw_ports = json.loads(ports_path.read_text())
+        ref_ports = {
+            key: _RefPortMeta(
+                display_name=v["display_name"],
+                lat=float(v["lat"]),
+                lon=float(v["lon"]),
+                ref_tide=str(v["ref_tide"]),
+                constants={k: (float(amp), float(g)) for k, (amp, g) in v["constants"].items()},
+            )
+            for key, v in raw_ports.items()
+        }
+
+        cos_mean_lat = float(np.cos(np.deg2rad(lats.mean())))
+        bbox = (
+            float(lats.min()),
+            float(lons.min()),
+            float(lats.max()),
+            float(lons.max()),
+        )
+        return cls(
+            lats=lats,
+            lons=lons,
+            u_ve=u_ve,
+            v_ve=v_ve,
+            u_me=u_me,
+            v_me=v_me,
+            ref_port_keys=ref_port_keys,
+            zone_names=zone_names,
+            atlas_ids=atlas_ids,
+            ref_ports=ref_ports,
+            bbox=bbox,
+            _cos_mean_lat=cos_mean_lat,
+        )
+
+    @classmethod
+    def _empty(cls) -> ShomC2dRegistry:
+        return cls(
+            lats=np.zeros(0, dtype=np.float32),
+            lons=np.zeros(0, dtype=np.float32),
+            u_ve=np.zeros((0, 13), dtype=np.float32),
+            v_ve=np.zeros((0, 13), dtype=np.float32),
+            u_me=np.zeros((0, 13), dtype=np.float32),
+            v_me=np.zeros((0, 13), dtype=np.float32),
+            ref_port_keys=np.zeros(0, dtype=object),
+            zone_names=np.zeros(0, dtype=object),
+            atlas_ids=np.zeros(0, dtype=np.int16),
+            ref_ports={},
+            bbox=(0.0, 0.0, 0.0, 0.0),
+            _cos_mean_lat=1.0,
+        )
+
+    # ------------------------------------------------------------------
+    # Spatial coverage
+    # ------------------------------------------------------------------
+
+    # Maximum acceptable distance (km) between a query point and the nearest
+    # SHOM C2D point for us to claim coverage. Beyond this, the query
+    # falls back through the cascade — even though the bbox might still
+    # contain it, the SHOM zone is too sparse to make the value meaningful.
+    _MAX_NEAREST_KM = 5.0
+
+    # Tolerance applied to the bbox short-circuit so float32-derived bbox
+    # bounds don't reject queries that sit exactly on the edge of the
+    # cloud. ~0.01° ≈ 1 km, well below the nearest-point distance gate.
+    _BBOX_SLACK_DEG = 0.01
+
+    def covers(self, lat: float, lon: float) -> bool:
+        """Whether SHOM C2D has a point within ``_MAX_NEAREST_KM`` of (lat, lon).
+
+        SHOM C2D is a scattered point cloud, not a regular grid: a query
+        can fall well inside the bbox of the Morbihan cartouche yet sit
+        on land or in a region SHOM didn't sample. The bbox test alone
+        would over-claim. We pair it with a real distance check.
+        """
+        if not self.lats.size:
+            return False
+        lat_min, lon_min, lat_max, lon_max = self.bbox
+        s = self._BBOX_SLACK_DEG
+        if not (lat_min - s <= lat <= lat_max + s and lon_min - s <= lon <= lon_max + s):
+            return False
+        idx, dist_km = self._nearest(lat, lon)
+        return idx is not None and dist_km <= self._MAX_NEAREST_KM
+
+    def _nearest(self, lat: float, lon: float) -> tuple[int | None, float]:
+        """Index of the nearest C2D point + distance in km, or ``(None, inf)``.
+
+        Brute-force vectorised distance over the full point set in a
+        local-tangent-plane projection (degrees-lon scaled by mean
+        ``cos(lat)`` so the metric is roughly isotropic in km). At ~13 k
+        points this runs in ~80 µs per query; no spatial index needed.
+        """
+        if not self.lats.size:
+            return None, float("inf")
+        dlat = self.lats - lat
+        dlon = (self.lons - lon) * self._cos_mean_lat
+        d2 = dlat * dlat + dlon * dlon  # squared distance in scaled degrees
+        idx = int(np.argmin(d2))
+        d_deg = float(np.sqrt(d2[idx]))
+        # 1° in our scaled space ≈ 111 km on the ground (lat scale dominant).
+        return idx, d_deg * 111.0
+
+    # ------------------------------------------------------------------
+    # Tide-event helpers (PM / BM at reference ports)
+    # ------------------------------------------------------------------
+
+    def _tide_event_time(self, port: _RefPortMeta, target_t: datetime) -> datetime:
+        """Find the nearest ``port.ref_tide`` event (PM or BM) to ``target_t``.
+
+        Sample tide height every 5 min over a ±7 h window around target_t,
+        spot the global maximum (PM) or minimum (BM) within that window
+        — a 14 h span exceeds the M2 period (12.42 h) so it always
+        contains exactly one event of each type. Returns a UTC datetime.
+
+        The approach is brute force on purpose: vectorised over ~170
+        sample points x 6 constituents = ~1000 cosines, well under a
+        millisecond per call. No bisection required.
+        """
+        if target_t.tzinfo is None:
+            target_t = target_t.replace(tzinfo=UTC)
+        n_steps = int(2 * _TIDE_SCAN_HALFWINDOW.total_seconds() / 60 / _TIDE_SCAN_STEP_MIN) + 1
+        offsets_min = np.linspace(
+            -_TIDE_SCAN_HALFWINDOW.total_seconds() / 60,
+            _TIDE_SCAN_HALFWINDOW.total_seconds() / 60,
+            n_steps,
+        )
+        scan_times = [target_t + timedelta(minutes=float(m)) for m in offsets_min]
+        heights = harmonic_predict(scan_times, port.constants)
+        idx = int(np.argmax(heights) if port.ref_tide == "PM" else np.argmin(heights))
+        return scan_times[idx]
+
+    def _coefficient_for_day(self, port: _RefPortMeta, target_t: datetime) -> float:
+        """Approximate tidal coefficient at the reference port for the day.
+
+        Predict the tide over a 25 h window centred on target_t and read
+        ``range = max - min``. Coef = 100 x range / 6.1 m, clamped to
+        [20, 120] (SHOM's documented range). The 6.1 m normalisation is
+        Brest's mean-equinox spring range, which is the standard
+        denominator for the French tidal coefficient regardless of port.
+        """
+        if target_t.tzinfo is None:
+            target_t = target_t.replace(tzinfo=UTC)
+        # 25 h window with 30-min step covers two semi-diurnal cycles.
+        offsets_min = np.linspace(-12.5 * 60, 12.5 * 60, 51)
+        scan_times = [target_t + timedelta(minutes=float(m)) for m in offsets_min]
+        heights = harmonic_predict(scan_times, port.constants)
+        rng = float(heights.max() - heights.min())
+        coef = 100.0 * rng / _BREST_MEAN_RANGE_M
+        return max(20.0, min(120.0, coef))
+
+    # ------------------------------------------------------------------
+    # Public predictor
+    # ------------------------------------------------------------------
+
+    def predict_current_series(
+        self, lat: float, lon: float, times: list[datetime]
+    ) -> tuple[np.ndarray, np.ndarray, str] | None:
+        """Predict (speeds_kn, dirs_to_deg, source_label) at (lat, lon) for ``times``.
+
+        Returns ``None`` when the query point is outside SHOM coverage
+        (caller falls back to MARC / SMOC). The source label embeds the
+        atlas id and zone name so downstream code can attribute the value,
+        e.g. ``"shom_c2d_558_morbihan"``.
+
+        The prediction is per-time independent: each query time gets its
+        own nearest tide event and its own day's coefficient. This costs
+        a handful of harmonic predictions per series and keeps the code
+        simple; if ever the call rate justifies it, a vectorised
+        per-series optimisation is straightforward.
+        """
+        idx, dist_km = self._nearest(lat, lon)
+        if idx is None or dist_km > self._MAX_NEAREST_KM:
+            return None
+
+        port_key = str(self.ref_port_keys[idx])
+        port = self.ref_ports.get(port_key)
+        if port is None:
+            return None  # build artefact mismatch — fail closed
+
+        u_ve = self.u_ve[idx]
+        v_ve = self.v_ve[idx]
+        u_me = self.u_me[idx]
+        v_me = self.v_me[idx]
+        atlas_id = int(self.atlas_ids[idx])
+        zone = str(self.zone_names[idx])
+        source_label = f"shom_c2d_{atlas_id}_{zone.lower()}"
+
+        speeds = np.empty(len(times), dtype=np.float32)
+        dirs = np.empty(len(times), dtype=np.float32)
+        for i, t in enumerate(times):
+            event_t = self._tide_event_time(port, t)
+            offset_h = (t - event_t).total_seconds() / 3600.0
+            # Clamp to the sampled range; np.interp already clips at the
+            # ends, but clamping explicitly keeps the intent clear.
+            offset_h = max(-6.0, min(6.0, offset_h))
+            u_ve_t = float(np.interp(offset_h, _HOUR_OFFSETS, u_ve))
+            v_ve_t = float(np.interp(offset_h, _HOUR_OFFSETS, v_ve))
+            u_me_t = float(np.interp(offset_h, _HOUR_OFFSETS, u_me))
+            v_me_t = float(np.interp(offset_h, _HOUR_OFFSETS, v_me))
+            coef = self._coefficient_for_day(port, t)
+            w = (coef - 45.0) / 50.0
+            u = u_me_t + w * (u_ve_t - u_me_t)
+            v = v_me_t + w * (v_ve_t - v_me_t)
+            speeds[i] = float(np.hypot(u, v))
+            # Convert (u east, v north) to compass "to" direction.
+            dirs[i] = float(np.rad2deg(np.arctan2(u, v)) % 360.0)
+        return speeds, dirs, source_label

vendor/data-adapters/src/openwind_data/routing/passage.py

@@ -36,6 +36,7 @@ from openwind_data.adapters.openmeteo import (
     DEFAULT_MODEL,
     OpenMeteoAdapter,
 )
+from openwind_data.currents.narrow_pass import confidence_for_point
 from openwind_data.routing.archetypes import BoatPolar, get_polar, lookup_polar
 from openwind_data.routing.geometry import (
     Point,
@@ -182,6 +183,13 @@ class SegmentReport:
     # ``"marc_finis_250m"``) when MARC PREVIMER atlas data overrides Open-Meteo
     # in covered zones. ``None`` when no current data is available.
     current_source: str | None = None
+    # Qualitative confidence in the current/tide value: ``"high"`` (MARC 250 m
+    # to 2 km, in coverage), ``"medium"`` (Open-Meteo SMOC 8 km global), or
+    # ``"low"`` (waypoint falls inside a known narrow tidal pass where every
+    # open product under-resolves the choke — Goulet de Brest, Raz de Sein,
+    # Fromveur, Goulet du Morbihan, Téignouse, Raz Blanchard, Raz de Barfleur,
+    # Chenal du Four). ``None`` when no current data is available.
+    current_confidence: str | None = None
     gust_kn: float | None = None
     wave_period_s: float | None = None
 
@@ -387,7 +395,7 @@ async def _estimate_with_model(
     reports: list[SegmentReport] = []
     cumulative_actual = timedelta(0)
     min_boat_speed = float("inf")
-    for seg, mid_time, _mid_pt, bundle in zip(
+    for seg, mid_time, mid_pt, bundle in zip(
         segments, seg_mid_times, seg_mid_points, bundles, strict=True
     ):
         wind_series = bundle.wind_by_model.get(model)
@@ -412,6 +420,7 @@ async def _estimate_with_model(
         cur_kn = sea_pt.current_speed_kn if sea_pt else None
         cur_to = sea_pt.current_direction_to_deg if sea_pt else None
         cur_src = sea_pt.current_source if sea_pt else None
+        cur_conf = confidence_for_point(mid_pt.lat, mid_pt.lon, cur_src)
         derate = 1.0
         if use_wave_correction and hs_m is not None:
             derate = wave_derate(hs_m, twa)
@@ -443,6 +452,7 @@ async def _estimate_with_model(
                 current_direction_to_deg=cur_to,
                 sog_kn=sog,
                 current_source=cur_src,
+                current_confidence=cur_conf,
                 gust_kn=wp.gust_kn,
                 wave_period_s=tp_s,
             )
@@ -533,8 +543,12 @@ async def _estimate_backward_with_model(
     reverse_reports: list[SegmentReport] = []
     end_time = target_utc
     min_boat_speed = float("inf")
-    for seg, mid_time, bundle in zip(
-        reversed(segments), reversed(seg_mid_times), reversed(bundles), strict=True
+    for seg, mid_time, mid_pt, bundle in zip(
+        reversed(segments),
+        reversed(seg_mid_times),
+        reversed(seg_mid_points),
+        reversed(bundles),
+        strict=True,
     ):
         wind_series = bundle.wind_by_model.get(model)
         if wind_series is None or not wind_series.points:
@@ -553,6 +567,7 @@ async def _estimate_backward_with_model(
         cur_kn = sea_pt.current_speed_kn if sea_pt else None
         cur_to = sea_pt.current_direction_to_deg if sea_pt else None
         cur_src = sea_pt.current_source if sea_pt else None
+        cur_conf = confidence_for_point(mid_pt.lat, mid_pt.lon, cur_src)
         derate = 1.0
         if use_wave_correction and hs_m is not None:
             derate = wave_derate(hs_m, twa)
@@ -582,6 +597,7 @@ async def _estimate_backward_with_model(
                 current_source=cur_src,
                 current_direction_to_deg=cur_to,
                 sog_kn=sog,
+                current_confidence=cur_conf,
                 gust_kn=wp.gust_kn,
                 wave_period_s=tp_s,
             )

vendor/mcp-core/src/openwind_mcp_core/server.py

@@ -41,6 +41,7 @@ from openwind_data.adapters.base import MarineDataAdapter
 from openwind_data.adapters.openmeteo import AUTO_MODEL, OpenMeteoAdapter
 from openwind_data.currents.marc_atlas import MarcAtlasRegistry
 from openwind_data.currents.router import CompositeMarineAdapter
+from openwind_data.currents.shom_c2d_registry import ShomC2dRegistry
 from openwind_data.routing import (
     Point,
     _build_conditions_summary,
@@ -406,6 +407,13 @@ uses unless overridden by tool parameters.
   captures globally. Even the MARC atlases do not replace a SHOM tide
   atlas or paper chart for fine navigation in a narrow pass.
 
+- Current confidence (``current_confidence`` per leg): qualitative tag
+  derived from the data source. ``"high"`` on SHOM Atlas C2D and MARC
+  PREVIMER (regional harmonic atlases); ``"medium"`` on Open-Meteo SMOC
+  (8 km global product); ``None`` when no current data is available.
+  A data-driven downgrade in choke points (zones where SHOM C2D peaks
+  exceed ~3 kt) will land with the C2D adapter.
+
 - Minimum boat speed / SOG: 0.5 kn floor to avoid blow-up in extreme
   stalls or strongly opposing currents.
 
@@ -493,10 +501,13 @@ def build_server(*, adapter: MarineDataAdapter | None = None) -> FastMCP:
 
     Args:
         adapter: optional `MarineDataAdapter` used by data-fetching tools.
-            Defaults to a `CompositeMarineAdapter` that wraps a fresh
-            `OpenMeteoAdapter` and the MARC PREVIMER atlases discovered
-            under ``MARC_ATLAS_DIR`` (or falls back to Open-Meteo only when
-            no MARC dataset is available locally). Override in tests.
+            Defaults to a ``CompositeMarineAdapter`` that wraps a fresh
+            ``OpenMeteoAdapter`` and stacks two coastal-detail sources on
+            top: the SHOM Atlas C2D registry under ``SHOM_C2D_DIR`` (when
+            built and shipped), and the MARC PREVIMER atlases under
+            ``MARC_ATLAS_DIR``. Either or both can be absent; the cascade
+            degrades gracefully (SHOM > MARC > SMOC). Override the whole
+            adapter in tests.
     """
     server: FastMCP = FastMCP("openwind")
     if adapter is not None:
@@ -504,13 +515,23 @@ def build_server(*, adapter: MarineDataAdapter | None = None) -> FastMCP:
     else:
         upstream = OpenMeteoAdapter()
         marc_dir = os.environ.get("MARC_ATLAS_DIR")
-        if marc_dir:
-            registry = MarcAtlasRegistry.from_directory(marc_dir)
-            if registry.atlases:
-                fetch_adapter = CompositeMarineAdapter(upstream=upstream, marc=registry)
-            else:
-                fetch_adapter = upstream
+        shom_dir = os.environ.get("SHOM_C2D_DIR")
+        marc_registry = MarcAtlasRegistry.from_directory(marc_dir) if marc_dir else None
+        shom_registry = ShomC2dRegistry.from_directory(shom_dir) if shom_dir else None
+        marc_available = marc_registry is not None and bool(marc_registry.atlases)
+        shom_available = shom_registry is not None and shom_registry.lats.size > 0
+        if marc_available:
+            fetch_adapter = CompositeMarineAdapter(
+                upstream=upstream,
+                marc=marc_registry,  # type: ignore[arg-type]
+                shom=shom_registry if shom_available else None,
+            )
         else:
+            # Without MARC the composite adapter has nothing to override
+            # currents with on the shelf; we keep upstream Open-Meteo only.
+            # (SHOM alone in the composite would still work, but mixing
+            # SHOM-only zones with raw SMOC elsewhere is more readable
+            # via the existing two-tier composite once MARC lands.)
             fetch_adapter = upstream
 
     @server.resource(