feat: source-derived Q&A with statewide CA ocean species coverage (#1)

Source-backed Q&A over the full California ocean sport-fishing species set.

- 78 distinct species with source-verified facts (size/bag/season/closure),
every value traced to a CDFW page or CCR Title 14: groundfish (RCG complex),
halibut, surfperch, seabass, sharks, sturgeon, crab, salmon, SoCal gamefish
(kelp/sand bass, sheephead, barracuda, bonito, yellowtail), nearshore species,
invertebrates (spiny lobster, scallops, squid, clams), and no-take species.
- Species resolution: model (MiniCPM) + deterministic name search with a guard
that prefers specific user-typed aliases (length-aware scoring), plus a
rule-card posture fallback for species without an extracted fact.
- "Refresh official sources" applies live snapshot freshness to the session;
structured facts stay curated and are never auto-derived from fetched HTML.
- Answers state regulations directly (source shown in the evidence section).

171 tests pass; verified end-to-end on the local MiniCPM model server.

README.md

@@ -35,11 +35,14 @@ Target badges and awards, pending final evidence:
 
 - Best Agent: source-backed question interpretation, evidence selection, and
   constrained wording over deterministic CDFW/CDPH facts or snippets.
-- OpenBMB: MiniCPM5-1B is the planned small-model path for constrained
-  safety-result explanation.
+- OpenBMB: MiniCPM5-1B (in-process GGUF or hosted, OpenAI-compatible) normalizes
+  messy questions into validated source-backed candidates; it never creates or
+  overrides facts.
 - Tiny Titan: the submitted model inventory stays at or below 4B parameters.
-- Off the Grid: bundled seed cache and last-good runtime cache can answer
-  supported questions without cloud APIs.
+- Off the Grid: the bundled seed cache and last-good runtime cache answer
+  supported questions with no model and no network. The optional MiniCPM
+  interpreter can run fully in-process from a local GGUF (no external API), or
+  via OpenBMB's hosted API; either way the core Q&A never requires it.
 - Off Brand: custom CoastWise Gradio interface.
 - Best Demo / Field Notes: public demo video, social post, and write-up links
   will be added before submission.
@@ -75,7 +78,7 @@ evidence.
 
 | Model | Provider | Source URL | Role | Parameters | Runtime mode | Required for core safety | Award relevance |
 |---|---|---|---|---:|---|---|---|
-| MiniCPM5-1B | OpenBMB | https://huggingface.co/openbmb/MiniCPM5-1B | Optional constrained wording over deterministic answers | 1.0B | Disabled/mocked fallback in current local MVP | No | OpenBMB, Tiny Titan |
+| MiniCPM5-1B | OpenBMB | https://huggingface.co/openbmb/MiniCPM5-1B | Optional source-backed question interpretation; normalizes messy questions into validated candidates and cannot create or override facts | 1.0B | Hosted OpenAI-compatible endpoint when configured, deterministic fallback otherwise | No | OpenBMB, Tiny Titan |
 
 No model fine-tuning is required for the MVP. Model output, when enabled, may
 only help with interpretation or wording and cannot create or override
@@ -85,6 +88,28 @@ next safe action.
 All listed models are under the hackathon 32B cap. Tiny Titan remains eligible
 only while every submitted model stays at or below 4B total parameters.
 
+### Enabling The MiniCPM Interpreter
+
+The MiniCPM interpreter is optional and off by default; the deterministic core
+answers supported questions with no model. Two ways to enable it, tried in this
+order (local first, then hosted, otherwise deterministic):
+
+Local, off the grid (no API key): runs MiniCPM5-1B in-process from a GGUF via
+`llama-cpp-python`, with no external API. Set `COASTWISE_LOCAL_MODEL=1` (the
+`llama-cpp-python` dependency must be installed). Optional overrides:
+`COASTWISE_LOCAL_REPO` (default `openbmb/MiniCPM5-1B-GGUF`) and
+`COASTWISE_LOCAL_FILE` (default `*Q4_K_M.gguf`).
+
+Hosted (OpenBMB API): set `COASTWISE_LLM_API_KEY` to an OpenBMB hosted key.
+Optional: `COASTWISE_LLM_BASE_URL` (default `https://api.modelbest.cn/v1`) and
+`COASTWISE_LLM_MODEL` (default `MiniCPM5-1B`).
+
+When neither is configured, CoastWise stays fully deterministic and still
+answers supported questions from cache. The model only normalizes the user's
+question into validated source-backed candidates; it never creates or overrides
+regulation facts, advisory facts, source links, dates, freshness, status, or the
+next safe action.
+
 ## Official Sources And Freshness
 
 Cached official source metadata is bundled for offline lookup. CoastWise treats

app.py

@@ -9,6 +9,8 @@ from datetime import datetime, timezone
 import gradio as gr
 
 from coastwise.ai import (
+    build_hosted_interpreter,
+    build_local_interpreter,
     build_lookup_workflow_trace,
     explain_safety_result,
     explanation_to_dict,
@@ -20,7 +22,7 @@ from coastwise.qna import answer_question, answer_to_dict
 from coastwise.rules import compose_safety_result, default_context, result_to_dict
 from coastwise.schemas import CoastalRegion, UserIntent
 from coastwise.search import search_species
-from coastwise.source_cache import DEFAULT_SEED_CACHE_DIR, load_seed_cache
+from coastwise.source_cache import DEFAULT_SEED_CACHE_DIR, SourceCache, load_seed_cache
 from coastwise.source_refresh import fetch_official_source, refresh_official_sources
 from coastwise.source_registry import load_official_sources
 from coastwise.submission import default_model_inventory
@@ -30,7 +32,6 @@ APP_TITLE = "CoastWise"
 
 SOURCE_BACKED_CONTROL_LABELS = (
     "Question",
-    "Beach or coastal area",
     "Ask",
     "Refresh official sources",
     "Source status",
@@ -362,8 +363,17 @@ REGION_LABELS = {
 }
 
 
+SOURCE_BACKED_INTERPRETER = build_local_interpreter() or build_hosted_interpreter()
+
+
+# Holds the most recent refreshed cache for the running session, so the
+# "Refresh official sources" button actually changes what subsequent answers
+# read. None means "use the bundled reviewed seed".
+_SESSION_CACHE: SourceCache | None = None
+
+
 def _active_cache():
-    return load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    return _SESSION_CACHE if _SESSION_CACHE is not None else load_seed_cache(DEFAULT_SEED_CACHE_DIR)
 
 
 def ask_source_backed_question(question: str, beach_or_coastal_area: str = "") -> dict[str, object]:
@@ -372,6 +382,7 @@ def ask_source_backed_question(question: str, beach_or_coastal_area: str = "") -
         beach_or_coastal_area,
         _active_cache(),
         datetime.now(timezone.utc),
+        model=SOURCE_BACKED_INTERPRETER,
     )
     return answer_to_dict(answer)
 
@@ -473,7 +484,7 @@ def render_source_backed_answer_from_cache(
     cache,
     now: datetime,
 ) -> str:
-    answer = answer_question(question, beach_or_coastal_area, cache, now)
+    answer = answer_question(question, beach_or_coastal_area, cache, now, model=SOURCE_BACKED_INTERPRETER)
     return _render_source_backed_answer_payload(answer_to_dict(answer))
 
 
@@ -517,15 +528,27 @@ def _bounded_live_fetcher(sources, per_source_timeout: float = 2.5, overall_dead
 
 
 def refresh_official_sources_status(fetcher=None) -> dict[str, object]:
+    global _SESSION_CACHE
     sources = load_official_sources()
     if fetcher is None:
         fetcher = _bounded_live_fetcher(sources)
-    result, _cache = refresh_official_sources(
+    base = _active_cache()
+    result, refreshed = refresh_official_sources(
         sources,
-        _active_cache(),
+        base,
         datetime.now(timezone.utc),
         fetcher,
     )
+    # Apply the re-fetch to the live session as updated snapshot freshness, but
+    # keep the reviewed chunks/facts: structured regulation values stay curated
+    # and are never auto-derived from freshly fetched HTML.
+    _SESSION_CACHE = SourceCache(
+        sources=refreshed.sources,
+        snapshots=refreshed.snapshots,
+        chunks=base.chunks,
+        facts=base.facts,
+        advisory_facts=base.advisory_facts,
+    )
     return {
         "message": result.user_message,
         "updated": result.updated_source_ids,

coastwise/ai.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+import ast
 import hashlib
+import json
+import os
 import re
+import urllib.request
 from collections.abc import Callable
 
 from coastwise.schemas import (
@@ -11,9 +15,12 @@ from coastwise.schemas import (
     GenerativeExplanation,
     LookupWorkflowTrace,
     ModelInventory,
+    ModelQuestionInterpretation,
     ModelRole,
+    RequestedFactType,
     SafetyResult,
     SourceBackedAnswer,
+    SourceBackedIntent,
 )
 
 FORBIDDEN_CLAIMS = (
@@ -249,6 +256,318 @@ def validate_cached_evidence_answer(packet: CachedEvidencePacket, text: str) ->
     return len(generated_tokens & evidence_tokens) >= 4
 
 
+def interpret_question_with_model(
+    question: str,
+    location_text: str | None,
+    *,
+    allowed_species: set[str],
+    allowed_locations: dict[str, str],
+    allowed_region_keys: set[str],
+    generator: Callable[[str], str | None] | None = None,
+) -> ModelQuestionInterpretation | None:
+    """Normalize a messy source-backed question using only provided candidates."""
+
+    if generator is None:
+        return None
+
+    allowed_intents = {intent.value for intent in SourceBackedIntent}
+    allowed_fact_types = {
+        fact_type.value
+        for fact_type in RequestedFactType
+        if fact_type != RequestedFactType.UNKNOWN
+    }
+    prompt = (
+        "Interpret this CoastWise question as JSON only. "
+        "Choose species_or_category only from allowed_species. "
+        "Choose location_name only from allowed_locations. "
+        "Choose region_key only from allowed_region_keys. "
+        "Choose intent only from allowed_intents. "
+        "Choose requested_fact_types only from allowed_fact_types. "
+        "Do not return regulation facts, legal conclusions, source links, dates, "
+        "open/closed status, or food-safety status.\n"
+        f"question={question}\n"
+        f"location_text={location_text or ''}\n"
+        f"allowed_species={sorted(allowed_species)}\n"
+        f"allowed_locations={json.dumps(allowed_locations, sort_keys=True)}\n"
+        f"allowed_region_keys={sorted(allowed_region_keys)}\n"
+        f"allowed_intents={sorted(allowed_intents)}\n"
+        f"allowed_fact_types={sorted(allowed_fact_types)}"
+    )
+
+    try:
+        raw = generator(prompt)
+        if not isinstance(raw, str) or not raw.strip():
+            return None
+        payload = json.loads(raw)
+    except Exception:
+        return None
+
+    if not isinstance(payload, dict):
+        return None
+
+    species = payload.get("species_or_category")
+    location_name = payload.get("location_name")
+    region_key = payload.get("region_key")
+    intent = payload.get("intent")
+    requested = payload.get("requested_fact_types")
+    confidence = payload.get("confidence")
+    notes = payload.get("notes")
+
+    if species is not None and not isinstance(species, str):
+        return None
+    if species is not None and species not in allowed_species:
+        return None
+    if location_name is not None and not isinstance(location_name, str):
+        return None
+    if location_name is not None and location_name not in allowed_locations:
+        canonical = next(
+            (name for name in allowed_locations if name.casefold() == location_name.casefold()),
+            None,
+        )
+        if canonical is None:
+            return None
+        location_name = canonical
+    if region_key is not None and not isinstance(region_key, str):
+        return None
+    if region_key is not None and region_key not in allowed_region_keys:
+        return None
+    if location_name is not None and allowed_locations[location_name] != region_key:
+        return None
+    if not isinstance(intent, str):
+        return None
+    if intent not in allowed_intents:
+        return None
+    if not isinstance(confidence, str):
+        return None
+    if confidence not in {"high", "medium"}:
+        return None
+    if not isinstance(requested, list) or not requested:
+        return None
+    if any(
+        not isinstance(value, str) or value not in allowed_fact_types for value in requested
+    ):
+        return None
+
+    try:
+        return ModelQuestionInterpretation(
+            species_or_category=species,
+            location_name=location_name,
+            region_key=region_key,
+            intent=intent,
+            requested_fact_types=tuple(requested),
+            confidence=confidence,
+            notes=notes if isinstance(notes, str) else None,
+        )
+    except ValueError:
+        return None
+
+
+DEFAULT_HOSTED_LLM_BASE_URL = "https://api.modelbest.cn/v1"
+DEFAULT_HOSTED_LLM_MODEL = "MiniCPM5-1B"
+
+
+def _extract_json_object(text: str) -> str | None:
+    """Return the outermost JSON object substring, ignoring prose or markdown fences."""
+
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end < start:
+        return None
+    return text[start : end + 1]
+
+
+def _post_chat_completion(
+    base_url: str,
+    api_key: str,
+    model: str,
+    prompt: str,
+    timeout: float,
+) -> str:
+    """POST one OpenAI-compatible chat completion and return the assistant text."""
+
+    url = base_url.rstrip("/") + "/chat/completions"
+    payload = {
+        "model": model,
+        "messages": [
+            {
+                "role": "system",
+                "content": "You output only a single JSON object. No prose, no markdown.",
+            },
+            {"role": "user", "content": prompt},
+        ],
+        "temperature": 0,
+        "max_tokens": 400,
+    }
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        body = json.loads(response.read().decode("utf-8"))
+    return body["choices"][0]["message"]["content"]
+
+
+def build_hosted_interpreter(
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    model: str | None = None,
+    timeout: float = 20.0,
+    post: Callable[[str, str, str, str, float], str] | None = None,
+) -> Callable[[str], str | None] | None:
+    """Build a fail-closed question-interpretation generator over a hosted MiniCPM endpoint.
+
+    Returns ``None`` when no API key is configured, so callers stay on the
+    deterministic interpretation path. The returned generator never raises: any
+    transport error or unparseable output yields ``None``, which the constrained
+    validator then rejects in favor of deterministic interpretation.
+    """
+
+    api_key = api_key if api_key is not None else os.environ.get("COASTWISE_LLM_API_KEY")
+    if not api_key:
+        return None
+    base_url = base_url or os.environ.get("COASTWISE_LLM_BASE_URL") or DEFAULT_HOSTED_LLM_BASE_URL
+    model = model or os.environ.get("COASTWISE_LLM_MODEL") or DEFAULT_HOSTED_LLM_MODEL
+    send = post or _post_chat_completion
+
+    def generate(prompt: str) -> str | None:
+        try:
+            content = send(base_url, api_key, model, prompt, timeout)
+        except Exception:
+            return None
+        if not isinstance(content, str):
+            return None
+        return _extract_json_object(content)
+
+    return generate
+
+
+def _parse_prompt_allowlist(prompt: str, key: str) -> list[str] | None:
+    """Recover an allowlist (e.g. ``allowed_species=[...]``) from the interpreter prompt."""
+
+    match = re.search(rf"{re.escape(key)}=(\[[^\n]*\])", prompt)
+    if match is None:
+        return None
+    try:
+        values = ast.literal_eval(match.group(1))
+    except (ValueError, SyntaxError):
+        return None
+    return [value for value in values if isinstance(value, str)]
+
+
+def _local_interpretation_schema(prompt: str) -> dict:
+    """Grammar schema constraining local model output to the prompt's allowlists.
+
+    Species, location, and region are optional and nullable so a location-free
+    question is not forced to invent a place; enum constraints (when the allowlist
+    is recoverable) keep the model from hallucinating out-of-allowlist values.
+    """
+
+    def required_enum(values: list[str] | None) -> dict:
+        if not values:
+            return {"type": "string"}
+        return {"type": "string", "enum": list(values)}
+
+    def nullable_enum(values: list[str] | None) -> dict:
+        if not values:
+            return {"type": ["string", "null"]}
+        return {"type": ["string", "null"], "enum": [*values, None]}
+
+    return {
+        "type": "object",
+        "properties": {
+            "species_or_category": required_enum(_parse_prompt_allowlist(prompt, "allowed_species")),
+            "location_name": nullable_enum(_parse_prompt_allowlist(prompt, "allowed_locations")),
+            "region_key": nullable_enum(_parse_prompt_allowlist(prompt, "allowed_region_keys")),
+            "intent": {"type": "string", "enum": [intent.value for intent in SourceBackedIntent]},
+            "requested_fact_types": {
+                "type": "array",
+                "minItems": 1,
+                "maxItems": 1,
+                "items": {
+                    "type": "string",
+                    "enum": [fact.value for fact in RequestedFactType if fact.value != "unknown"],
+                },
+            },
+            "confidence": {"type": "string", "enum": ["high", "medium"]},
+        },
+        "required": ["species_or_category", "intent", "requested_fact_types", "confidence"],
+    }
+
+
+def build_local_interpreter(
+    *,
+    enabled: bool | None = None,
+    model_factory: Callable[[], object] | None = None,
+    repo_id: str | None = None,
+    filename: str | None = None,
+) -> Callable[[str], str | None] | None:
+    """Build a keyless, in-process MiniCPM interpreter backed by a local GGUF model.
+
+    Disabled by default; set ``COASTWISE_LOCAL_MODEL=1`` (or pass ``enabled=True``)
+    to turn it on. Returns ``None`` when disabled or when ``llama-cpp-python`` is
+    unavailable, so callers fall through to the hosted or deterministic path. The
+    model loads lazily on first use and is cached; the returned generator never
+    raises.
+    """
+
+    if enabled is None:
+        flag = os.environ.get("COASTWISE_LOCAL_MODEL", "").strip().lower()
+        enabled = flag not in ("", "0", "false", "no")
+    if not enabled:
+        return None
+
+    if model_factory is None:
+        try:
+            from llama_cpp import Llama
+        except Exception:
+            return None
+        repo = repo_id or os.environ.get("COASTWISE_LOCAL_REPO") or "openbmb/MiniCPM5-1B-GGUF"
+        file = filename or os.environ.get("COASTWISE_LOCAL_FILE") or "*Q4_K_M.gguf"
+
+        def model_factory() -> object:
+            return Llama.from_pretrained(repo_id=repo, filename=file, n_ctx=2048, verbose=False)
+
+    state: dict[str, object | None] = {"model": None}
+
+    def generate(prompt: str) -> str | None:
+        try:
+            if state["model"] is None:
+                state["model"] = model_factory()
+            response = state["model"].create_chat_completion(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": (
+                            "You interpret a California ocean fishing question into one JSON "
+                            "object. Use only values from the allowed lists in the question; map "
+                            "misspelled or informal species and place names to the closest allowed "
+                            "value. Set location_name and region_key to null only when the question "
+                            "names no place at all. Never invent a value outside the allowed lists. "
+                            "Output only the JSON object."
+                        ),
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0,
+                max_tokens=400,
+                response_format={"type": "json_object", "schema": _local_interpretation_schema(prompt)},
+            )
+            content = response["choices"][0]["message"]["content"]
+        except Exception:
+            return None
+        if not isinstance(content, str):
+            return None
+        return _extract_json_object(content)
+
+    return generate
+
+
 def explain_safety_result(
     result: SafetyResult,
     inventory: ModelInventory,

coastwise/locations.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import difflib
 import re
 
 from coastwise.schemas import LocationContext
@@ -17,15 +18,102 @@ LOCATION_ALIASES: dict[str, tuple[str, str, str]] = {
     "santa barbara": ("Santa Barbara", "southern", "Southern California ocean region"),
     "san diego bay": ("San Diego Bay", "southern", "Southern California ocean region"),
     "san francisco bay": ("San Francisco Bay", "san_francisco_bay", "San Francisco Bay region"),
+    "sf": ("San Francisco", "san_francisco", "San Francisco coast"),
 }
 
 UNSUPPORTED_LOCATION_TERMS = ("lake", "tahoe", "river", "stream", "freshwater", "inland")
 
+REGION_LOCATION_CANDIDATES: dict[str, tuple[str, str]] = {
+    "Northern": ("northern", "Northern California ocean region"),
+    "Northern Ocean Region": ("northern", "Northern California ocean region"),
+    "Mendocino": ("mendocino", "Mendocino California ocean region"),
+    "Mendocino Ocean Region": ("mendocino", "Mendocino California ocean region"),
+    "San Francisco": ("san_francisco", "San Francisco coast"),
+    "San Francisco Ocean Region": ("san_francisco", "San Francisco coast"),
+    "Central": ("central", "Central California ocean region"),
+    "Central Ocean Region": ("central", "Central California ocean region"),
+    "Southern": ("southern", "Southern California ocean region"),
+    "Southern Ocean Region": ("southern", "Southern California ocean region"),
+    "San Francisco Bay": ("san_francisco_bay", "San Francisco Bay region"),
+}
+
+
+def _location_candidate_metadata() -> dict[str, tuple[str, str]]:
+    candidates = {display: (region_key, scope) for display, region_key, scope in LOCATION_ALIASES.values()}
+    candidates.update(REGION_LOCATION_CANDIDATES)
+    return candidates
+
+
+def location_candidates() -> dict[str, str]:
+    """Return validated location names that a model may choose from."""
+
+    candidates = {name: region_key for name, (region_key, _scope) in _location_candidate_metadata().items()}
+    return dict(sorted(candidates.items()))
+
+
+def location_context_from_model(
+    question: str,
+    location_text: str | None,
+    location_name: str | None,
+    region_key: str | None,
+) -> LocationContext:
+    """Build location context from already validated model output."""
+
+    if not location_name or not region_key:
+        return parse_location(question, location_text)
+    candidate_metadata = _location_candidate_metadata()
+    candidate = candidate_metadata.get(location_name)
+    if candidate is None or candidate[0] != region_key:
+        return parse_location(question, location_text)
+    scope = candidate[1]
+    return LocationContext(
+        raw_question_location=location_name,
+        raw_location_input=location_text or None,
+        matched_place=location_name,
+        area_or_scope=scope,
+        confidence="recognized",
+        warning=None,
+        region_key=region_key,
+    )
+
 
 def _normalize(value: str) -> str:
     return " ".join(re.sub(r"[^a-z0-9]+", " ", value.casefold()).split())
 
 
+def _fuzzy_location_match(combined: str) -> tuple[str, str, str] | None:
+    """Recover a known coastal place from a misspelled/garbled question via fuzzy match."""
+
+    names: dict[str, tuple[str, str, str]] = {}
+    for alias, (display, region_key, scope) in LOCATION_ALIASES.items():
+        names.setdefault(_normalize(alias), (display, region_key, scope))
+        names.setdefault(_normalize(display), (display, region_key, scope))
+    for display, (region_key, scope) in REGION_LOCATION_CANDIDATES.items():
+        names.setdefault(_normalize(display), (display, region_key, scope))
+
+    place_keys = list(names)
+    tokens = combined.split()
+    windows = {
+        " ".join(tokens[index : index + size])
+        for size in (1, 2, 3)
+        for index in range(len(tokens) - size + 1)
+    }
+    best_ratio = 0.0
+    best_key: str | None = None
+    for window in windows:
+        if len(window) < 4:
+            continue
+        match = difflib.get_close_matches(window, place_keys, n=1, cutoff=0.84)
+        if not match:
+            continue
+        ratio = difflib.SequenceMatcher(None, window, match[0]).ratio()
+        if ratio > best_ratio:
+            best_ratio, best_key = ratio, match[0]
+    if best_key is None:
+        return None
+    return names[best_key]
+
+
 def parse_location(question: str, location_text: str | None = None) -> LocationContext:
     """Parse a user-facing beach or coastal-area location."""
 
@@ -44,8 +132,9 @@ def parse_location(question: str, location_text: str | None = None) -> LocationC
             region_key=None,
         )
 
+    padded = f" {combined} "
     for alias, (display, region_key, scope) in LOCATION_ALIASES.items():
-        if alias in combined:
+        if f" {alias} " in padded:
             raw_question_location = alias if alias in normalized_question else None
             return LocationContext(
                 raw_question_location=raw_question_location,
@@ -57,6 +146,19 @@ def parse_location(question: str, location_text: str | None = None) -> LocationC
                 region_key=region_key,
             )
 
+    fuzzy = _fuzzy_location_match(combined)
+    if fuzzy is not None:
+        display, region_key, scope = fuzzy
+        return LocationContext(
+            raw_question_location=None,
+            raw_location_input=location_text or None,
+            matched_place=display,
+            area_or_scope=scope,
+            confidence="recognized",
+            warning=None,
+            region_key=region_key,
+        )
+
     if normalized_input:
         return LocationContext(
             raw_question_location=None,

coastwise/qna.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
-from dataclasses import replace
-from datetime import datetime
+from dataclasses import dataclass, replace
+from datetime import datetime, timezone
 
 from coastwise.advisories import source_backed_advisory_facts
-from coastwise.ai import synthesize_cached_evidence_answer
-from coastwise.locations import parse_location
+from coastwise.ai import interpret_question_with_model, synthesize_cached_evidence_answer
+from coastwise.data import all_rule_cards, get_rule_card
+from coastwise.locations import location_candidates, location_context_from_model, parse_location
 from coastwise.schemas import (
     AdvisoryFact,
     AnswerStatus,
@@ -15,15 +16,17 @@ from coastwise.schemas import (
     CachedEvidenceSource,
     EvidenceType,
     FreshnessStatus,
+    HarvestStatus,
     LocationContext,
     QuestionInterpretation,
     RefreshStatus,
     RequestedFactType,
+    SourceBackedIntent,
     SourceBackedAnswer,
     SourceChunk,
     StructuredRegulationFact,
 )
-from coastwise.search import normalize_query, search_source_candidates
+from coastwise.search import normalize_query, search_source_candidates, search_species
 from coastwise.source_cache import SourceCache, freshness_status
 from coastwise.submission import default_model_inventory
 
@@ -65,6 +68,23 @@ SHELLFISH_SOURCE_TERMS = (
     "shellfish",
 )
 
+NON_SPECIES_MODEL_ALLOWLIST_TERMS = frozenset(
+    {
+        "general",
+        "region",
+        "regional",
+        "regulation",
+        "regulations",
+        "rule",
+        "rules",
+        "source",
+        "sources",
+        "summary",
+        "topic",
+        "topics",
+    }
+)
+
 SOURCE_BACKED_FORBIDDEN_COPY = (
     "safe to eat",
     "definitely legal",
@@ -81,13 +101,21 @@ PUBLIC_SAVED_EVIDENCE_NEXT_ACTION = (
 )
 
 
+@dataclass(frozen=True)
+class AnswerPlan:
+    interpretation: QuestionInterpretation
+    intent: SourceBackedIntent
+    requested_fact_types: tuple[RequestedFactType, ...]
+    missing_fact_label: str
+
+
 def _requested_fact_type(question: str) -> RequestedFactType:
     normalized = normalize_query(question)
     if "min" in normalized or "minimum" in normalized or "size" in normalized:
         return RequestedFactType.MINIMUM_SIZE
     if "bag" in normalized or "limit" in normalized:
         return RequestedFactType.BAG_LIMIT
-    if any(term in normalized for term in ("season", "open", "closed", "harvest", "keep", "take")):
+    if any(term in normalized for term in ("season", "open", "closed", "harvest", "keep", "take", "catch", "allowed")):
         return RequestedFactType.SEASON
     if any(term in normalized for term in ("safe", "eat", "consume", "advisory", "biotoxin", "cdph", "toxin")):
         return RequestedFactType.ADVISORY
@@ -103,6 +131,70 @@ def _unsupported_scope(question: str, location_context: LocationContext) -> bool
     return location_context.confidence == "unsupported" or any(term in normalized for term in UNSUPPORTED_SCOPE_TERMS)
 
 
+def _allowed_species_from_cache(cache: SourceCache) -> set[str]:
+    species = {fact.species_or_category for fact in cache.facts}
+    species.update(fact.affected_species_or_category for fact in cache.advisory_facts)
+    for chunk in cache.chunks:
+        for term in chunk.species_or_category_terms:
+            normalized = normalize_query(term)
+            if normalized:
+                species.add(normalized.replace(" ", "_"))
+    # Offer the full curated species taxonomy so the model can resolve any
+    # supported species to its exact key instead of rounding an unknown one to a
+    # wrong neighbour (e.g. "california scorpionfish" -> california_halibut).
+    species.update(card.key for card in all_rule_cards() if card.key != "unknown")
+    return {
+        value
+        for value in species
+        if value and value not in NON_SPECIES_MODEL_ALLOWLIST_TERMS
+    }
+
+
+def _primary_requested_fact_type(requested: tuple[RequestedFactType, ...]) -> RequestedFactType:
+    priority = (
+        RequestedFactType.SEASON,
+        RequestedFactType.CLOSURE,
+        RequestedFactType.ADVISORY,
+        RequestedFactType.QUARANTINE,
+        RequestedFactType.BAG_LIMIT,
+        RequestedFactType.POSSESSION_LIMIT,
+        RequestedFactType.MINIMUM_SIZE,
+        RequestedFactType.GEAR_OR_METHOD,
+        RequestedFactType.GENERAL_SUMMARY,
+    )
+    for fact_type in priority:
+        if fact_type in requested:
+            return fact_type
+    return requested[0] if requested else RequestedFactType.GENERAL_SUMMARY
+
+
+def _guarded_model_species(
+    question: str, model_species: str | None, cache: SourceCache
+) -> str | None:
+    """Correct a small-model species pick that fights deterministic name search.
+
+    The 1B model picks from a large species enum and can (a) round a rare species
+    to a wrong in-enum species with no lexical basis ("soupfin shark" -> mussels),
+    or (b) pick a substring species over the specific one the user typed
+    ("kelp bass" -> kelp plant; "great white shark" -> basking shark).
+
+    A strong, specific cached-species alias the user actually typed beats the
+    model's pick. Otherwise, if the model's pick isn't among any deterministic
+    candidate, fall back to the top candidate. When deterministic search finds
+    nothing (e.g. a typo only the model resolves), keep the model's choice.
+    """
+
+    if not model_species:
+        return model_species
+    source = search_source_candidates(question, cache)
+    if source and source[0].score >= 0.85 and source[0].rule_card_key != model_species:
+        return source[0].rule_card_key
+    candidates = source or search_species(question)
+    if candidates and model_species not in {match.rule_card_key for match in candidates}:
+        return candidates[0].rule_card_key
+    return model_species
+
+
 def interpret_question(
     question: str,
     location_text: str | None,
@@ -124,9 +216,51 @@ def interpret_question(
             model_used=False,
         )
 
+    model_interpretation = interpret_question_with_model(
+        question,
+        location_text,
+        allowed_species=_allowed_species_from_cache(cache),
+        allowed_locations=location_candidates(),
+        allowed_region_keys={source.region_key for source in cache.sources if source.region_key},
+        generator=model,
+    )
+    if model_interpretation is not None:
+        model_intent: SourceBackedIntent = model_interpretation.intent
+        model_location = location_context_from_model(
+            question,
+            location_text,
+            model_interpretation.location_name,
+            model_interpretation.region_key,
+        )
+        deterministic_fact_type = _requested_fact_type(question)
+        model_species = _guarded_model_species(
+            question, model_interpretation.species_or_category, cache
+        )
+        return QuestionInterpretation(
+            question=question,
+            species_or_category=model_species,
+            requested_fact_type=deterministic_fact_type,
+            location_context=model_location,
+            scope="california_ocean",
+            confidence=model_interpretation.confidence,
+            model_used=True,
+            model_notes=(
+                f"intent={model_intent.value}; "
+                f"requested={deterministic_fact_type.value}"
+            ),
+        )
+
     candidates = search_source_candidates(question, cache)
-    species_key = candidates[0].rule_card_key if candidates else None
-    confidence = "high" if species_key else "medium"
+    if candidates:
+        species_key = candidates[0].rule_card_key
+        confidence = "high"
+    else:
+        # No cached source fact for the species; fall back to the full curated
+        # rule-card taxonomy so any supported species still resolves (and can
+        # answer with reviewed card guidance) instead of going unsupported.
+        card_candidates = search_species(question)
+        species_key = card_candidates[0].rule_card_key if card_candidates else None
+        confidence = "low" if species_key else "medium"
     return QuestionInterpretation(
         question=question,
         species_or_category=species_key,
@@ -138,24 +272,226 @@ def interpret_question(
     )
 
 
+def _intent_from_interpretation(interpretation: QuestionInterpretation) -> SourceBackedIntent:
+    notes = interpretation.model_notes or ""
+    for token in notes.split(";"):
+        token = token.strip()
+        if token.startswith("intent="):
+            try:
+                return SourceBackedIntent(token.removeprefix("intent="))
+            except ValueError:
+                break
+    if interpretation.requested_fact_type in {RequestedFactType.SEASON, RequestedFactType.CLOSURE}:
+        return SourceBackedIntent.SEASON_CLOSURE
+    if interpretation.requested_fact_type in {RequestedFactType.ADVISORY, RequestedFactType.QUARANTINE}:
+        return SourceBackedIntent.FOOD_SAFETY_ADVISORY
+    if interpretation.requested_fact_type in {RequestedFactType.MINIMUM_SIZE, RequestedFactType.BAG_LIMIT, RequestedFactType.POSSESSION_LIMIT}:
+        return SourceBackedIntent.LIMITS
+    if interpretation.requested_fact_type is RequestedFactType.GEAR_OR_METHOD:
+        return SourceBackedIntent.GEAR_METHOD
+    return SourceBackedIntent.GENERAL
+
+
+def _requested_fact_types_from_interpretation(
+    interpretation: QuestionInterpretation,
+) -> tuple[RequestedFactType, ...]:
+    notes = interpretation.model_notes or ""
+    for token in notes.split(";"):
+        token = token.strip()
+        if token.startswith("requested="):
+            values = [value for value in token.removeprefix("requested=").split(",") if value]
+            result: list[RequestedFactType] = []
+            for value in values:
+                try:
+                    result.append(RequestedFactType(value))
+                except ValueError:
+                    continue
+            if result:
+                return tuple(dict.fromkeys(result))
+    if interpretation.requested_fact_type is RequestedFactType.SEASON:
+        return (RequestedFactType.SEASON, RequestedFactType.CLOSURE)
+    return (interpretation.requested_fact_type,)
+
+
+def _missing_fact_label(interpretation: QuestionInterpretation, requested: tuple[RequestedFactType, ...]) -> str:
+    display = (interpretation.species_or_category or "requested topic").replace("_", " ")
+    place = interpretation.location_context.matched_place or interpretation.location_context.area_or_scope
+    if RequestedFactType.SEASON in requested or RequestedFactType.CLOSURE in requested:
+        return f"{display} open/closed season or closure status for {place}"
+    if RequestedFactType.GEAR_OR_METHOD in requested:
+        return f"{display} gear or method notes for {place}"
+    if RequestedFactType.ADVISORY in requested or RequestedFactType.QUARANTINE in requested:
+        return f"{display} CDPH advisory or quarantine status for {place}"
+    return f"{display} {requested[0].value.replace('_', ' ')} for {place}"
+
+
+def _build_answer_plan(interpretation: QuestionInterpretation) -> AnswerPlan:
+    requested = _requested_fact_types_from_interpretation(interpretation)
+    return AnswerPlan(
+        interpretation=interpretation,
+        intent=_intent_from_interpretation(interpretation),
+        requested_fact_types=requested,
+        missing_fact_label=_missing_fact_label(interpretation, requested),
+    )
+
+
 def _matching_structured_fact(
     interpretation: QuestionInterpretation,
     cache: SourceCache,
 ) -> StructuredRegulationFact | None:
-    if not interpretation.species_or_category:
+    species = interpretation.species_or_category
+    if not species:
         return None
-    for fact in cache.facts:
-        same_species = fact.species_or_category == interpretation.species_or_category
+    region_key = interpretation.location_context.region_key
+    species_facts = [fact for fact in cache.facts if fact.species_or_category == species]
+    # When real facts exist, never let a generic "verify" general_summary
+    # placeholder answer a question — those flow to the species-fact bundle.
+    has_real_facts = any(
+        fact.fact_type is not RequestedFactType.GENERAL_SUMMARY for fact in species_facts
+    )
+    for fact in species_facts:
         same_type = fact.fact_type is interpretation.requested_fact_type
         general_summary = (
             interpretation.requested_fact_type is RequestedFactType.GENERAL_SUMMARY
             and fact.fact_type is RequestedFactType.GENERAL_SUMMARY
         )
-        if same_species and (same_type or general_summary):
+        if general_summary and has_real_facts:
+            continue
+        region_ok = not fact.region_key or not region_key or fact.region_key == region_key
+        if region_ok and (same_type or general_summary):
             return fact
     return None
 
 
+PERMISSION_QUESTION_TERMS = ("legal", "catch", "keep", "harvest", "take", "allowed", "can i", "may i")
+
+PERMISSION_FACT_TYPES = (
+    RequestedFactType.SEASON,
+    RequestedFactType.CLOSURE,
+    RequestedFactType.MINIMUM_SIZE,
+    RequestedFactType.BAG_LIMIT,
+    RequestedFactType.POSSESSION_LIMIT,
+    RequestedFactType.GEAR_OR_METHOD,
+)
+
+
+def _is_permission_question(question: str) -> bool:
+    normalized = normalize_query(question)
+    return any(term in normalized for term in PERMISSION_QUESTION_TERMS)
+
+
+def _actionable_species_facts(
+    interpretation: QuestionInterpretation,
+    cache: SourceCache,
+) -> list[StructuredRegulationFact]:
+    species = interpretation.species_or_category
+    if not species:
+        return []
+    region_key = interpretation.location_context.region_key
+    return [
+        fact
+        for fact in cache.facts
+        if fact.species_or_category == species
+        and fact.fact_type in PERMISSION_FACT_TYPES
+        and (not fact.region_key or not region_key or fact.region_key == region_key)
+    ]
+
+
+BUNDLE_FALLBACK_FACT_TYPES = (
+    RequestedFactType.MINIMUM_SIZE,
+    RequestedFactType.BAG_LIMIT,
+    RequestedFactType.POSSESSION_LIMIT,
+    RequestedFactType.SEASON,
+    RequestedFactType.CLOSURE,
+    RequestedFactType.GEAR_OR_METHOD,
+)
+
+
+def _species_fact_bundle(
+    interpretation: QuestionInterpretation,
+    cache: SourceCache,
+) -> list[StructuredRegulationFact]:
+    """All non-advisory structured facts for the species, region-filtered.
+
+    Lets a recognized species with real facts answer a general or
+    otherwise-unmatched question instead of dropping to a snippet partial.
+    """
+
+    species = interpretation.species_or_category
+    if not species:
+        return []
+    region_key = interpretation.location_context.region_key
+    return [
+        fact
+        for fact in cache.facts
+        if fact.species_or_category == species
+        and fact.fact_type in BUNDLE_FALLBACK_FACT_TYPES
+        and (not fact.region_key or not region_key or fact.region_key == region_key)
+    ]
+
+
+def _matching_structured_facts_for_plan(
+    plan: AnswerPlan,
+    cache: SourceCache,
+) -> list[StructuredRegulationFact]:
+    species = plan.interpretation.species_or_category
+    if not species:
+        return []
+    region_key = plan.interpretation.location_context.region_key
+    matches: list[StructuredRegulationFact] = []
+    for fact in cache.facts:
+        if fact.species_or_category != species:
+            continue
+        if fact.fact_type not in plan.requested_fact_types:
+            continue
+        if fact.region_key and region_key and fact.region_key != region_key:
+            continue
+        matches.append(fact)
+    return matches
+
+
+def _structured_fact_bundle_answer(
+    facts: list[StructuredRegulationFact],
+    cache: SourceCache,
+    now: datetime,
+    interpretation: QuestionInterpretation,
+    *,
+    permission: bool = False,
+) -> SourceBackedAnswer:
+    primary = facts[0]
+    retrieved_at, status, refresh_status = _snapshot_freshness(primary.source_id, cache, now)
+    # Lead with the regulation facts directly; the source is shown in the
+    # evidence section, so an inline "Cached ... evidence indicates" preamble is
+    # redundant clutter.
+    direct = " ".join(_structured_direct_answer(fact) for fact in facts)
+    next_action = "Verify current CDFW/CDPH guidance before harvest or consumption."
+    if status is FreshnessStatus.STALE:
+        next_action = "Source cache is stale; verify official CDFW/CDPH guidance before harvest or consumption."
+    notes: tuple[str, ...] = ()
+    if permission:
+        present = {fact.fact_type for fact in facts}
+        if RequestedFactType.SEASON not in present and RequestedFactType.CLOSURE not in present:
+            notes = (
+                "Cached structured facts do not include open/closed season or closure status; "
+                "CoastWise cannot confirm legality, so verify current CDFW openers and closures.",
+            )
+    return SourceBackedAnswer(
+        status=AnswerStatus.ANSWERED,
+        direct_answer=direct,
+        evidence_type=EvidenceType.STRUCTURED_FACT,
+        species_or_category=primary.display_name,
+        location_context=interpretation.location_context,
+        source_links=tuple(dict.fromkeys(fact.source_url for fact in facts)),
+        source_titles=tuple(dict.fromkeys(_source_title(fact.source_id, cache) for fact in facts)),
+        retrieved_at=retrieved_at or primary.retrieved_at,
+        freshness_status=status,
+        refresh_status=refresh_status,
+        supporting_snippets=tuple(dict.fromkeys(fact.supporting_snippet for fact in facts)),
+        uncertainty_notes=notes,
+        next_safe_action=next_action,
+    )
+
+
 def _matching_chunk(interpretation: QuestionInterpretation, cache: SourceCache) -> SourceChunk | None:
     query_tokens = set(normalize_query(interpretation.question).split())
     best: tuple[int, SourceChunk] | None = None
@@ -203,18 +539,34 @@ def build_cached_evidence_packet(
     now: datetime,
     *,
     limit: int = 3,
+    plan: AnswerPlan | None = None,
 ) -> CachedEvidencePacket | None:
     """Build a compact evidence packet from cached source chunks."""
 
     if not interpretation.species_or_category:
         return None
 
+    requested = plan.requested_fact_types if plan is not None else (interpretation.requested_fact_type,)
     ranked = sorted(
         ((_chunk_relevance_score(interpretation, chunk), chunk) for chunk in cache.chunks),
         key=lambda item: item[0],
         reverse=True,
     )
-    selected = [chunk for score, chunk in ranked if score >= 2][:limit]
+    species_tokens = set(normalize_query(interpretation.species_or_category.replace("_", " ")).split())
+    selected = [
+        chunk
+        for score, chunk in ranked
+        if score >= 2
+        and (
+            normalize_query(interpretation.species_or_category.replace("_", " "))
+            in {normalize_query(term) for term in chunk.species_or_category_terms}
+            or bool(species_tokens & set(chunk.tokens))
+            or (
+                bool(species_tokens & set(SHELLFISH_SOURCE_TERMS))
+                and bool(set(chunk.tokens) & set(SHELLFISH_SOURCE_TERMS))
+            )
+        )
+    ][:limit]
     if not selected:
         return None
 
@@ -233,15 +585,18 @@ def build_cached_evidence_packet(
         )
 
     display = interpretation.species_or_category.replace("_", " ")
+    next_action = PUBLIC_SAVED_EVIDENCE_NEXT_ACTION
+    if RequestedFactType.ADVISORY in requested or RequestedFactType.QUARANTINE in requested:
+        next_action = "Use saved official CDPH details as decision support; do not treat CoastWise as proof of food safety."
     return CachedEvidencePacket(
         question=interpretation.question,
         species_or_category=interpretation.species_or_category,
         display_name=display[0].upper() + display[1:],
-        requested_fact_type=interpretation.requested_fact_type,
+        requested_fact_type=_primary_requested_fact_type(requested),
         matched_place=interpretation.location_context.matched_place,
         region_key=interpretation.location_context.region_key,
         sources=tuple(sources),
-        deterministic_next_safe_action=PUBLIC_SAVED_EVIDENCE_NEXT_ACTION,
+        deterministic_next_safe_action=next_action,
     )
 
 
@@ -250,13 +605,29 @@ def _source_title(source_id: str, cache: SourceCache) -> str:
     return source.title if source is not None else source_id
 
 
+def _is_no_limit_value(value: str) -> bool:
+    normalized = value.strip().casefold()
+    return (
+        normalized in {"none", "no limit", "unlimited"}
+        or normalized.startswith("no minimum")
+        or normalized.startswith("no daily")
+    )
+
+
 def _structured_direct_answer(fact: StructuredRegulationFact) -> str:
+    units = f" {fact.units}" if fact.units else ""
     if fact.fact_type is RequestedFactType.MINIMUM_SIZE:
-        units = f" {fact.units}" if fact.units else ""
+        if _is_no_limit_value(fact.value):
+            return f"{fact.display_name} has no minimum size limit."
         return f"{fact.display_name} minimum size is {fact.value}{units}."
     if fact.fact_type is RequestedFactType.BAG_LIMIT:
-        units = f" {fact.units}" if fact.units else ""
+        if _is_no_limit_value(fact.value):
+            return f"{fact.display_name} has no daily bag limit{units}."
         return f"{fact.display_name} bag limit is {fact.value}{units}."
+    if fact.fact_type is RequestedFactType.POSSESSION_LIMIT:
+        return f"{fact.display_name} possession limit is {fact.value}{units}."
+    if fact.fact_type is RequestedFactType.SEASON:
+        return f"{fact.display_name} season is {fact.value}"
     return f"{fact.display_name}: {fact.value}"
 
 
@@ -464,6 +835,48 @@ def _with_safe_answer_copy(answer: SourceBackedAnswer) -> SourceBackedAnswer:
     )
 
 
+def _rule_card_fallback_answer(
+    interpretation: QuestionInterpretation,
+    now: datetime,
+) -> SourceBackedAnswer | None:
+    """Reviewed rule-card posture for a recognized species with no extracted fact.
+
+    Keeps every supported species answerable with its correct harvest posture
+    (e.g. "rules apply; verify") instead of an unsupported reply or a wrong
+    species, without asserting an exact regulation value.
+    """
+
+    species_key = interpretation.species_or_category
+    if not species_key:
+        return None
+    card = get_rule_card(species_key)
+    if card.key == "unknown" or not card.source_urls:
+        return None
+    notes = " ".join(card.rule_notes)
+    direct = card.short_answer if not notes else f"{card.short_answer} {notes}"
+    cache_dt = datetime(
+        card.cache_date.year, card.cache_date.month, card.cache_date.day, tzinfo=timezone.utc
+    )
+    return SourceBackedAnswer(
+        status=AnswerStatus.PARTIAL,
+        direct_answer=direct,
+        evidence_type=EvidenceType.SOURCE_SNIPPET,
+        species_or_category=card.display_name,
+        location_context=interpretation.location_context,
+        source_links=tuple(card.source_urls),
+        source_titles=tuple(card.source_names),
+        retrieved_at=cache_dt,
+        freshness_status=FreshnessStatus.CURRENT,
+        refresh_status=None,
+        supporting_snippets=(direct,),
+        uncertainty_notes=(
+            "This is curated CoastWise rule-card guidance, not an extracted official "
+            "value; verify the exact current CDFW/CDPH rules for this species.",
+        ),
+        next_safe_action="Verify current official CDFW/CDPH rules for this species before harvest or consumption.",
+    )
+
+
 def answer_question(
     question: str,
     location_text: str | None,
@@ -510,10 +923,26 @@ def answer_question(
             next_safe_action="Use official CDFW/CDPH sources for the relevant location and activity.",
         )
 
+    plan = _build_answer_plan(interpretation)
+
     advisory_facts = _matching_advisory_facts(interpretation, cache)
     if advisory_facts:
         return _advisory_answer(interpretation, advisory_facts, cache, now)
 
+    if _is_permission_question(interpretation.question) and interpretation.species_or_category:
+        permission_facts = _actionable_species_facts(interpretation, cache)
+        if permission_facts:
+            return _structured_fact_bundle_answer(
+                permission_facts, cache, now, interpretation, permission=True
+            )
+    structured_facts = _matching_structured_facts_for_plan(plan, cache)
+    if structured_facts and plan.intent in {
+        SourceBackedIntent.PERMISSION_STATUS,
+        SourceBackedIntent.SEASON_CLOSURE,
+        SourceBackedIntent.REGIONAL_RULES,
+    }:
+        return _structured_fact_bundle_answer(structured_facts, cache, now, interpretation)
+
     fact = _matching_structured_fact(interpretation, cache)
     if fact is not None:
         retrieved_at, status, refresh_status = _snapshot_freshness(fact.source_id, cache, now)
@@ -536,9 +965,34 @@ def answer_question(
             next_safe_action=next_action,
         )
 
-    packet = build_cached_evidence_packet(interpretation, cache, now)
+    # General "rules / restrictions / tell me about X" questions surface the full
+    # set of real facts. A specific fact-type miss (e.g. season for an area we
+    # have no season fact for) is left to the honest partial below, not answered
+    # with unrelated facts.
+    if (
+        interpretation.requested_fact_type is RequestedFactType.GENERAL_SUMMARY
+        and not _question_needs_advisory_evidence(interpretation)
+    ):
+        bundle = _species_fact_bundle(interpretation, cache)
+        if bundle:
+            return _structured_fact_bundle_answer(bundle, cache, now, interpretation)
+
+    packet = build_cached_evidence_packet(interpretation, cache, now, plan=plan)
     if packet is not None:
-        return _cached_evidence_answer(packet, interpretation, cache, now, model=model)
+        packet_answer = _cached_evidence_answer(packet, interpretation, cache, now, model=model)
+        if packet_answer.status is AnswerStatus.PARTIAL:
+            packet_answer = replace(
+                packet_answer,
+                direct_answer=(
+                    f"CoastWise found relevant cached official evidence, but the cache "
+                    f"does not include an extracted {plan.missing_fact_label}."
+                ),
+            )
+        return packet_answer
+
+    card_answer = _rule_card_fallback_answer(interpretation, now)
+    if card_answer is not None:
+        return card_answer
 
     chunk = _matching_chunk(interpretation, cache)
     if chunk is not None:

coastwise/schemas.py

@@ -40,6 +40,7 @@ class ModelRole(StrEnum):
     PHOTO_CANDIDATE = "photo_candidate"
     EMBEDDING_OR_RANKER = "embedding_or_ranker"
     DEMO_OR_SUBMISSION_SUPPORT = "demo_or_submission_support"
+    QUESTION_INTERPRETATION = "question_interpretation"
 
 
 class RuntimeMode(StrEnum):
@@ -105,6 +106,16 @@ class RequestedFactType(StrEnum):
     UNKNOWN = "unknown"
 
 
+class SourceBackedIntent(StrEnum):
+    PERMISSION_STATUS = "permission_status"
+    LIMITS = "limits"
+    SEASON_CLOSURE = "season_closure"
+    GEAR_METHOD = "gear_method"
+    FOOD_SAFETY_ADVISORY = "food_safety_advisory"
+    REGIONAL_RULES = "regional_rules"
+    GENERAL = "general"
+
+
 class AnswerStatus(StrEnum):
     ANSWERED = "answered"
     PARTIAL = "partial"
@@ -725,6 +736,27 @@ class QuestionInterpretation:
             raise ValueError("question confidence is not supported")
 
 
+@dataclass(frozen=True)
+class ModelQuestionInterpretation:
+    species_or_category: str | None
+    location_name: str | None
+    region_key: str | None
+    intent: SourceBackedIntent | str
+    requested_fact_types: tuple[RequestedFactType | str, ...]
+    confidence: str
+    notes: str | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "intent", _coerce_enum(SourceBackedIntent, self.intent))
+        object.__setattr__(
+            self,
+            "requested_fact_types",
+            tuple(_coerce_enum(RequestedFactType, value) for value in self.requested_fact_types),
+        )
+        if self.confidence not in {"high", "medium", "low", "ambiguous"}:
+            raise ValueError("model interpretation confidence is not supported")
+
+
 @dataclass(frozen=True)
 class SourceBackedAnswer:
     status: AnswerStatus | str

coastwise/search.py

@@ -176,8 +176,16 @@ def search_source_candidates(query: str, cache: SourceCache, *, limit: int = 6)
 
     matches: list[SpeciesMatch] = []
     for alias, key in index.items():
-        if alias in normalized or normalized in alias:
-            matches.append(SpeciesMatch(key, _source_display_name(key), 0.72, "source_partial"))
+        if alias in normalized:
+            # The user typed this alias: a longer/more specific alias wins, so
+            # "kelp bass" beats "kelp" and "rock crab" beats "crab".
+            score = 0.7 + min(0.25, 0.02 * len(alias))
+        elif normalized in alias:
+            # The query is only a fragment of the alias: weaker signal.
+            score = 0.5
+        else:
+            continue
+        matches.append(SpeciesMatch(key, _source_display_name(key), score, "source_partial"))
 
     deduped: dict[str, SpeciesMatch] = {}
     for match in sorted(matches, key=lambda item: item.score, reverse=True):

coastwise/source_extract.py

@@ -141,6 +141,92 @@ def default_structured_validation_set() -> StructuredValidationSet:
     )
 
 
+def _region_key_from_text(lowered: str) -> str | None:
+    if "mendocino" in lowered:
+        return "mendocino"
+    if "san francisco bay" in lowered:
+        return "san_francisco_bay"
+    if "san francisco" in lowered or "pacifica" in lowered or "half moon bay" in lowered:
+        return "san_francisco"
+    if "monterey" in lowered or "central" in lowered:
+        return "central"
+    if "northern" in lowered:
+        return "northern"
+    if "southern" in lowered:
+        return "southern"
+    return None
+
+
+def _append_explicit_dungeness_facts(
+    chunk: SourceChunk, facts: list[StructuredRegulationFact]
+) -> None:
+    lowered = chunk.text.casefold()
+    if "dungeness crab" not in lowered:
+        return
+    region_key = _region_key_from_text(lowered)
+    if "season status is closed" in lowered or "season is closed" in lowered:
+        facts.append(
+            StructuredRegulationFact(
+                id=f"{chunk.id}:dungeness_crab:season",
+                species_or_category="dungeness_crab",
+                display_name="Dungeness crab",
+                aliases=("dungeness crabs",),
+                area_or_scope=chunk.heading or "California recreational crab fishery",
+                fact_type=RequestedFactType.SEASON,
+                value="season status is closed in the cached official source text",
+                units=None,
+                source_id=chunk.source_id,
+                source_url=chunk.source_url,
+                retrieved_at=chunk.retrieved_at,
+                supporting_chunk_id=chunk.id,
+                supporting_snippet=chunk.text,
+                region_key=region_key,
+                validation_set=False,
+            )
+        )
+    elif "season status is open" in lowered or "season is open" in lowered:
+        facts.append(
+            StructuredRegulationFact(
+                id=f"{chunk.id}:dungeness_crab:season",
+                species_or_category="dungeness_crab",
+                display_name="Dungeness crab",
+                aliases=("dungeness crabs",),
+                area_or_scope=chunk.heading or "California recreational crab fishery",
+                fact_type=RequestedFactType.SEASON,
+                value="season status is open in the cached official source text",
+                units=None,
+                source_id=chunk.source_id,
+                source_url=chunk.source_url,
+                retrieved_at=chunk.retrieved_at,
+                supporting_chunk_id=chunk.id,
+                supporting_snippet=chunk.text,
+                region_key=region_key,
+                validation_set=False,
+            )
+        )
+    if "trap" in lowered or "hoop net" in lowered or "hoop-net" in lowered:
+        facts.append(
+            StructuredRegulationFact(
+                id=f"{chunk.id}:dungeness_crab:gear",
+                species_or_category="dungeness_crab",
+                display_name="Dungeness crab",
+                aliases=("dungeness crabs",),
+                area_or_scope=chunk.heading or "California recreational crab fishery",
+                fact_type=RequestedFactType.GEAR_OR_METHOD,
+                value="gear or method rules are referenced in the cached official source text",
+                units=None,
+                source_id=chunk.source_id,
+                source_url=chunk.source_url,
+                retrieved_at=chunk.retrieved_at,
+                supporting_chunk_id=chunk.id,
+                supporting_snippet=chunk.text,
+                region_key=region_key,
+                gear_or_method_notes="Dungeness crab trap and hoop net rules are referenced.",
+                validation_set=False,
+            )
+        )
+
+
 def extract_structured_facts(
     chunks: tuple[SourceChunk, ...] | list[SourceChunk],
     validation_set: StructuredValidationSet,
@@ -211,6 +297,7 @@ def extract_structured_facts(
                     validation_set=True,
                 )
             )
+        _append_explicit_dungeness_facts(chunk, facts)
 
     fact_ids = {fact.id for fact in facts}
     for required_id in ("lingcod_min_size", "lingcod_bag_limit", "dungeness_crab_bag_limit"):

coastwise/submission.py

@@ -24,8 +24,8 @@ def default_model_inventory() -> ModelInventory:
                 provider="OpenBMB",
                 source_url="https://huggingface.co/openbmb/MiniCPM5-1B",
                 total_parameters_b=1.0,
-                roles=(ModelRole.SAFETY_EXPLANATION,),
-                runtime_mode=RuntimeMode.DISABLED_OR_MOCKED,
+                roles=(ModelRole.QUESTION_INTERPRETATION, ModelRole.SAFETY_EXPLANATION),
+                runtime_mode=RuntimeMode.HOSTED_ENDPOINT,
                 required_for_core_safety=False,
                 award_relevance=(AwardTag.OPENBMB, AwardTag.TINY_TITAN),
             ),

data/source-cache/seed/chunks.json

@@ -84,14 +84,14 @@
     "location_terms": []
   },
   {
-    "id": "chunk_cabezon_context",
+    "id": "chunk_cabezon_groundfish",
     "source_id": "cdfw_groundfish_summary",
     "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
     "source_title": "CDFW Groundfish Summary",
     "retrieved_at": "2026-06-15T12:00:00+00:00",
-    "heading": "Cabezon Context",
-    "text": "Saved CDFW groundfish summary information includes cabezon as a groundfish species. Restrictions may include season, depth, bag, size, gear, and area rules, but this saved cache does not include a reviewed exact cabezon limit.",
-    "tokens": ["saved", "cdfw", "groundfish", "cabezon", "restrictions", "season", "depth", "bag", "size", "gear", "area"],
+    "heading": "Cabezon Daily Bag and Minimum Size Limits",
+    "text": "Cabezon, section 28.28, has no minimum size limit. The daily bag limit is 10 fish in combination per person as part of the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate. Open season and depth constraints vary by management area and change in-season; verify current CDFW groundfish openers and depth limits before fishing.",
+    "tokens": ["cabezon", "groundfish", "no", "minimum", "size", "limit", "daily", "bag", "10", "rcg", "complex", "rockfish", "greenling", "section"],
     "species_or_category_terms": ["cabezon"],
     "location_terms": []
   },

data/source-cache/seed/facts.json

@@ -4,7 +4,9 @@
       "id": "lingcod_min_size",
       "species_or_category": "lingcod",
       "display_name": "Lingcod",
-      "aliases": ["ling cod"],
+      "aliases": [
+        "ling cod"
+      ],
       "area_or_scope": "California ocean statewide groundfish regulations",
       "fact_type": "minimum_size",
       "value": "22",
@@ -20,7 +22,9 @@
       "id": "lingcod_bag_limit",
       "species_or_category": "lingcod",
       "display_name": "Lingcod",
-      "aliases": ["ling cod"],
+      "aliases": [
+        "ling cod"
+      ],
       "area_or_scope": "California ocean statewide groundfish regulations",
       "fact_type": "bag_limit",
       "value": "2",
@@ -32,11 +36,52 @@
       "supporting_snippet": "Lingcod, section 28.27, daily bag limit is 2 fish per person. Minimum size limit is 22 inches total length.",
       "validation_set": true
     },
+    {
+      "id": "cabezon_min_size",
+      "species_or_category": "cabezon",
+      "display_name": "Cabezon",
+      "aliases": [
+        "cabazon",
+        "cabezone"
+      ],
+      "area_or_scope": "California ocean statewide groundfish regulations",
+      "fact_type": "minimum_size",
+      "value": "no minimum size limit",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-14T12:00:00+00:00",
+      "supporting_chunk_id": "chunk_cabezon_groundfish",
+      "supporting_snippet": "Cabezon, section 28.28, has no minimum size limit. The daily bag limit is 10 fish in combination per person as part of the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate.",
+      "validation_set": true
+    },
+    {
+      "id": "cabezon_bag_limit",
+      "species_or_category": "cabezon",
+      "display_name": "Cabezon",
+      "aliases": [
+        "cabazon",
+        "cabezone"
+      ],
+      "area_or_scope": "California ocean statewide groundfish regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish per person in the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate",
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-14T12:00:00+00:00",
+      "supporting_chunk_id": "chunk_cabezon_groundfish",
+      "supporting_snippet": "Cabezon, section 28.28, has no minimum size limit. The daily bag limit is 10 fish in combination per person as part of the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate.",
+      "validation_set": true
+    },
     {
       "id": "dungeness_crab_bag_limit",
       "species_or_category": "dungeness_crab",
       "display_name": "Dungeness crab",
-      "aliases": ["dungeness crabs", "crab"],
+      "aliases": [
+        "dungeness crabs",
+        "crab"
+      ],
       "area_or_scope": "California recreational crab fishery",
       "fact_type": "general_summary",
       "value": "Verify current CDFW Dungeness crab season, trap/hoop-net rules, public health closures, and crab rules before harvest.",
@@ -46,6 +91,1908 @@
       "supporting_chunk_id": "chunk_dungeness_crab",
       "supporting_snippet": "CDFW recreational crab fishery materials link Dungeness crab season, crab trap, hoop net, public health closure, and current recreational ocean fishing regulation information.",
       "validation_set": true
+    },
+    {
+      "id": "rockfish_min_size",
+      "species_or_category": "rockfish",
+      "display_name": "Rockfish",
+      "aliases": [
+        "rcg complex",
+        "rock fish"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "no minimum size limit",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Rockfishes (RCG Complex): No minimum size limit.",
+      "validation_set": true
+    },
+    {
+      "id": "rockfish_bag_limit",
+      "species_or_category": "rockfish",
+      "display_name": "Rockfish",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish per person in the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate, with sub-limits: copper rockfish 1; vermilion/sunset rockfish 4 in the Northern Management Area and 2 elsewhere; canary rockfish 2",
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "10 fish in combination per person, except: Copper rockfish: 1 fish per person; Vermilion/sunset rockfish: 4 (Northern) / 2 (other areas); Canary rockfish: 2 fish per person.",
+      "validation_set": true
+    },
+    {
+      "id": "greenlings_min_size",
+      "species_or_category": "greenlings",
+      "display_name": "Kelp and rock greenling",
+      "aliases": [
+        "greenling",
+        "kelp greenling",
+        "rock greenling"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "no minimum size limit",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Greenlings (RCG Complex): No minimum size limit.",
+      "validation_set": true
+    },
+    {
+      "id": "greenlings_bag_limit",
+      "species_or_category": "greenlings",
+      "display_name": "Kelp and rock greenling",
+      "aliases": [
+        "greenling"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish per person in the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate",
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Greenlings are part of the RCG Complex aggregate of 10 fish in combination per person.",
+      "validation_set": true
+    },
+    {
+      "id": "cabezon_season_sf",
+      "species_or_category": "cabezon",
+      "display_name": "Cabezon",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from April 1 through December 31 at all depths, and closed January 1 through March 31. These dates apply to the Northern, Mendocino, San Francisco, and Central management areas (the Southern area differs). Shore-based anglers and spear divers are exempt from seasons and depth limits. Verify current in-season depth changes.",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Jan 1 - Mar 31: Closed - unlawful to possess in all waters; Apr 1 - Dec 31: Open all depths. Shore-based anglers and spear divers are exempt from seasons and depths.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2026-04-01",
+      "effective_end": "2026-12-31"
+    },
+    {
+      "id": "lingcod_season_sf",
+      "species_or_category": "lingcod",
+      "display_name": "Lingcod",
+      "aliases": [
+        "ling cod"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from April 1 through December 31 at all depths, and closed January 1 through March 31. These dates apply to the Northern, Mendocino, San Francisco, and Central management areas (the Southern area differs). Shore-based anglers and spear divers are exempt from seasons and depth limits. Verify current in-season depth changes.",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Jan 1 - Mar 31: Closed - unlawful to possess in all waters; Apr 1 - Dec 31: Open all depths. Shore-based anglers and spear divers are exempt from seasons and depths.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2026-04-01",
+      "effective_end": "2026-12-31"
+    },
+    {
+      "id": "rockfish_season_sf",
+      "species_or_category": "rockfish",
+      "display_name": "Rockfish",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from April 1 through December 31 at all depths, and closed January 1 through March 31. These dates apply to the Northern, Mendocino, San Francisco, and Central management areas (the Southern area differs). Shore-based anglers and spear divers are exempt from seasons and depth limits. Verify current in-season depth changes.",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Jan 1 - Mar 31: Closed - unlawful to possess in all waters; Apr 1 - Dec 31: Open all depths. Shore-based anglers and spear divers are exempt from seasons and depths.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2026-04-01",
+      "effective_end": "2026-12-31"
+    },
+    {
+      "id": "greenlings_season_sf",
+      "species_or_category": "greenlings",
+      "display_name": "Kelp and rock greenling",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from April 1 through December 31 at all depths, and closed January 1 through March 31. These dates apply to the Northern, Mendocino, San Francisco, and Central management areas (the Southern area differs). Shore-based anglers and spear divers are exempt from seasons and depth limits. Verify current in-season depth changes.",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Jan 1 - Mar 31: Closed - unlawful to possess in all waters; Apr 1 - Dec 31: Open all depths. Shore-based anglers and spear divers are exempt from seasons and depths.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2026-04-01",
+      "effective_end": "2026-12-31"
+    },
+    {
+      "id": "yelloweye_rockfish_no_retention",
+      "species_or_category": "yelloweye_rockfish",
+      "display_name": "Yelloweye rockfish",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "No retention at any time; may not be taken or possessed (zero fish per person).",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed in California - no retention at any time, zero fish per person.",
+      "validation_set": true
+    },
+    {
+      "id": "quillback_rockfish_no_retention",
+      "species_or_category": "quillback_rockfish",
+      "display_name": "Quillback rockfish",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "No retention at any time; may not be taken or possessed (zero fish per person).",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person.",
+      "validation_set": true
+    },
+    {
+      "id": "cowcod_no_retention",
+      "species_or_category": "cowcod",
+      "display_name": "Cowcod",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "No retention at any time; may not be taken or possessed (zero fish per person).",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person.",
+      "validation_set": true
+    },
+    {
+      "id": "bronzespotted_rockfish_no_retention",
+      "species_or_category": "bronzespotted_rockfish",
+      "display_name": "Bronzespotted rockfish",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "No retention at any time; may not be taken or possessed (zero fish per person).",
+      "units": null,
+      "source_id": "cdfw_groundfish_summary",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person.",
+      "validation_set": true
+    },
+    {
+      "id": "flatfish_bag_limit",
+      "species_or_category": "flatfish",
+      "display_name": "Pacific sanddab and other flatfish",
+      "aliases": [
+        "sanddab",
+        "petrale sole",
+        "starry flounder"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(sanddabs, petrale sole, and starry flounder)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: ... sanddabs ... petrale sole and starry flounder. (CCR T14 27.60(b))",
+      "validation_set": true
+    },
+    {
+      "id": "jacksmelt_topsmelt_bag_limit",
+      "species_or_category": "jacksmelt_topsmelt",
+      "display_name": "Jacksmelt and topsmelt",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(jacksmelt and topsmelt)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: ... jacksmelt, topsmelt ... (CCR T14 27.60(b))",
+      "validation_set": true
+    },
+    {
+      "id": "california_halibut_min_size",
+      "species_or_category": "california_halibut",
+      "display_name": "California halibut",
+      "aliases": [
+        "halibut",
+        "ca halibut"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "22",
+      "units": "inches total length",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California halibut ... 22 inches total length.",
+      "validation_set": true
+    },
+    {
+      "id": "california_halibut_bag_limit",
+      "species_or_category": "california_halibut",
+      "display_name": "California halibut",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "2",
+      "units": "fish (north of Point Sur, which includes the San Francisco area; the limit differs south of Point Sur)",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California halibut ... two fish north of Point Sur ... remains open year-round.",
+      "validation_set": true
+    },
+    {
+      "id": "pacific_halibut_min_size",
+      "species_or_category": "pacific_halibut",
+      "display_name": "Pacific halibut",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "no minimum size limit",
+      "units": null,
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Conservation/Marine/Pacific-Halibut",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no minimum size limit. The daily bag and possession limit for Pacific halibut is one fish.",
+      "validation_set": true
+    },
+    {
+      "id": "pacific_halibut_bag_limit",
+      "species_or_category": "pacific_halibut",
+      "display_name": "Pacific halibut",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "1",
+      "units": "fish per day",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Conservation/Marine/Pacific-Halibut",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The daily bag and possession limit for Pacific halibut is one fish.",
+      "validation_set": true
+    },
+    {
+      "id": "pacific_halibut_season",
+      "species_or_category": "pacific_halibut",
+      "display_name": "Pacific halibut",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from April 1 for the 2026 season; it stays open until November 15 north of Point Arena and through December 31 south of Point Arena, or until the quota is reached. Verify current status.",
+      "units": null,
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Conservation/Marine/Pacific-Halibut",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The 2026 recreational Pacific halibut fishery opens April 1. North of Point Arena the fishery is open until November 15; south of Point Arena it is open through December 31.",
+      "validation_set": true,
+      "effective_start": "2026-04-01"
+    },
+    {
+      "id": "white_seabass_min_size",
+      "species_or_category": "white_seabass",
+      "display_name": "White seabass",
+      "aliases": [
+        "seabass",
+        "white sea bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "28",
+      "units": "inches total length (or 20 inches alternate length)",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "White Seabass ... 28 inches total length or 20 inches alternate length.",
+      "validation_set": true
+    },
+    {
+      "id": "white_seabass_bag_limit",
+      "species_or_category": "white_seabass",
+      "display_name": "White seabass",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "3",
+      "units": "fish (only one fish may be taken south of Point Conception between March 15 and June 15)",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "White Seabass ... three fish except that only one fish may be taken in waters south of Point Conception between March 15 and June 15.",
+      "validation_set": true
+    },
+    {
+      "id": "surfperch_min_size",
+      "species_or_category": "surfperch",
+      "display_name": "Surfperch",
+      "aliases": [
+        "surf perch",
+        "redtail surfperch"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "10½",
+      "units": "inches total length for redtail surfperch (most other surfperch have no minimum size limit)",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Redtail Surfperch ... Minimum Size: 10½ inches total length.",
+      "validation_set": true
+    },
+    {
+      "id": "surfperch_bag_limit",
+      "species_or_category": "surfperch",
+      "display_name": "Surfperch",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "20",
+      "units": "fish in combination of all species, with no more than 10 of any one species; shiner surfperch have a separate limit of 20",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "20 fish in combination of all species (except shiner perch), with not more than 10 fish of any one species ... Shiner Perch: separate bag and possession limit of 20 fish.",
+      "validation_set": true
+    },
+    {
+      "id": "leopard_shark_min_size",
+      "species_or_category": "leopard_shark",
+      "display_name": "Leopard shark",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "36",
+      "units": "inches total length",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Leopard Shark ... 36 inches total length ... open year-round, at all depths.",
+      "validation_set": true
+    },
+    {
+      "id": "leopard_shark_bag_limit",
+      "species_or_category": "leopard_shark",
+      "display_name": "Leopard shark",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "3",
+      "units": "fish",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Leopard Shark ... 3 fish ... open year-round, at all depths.",
+      "validation_set": true
+    },
+    {
+      "id": "state_managed_sharks_bag_limit",
+      "species_or_category": "state_managed_sharks",
+      "display_name": "State-managed sharks",
+      "aliases": [
+        "sharks",
+        "sevengill shark",
+        "mako shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "2",
+      "units": "fish per day for shortfin mako, common thresher, and blue shark (no size limit); sixgill and broadnose sevengill shark are limited to 1 fish per day",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The bag limits for shortfin mako shark, common thresher shark, and blue shark allow take of two fish per day with no size limit. The bag limits for sixgill shark and broadnose sevengill shark allow take of one fish per day with no size limit.",
+      "validation_set": true
+    },
+    {
+      "id": "white_sturgeon_retention",
+      "species_or_category": "white_sturgeon",
+      "display_name": "White sturgeon",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Catch-and-release only; no retention permitted (zero fish). White sturgeon greater than 60 inches fork length may not be removed from the water.",
+      "units": null,
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The White Sturgeon sport fishery is catch-and-release only. No harvest is permitted. White sturgeon greater than 60 inches fork length may not be removed from the water.",
+      "validation_set": true
+    },
+    {
+      "id": "green_sturgeon_retention",
+      "species_or_category": "green_sturgeon",
+      "display_name": "Green sturgeon",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Fully protected; no take. Green sturgeon must be released immediately and may not be removed from the water.",
+      "units": null,
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Green Sturgeon ... may not be removed from the water and must be released immediately.",
+      "validation_set": true
+    },
+    {
+      "id": "pacific_herring_bag_limit",
+      "species_or_category": "pacific_herring",
+      "display_name": "Pacific herring",
+      "aliases": [
+        "herring"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "gallons per day (approximately 100 lb or 520 fish)",
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Open year-round. Ten gallons of Pacific herring may be taken per day (approximately 100 lb. or 520 fish).",
+      "validation_set": true
+    },
+    {
+      "id": "tunas_season",
+      "species_or_category": "tunas",
+      "display_name": "Tunas",
+      "aliases": [
+        "tuna",
+        "albacore"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open year-round. Bag, possession, and size limits apply - verify current CDFW ocean sport fishing regulations.",
+      "units": null,
+      "source_id": "cdfw_region_san_francisco",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The recreational fishery for tunas is open year-round.",
+      "validation_set": true
+    },
+    {
+      "id": "rock_crab_bag_limit",
+      "species_or_category": "rock_crab",
+      "display_name": "Rock crab",
+      "aliases": [
+        "red rock crab",
+        "yellow rock crab",
+        "brown rock crab"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "35",
+      "units": "crab per day",
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The recreational fishery for all rock crab species is open year-round, statewide. The daily bag limit is 35 crab.",
+      "validation_set": true
+    },
+    {
+      "id": "rock_crab_min_size",
+      "species_or_category": "rock_crab",
+      "display_name": "Rock crab",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "4",
+      "units": "inches",
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "For all rock crab species ... the minimum size limit is 4 inches.",
+      "validation_set": true
+    },
+    {
+      "id": "rock_crab_season",
+      "species_or_category": "rock_crab",
+      "display_name": "Rock crab",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open year-round, statewide.",
+      "units": null,
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The recreational fishery for all rock crab species is open year-round, statewide.",
+      "validation_set": true
+    },
+    {
+      "id": "dungeness_crab_season_sf",
+      "species_or_category": "dungeness_crab",
+      "display_name": "Dungeness crab",
+      "aliases": [
+        "dungeness crabs"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from November 1, 2025 through June 30, 2026 in waters south of the Sonoma/Mendocino county line, which includes the San Francisco area. North of that line the season is open from November 1, 2025 through July 30, 2026. The 2025-26 opener was delayed by domoic-acid and whale-entanglement closures; verify current CDFW openers and health advisories before harvest.",
+      "units": null,
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Dungeness Crab (south of the Sonoma/Mendocino county line): Open from November 1, 2025 through June 30, 2026.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2025-11-01",
+      "effective_end": "2026-06-30"
+    },
+    {
+      "id": "ocean_salmon_season_sf",
+      "species_or_category": "ocean_salmon",
+      "display_name": "Ocean salmon",
+      "aliases": [
+        "salmon"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open June 27 - July 22 and August 1 - 31 in the San Francisco zone (Point Arena to Pigeon Point) for the 2026 season; minimum size 20 inches total length (24 inches through May 15). Dates vary by zone and can change in-season; verify current CDFW salmon regulations.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Salmon",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Point Arena to Pigeon Point (San Francisco): June 27 - July 22, August 1 - 31.",
+      "validation_set": true,
+      "region_key": "san_francisco",
+      "effective_start": "2026-06-27"
+    },
+    {
+      "id": "red_abalone_closure",
+      "species_or_category": "red_abalone",
+      "display_name": "Red abalone",
+      "aliases": [
+        "abalone"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "The recreational red abalone fishery is closed; the closure was extended to 2036. All ocean waters are closed to the take of abalone (CCR T14 29.15).",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Abalone",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The poor condition of red abalone populations led the California Fish and Game Commission to close the fishery in 2018 ... the closure was extended to 2036 at the December, 2025 Commission meeting.",
+      "validation_set": true
+    },
+    {
+      "id": "purple_urchin_bag_limit",
+      "species_or_category": "purple_urchin",
+      "display_name": "Purple sea urchin",
+      "aliases": [
+        "sea urchin",
+        "purple urchin"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "35",
+      "units": "sea urchins per species per day (40 gallons when skin or SCUBA diving in Humboldt, Mendocino, and Sonoma counties); no possession limit (CCR T14 29.06)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The daily bag limit for sea urchin is 35 individuals for each species. The daily bag limit for purple sea urchin is forty (40) gallons when taken while skin or SCUBA diving in ocean waters of Humboldt, Mendocino, and Sonoma counties.",
+      "validation_set": true
+    },
+    {
+      "id": "kelp_plants_bag_limit",
+      "species_or_category": "kelp_plants",
+      "display_name": "Kelp and marine aquatic plants",
+      "aliases": [
+        "kelp",
+        "seaweed",
+        "marine plants"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "pounds wet weight in the aggregate per day for marine aquatic plants for which take is authorized (CCR T14 30.00)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "The daily bag limit on all marine aquatic plants for which the take is authorized ... is 10 pounds wet weight in the aggregate.",
+      "validation_set": true
+    },
+    {
+      "id": "sea_palm_closure",
+      "species_or_category": "sea_palm",
+      "display_name": "Sea palm",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Sea palm may not be cut or disturbed (protected; CCR T14 30.10).",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No eel grass (Zostera), surf grass (Phyllospadix) or sea palm (Postelsia) may be cut or disturbed.",
+      "validation_set": true
+    },
+    {
+      "id": "eelgrass_surfgrass_closure",
+      "species_or_category": "eelgrass_surfgrass",
+      "display_name": "Eelgrass and surfgrass",
+      "aliases": [
+        "eelgrass",
+        "surfgrass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Eelgrass and surfgrass may not be cut or disturbed (protected habitat; CCR T14 30.10).",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No eel grass (Zostera), surf grass (Phyllospadix) or sea palm (Postelsia) may be cut or disturbed.",
+      "validation_set": true
+    },
+    {
+      "id": "garibaldi_closure",
+      "species_or_category": "garibaldi",
+      "display_name": "Garibaldi",
+      "aliases": [],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Garibaldi may not be taken or possessed (protected; CCR T14 28.05).",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Garibaldi. May not be taken or possessed.",
+      "validation_set": true
+    },
+    {
+      "id": "dungeness_crab_daily_bag",
+      "species_or_category": "dungeness_crab",
+      "display_name": "Dungeness crab",
+      "aliases": [
+        "dungeness crabs"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "crab per day",
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Dungeness crab: the daily bag limit is 10 crab.",
+      "validation_set": true
+    },
+    {
+      "id": "dungeness_crab_min_size",
+      "species_or_category": "dungeness_crab",
+      "display_name": "Dungeness crab",
+      "aliases": [
+        "dungeness crabs"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "5¾",
+      "units": "inches",
+      "source_id": "cdfw_crabs",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Dungeness crab: the minimum size limit is 5¾ inches.",
+      "validation_set": true
+    },
+    {
+      "id": "kelp_bass_min_size",
+      "species_or_category": "kelp_bass",
+      "display_name": "Kelp bass",
+      "aliases": [
+        "calico bass",
+        "calico",
+        "kelp bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "14",
+      "units": "inches total length",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length.",
+      "validation_set": false
+    },
+    {
+      "id": "kelp_bass_bag_limit",
+      "species_or_category": "kelp_bass",
+      "display_name": "Kelp bass",
+      "aliases": [
+        "calico bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "5",
+      "units": "fish in any combination of kelp, barred sand, and spotted sand bass per day",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Five fish in any combination of species (kelp bass, barred sand bass, spotted sand bass).",
+      "validation_set": false
+    },
+    {
+      "id": "barred_sand_bass_min_size",
+      "species_or_category": "barred_sand_bass",
+      "display_name": "Barred sand bass",
+      "aliases": [
+        "sand bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "14",
+      "units": "inches total length",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length.",
+      "validation_set": false
+    },
+    {
+      "id": "barred_sand_bass_bag_limit",
+      "species_or_category": "barred_sand_bass",
+      "display_name": "Barred sand bass",
+      "aliases": [
+        "sand bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "5",
+      "units": "fish in any combination of kelp/barred sand/spotted sand bass, of which no more than 4 may be barred sand bass",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Five fish in any combination of species, except no more than 4 barred sand bass may be taken. The minimum size limit is 14 inches.",
+      "validation_set": false
+    },
+    {
+      "id": "spotted_sand_bass_min_size",
+      "species_or_category": "spotted_sand_bass",
+      "display_name": "Spotted sand bass",
+      "aliases": [
+        "spotted bay bass",
+        "spotty"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "14",
+      "units": "inches total length",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length.",
+      "validation_set": false
+    },
+    {
+      "id": "spotted_sand_bass_bag_limit",
+      "species_or_category": "spotted_sand_bass",
+      "display_name": "Spotted sand bass",
+      "aliases": [
+        "spotted bay bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "5",
+      "units": "fish in any combination of kelp/barred sand/spotted sand bass per day",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Five fish in any combination of species (kelp bass, barred sand bass, spotted sand bass).",
+      "validation_set": false
+    },
+    {
+      "id": "california_sheephead_min_size",
+      "species_or_category": "california_sheephead",
+      "display_name": "California sheephead",
+      "aliases": [
+        "sheephead",
+        "sheepshead"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "12",
+      "units": "inches total length",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California sheephead: 2 fish, with a minimum size limit of 12 inches total length.",
+      "validation_set": false
+    },
+    {
+      "id": "california_sheephead_bag_limit",
+      "species_or_category": "california_sheephead",
+      "display_name": "California sheephead",
+      "aliases": [
+        "sheephead"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "2",
+      "units": "fish per day",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California sheephead: 2 fish, with a minimum size limit of 12 inches total length.",
+      "validation_set": false
+    },
+    {
+      "id": "california_barracuda_min_size",
+      "species_or_category": "california_barracuda",
+      "display_name": "California barracuda",
+      "aliases": [
+        "barracuda",
+        "pacific barracuda"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "28",
+      "units": "inches total length (or 17 inches alternate length)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California barracuda minimum size: twenty-eight inches total length or seventeen inches alternate length (CCR T14 28.25).",
+      "validation_set": false
+    },
+    {
+      "id": "pacific_bonito_min_size",
+      "species_or_category": "pacific_bonito",
+      "display_name": "Pacific bonito",
+      "aliases": [
+        "bonito"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "24",
+      "units": "inches fork length or 5 pounds, except up to 5 smaller fish may be taken",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Pacific bonito minimum size: twenty-four inches fork length or five pounds, except that five fish less than twenty-four inches or five pounds may be taken (CCR T14 28.32).",
+      "validation_set": false
+    },
+    {
+      "id": "pacific_bonito_bag_limit",
+      "species_or_category": "pacific_bonito",
+      "display_name": "Pacific bonito",
+      "aliases": [
+        "bonito"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Pacific bonito limit: ten (CCR T14 28.32).",
+      "validation_set": false
+    },
+    {
+      "id": "california_yellowtail_min_size",
+      "species_or_category": "california_yellowtail",
+      "display_name": "California yellowtail",
+      "aliases": [
+        "yellowtail"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "24",
+      "units": "inches fork length, except up to 5 smaller fish may be taken",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California yellowtail: the minimum size limit is 24 inches fork length, except that up to five fish less than 24 inches fork length may be taken.",
+      "validation_set": false
+    },
+    {
+      "id": "california_yellowtail_bag_limit",
+      "species_or_category": "california_yellowtail",
+      "display_name": "California yellowtail",
+      "aliases": [
+        "yellowtail"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish per day",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California yellowtail: ten fish.",
+      "validation_set": false
+    },
+    {
+      "id": "ocean_whitefish_min_size",
+      "species_or_category": "ocean_whitefish",
+      "display_name": "Ocean whitefish",
+      "aliases": [
+        "whitefish"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "no minimum size limit",
+      "units": null,
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Ocean whitefish: 10 fish within the general daily bag limit of 20 fish total, with no minimum size limit.",
+      "validation_set": false
+    },
+    {
+      "id": "ocean_whitefish_bag_limit",
+      "species_or_category": "ocean_whitefish",
+      "display_name": "Ocean whitefish",
+      "aliases": [
+        "whitefish"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish within the general daily bag limit of 20 finfish total",
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Ocean whitefish: 10 fish within the general daily bag limit of 20 fish total.",
+      "validation_set": false
+    },
+    {
+      "id": "california_grunion_season",
+      "species_or_category": "california_grunion",
+      "display_name": "California grunion",
+      "aliases": [
+        "grunion"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open to take by hand only, except closed (no take) from April 1 through June 30.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "It shall be unlawful to take grunion from April 1 through June 30 (CCR T14 28.00).",
+      "validation_set": false,
+      "effective_start": "2026-04-01",
+      "effective_end": "2026-06-30"
+    },
+    {
+      "id": "california_grunion_bag_limit",
+      "species_or_category": "california_grunion",
+      "display_name": "California grunion",
+      "aliases": [
+        "grunion"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "30",
+      "units": "fish per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California grunion limit: 30 (CCR T14 28.00).",
+      "validation_set": false
+    },
+    {
+      "id": "giant_sea_bass_closure",
+      "species_or_category": "giant_sea_bass",
+      "display_name": "Giant sea bass",
+      "aliases": [
+        "black sea bass",
+        "giant black sea bass"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Giant sea bass may not be taken off California; fish taken incidental to other fishing must be immediately returned to the water (CCR T14 28.10).",
+      "validation_set": false
+    },
+    {
+      "id": "northern_anchovy_bag_limit",
+      "species_or_category": "northern_anchovy",
+      "display_name": "Northern anchovy",
+      "aliases": [
+        "anchovy",
+        "anchovies"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "pacific_sardine_bag_limit",
+      "species_or_category": "pacific_sardine",
+      "display_name": "Pacific sardine",
+      "aliases": [
+        "sardine",
+        "sardines"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "pacific_mackerel_bag_limit",
+      "species_or_category": "pacific_mackerel",
+      "display_name": "Pacific mackerel",
+      "aliases": [
+        "mackerel",
+        "spanish mackerel"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "jack_mackerel_bag_limit",
+      "species_or_category": "jack_mackerel",
+      "display_name": "Jack mackerel",
+      "aliases": [
+        "jack mackerel"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "queenfish_bag_limit",
+      "species_or_category": "queenfish",
+      "display_name": "Queenfish",
+      "aliases": [
+        "queenfish",
+        "herring queenfish"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "pacific_butterfish_bag_limit",
+      "species_or_category": "pacific_butterfish",
+      "display_name": "Pacific butterfish (pompano)",
+      "aliases": [
+        "butterfish",
+        "pompano",
+        "pacific pompano"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(CCR T14 27.60(b))",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).",
+      "validation_set": false
+    },
+    {
+      "id": "white_croaker_bag_limit",
+      "species_or_category": "white_croaker",
+      "display_name": "White croaker",
+      "aliases": [
+        "white croaker",
+        "kingfish",
+        "tomcod"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "yellowfin_croaker_bag_limit",
+      "species_or_category": "yellowfin_croaker",
+      "display_name": "Yellowfin croaker",
+      "aliases": [
+        "yellowfin croaker"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "spotfin_croaker_bag_limit",
+      "species_or_category": "spotfin_croaker",
+      "display_name": "Spotfin croaker",
+      "aliases": [
+        "spotfin croaker"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "california_corbina_bag_limit",
+      "species_or_category": "california_corbina",
+      "display_name": "California corbina",
+      "aliases": [
+        "corbina",
+        "corvina"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "opaleye_bag_limit",
+      "species_or_category": "opaleye",
+      "display_name": "Opaleye",
+      "aliases": [
+        "opaleye",
+        "opal eye"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "halfmoon_bag_limit",
+      "species_or_category": "halfmoon",
+      "display_name": "Halfmoon",
+      "aliases": [
+        "halfmoon",
+        "blue perch",
+        "catalina blue perch"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "sargo_bag_limit",
+      "species_or_category": "sargo",
+      "display_name": "Sargo",
+      "aliases": [
+        "sargo",
+        "china croaker"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "spiny_dogfish_bag_limit",
+      "species_or_category": "spiny_dogfish",
+      "display_name": "Spiny dogfish",
+      "aliases": [
+        "spiny dogfish",
+        "dogfish",
+        "mud shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "skates_bag_limit",
+      "species_or_category": "skates",
+      "display_name": "Skates",
+      "aliases": [
+        "skate",
+        "skates",
+        "big skate",
+        "longnose skate"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "bat_ray_bag_limit",
+      "species_or_category": "bat_ray",
+      "display_name": "Bat ray",
+      "aliases": [
+        "bat ray",
+        "bat stingray"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "shovelnose_guitarfish_bag_limit",
+      "species_or_category": "shovelnose_guitarfish",
+      "display_name": "Shovelnose guitarfish",
+      "aliases": [
+        "guitarfish",
+        "shovelnose guitarfish",
+        "shovelnose shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "thornback_ray_bag_limit",
+      "species_or_category": "thornback_ray",
+      "display_name": "Thornback ray",
+      "aliases": [
+        "thornback",
+        "thornback ray"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "round_stingray_bag_limit",
+      "species_or_category": "round_stingray",
+      "display_name": "Round stingray",
+      "aliases": [
+        "round stingray",
+        "stingray",
+        "round ray"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "fish of any one species per day, within the general limit of 20 finfish in combination of all species (no species-specific minimum size limit; CCR T14 27.60)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).",
+      "validation_set": false
+    },
+    {
+      "id": "white_shark_closure",
+      "species_or_category": "white_shark",
+      "display_name": "White shark (great white)",
+      "aliases": [
+        "great white",
+        "white shark",
+        "great white shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_region_southern",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "White sharks may not be taken or possessed at any time (CCR T14 28.06; CDFW Southern region).",
+      "validation_set": false
+    },
+    {
+      "id": "gulf_grouper_closure",
+      "species_or_category": "gulf_grouper",
+      "display_name": "Gulf grouper",
+      "aliases": [
+        "gulf grouper"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Gulf grouper may not be taken or possessed (CCR T14 28.12).",
+      "validation_set": false
+    },
+    {
+      "id": "broomtail_grouper_closure",
+      "species_or_category": "broomtail_grouper",
+      "display_name": "Broomtail grouper",
+      "aliases": [
+        "broomtail grouper"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Broomtail grouper may not be taken or possessed (CCR T14 28.12).",
+      "validation_set": false
+    },
+    {
+      "id": "basking_shark_closure",
+      "species_or_category": "basking_shark",
+      "display_name": "Basking shark",
+      "aliases": [
+        "basking shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Basking sharks are prohibited from general retention in the U.S. West Coast HMS fishery (50 CFR 660.705).",
+      "validation_set": false
+    },
+    {
+      "id": "megamouth_shark_closure",
+      "species_or_category": "megamouth_shark",
+      "display_name": "Megamouth shark",
+      "aliases": [
+        "megamouth",
+        "megamouth shark"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Megamouth sharks are prohibited from general retention in the U.S. West Coast HMS fishery (50 CFR 660.705).",
+      "validation_set": false
+    },
+    {
+      "id": "california_spiny_lobster_min_size",
+      "species_or_category": "california_spiny_lobster",
+      "display_name": "California spiny lobster",
+      "aliases": [
+        "spiny lobster"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "3¼",
+      "units": "inches carapace (straight line on the mid-line of the back, rear of eye socket to rear of body shell)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California spiny lobster minimum size: 3 and 1/4 inches measured on the mid-line of the back from the rear edge of the eye socket to the rear edge of the body shell (CCR T14 29.90).",
+      "validation_set": false
+    },
+    {
+      "id": "california_spiny_lobster_bag_limit",
+      "species_or_category": "california_spiny_lobster",
+      "display_name": "California spiny lobster",
+      "aliases": [
+        "spiny lobster"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "7",
+      "units": "lobster per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "California spiny lobster daily bag limit: seven (CCR T14 29.90).",
+      "validation_set": false
+    },
+    {
+      "id": "california_spiny_lobster_season",
+      "species_or_category": "california_spiny_lobster",
+      "display_name": "California spiny lobster",
+      "aliases": [
+        "spiny lobster"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "season",
+      "value": "open from 6:00 p.m. on the Friday preceding the first Wednesday in October through the first Wednesday after the 15th of March.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Open season: from 6:00 p.m. on the Friday before the first Wednesday in October through the first Wednesday after the 15th of March (CCR T14 29.90).",
+      "validation_set": false
+    },
+    {
+      "id": "rock_scallop_bag_limit",
+      "species_or_category": "rock_scallop",
+      "display_name": "Rock scallop",
+      "aliases": [
+        "rock scallop",
+        "scallop",
+        "scallops"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "scallops per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Rock scallop limit: ten (CCR T14 29.60).",
+      "validation_set": false
+    },
+    {
+      "id": "speckled_scallop_closure",
+      "species_or_category": "speckled_scallop",
+      "display_name": "Speckled (bay) scallop",
+      "aliases": [
+        "bay scallop",
+        "speckled scallop"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "closure",
+      "value": "Take and possession prohibited in California ocean waters; may not be taken or possessed.",
+      "units": null,
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Speckled (bay) scallops may not be taken or possessed (CCR T14 29.65).",
+      "validation_set": false
+    },
+    {
+      "id": "market_squid_bag_limit",
+      "species_or_category": "market_squid",
+      "display_name": "Market squid",
+      "aliases": [
+        "squid",
+        "calamari",
+        "market squid"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "no daily bag limit",
+      "units": "(may be taken with hand-held dip nets)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Squid may be taken with hand-held dip nets. There is no limit (CCR T14 29.70).",
+      "validation_set": false
+    },
+    {
+      "id": "kellets_whelk_bag_limit",
+      "species_or_category": "kellets_whelk",
+      "display_name": "Kellet's whelk",
+      "aliases": [
+        "whelk",
+        "kellets whelk",
+        "kellet's whelk"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "35",
+      "units": "whelks per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Kellet's whelk: 35 whelks; season July 1 through the first Wednesday after the 15th of March (CCR T14 29.17, 29.05).",
+      "validation_set": false
+    },
+    {
+      "id": "octopus_bag_limit",
+      "species_or_category": "octopus",
+      "display_name": "Octopus",
+      "aliases": [
+        "octopus",
+        "octopuses",
+        "octopi"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "35",
+      "units": "octopus per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Octopus: 35 octopus, year round (CCR T14 29.05).",
+      "validation_set": false
+    },
+    {
+      "id": "native_oyster_bag_limit",
+      "species_or_category": "native_oyster",
+      "display_name": "Native oyster",
+      "aliases": [
+        "oyster",
+        "oysters",
+        "native oyster"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "35",
+      "units": "oysters per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Oysters, all: 35 oysters, year round (CCR T14 29.05).",
+      "validation_set": false
+    },
+    {
+      "id": "ghost_shrimp_bag_limit",
+      "species_or_category": "ghost_shrimp",
+      "display_name": "Ghost shrimp and blue mud shrimp",
+      "aliases": [
+        "ghost shrimp",
+        "mud shrimp",
+        "blue mud shrimp"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "50",
+      "units": "in combination per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Ghost shrimp and blue mud shrimp limit: fifty in combination (CCR T14 29.87).",
+      "validation_set": false
+    },
+    {
+      "id": "coonstripe_shrimp_bag_limit",
+      "species_or_category": "coonstripe_shrimp",
+      "display_name": "Coonstripe shrimp",
+      "aliases": [
+        "coonstripe shrimp"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "20",
+      "units": "pounds in the shell, heads on, per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Coonstripe shrimp: twenty pounds (in the shell, heads on) (CCR T14 29.88).",
+      "validation_set": false
+    },
+    {
+      "id": "sand_crab_bag_limit",
+      "species_or_category": "sand_crab",
+      "display_name": "Sand crab (mole crab)",
+      "aliases": [
+        "sand crab",
+        "mole crab",
+        "sand crabs"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "50",
+      "units": "per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Sand crabs (Emerita analoga): fifty (CCR T14 29.85).",
+      "validation_set": false
+    },
+    {
+      "id": "gaper_clam_bag_limit",
+      "species_or_category": "gaper_clam",
+      "display_name": "Gaper clam (horseneck clam)",
+      "aliases": [
+        "gaper clam",
+        "horseneck clam",
+        "horse clam"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "of each species per day (Humboldt Bay: 50 in combination, max 25 gaper; Elkhorn Slough: 12 in combination)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Gaper/horseneck clams: limit ten of each species, except in Humboldt Bay fifty in combination (no more than 25 gaper) and in Elkhorn Slough twelve in combination (CCR T14 29.25).",
+      "validation_set": false
+    },
+    {
+      "id": "geoduck_clam_bag_limit",
+      "species_or_category": "geoduck_clam",
+      "display_name": "Geoduck clam",
+      "aliases": [
+        "geoduck",
+        "geoduck clam"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "3",
+      "units": "clams per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Geoduck clams: limit three; the first three dug must be retained as the bag limit (CCR T14 29.30).",
+      "validation_set": false
+    },
+    {
+      "id": "pismo_clam_min_size",
+      "species_or_category": "pismo_clam",
+      "display_name": "Pismo clam",
+      "aliases": [
+        "pismo clam"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "minimum_size",
+      "value": "5",
+      "units": "inches greatest diameter",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Pismo clams: minimum size five inches in greatest diameter; limit ten (CCR T14 29.40).",
+      "validation_set": false
+    },
+    {
+      "id": "pismo_clam_bag_limit",
+      "species_or_category": "pismo_clam",
+      "display_name": "Pismo clam",
+      "aliases": [
+        "pismo clam"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "10",
+      "units": "clams per day",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Pismo clams: limit ten (CCR T14 29.40).",
+      "validation_set": false
+    },
+    {
+      "id": "razor_clam_bag_limit",
+      "species_or_category": "razor_clam",
+      "display_name": "Razor clam",
+      "aliases": [
+        "razor clam",
+        "razor clams"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "20",
+      "units": "clams per day (the first 20 dug must be retained regardless of size or condition)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Razor clams: limit twenty; the first twenty dug must be retained as the bag limit (CCR T14 29.45).",
+      "validation_set": false
+    },
+    {
+      "id": "littleneck_clam_bag_limit",
+      "species_or_category": "littleneck_clam",
+      "display_name": "Littleneck, cockle, and softshell clams",
+      "aliases": [
+        "littleneck clam",
+        "cockle",
+        "softshell clam",
+        "soft-shell clam",
+        "quahog",
+        "chione"
+      ],
+      "area_or_scope": "California ocean sport fishing regulations",
+      "fact_type": "bag_limit",
+      "value": "50",
+      "units": "in combination per day (minimum size 1½ inches, except no size limit for soft-shell clams)",
+      "source_id": "cdfw_ocean_regulations",
+      "source_url": "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs",
+      "retrieved_at": "2026-06-15T12:00:00+00:00",
+      "supporting_chunk_id": "",
+      "supporting_snippet": "Littleneck clams, soft-shell clams, chiones, northern quahogs and cockles: limit fifty in combination; minimum size one and one-half inches, except no size limit for soft-shell clams (CCR T14 29.35).",
+      "validation_set": false
     }
   ],
   "advisory_facts": [

requirements.txt

@@ -1,3 +1,5 @@
 gradio>=6.0
 pytest>=8.0
 Pillow>=10.0
+# Optional: in-process MiniCPM GGUF interpreter (COASTWISE_LOCAL_MODEL=1)
+llama-cpp-python>=0.3

scripts/seed_expand.py

@@ -0,0 +1,270 @@
+"""One-shot seed expansion: append source-verified structured facts.
+
+Every value here was verified against the cited official CDFW/CCR page during
+the 2026-06-15 research pass. species_or_category uses the curated RULE_CARD key
+so both the model and deterministic interpreters resolve to it.
+"""
+
+import json
+from pathlib import Path
+
+FACTS_PATH = Path("data/source-cache/seed/facts.json")
+
+GROUNDFISH = "cdfw_groundfish_summary"
+GROUNDFISH_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Groundfish-Summary"
+SF = "cdfw_region_san_francisco"
+SF_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/San-Francisco"
+OCEAN = "cdfw_ocean_regulations"
+GENERAL_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs"
+INVERT_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs"
+ABALONE_URL = "https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Abalone"
+SALMON_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Salmon"
+PHALIBUT_URL = "https://wildlife.ca.gov/Conservation/Marine/Pacific-Halibut"
+CRABS = "cdfw_crabs"
+CRABS_URL = "https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Crabs"
+NOW = "2026-06-15T12:00:00+00:00"
+
+RCG_SEASON = (
+    "open from April 1 through December 31 at all depths, and closed January 1 "
+    "through March 31. These dates apply to the Northern, Mendocino, San Francisco, "
+    "and Central management areas (the Southern area differs). Shore-based anglers "
+    "and spear divers are exempt from seasons and depth limits. Verify current "
+    "in-season depth changes."
+)
+RCG_SEASON_QUOTE = (
+    "Jan 1 - Mar 31: Closed - unlawful to possess in all waters; Apr 1 - Dec 31: "
+    "Open all depths. Shore-based anglers and spear divers are exempt from seasons "
+    "and depths."
+)
+
+
+def fact(
+    id, species, display, fact_type, value, *, units=None, source_id, source_url,
+    snippet, chunk="", region_key=None, aliases=(), eff_start=None, eff_end=None,
+):
+    entry = {
+        "id": id,
+        "species_or_category": species,
+        "display_name": display,
+        "aliases": list(aliases),
+        "area_or_scope": "California ocean sport fishing regulations",
+        "fact_type": fact_type,
+        "value": value,
+        "units": units,
+        "source_id": source_id,
+        "source_url": source_url,
+        "retrieved_at": NOW,
+        "supporting_chunk_id": chunk,
+        "supporting_snippet": snippet,
+        "validation_set": True,
+    }
+    if region_key:
+        entry["region_key"] = region_key
+    if eff_start:
+        entry["effective_start"] = eff_start
+    if eff_end:
+        entry["effective_end"] = eff_end
+    return entry
+
+
+NEW_FACTS = [
+    # --- RCG complex groundfish: rockfish + greenlings (cabezon/lingcod already seeded) ---
+    fact("rockfish_min_size", "rockfish", "Rockfish", "minimum_size", "no minimum size limit",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, aliases=["rcg complex", "rock fish"],
+         snippet="Rockfishes (RCG Complex): No minimum size limit."),
+    fact("rockfish_bag_limit", "rockfish", "Rockfish", "bag_limit", "10",
+         units="fish per person in the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate, with sub-limits: copper rockfish 1; vermilion/sunset rockfish 4 in the Northern Management Area and 2 elsewhere; canary rockfish 2",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL,
+         snippet="10 fish in combination per person, except: Copper rockfish: 1 fish per person; Vermilion/sunset rockfish: 4 (Northern) / 2 (other areas); Canary rockfish: 2 fish per person."),
+    fact("greenlings_min_size", "greenlings", "Kelp and rock greenling", "minimum_size", "no minimum size limit",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, aliases=["greenling", "kelp greenling", "rock greenling"],
+         snippet="Greenlings (RCG Complex): No minimum size limit."),
+    fact("greenlings_bag_limit", "greenlings", "Kelp and rock greenling", "bag_limit", "10",
+         units="fish per person in the Rockfish, Cabezon, and Greenling (RCG) Complex aggregate",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, aliases=["greenling"],
+         snippet="Greenlings are part of the RCG Complex aggregate of 10 fish in combination per person."),
+    # --- RCG complex season, scoped to the SF management area ---
+    fact("cabezon_season_sf", "cabezon", "Cabezon", "season", RCG_SEASON, region_key="san_francisco",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, snippet=RCG_SEASON_QUOTE,
+         eff_start="2026-04-01", eff_end="2026-12-31"),
+    fact("lingcod_season_sf", "lingcod", "Lingcod", "season", RCG_SEASON, region_key="san_francisco",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, snippet=RCG_SEASON_QUOTE,
+         eff_start="2026-04-01", eff_end="2026-12-31", aliases=["ling cod"]),
+    fact("rockfish_season_sf", "rockfish", "Rockfish", "season", RCG_SEASON, region_key="san_francisco",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, snippet=RCG_SEASON_QUOTE,
+         eff_start="2026-04-01", eff_end="2026-12-31"),
+    fact("greenlings_season_sf", "greenlings", "Kelp and rock greenling", "season", RCG_SEASON, region_key="san_francisco",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL, snippet=RCG_SEASON_QUOTE,
+         eff_start="2026-04-01", eff_end="2026-12-31"),
+    # --- No-retention rockfish exceptions (statewide closures) ---
+    fact("yelloweye_rockfish_no_retention", "yelloweye_rockfish", "Yelloweye rockfish", "closure",
+         "No retention at any time; may not be taken or possessed (zero fish per person).",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL,
+         snippet="Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed in California - no retention at any time, zero fish per person."),
+    fact("quillback_rockfish_no_retention", "quillback_rockfish", "Quillback rockfish", "closure",
+         "No retention at any time; may not be taken or possessed (zero fish per person).",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL,
+         snippet="Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person."),
+    fact("cowcod_no_retention", "cowcod", "Cowcod", "closure",
+         "No retention at any time; may not be taken or possessed (zero fish per person).",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL,
+         snippet="Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person."),
+    fact("bronzespotted_rockfish_no_retention", "bronzespotted_rockfish", "Bronzespotted rockfish", "closure",
+         "No retention at any time; may not be taken or possessed (zero fish per person).",
+         source_id=GROUNDFISH, source_url=GROUNDFISH_URL,
+         snippet="Bronzespotted Rockfish, Cowcod, Quillback Rockfish, and Yelloweye Rockfish may not be taken or possessed - no retention at any time, zero fish per person."),
+    # --- Flatfish & smelt: no daily bag limit (CCR 27.60(b)) ---
+    fact("flatfish_bag_limit", "flatfish", "Pacific sanddab and other flatfish", "bag_limit", "no daily bag limit",
+         units="(sanddabs, petrale sole, and starry flounder)", source_id=OCEAN, source_url=GENERAL_URL,
+         aliases=["sanddab", "petrale sole", "starry flounder"],
+         snippet="There is no limit on the following species: ... sanddabs ... petrale sole and starry flounder. (CCR T14 27.60(b))"),
+    fact("jacksmelt_topsmelt_bag_limit", "jacksmelt_topsmelt", "Jacksmelt and topsmelt", "bag_limit", "no daily bag limit",
+         units="(jacksmelt and topsmelt)", source_id=OCEAN, source_url=GENERAL_URL,
+         snippet="There is no limit on the following species: ... jacksmelt, topsmelt ... (CCR T14 27.60(b))"),
+    # --- California halibut ---
+    fact("california_halibut_min_size", "california_halibut", "California halibut", "minimum_size", "22",
+         units="inches total length", source_id=SF, source_url=SF_URL, aliases=["halibut", "ca halibut"],
+         snippet="California halibut ... 22 inches total length."),
+    fact("california_halibut_bag_limit", "california_halibut", "California halibut", "bag_limit", "2",
+         units="fish (north of Point Sur, which includes the San Francisco area; the limit differs south of Point Sur)",
+         source_id=SF, source_url=SF_URL,
+         snippet="California halibut ... two fish north of Point Sur ... remains open year-round."),
+    # --- Pacific halibut ---
+    fact("pacific_halibut_min_size", "pacific_halibut", "Pacific halibut", "minimum_size", "no minimum size limit",
+         source_id=SF, source_url=PHALIBUT_URL,
+         snippet="There is no minimum size limit. The daily bag and possession limit for Pacific halibut is one fish."),
+    fact("pacific_halibut_bag_limit", "pacific_halibut", "Pacific halibut", "bag_limit", "1", units="fish per day",
+         source_id=SF, source_url=PHALIBUT_URL,
+         snippet="The daily bag and possession limit for Pacific halibut is one fish."),
+    fact("pacific_halibut_season", "pacific_halibut", "Pacific halibut", "season",
+         "open from April 1 for the 2026 season; it stays open until November 15 north of Point Arena and through December 31 south of Point Arena, or until the quota is reached. Verify current status.",
+         source_id=SF, source_url=PHALIBUT_URL, eff_start="2026-04-01",
+         snippet="The 2026 recreational Pacific halibut fishery opens April 1. North of Point Arena the fishery is open until November 15; south of Point Arena it is open through December 31."),
+    # --- White seabass ---
+    fact("white_seabass_min_size", "white_seabass", "White seabass", "minimum_size", "28",
+         units="inches total length (or 20 inches alternate length)", source_id=SF, source_url=SF_URL,
+         aliases=["seabass", "white sea bass"],
+         snippet="White Seabass ... 28 inches total length or 20 inches alternate length."),
+    fact("white_seabass_bag_limit", "white_seabass", "White seabass", "bag_limit", "3",
+         units="fish (only one fish may be taken south of Point Conception between March 15 and June 15)",
+         source_id=SF, source_url=SF_URL,
+         snippet="White Seabass ... three fish except that only one fish may be taken in waters south of Point Conception between March 15 and June 15."),
+    # --- Surfperch (redtail size + general bag) ---
+    fact("surfperch_min_size", "surfperch", "Surfperch", "minimum_size", "10½",
+         units="inches total length for redtail surfperch (most other surfperch have no minimum size limit)",
+         source_id=SF, source_url=SF_URL, aliases=["surf perch", "redtail surfperch"],
+         snippet="Redtail Surfperch ... Minimum Size: 10½ inches total length."),
+    fact("surfperch_bag_limit", "surfperch", "Surfperch", "bag_limit", "20",
+         units="fish in combination of all species, with no more than 10 of any one species; shiner surfperch have a separate limit of 20",
+         source_id=SF, source_url=SF_URL,
+         snippet="20 fish in combination of all species (except shiner perch), with not more than 10 fish of any one species ... Shiner Perch: separate bag and possession limit of 20 fish."),
+    # --- Sharks ---
+    fact("leopard_shark_min_size", "leopard_shark", "Leopard shark", "minimum_size", "36",
+         units="inches total length", source_id=SF, source_url=SF_URL,
+         snippet="Leopard Shark ... 36 inches total length ... open year-round, at all depths."),
+    fact("leopard_shark_bag_limit", "leopard_shark", "Leopard shark", "bag_limit", "3", units="fish",
+         source_id=SF, source_url=SF_URL,
+         snippet="Leopard Shark ... 3 fish ... open year-round, at all depths."),
+    fact("state_managed_sharks_bag_limit", "state_managed_sharks", "State-managed sharks", "bag_limit", "2",
+         units="fish per day for shortfin mako, common thresher, and blue shark (no size limit); sixgill and broadnose sevengill shark are limited to 1 fish per day",
+         source_id=SF, source_url=SF_URL, aliases=["sharks", "sevengill shark", "mako shark"],
+         snippet="The bag limits for shortfin mako shark, common thresher shark, and blue shark allow take of two fish per day with no size limit. The bag limits for sixgill shark and broadnose sevengill shark allow take of one fish per day with no size limit."),
+    # --- Sturgeon (retention prohibited) ---
+    fact("white_sturgeon_retention", "white_sturgeon", "White sturgeon", "closure",
+         "Catch-and-release only; no retention permitted (zero fish). White sturgeon greater than 60 inches fork length may not be removed from the water.",
+         source_id=SF, source_url=SF_URL,
+         snippet="The White Sturgeon sport fishery is catch-and-release only. No harvest is permitted. White sturgeon greater than 60 inches fork length may not be removed from the water."),
+    fact("green_sturgeon_retention", "green_sturgeon", "Green sturgeon", "closure",
+         "Fully protected; no take. Green sturgeon must be released immediately and may not be removed from the water.",
+         source_id=SF, source_url=SF_URL,
+         snippet="Green Sturgeon ... may not be removed from the water and must be released immediately."),
+    # --- Pacific herring ---
+    fact("pacific_herring_bag_limit", "pacific_herring", "Pacific herring", "bag_limit", "10",
+         units="gallons per day (approximately 100 lb or 520 fish)", source_id=SF, source_url=SF_URL,
+         aliases=["herring"],
+         snippet="Open year-round. Ten gallons of Pacific herring may be taken per day (approximately 100 lb. or 520 fish)."),
+    # --- Tunas (year-round; numeric limits not fabricated) ---
+    fact("tunas_season", "tunas", "Tunas", "season",
+         "open year-round. Bag, possession, and size limits apply - verify current CDFW ocean sport fishing regulations.",
+         source_id=SF, source_url=SF_URL, aliases=["tuna", "albacore"],
+         snippet="The recreational fishery for tunas is open year-round."),
+    # --- Rock crab ---
+    fact("rock_crab_bag_limit", "rock_crab", "Rock crab", "bag_limit", "35", units="crab per day",
+         source_id=CRABS, source_url=SF_URL, aliases=["red rock crab", "yellow rock crab", "brown rock crab"],
+         snippet="The recreational fishery for all rock crab species is open year-round, statewide. The daily bag limit is 35 crab."),
+    fact("rock_crab_min_size", "rock_crab", "Rock crab", "minimum_size", "4", units="inches",
+         source_id=CRABS, source_url=SF_URL,
+         snippet="For all rock crab species ... the minimum size limit is 4 inches."),
+    fact("rock_crab_season", "rock_crab", "Rock crab", "season", "open year-round, statewide.",
+         source_id=CRABS, source_url=SF_URL,
+         snippet="The recreational fishery for all rock crab species is open year-round, statewide."),
+    # --- Dungeness crab bag + size (recreational) ---
+    fact("dungeness_crab_daily_bag", "dungeness_crab", "Dungeness crab", "bag_limit", "10", units="crab per day",
+         source_id=CRABS, source_url=SF_URL, aliases=["dungeness crabs"],
+         snippet="Dungeness crab: the daily bag limit is 10 crab."),
+    fact("dungeness_crab_min_size", "dungeness_crab", "Dungeness crab", "minimum_size", "5¾", units="inches",
+         source_id=CRABS, source_url=SF_URL, aliases=["dungeness crabs"],
+         snippet="Dungeness crab: the minimum size limit is 5¾ inches."),
+    # --- Dungeness crab season, SF / north-central area ---
+    fact("dungeness_crab_season_sf", "dungeness_crab", "Dungeness crab", "season",
+         "open from November 1, 2025 through June 30, 2026 in waters south of the Sonoma/Mendocino county line, which includes the San Francisco area. North of that line the season is open from November 1, 2025 through July 30, 2026. The 2025-26 opener was delayed by domoic-acid and whale-entanglement closures; verify current CDFW openers and health advisories before harvest.",
+         region_key="san_francisco", source_id=CRABS, source_url=SF_URL,
+         eff_start="2025-11-01", eff_end="2026-06-30", aliases=["dungeness crabs"],
+         snippet="Dungeness Crab (south of the Sonoma/Mendocino county line): Open from November 1, 2025 through June 30, 2026."),
+    # --- Ocean salmon, SF zone 2026 ---
+    fact("ocean_salmon_season_sf", "ocean_salmon", "Ocean salmon", "season",
+         "open June 27 - July 22 and August 1 - 31 in the San Francisco zone (Point Arena to Pigeon Point) for the 2026 season; minimum size 20 inches total length (24 inches through May 15). Dates vary by zone and can change in-season; verify current CDFW salmon regulations.",
+         region_key="san_francisco", source_id=OCEAN, source_url=SALMON_URL, aliases=["salmon"],
+         eff_start="2026-06-27",
+         snippet="Point Arena to Pigeon Point (San Francisco): June 27 - July 22, August 1 - 31."),
+    # --- Red abalone (closed) ---
+    fact("red_abalone_closure", "red_abalone", "Red abalone", "closure",
+         "The recreational red abalone fishery is closed; the closure was extended to 2036. All ocean waters are closed to the take of abalone (CCR T14 29.15).",
+         source_id=OCEAN, source_url=ABALONE_URL, aliases=["abalone"],
+         snippet="The poor condition of red abalone populations led the California Fish and Game Commission to close the fishery in 2018 ... the closure was extended to 2036 at the December, 2025 Commission meeting."),
+    # --- Purple sea urchin ---
+    fact("purple_urchin_bag_limit", "purple_urchin", "Purple sea urchin", "bag_limit", "35",
+         units="sea urchins per species per day (40 gallons when skin or SCUBA diving in Humboldt, Mendocino, and Sonoma counties); no possession limit (CCR T14 29.06)",
+         source_id=OCEAN, source_url=INVERT_URL, aliases=["sea urchin", "purple urchin"],
+         snippet="The daily bag limit for sea urchin is 35 individuals for each species. The daily bag limit for purple sea urchin is forty (40) gallons when taken while skin or SCUBA diving in ocean waters of Humboldt, Mendocino, and Sonoma counties."),
+    # --- Kelp / marine plants ---
+    fact("kelp_plants_bag_limit", "kelp_plants", "Kelp and marine aquatic plants", "bag_limit", "10",
+         units="pounds wet weight in the aggregate per day for marine aquatic plants for which take is authorized (CCR T14 30.00)",
+         source_id=OCEAN, source_url=INVERT_URL, aliases=["kelp", "seaweed", "marine plants"],
+         snippet="The daily bag limit on all marine aquatic plants for which the take is authorized ... is 10 pounds wet weight in the aggregate."),
+    # --- Protected plants & fish ---
+    fact("sea_palm_closure", "sea_palm", "Sea palm", "closure",
+         "Sea palm may not be cut or disturbed (protected; CCR T14 30.10).",
+         source_id=OCEAN, source_url=INVERT_URL,
+         snippet="No eel grass (Zostera), surf grass (Phyllospadix) or sea palm (Postelsia) may be cut or disturbed."),
+    fact("eelgrass_surfgrass_closure", "eelgrass_surfgrass", "Eelgrass and surfgrass", "closure",
+         "Eelgrass and surfgrass may not be cut or disturbed (protected habitat; CCR T14 30.10).",
+         source_id=OCEAN, source_url=INVERT_URL, aliases=["eelgrass", "surfgrass"],
+         snippet="No eel grass (Zostera), surf grass (Phyllospadix) or sea palm (Postelsia) may be cut or disturbed."),
+    fact("garibaldi_closure", "garibaldi", "Garibaldi", "closure",
+         "Garibaldi may not be taken or possessed (protected; CCR T14 28.05).",
+         source_id=OCEAN, source_url=GENERAL_URL,
+         snippet="Garibaldi. May not be taken or possessed."),
+    # Note: clams (and mussels) intentionally have no structured bag/size fact -
+    # clam/mussel questions route to the CDPH shellfish advisory, which is the
+    # correct food-safety answer; a bag-limit fact would be unreachable.
+]
+
+
+def main():
+    data = json.loads(FACTS_PATH.read_text())
+    by_id = {f["id"]: i for i, f in enumerate(data["structured_facts"])}
+    added = updated = 0
+    for entry in NEW_FACTS:
+        if entry["id"] in by_id:
+            data["structured_facts"][by_id[entry["id"]]] = entry
+            updated += 1
+        else:
+            data["structured_facts"].append(entry)
+            added += 1
+    FACTS_PATH.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    print(f"added {added}, updated {updated}; total now {len(data['structured_facts'])}")
+
+
+if __name__ == "__main__":
+    main()

scripts/seed_expand_statewide.py

@@ -0,0 +1,248 @@
+"""Phase-2 seed expansion: statewide CA ocean species (esp. Southern + inverts).
+
+Every value verified against the cited CDFW page or CCR Title 14 during the
+2026-06-15 research pass. Species without a curated rule card are detected via
+the fact alias index, so facts alone make them answerable.
+"""
+
+import json
+from pathlib import Path
+
+FACTS_PATH = Path("data/source-cache/seed/facts.json")
+
+SOUTH = "cdfw_region_southern"
+SOUTH_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Fishing-Map/Southern"
+OCEAN = "cdfw_ocean_regulations"
+GENERAL_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/General-Ocean-Fishing-Regs"
+INVERT_URL = "https://wildlife.ca.gov/Fishing/Ocean/Regulations/Sport-Fishing/Invertebrate-Fishing-Regs"
+NOW = "2026-06-15T12:00:00+00:00"
+
+GENERAL_BAG = "10"
+GENERAL_BAG_UNITS = (
+    "fish of any one species per day, within the general limit of 20 finfish in "
+    "combination of all species (no species-specific minimum size limit; CCR T14 27.60)"
+)
+NO_TAKE = "Take and possession prohibited in California ocean waters; may not be taken or possessed."
+
+
+def f(id, species, display, fact_type, value, *, units=None, source_id, source_url,
+      snippet, aliases=(), region_key=None, eff_start=None, eff_end=None):
+    entry = {
+        "id": id, "species_or_category": species, "display_name": display,
+        "aliases": list(aliases), "area_or_scope": "California ocean sport fishing regulations",
+        "fact_type": fact_type, "value": value, "units": units,
+        "source_id": source_id, "source_url": source_url, "retrieved_at": NOW,
+        "supporting_chunk_id": "", "supporting_snippet": snippet, "validation_set": False,
+    }
+    if region_key:
+        entry["region_key"] = region_key
+    if eff_start:
+        entry["effective_start"] = eff_start
+    if eff_end:
+        entry["effective_end"] = eff_end
+    return entry
+
+
+def general_limit(key, display, aliases):
+    return f(f"{key}_bag_limit", key, display, "bag_limit", GENERAL_BAG, units=GENERAL_BAG_UNITS,
+             source_id=OCEAN, source_url=GENERAL_URL, aliases=aliases,
+             snippet="No more than 20 finfish in combination of all species, with not more than 10 of any one species, may be taken or possessed (CCR T14 27.60).")
+
+
+def no_limit(key, display, aliases):
+    return f(f"{key}_bag_limit", key, display, "bag_limit", "no daily bag limit", units="(CCR T14 27.60(b))",
+             source_id=OCEAN, source_url=GENERAL_URL, aliases=aliases,
+             snippet="There is no limit on the following species: anchovy, jacksmelt, topsmelt, Pacific butterfish (pompano), queenfish, sanddabs, skipjack, jack mackerel, Pacific mackerel, ... Pacific sardine ... (CCR T14 27.60(b)).")
+
+
+def no_take(key, display, aliases, source_url=GENERAL_URL, source_id=OCEAN, snippet=None):
+    return f(f"{key}_closure", key, display, "closure", NO_TAKE, source_id=source_id, source_url=source_url,
+             aliases=aliases, snippet=snippet or f"{display}: may not be taken or possessed.")
+
+
+NEW = [
+    # --- Southern California bass complex (CCR 28.30 / Southern page) ---
+    f("kelp_bass_min_size", "kelp_bass", "Kelp bass", "minimum_size", "14", units="inches total length",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["calico bass", "calico", "kelp bass"],
+      snippet="Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length."),
+    f("kelp_bass_bag_limit", "kelp_bass", "Kelp bass", "bag_limit", "5",
+      units="fish in any combination of kelp, barred sand, and spotted sand bass per day",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["calico bass"],
+      snippet="Five fish in any combination of species (kelp bass, barred sand bass, spotted sand bass)."),
+    f("barred_sand_bass_min_size", "barred_sand_bass", "Barred sand bass", "minimum_size", "14", units="inches total length",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["sand bass"],
+      snippet="Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length."),
+    f("barred_sand_bass_bag_limit", "barred_sand_bass", "Barred sand bass", "bag_limit", "5",
+      units="fish in any combination of kelp/barred sand/spotted sand bass, of which no more than 4 may be barred sand bass",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["sand bass"],
+      snippet="Five fish in any combination of species, except no more than 4 barred sand bass may be taken. The minimum size limit is 14 inches."),
+    f("spotted_sand_bass_min_size", "spotted_sand_bass", "Spotted sand bass", "minimum_size", "14", units="inches total length",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["spotted bay bass", "spotty"],
+      snippet="Kelp bass, barred sand bass and spotted sand bass: the minimum size limit is 14 inches total length."),
+    f("spotted_sand_bass_bag_limit", "spotted_sand_bass", "Spotted sand bass", "bag_limit", "5",
+      units="fish in any combination of kelp/barred sand/spotted sand bass per day",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["spotted bay bass"],
+      snippet="Five fish in any combination of species (kelp bass, barred sand bass, spotted sand bass)."),
+    # --- California sheephead (Southern page) ---
+    f("california_sheephead_min_size", "california_sheephead", "California sheephead", "minimum_size", "12", units="inches total length",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["sheephead", "sheepshead"],
+      snippet="California sheephead: 2 fish, with a minimum size limit of 12 inches total length."),
+    f("california_sheephead_bag_limit", "california_sheephead", "California sheephead", "bag_limit", "2", units="fish per day",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["sheephead"],
+      snippet="California sheephead: 2 fish, with a minimum size limit of 12 inches total length."),
+    # --- California barracuda (CCR 28.25) ---
+    f("california_barracuda_min_size", "california_barracuda", "California barracuda", "minimum_size", "28",
+      units="inches total length (or 17 inches alternate length)",
+      source_id=OCEAN, source_url=GENERAL_URL, aliases=["barracuda", "pacific barracuda"],
+      snippet="California barracuda minimum size: twenty-eight inches total length or seventeen inches alternate length (CCR T14 28.25)."),
+    # --- Pacific bonito (CCR 28.32) ---
+    f("pacific_bonito_min_size", "pacific_bonito", "Pacific bonito", "minimum_size", "24",
+      units="inches fork length or 5 pounds, except up to 5 smaller fish may be taken",
+      source_id=OCEAN, source_url=GENERAL_URL, aliases=["bonito"],
+      snippet="Pacific bonito minimum size: twenty-four inches fork length or five pounds, except that five fish less than twenty-four inches or five pounds may be taken (CCR T14 28.32)."),
+    f("pacific_bonito_bag_limit", "pacific_bonito", "Pacific bonito", "bag_limit", "10", units="fish per day",
+      source_id=OCEAN, source_url=GENERAL_URL, aliases=["bonito"],
+      snippet="Pacific bonito limit: ten (CCR T14 28.32)."),
+    # --- California yellowtail (Southern page) ---
+    f("california_yellowtail_min_size", "california_yellowtail", "California yellowtail", "minimum_size", "24",
+      units="inches fork length, except up to 5 smaller fish may be taken",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["yellowtail"],
+      snippet="California yellowtail: the minimum size limit is 24 inches fork length, except that up to five fish less than 24 inches fork length may be taken."),
+    f("california_yellowtail_bag_limit", "california_yellowtail", "California yellowtail", "bag_limit", "10", units="fish per day",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["yellowtail"],
+      snippet="California yellowtail: ten fish."),
+    # --- Ocean whitefish (Southern page) ---
+    f("ocean_whitefish_min_size", "ocean_whitefish", "Ocean whitefish", "minimum_size", "no minimum size limit",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["whitefish"],
+      snippet="Ocean whitefish: 10 fish within the general daily bag limit of 20 fish total, with no minimum size limit."),
+    f("ocean_whitefish_bag_limit", "ocean_whitefish", "Ocean whitefish", "bag_limit", "10",
+      units="fish within the general daily bag limit of 20 finfish total",
+      source_id=SOUTH, source_url=SOUTH_URL, aliases=["whitefish"],
+      snippet="Ocean whitefish: 10 fish within the general daily bag limit of 20 fish total."),
+    # --- California grunion (CCR 28.00) ---
+    f("california_grunion_season", "california_grunion", "California grunion", "season",
+      "open to take by hand only, except closed (no take) from April 1 through June 30.",
+      source_id=OCEAN, source_url=GENERAL_URL, aliases=["grunion"], eff_start="2026-04-01", eff_end="2026-06-30",
+      snippet="It shall be unlawful to take grunion from April 1 through June 30 (CCR T14 28.00)."),
+    f("california_grunion_bag_limit", "california_grunion", "California grunion", "bag_limit", "30", units="fish per day",
+      source_id=OCEAN, source_url=GENERAL_URL, aliases=["grunion"],
+      snippet="California grunion limit: 30 (CCR T14 28.00)."),
+    # --- Giant (black) sea bass: no-take off California (CCR 28.10) ---
+    no_take("giant_sea_bass", "Giant sea bass", ["black sea bass", "giant black sea bass"],
+            snippet="Giant sea bass may not be taken off California; fish taken incidental to other fishing must be immediately returned to the water (CCR T14 28.10)."),
+    # --- No-limit baitfish/pelagics (CCR 27.60(b)) ---
+    no_limit("northern_anchovy", "Northern anchovy", ["anchovy", "anchovies"]),
+    no_limit("pacific_sardine", "Pacific sardine", ["sardine", "sardines"]),
+    no_limit("pacific_mackerel", "Pacific mackerel", ["mackerel", "spanish mackerel"]),
+    no_limit("jack_mackerel", "Jack mackerel", ["jack mackerel"]),
+    no_limit("queenfish", "Queenfish", ["queenfish", "herring queenfish"]),
+    no_limit("pacific_butterfish", "Pacific butterfish (pompano)", ["butterfish", "pompano", "pacific pompano"]),
+    # --- General-limit nearshore SoCal finfish (CCR 27.60) ---
+    general_limit("white_croaker", "White croaker", ["white croaker", "kingfish", "tomcod"]),
+    general_limit("yellowfin_croaker", "Yellowfin croaker", ["yellowfin croaker"]),
+    general_limit("spotfin_croaker", "Spotfin croaker", ["spotfin croaker"]),
+    general_limit("california_corbina", "California corbina", ["corbina", "corvina"]),
+    general_limit("opaleye", "Opaleye", ["opaleye", "opal eye"]),
+    general_limit("halfmoon", "Halfmoon", ["halfmoon", "blue perch", "catalina blue perch"]),
+    general_limit("sargo", "Sargo", ["sargo", "china croaker"]),
+    # --- Sharks / rays / skates ---
+    general_limit("spiny_dogfish", "Spiny dogfish", ["spiny dogfish", "dogfish", "mud shark"]),
+    general_limit("skates", "Skates", ["skate", "skates", "big skate", "longnose skate"]),
+    general_limit("bat_ray", "Bat ray", ["bat ray", "bat stingray"]),
+    general_limit("shovelnose_guitarfish", "Shovelnose guitarfish", ["guitarfish", "shovelnose guitarfish", "shovelnose shark"]),
+    general_limit("thornback_ray", "Thornback ray", ["thornback", "thornback ray"]),
+    general_limit("round_stingray", "Round stingray", ["round stingray", "stingray", "round ray"]),
+    no_take("white_shark", "White shark (great white)", ["great white", "white shark", "great white shark"],
+            source_id=SOUTH, source_url=SOUTH_URL,
+            snippet="White sharks may not be taken or possessed at any time (CCR T14 28.06; CDFW Southern region)."),
+    no_take("gulf_grouper", "Gulf grouper", ["gulf grouper"],
+            snippet="Gulf grouper may not be taken or possessed (CCR T14 28.12)."),
+    no_take("broomtail_grouper", "Broomtail grouper", ["broomtail grouper"],
+            snippet="Broomtail grouper may not be taken or possessed (CCR T14 28.12)."),
+    no_take("basking_shark", "Basking shark", ["basking shark"],
+            snippet="Basking sharks are prohibited from general retention in the U.S. West Coast HMS fishery (50 CFR 660.705)."),
+    no_take("megamouth_shark", "Megamouth shark", ["megamouth", "megamouth shark"],
+            snippet="Megamouth sharks are prohibited from general retention in the U.S. West Coast HMS fishery (50 CFR 660.705)."),
+    # --- Invertebrates ---
+    f("california_spiny_lobster_min_size", "california_spiny_lobster", "California spiny lobster", "minimum_size",
+      "3¼", units="inches carapace (straight line on the mid-line of the back, rear of eye socket to rear of body shell)",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["spiny lobster"],
+      snippet="California spiny lobster minimum size: 3 and 1/4 inches measured on the mid-line of the back from the rear edge of the eye socket to the rear edge of the body shell (CCR T14 29.90)."),
+    f("california_spiny_lobster_bag_limit", "california_spiny_lobster", "California spiny lobster", "bag_limit", "7", units="lobster per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["spiny lobster"],
+      snippet="California spiny lobster daily bag limit: seven (CCR T14 29.90)."),
+    f("california_spiny_lobster_season", "california_spiny_lobster", "California spiny lobster", "season",
+      "open from 6:00 p.m. on the Friday preceding the first Wednesday in October through the first Wednesday after the 15th of March.",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["spiny lobster"],
+      snippet="Open season: from 6:00 p.m. on the Friday before the first Wednesday in October through the first Wednesday after the 15th of March (CCR T14 29.90)."),
+    f("rock_scallop_bag_limit", "rock_scallop", "Rock scallop", "bag_limit", "10", units="scallops per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["rock scallop", "scallop", "scallops"],
+      snippet="Rock scallop limit: ten (CCR T14 29.60)."),
+    no_take("speckled_scallop", "Speckled (bay) scallop", ["bay scallop", "speckled scallop"],
+            source_id=OCEAN, source_url=INVERT_URL,
+            snippet="Speckled (bay) scallops may not be taken or possessed (CCR T14 29.65)."),
+    f("market_squid_bag_limit", "market_squid", "Market squid", "bag_limit", "no daily bag limit", units="(may be taken with hand-held dip nets)",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["squid", "calamari", "market squid"],
+      snippet="Squid may be taken with hand-held dip nets. There is no limit (CCR T14 29.70)."),
+    f("kellets_whelk_bag_limit", "kellets_whelk", "Kellet's whelk", "bag_limit", "35", units="whelks per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["whelk", "kellets whelk", "kellet's whelk"],
+      snippet="Kellet's whelk: 35 whelks; season July 1 through the first Wednesday after the 15th of March (CCR T14 29.17, 29.05)."),
+    f("octopus_bag_limit", "octopus", "Octopus", "bag_limit", "35", units="octopus per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["octopus", "octopuses", "octopi"],
+      snippet="Octopus: 35 octopus, year round (CCR T14 29.05)."),
+    f("native_oyster_bag_limit", "native_oyster", "Native oyster", "bag_limit", "35", units="oysters per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["oyster", "oysters", "native oyster"],
+      snippet="Oysters, all: 35 oysters, year round (CCR T14 29.05)."),
+    f("ghost_shrimp_bag_limit", "ghost_shrimp", "Ghost shrimp and blue mud shrimp", "bag_limit", "50", units="in combination per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["ghost shrimp", "mud shrimp", "blue mud shrimp"],
+      snippet="Ghost shrimp and blue mud shrimp limit: fifty in combination (CCR T14 29.87)."),
+    f("coonstripe_shrimp_bag_limit", "coonstripe_shrimp", "Coonstripe shrimp", "bag_limit", "20",
+      units="pounds in the shell, heads on, per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["coonstripe shrimp"],
+      snippet="Coonstripe shrimp: twenty pounds (in the shell, heads on) (CCR T14 29.88)."),
+    f("sand_crab_bag_limit", "sand_crab", "Sand crab (mole crab)", "bag_limit", "50", units="per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["sand crab", "mole crab", "sand crabs"],
+      snippet="Sand crabs (Emerita analoga): fifty (CCR T14 29.85)."),
+    # --- Distinct named clams (own CCR sections) ---
+    f("gaper_clam_bag_limit", "gaper_clam", "Gaper clam (horseneck clam)", "bag_limit", "10",
+      units="of each species per day (Humboldt Bay: 50 in combination, max 25 gaper; Elkhorn Slough: 12 in combination)",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["gaper clam", "horseneck clam", "horse clam"],
+      snippet="Gaper/horseneck clams: limit ten of each species, except in Humboldt Bay fifty in combination (no more than 25 gaper) and in Elkhorn Slough twelve in combination (CCR T14 29.25)."),
+    f("geoduck_clam_bag_limit", "geoduck_clam", "Geoduck clam", "bag_limit", "3", units="clams per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["geoduck", "geoduck clam"],
+      snippet="Geoduck clams: limit three; the first three dug must be retained as the bag limit (CCR T14 29.30)."),
+    f("pismo_clam_min_size", "pismo_clam", "Pismo clam", "minimum_size", "5", units="inches greatest diameter",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["pismo clam"],
+      snippet="Pismo clams: minimum size five inches in greatest diameter; limit ten (CCR T14 29.40)."),
+    f("pismo_clam_bag_limit", "pismo_clam", "Pismo clam", "bag_limit", "10", units="clams per day",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["pismo clam"],
+      snippet="Pismo clams: limit ten (CCR T14 29.40)."),
+    f("razor_clam_bag_limit", "razor_clam", "Razor clam", "bag_limit", "20",
+      units="clams per day (the first 20 dug must be retained regardless of size or condition)",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["razor clam", "razor clams"],
+      snippet="Razor clams: limit twenty; the first twenty dug must be retained as the bag limit (CCR T14 29.45)."),
+    f("littleneck_clam_bag_limit", "littleneck_clam", "Littleneck, cockle, and softshell clams", "bag_limit", "50",
+      units="in combination per day (minimum size 1½ inches, except no size limit for soft-shell clams)",
+      source_id=OCEAN, source_url=INVERT_URL, aliases=["littleneck clam", "cockle", "softshell clam", "soft-shell clam", "quahog", "chione"],
+      snippet="Littleneck clams, soft-shell clams, chiones, northern quahogs and cockles: limit fifty in combination; minimum size one and one-half inches, except no size limit for soft-shell clams (CCR T14 29.35)."),
+]
+
+
+def main():
+    data = json.loads(FACTS_PATH.read_text())
+    by_id = {f["id"]: i for i, f in enumerate(data["structured_facts"])}
+    added = updated = 0
+    for entry in NEW:
+        if entry["id"] in by_id:
+            data["structured_facts"][by_id[entry["id"]]] = entry
+            updated += 1
+        else:
+            data["structured_facts"].append(entry)
+            added += 1
+    FACTS_PATH.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    species = {f["species_or_category"] for f in data["structured_facts"]}
+    print(f"added {added}, updated {updated}; total facts {len(data['structured_facts'])}, distinct species {len(species)}")
+
+
+if __name__ == "__main__":
+    main()

tests/fixtures/real_user_queries.json

@@ -9,6 +9,24 @@
     "forbidden_answer_terms": [],
     "forbidden_direct_answer_concepts": ["dungeness_generic_fallback"]
   },
+  {
+    "query": "im in mandocino. is it legal to harvest dungenese crabs?",
+    "expected_species": "dungeness_crab",
+    "expected_place": "Mendocino",
+    "expected_statuses": ["answered", "partial"],
+    "required_source_terms": ["CDFW"],
+    "required_answer_terms": ["Dungeness crab"],
+    "forbidden_answer_terms": ["you may harvest", "legal to harvest", "definitely legal"],
+    "forbidden_direct_answer_concepts": ["dungeness_generic_fallback"],
+    "model_interpretation": {
+      "species_or_category": "dungeness_crab",
+      "location_name": "Mendocino",
+      "region_key": "mendocino",
+      "intent": "permission_status",
+      "requested_fact_types": ["season", "closure"],
+      "confidence": "high"
+    }
+  },
   {
     "query": "is mussel safe to eat?",
     "expected_species": "mussels",
@@ -50,7 +68,7 @@
     "query": "what are the restirctions on cabezone?",
     "expected_species": "cabezon",
     "expected_place": null,
-    "expected_statuses": ["partial"],
+    "expected_statuses": ["answered", "partial"],
     "required_source_terms": ["CDFW"],
     "required_answer_terms": ["cabezon"],
     "forbidden_answer_terms": ["authorized", "you may harvest"]
@@ -59,7 +77,7 @@
     "query": "what are the restrictions on cabezon?",
     "expected_species": "cabezon",
     "expected_place": null,
-    "expected_statuses": ["partial"],
+    "expected_statuses": ["answered", "partial"],
     "required_source_terms": ["CDFW"],
     "required_answer_terms": ["cabezon"],
     "forbidden_answer_terms": ["authorized", "you may harvest"]

tests/test_ai.py

@@ -1,9 +1,13 @@
 """Constrained generated explanation tests."""
 
+import json
 from datetime import date, datetime, timezone
 
 from coastwise.ai import (
+    build_hosted_interpreter,
+    build_local_interpreter,
     explain_safety_result,
+    interpret_question_with_model,
     synthesize_cached_evidence_answer,
     validate_cached_evidence_answer,
     validate_generated_text,
@@ -178,3 +182,310 @@ def test_cached_evidence_answer_falls_back_when_model_is_unavailable():
     assert explanation.fallback_used
     assert explanation.blocked_reason == "model_unavailable"
     assert "Rock crab" in explanation.text
+
+
+def test_model_interpreter_accepts_only_allowlisted_candidates():
+    prompts = []
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+        "notes": "Normalized spelling.",
+    }
+
+    result = interpret_question_with_model(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        allowed_species={"dungeness_crab", "lingcod"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino", "central"},
+        generator=lambda prompt: prompts.append(prompt) or json.dumps(payload),
+    )
+
+    assert result is not None
+    assert result.species_or_category == "dungeness_crab"
+    assert result.location_name == "Mendocino"
+    assert result.region_key == "mendocino"
+    assert result.intent.value == "permission_status"
+    assert [fact.value for fact in result.requested_fact_types] == ["season", "closure"]
+    assert 'allowed_locations={"Mendocino": "mendocino"}' in prompts[0]
+
+
+def test_model_interpreter_rejects_unknown_candidates_and_facts():
+    payload = {
+        "species_or_category": "maine_lobster",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+
+    result = interpret_question_with_model(
+        "can I harvest lobster in mendocino?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: json.dumps(payload),
+    )
+    unknown_fact_type = interpret_question_with_model(
+        "can I harvest crab in mendocino?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: json.dumps(
+            {
+                "species_or_category": "dungeness_crab",
+                "location_name": "Mendocino",
+                "region_key": "mendocino",
+                "intent": "permission_status",
+                "requested_fact_types": ["unknown"],
+                "confidence": "high",
+            }
+        ),
+    )
+
+    assert result is None
+    assert unknown_fact_type is None
+
+
+def test_model_interpreter_falls_back_on_invalid_json_or_low_confidence():
+    invalid = interpret_question_with_model(
+        "can I harvest crab?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: "not json",
+    )
+    low_confidence = interpret_question_with_model(
+        "can I harvest crab?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: json.dumps(
+            {
+                "species_or_category": "dungeness_crab",
+                "location_name": "Mendocino",
+                "region_key": "mendocino",
+                "intent": "permission_status",
+                "requested_fact_types": ["season"],
+                "confidence": "low",
+            }
+        ),
+    )
+    malformed_confidence = interpret_question_with_model(
+        "can I harvest crab?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: json.dumps(
+            {
+                "species_or_category": "dungeness_crab",
+                "location_name": "Mendocino",
+                "region_key": "mendocino",
+                "intent": "permission_status",
+                "requested_fact_types": ["season"],
+                "confidence": ["high"],
+            }
+        ),
+    )
+
+    assert invalid is None
+    assert low_confidence is None
+    assert malformed_confidence is None
+
+
+def test_build_hosted_interpreter_returns_none_without_api_key():
+    assert build_hosted_interpreter(api_key="") is None
+
+
+def test_hosted_interpreter_posts_openai_chat_and_returns_model_json():
+    calls = []
+
+    def fake_post(base_url, api_key, model, prompt, timeout):
+        calls.append((base_url, api_key, model, prompt, timeout))
+        return '{"species_or_category": "dungeness_crab"}'
+
+    generate = build_hosted_interpreter(
+        api_key="secret-key",
+        base_url="https://api.modelbest.cn/v1",
+        model="MiniCPM5-1B",
+        post=fake_post,
+    )
+    out = generate("interpret this question as JSON")
+
+    assert out == '{"species_or_category": "dungeness_crab"}'
+    assert len(calls) == 1
+    base_url, api_key, model, prompt, _timeout = calls[0]
+    assert base_url == "https://api.modelbest.cn/v1"
+    assert api_key == "secret-key"
+    assert model == "MiniCPM5-1B"
+    assert prompt == "interpret this question as JSON"
+
+
+def test_hosted_interpreter_extracts_json_from_fenced_or_prose_output():
+    fenced = build_hosted_interpreter(
+        api_key="k",
+        post=lambda *_a, **_k: '```json\n{"species_or_category": "lingcod"}\n```',
+    )
+    assert fenced("p") == '{"species_or_category": "lingcod"}'
+
+    prose = build_hosted_interpreter(
+        api_key="k",
+        post=lambda *_a, **_k: 'Sure: {"species_or_category": "lingcod"} hope this helps',
+    )
+    assert prose("p") == '{"species_or_category": "lingcod"}'
+
+
+def test_hosted_interpreter_fails_closed_on_transport_error_or_garbage():
+    def boom(*_a, **_k):
+        raise RuntimeError("network down")
+
+    assert build_hosted_interpreter(api_key="k", post=boom)("p") is None
+    assert build_hosted_interpreter(api_key="k", post=lambda *_a, **_k: "no json here")("p") is None
+
+
+def test_hosted_interpreter_output_drives_constrained_validation():
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+    }
+    generate = build_hosted_interpreter(
+        api_key="k",
+        post=lambda *_a, **_k: f"```json\n{json.dumps(payload)}\n```",
+    )
+    result = interpret_question_with_model(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        allowed_species={"dungeness_crab", "lingcod"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=generate,
+    )
+    assert result is not None
+    assert result.species_or_category == "dungeness_crab"
+    assert result.location_name == "Mendocino"
+    assert result.region_key == "mendocino"
+    assert result.intent.value == "permission_status"
+
+
+def test_build_local_interpreter_disabled_returns_none():
+    assert build_local_interpreter(enabled=False) is None
+
+
+def test_local_interpreter_lazy_loads_once_and_returns_model_json():
+    loads = {"n": 0}
+
+    class FakeModel:
+        def create_chat_completion(self, messages, **kwargs):
+            return {"choices": [{"message": {"content": '{"species_or_category": "lingcod"}'}}]}
+
+    def factory():
+        loads["n"] += 1
+        return FakeModel()
+
+    generate = build_local_interpreter(enabled=True, model_factory=factory)
+    assert generate("first prompt") == '{"species_or_category": "lingcod"}'
+    assert generate("second prompt") == '{"species_or_category": "lingcod"}'
+    assert loads["n"] == 1
+
+
+def test_local_interpreter_extracts_json_and_fails_closed():
+    class FencedModel:
+        def create_chat_completion(self, messages, **kwargs):
+            return {
+                "choices": [
+                    {"message": {"content": '```json\n{"species_or_category": "dungeness_crab"}\n```'}}
+                ]
+            }
+
+    fenced = build_local_interpreter(enabled=True, model_factory=lambda: FencedModel())
+    assert fenced("p") == '{"species_or_category": "dungeness_crab"}'
+
+    def boom_factory():
+        raise RuntimeError("model load failed")
+
+    assert build_local_interpreter(enabled=True, model_factory=boom_factory)("p") is None
+
+
+def test_model_interpreter_canonicalizes_case_insensitive_location_name():
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+
+    result = interpret_question_with_model(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        allowed_species={"dungeness_crab"},
+        allowed_locations={"Mendocino": "mendocino"},
+        allowed_region_keys={"mendocino"},
+        generator=lambda _prompt: json.dumps(payload),
+    )
+
+    assert result is not None
+    assert result.location_name == "Mendocino"
+    assert result.region_key == "mendocino"
+
+
+def test_local_interpreter_constrains_output_with_json_schema():
+    captured = {}
+
+    class RecordingModel:
+        def create_chat_completion(self, messages, **kwargs):
+            captured.update(kwargs)
+            return {"choices": [{"message": {"content": '{"species_or_category": "lingcod"}'}}]}
+
+    generate = build_local_interpreter(enabled=True, model_factory=lambda: RecordingModel())
+    generate("some prompt")
+
+    response_format = captured.get("response_format") or {}
+    assert response_format.get("type") == "json_object"
+    schema = response_format.get("schema") or {}
+    assert "confidence" in (schema.get("required") or [])
+    assert schema.get("properties", {}).get("confidence", {}).get("enum") == ["high", "medium"]
+
+
+def test_local_interpreter_schema_constrains_to_prompt_allowlists():
+    captured = {}
+
+    class RecordingModel:
+        def create_chat_completion(self, messages, **kwargs):
+            captured.update(kwargs)
+            return {"choices": [{"message": {"content": "{}"}}]}
+
+    generate = build_local_interpreter(enabled=True, model_factory=lambda: RecordingModel())
+    generate(
+        "question=x\n"
+        "allowed_species=['dungeness_crab', 'lingcod']\n"
+        "allowed_locations=['Mendocino', 'Monterey']\n"
+        "allowed_region_keys=['central', 'mendocino']"
+    )
+
+    schema = captured["response_format"]["schema"]
+    props = schema["properties"]
+    assert set(props["species_or_category"]["enum"]) >= {"dungeness_crab", "lingcod"}
+    assert "Mendocino" in props["location_name"]["enum"]
+    assert "mendocino" in props["region_key"]["enum"]
+    # species is required (model must pick from the allowlist, never null/omit)
+    assert "species_or_category" in schema["required"]
+    # location/region are optional so location-less questions are not forced to invent a place
+    assert "location_name" not in schema["required"]
+    assert "region_key" not in schema["required"]
+    assert None in props["location_name"]["enum"]

tests/test_app.py

@@ -1,5 +1,6 @@
 """Gradio app integration tests."""
 
+import json
 import time
 from dataclasses import replace
 from datetime import datetime, timedelta, timezone
@@ -11,6 +12,28 @@ import app
 from coastwise.source_cache import DEFAULT_SEED_CACHE_DIR, SourceCache, load_seed_cache
 
 
+def test_manual_refresh_applies_to_active_cache_and_preserves_curated_facts():
+    from coastwise.schemas import RefreshStatus
+
+    app._SESSION_CACHE = None
+    try:
+        before = app._active_cache()
+        assert not any(s.refresh_status is RefreshStatus.UPDATED for s in before.snapshots)
+
+        app.refresh_official_sources_status(
+            fetcher=lambda source: f"refreshed official source text for {source.id} 2026"
+        )
+
+        after = app._active_cache()
+        # Refresh now actually changes what subsequent answers read.
+        assert any(s.refresh_status is RefreshStatus.UPDATED for s in after.snapshots)
+        # Curated structured facts are preserved, never auto-derived from fetched text.
+        assert len(after.facts) == len(before.facts)
+        assert after.facts == before.facts
+    finally:
+        app._SESSION_CACHE = None
+
+
 def test_app_import_exposes_coastwise_identity_without_launching():
     assert app.APP_TITLE == "CoastWise"
     assert isinstance(app.demo, gr.Blocks)
@@ -25,7 +48,7 @@ def test_build_app_returns_blocks_with_lookup_shell():
 
 def test_source_backed_app_shell_exposes_primary_controls_without_legacy_inputs():
     assert "Question" in app.SOURCE_BACKED_CONTROL_LABELS
-    assert "Beach or coastal area" in app.SOURCE_BACKED_CONTROL_LABELS
+    assert "Beach or coastal area" not in app.SOURCE_BACKED_CONTROL_LABELS
     assert "Refresh official sources" in app.SOURCE_BACKED_CONTROL_LABELS
     assert "Intent" not in app.SOURCE_BACKED_CONTROL_LABELS
     assert "Region" not in app.SOURCE_BACKED_CONTROL_LABELS
@@ -194,3 +217,22 @@ def test_lookup_photo_candidate_returns_candidate_without_harvest_guidance():
     assert result["candidates"][0]["rule_card_key"] == "mussels"
     assert "not confirmed" in result["candidates"][0]["limitations"].lower()
     assert "harvest_status" not in result
+
+
+def test_app_routes_questions_through_configured_interpreter(monkeypatch):
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+    }
+    monkeypatch.setattr(app, "SOURCE_BACKED_INTERPRETER", lambda _prompt: json.dumps(payload))
+
+    result = app.ask_source_backed_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?", ""
+    )
+
+    assert result["matched_place"] == "Mendocino"
+    assert "dungeness crab" in (result["species_or_category"] or "").casefold()

tests/test_locations.py

@@ -1,6 +1,6 @@
 """Location parsing tests."""
 
-from coastwise.locations import parse_location
+from coastwise.locations import location_context_from_model, location_candidates, parse_location
 
 
 def test_parse_location_from_question_or_optional_beach_field():
@@ -25,3 +25,84 @@ def test_parse_location_recognizes_half_moon_bay_for_public_queries():
     assert context.matched_place == "Half Moon Bay"
     assert context.region_key == "san_francisco"
     assert context.confidence == "recognized"
+
+
+def test_location_candidates_include_official_regions_without_typo_alias_growth():
+    candidates = location_candidates()
+
+    assert candidates["Mendocino"] == "mendocino"
+    assert candidates["Mendocino Ocean Region"] == "mendocino"
+    assert "Mandocino" not in candidates
+
+
+def test_location_context_from_validated_model_output():
+    context = location_context_from_model(
+        question="im in mandocino. is it legal to harvest dungenese crabs?",
+        location_text="",
+        location_name="Mendocino",
+        region_key="mendocino",
+    )
+
+    assert context.matched_place == "Mendocino"
+    assert context.region_key == "mendocino"
+    assert context.confidence == "recognized"
+    assert context.warning is None
+
+
+def test_location_context_from_model_preserves_existing_alias_scope():
+    context = location_context_from_model(
+        question="can I eat mussels from pacifica today?",
+        location_text="",
+        location_name="Pacifica",
+        region_key="san_francisco",
+    )
+
+    assert context.matched_place == "Pacifica"
+    assert context.region_key == "san_francisco"
+    assert context.area_or_scope == "San Francisco coast"
+
+
+def test_location_context_from_missing_model_output_falls_back_to_parse_location():
+    context = location_context_from_model(
+        question="can I eat mussels from Pacifica today?",
+        location_text="",
+        location_name=None,
+        region_key=None,
+    )
+
+    assert context.matched_place == "Pacifica"
+    assert context.region_key == "san_francisco"
+    assert context.area_or_scope == "San Francisco coast"
+
+
+def test_location_context_from_model_name_region_mismatch_falls_back_to_parse_location():
+    context = location_context_from_model(
+        question="what's the lingcod size?",
+        location_text="Monterey",
+        location_name="Pacifica",
+        region_key="central",
+    )
+
+    assert context.matched_place == "Monterey"
+    assert context.region_key == "central"
+    assert context.area_or_scope == "Central California ocean region"
+
+
+def test_parse_location_fuzzy_matches_misspelled_mendocino():
+    context = parse_location("im in mandocino. is it legal to harvest dungenese crabs?", "")
+
+    assert context.matched_place == "Mendocino"
+    assert context.region_key == "mendocino"
+
+
+def test_parse_location_fuzzy_does_not_false_match_plain_species_question():
+    context = parse_location("what's the min size of lingcod?", "")
+
+    assert context.matched_place is None
+
+
+def test_parse_location_recognizes_sf_abbreviation():
+    context = parse_location("is it legal to catch lingcod in sf", "")
+
+    assert context.matched_place == "San Francisco"
+    assert context.region_key == "san_francisco"

tests/test_qna.py

@@ -1,10 +1,19 @@
 """Source-backed Q&A tests."""
 
+import json
 from dataclasses import replace
 from datetime import datetime, timedelta, timezone
 
-from coastwise.qna import answer_question
-from coastwise.schemas import AnswerStatus, EvidenceType, FreshnessStatus
+import pytest
+
+from coastwise.qna import answer_question, answer_to_dict, interpret_question
+from coastwise.schemas import (
+    AnswerStatus,
+    EvidenceType,
+    FreshnessStatus,
+    RequestedFactType,
+    StructuredRegulationFact,
+)
 from coastwise.source_cache import DEFAULT_SEED_CACHE_DIR, SourceCache, load_seed_cache
 
 
@@ -136,16 +145,21 @@ def test_dungeness_season_answer_uses_saved_evidence_instead_of_generic_verify_f
     assert "Dungeness crab: Verify current CDFW" not in answer.direct_answer
 
 
-def test_structured_lingcod_answer_does_not_call_model_when_exact_fact_exists():
-    def fail_if_called(_prompt):
-        raise AssertionError("structured fact path should not call model")
-
+def test_structured_lingcod_answer_uses_exact_fact_after_invalid_model_interpretation():
+    payload = {
+        "species_or_category": "maine_lobster",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
     answer = answer_question(
         "what's the min size of lingcod?",
         "",
         load_seed_cache(DEFAULT_SEED_CACHE_DIR),
         NOW,
-        model=fail_if_called,
+        model=lambda _prompt: json.dumps(payload),
     )
 
     assert answer.status is AnswerStatus.ANSWERED
@@ -154,7 +168,7 @@ def test_structured_lingcod_answer_does_not_call_model_when_exact_fact_exists():
     assert not answer.model_assisted
 
 
-def test_harvest_question_with_typos_uses_cached_evidence_not_bare_warning():
+def test_harvest_question_with_typos_answers_with_dated_sf_dungeness_season():
     answer = answer_question(
         "can i harvest dugenese crabs in pacifica today?",
         "",
@@ -163,9 +177,559 @@ def test_harvest_question_with_typos_uses_cached_evidence_not_bare_warning():
         model=lambda _prompt: None,
     )
 
-    assert answer.status is AnswerStatus.PARTIAL
-    assert answer.evidence_type is EvidenceType.SOURCE_SNIPPET
+    # Pacifica resolves to the San Francisco area, which now has a dated season fact.
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
     assert answer.location_context.matched_place == "Pacifica"
-    assert any("Pacifica" in snippet for snippet in answer.supporting_snippets)
-    assert "saved official source text" in answer.direct_answer
-    assert "does not have an extracted exact answer" in answer.direct_answer
+    lowered = answer.direct_answer.casefold()
+    assert "season is open" in lowered
+    assert "november" in lowered  # real SF-area Dungeness season dates
+    # States the season; never asserts personal legality to harvest.
+    assert "you may harvest" not in lowered
+    assert "legal to harvest" not in lowered
+
+
+def test_interpret_question_uses_model_for_messy_species_location_and_intent():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+        "notes": "Normalized misspellings.",
+    }
+
+    interpretation = interpret_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert interpretation.model_used
+    assert interpretation.species_or_category == "dungeness_crab"
+    assert interpretation.location_context.matched_place == "Mendocino"
+    assert interpretation.location_context.region_key == "mendocino"
+    assert interpretation.requested_fact_type is RequestedFactType.SEASON
+    assert "permission_status" in (interpretation.model_notes or "")
+
+
+def test_interpret_question_rejects_model_generic_regional_species_term():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "regional",
+        "location_name": "Monterey",
+        "region_key": "central",
+        "intent": "regional_rules",
+        "requested_fact_types": ["general_summary"],
+        "confidence": "high",
+    }
+
+    interpretation = interpret_question(
+        "what should I check near Monterey?",
+        "Monterey",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert not interpretation.model_used
+    assert interpretation.species_or_category is None
+
+
+def test_interpret_question_rejects_model_unknown_species_and_uses_fallback():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "maine_lobster",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+
+    interpretation = interpret_question(
+        "can I harvest lobster in mendocino?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert not interpretation.model_used
+    assert interpretation.species_or_category is None
+
+
+def test_answer_question_uses_model_path_for_source_backed_dungeness_mendocino():
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+        "notes": "Normalized misspellings.",
+    }
+
+    answer = answer_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        load_seed_cache(DEFAULT_SEED_CACHE_DIR),
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
+    assert answer.source_links
+    assert answer.retrieved_at is not None
+    assert answer.freshness_status is FreshnessStatus.CURRENT
+    assert answer.next_safe_action
+    assert "legal to harvest" not in answer.direct_answer.casefold()
+    assert answer.location_context.matched_place == "Mendocino"
+
+
+def test_answer_question_rejects_unknown_model_species_without_lobster_source_answer():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "maine_lobster",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+
+    interpretation = interpret_question(
+        "can I harvest maine lobster in mendocino?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+    answer = answer_question(
+        "can I harvest maine lobster in mendocino?",
+        "",
+        cache,
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert not interpretation.model_used
+    assert interpretation.species_or_category is None
+    assert answer.status is AnswerStatus.UNSUPPORTED
+    assert answer.evidence_type is EvidenceType.UNSUPPORTED
+    assert answer.species_or_category is None
+    assert not answer.source_links
+
+
+def test_permission_question_surfaces_statewide_facts_and_flags_missing_area_season():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+    }
+
+    answer = answer_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        cache,
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    # Statewide bag/size apply in Mendocino and are surfaced; the area-specific
+    # season we lack for Mendocino is flagged, and legality is never asserted.
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
+    assert answer.location_context.matched_place == "Mendocino"
+    assert "10 crab" in answer.direct_answer.casefold()
+    notes = " ".join(answer.uncertainty_notes).casefold()
+    assert "season" in notes or "closure" in notes
+    assert "legal to harvest" not in answer.direct_answer.casefold()
+    assert not any("cabezon" in snippet.casefold() for snippet in answer.supporting_snippets)
+    assert any("crab" in snippet.casefold() for snippet in answer.supporting_snippets)
+
+
+def test_answer_question_unsupported_scope_cannot_be_overridden_by_model():
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+
+    answer = answer_question(
+        "what is the trout limit in freshwater Lake Tahoe?",
+        "",
+        load_seed_cache(DEFAULT_SEED_CACHE_DIR),
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert answer.status is AnswerStatus.UNSUPPORTED
+    assert answer.evidence_type is EvidenceType.UNSUPPORTED
+    assert answer.location_context.confidence == "unsupported"
+    assert answer.location_context.matched_place is None
+    assert not answer.source_links
+
+
+def test_permission_question_answers_directly_when_season_fact_exists():
+    seed = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    season_fact = StructuredRegulationFact(
+        id="dungeness_crab_mendocino_season_status",
+        species_or_category="dungeness_crab",
+        display_name="Dungeness crab",
+        aliases=("dungeness crabs",),
+        area_or_scope="Mendocino California ocean region",
+        fact_type=RequestedFactType.SEASON,
+        value="season status is closed in the cached official source text",
+        units=None,
+        source_id="cdfw_crabs",
+        source_url="https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Crabs",
+        retrieved_at=NOW,
+        supporting_chunk_id="chunk_dungeness_crab_season_context",
+        supporting_snippet="Dungeness crab season status is closed in this test source text.",
+        region_key="mendocino",
+        validation_set=True,
+    )
+    cache = SourceCache(
+        sources=seed.sources,
+        snapshots=seed.snapshots,
+        chunks=seed.chunks,
+        facts=(*seed.facts, season_fact),
+        advisory_facts=seed.advisory_facts,
+    )
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+    }
+
+    answer = answer_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        cache,
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
+    # Source is attributed via source_titles, not an inline preamble.
+    assert any("CDFW" in title for title in answer.source_titles)
+    assert "closed" in answer.direct_answer
+    assert "legal to harvest" not in answer.direct_answer.casefold()
+    assert answer.location_context.region_key == "mendocino"
+
+
+def test_answer_to_dict_sanitizes_structured_bundle_forbidden_copy():
+    """A structured-fact value carrying forbidden copy is sanitized at serialization."""
+    seed = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    poisoned = StructuredRegulationFact(
+        id="dungeness_crab_mendocino_poisoned",
+        species_or_category="dungeness_crab",
+        display_name="Dungeness crab",
+        aliases=("dungeness crabs",),
+        area_or_scope="Mendocino California ocean region",
+        fact_type=RequestedFactType.SEASON,
+        value="legal to harvest now per cached source",
+        units=None,
+        source_id="cdfw_crabs",
+        source_url="https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Crabs",
+        retrieved_at=NOW,
+        supporting_chunk_id="chunk_dungeness_crab_season_context",
+        supporting_snippet="Test poisoned snippet.",
+        region_key="mendocino",
+        validation_set=True,
+    )
+    cache = SourceCache(
+        sources=seed.sources,
+        snapshots=seed.snapshots,
+        chunks=seed.chunks,
+        facts=(*seed.facts, poisoned),
+        advisory_facts=seed.advisory_facts,
+    )
+    payload = {
+        "species_or_category": "dungeness_crab",
+        "location_name": "Mendocino",
+        "region_key": "mendocino",
+        "intent": "permission_status",
+        "requested_fact_types": ["season", "closure"],
+        "confidence": "high",
+    }
+
+    answer = answer_question(
+        "im in mandocino. is it legal to harvest dungenese crabs?",
+        "",
+        cache,
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    # The raw bundle answer is ANSWERED and carries the forbidden phrase verbatim...
+    assert answer.status is AnswerStatus.ANSWERED
+    assert "legal to harvest" in answer.direct_answer.casefold()
+
+    # ...but the serialization boundary the UI uses sanitizes and downgrades it.
+    serialized = answer_to_dict(answer)
+    assert serialized["status"] == "partial"
+    assert "legal to harvest" not in serialized["direct_answer"].casefold()
+
+
+def test_cabezon_evidence_excludes_unrelated_species_snippets():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "cabezon",
+        "intent": "general",
+        "requested_fact_types": ["advisory"],
+        "confidence": "high",
+    }
+
+    answer = answer_question(
+        "is it legal to catch cabazon in pacifica?",
+        "",
+        cache,
+        NOW,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    joined = " ".join(answer.supporting_snippets).casefold()
+    assert "cabezon" in joined
+    assert "dungeness" not in joined
+    assert "quarantine" not in joined
+
+
+def test_model_path_uses_deterministic_fact_type_not_model_advisory_misclassification():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    payload = {
+        "species_or_category": "cabezon",
+        "intent": "general",
+        "requested_fact_types": ["advisory"],
+        "confidence": "high",
+    }
+
+    interpretation = interpret_question(
+        "is it legal to catch cabazon in pacifica?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+
+    assert interpretation.model_used
+    assert interpretation.species_or_category == "cabezon"
+    assert interpretation.location_context.matched_place == "Pacifica"
+    # the model mislabeled a catch question as "advisory"; deterministic wins
+    assert interpretation.requested_fact_type is RequestedFactType.SEASON
+    assert "advisory" not in (interpretation.model_notes or "")
+
+
+def test_permission_question_surfaces_all_available_species_facts():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question("is it legal to catch lingcod?", "", cache, NOW)
+
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
+    lowered = answer.direct_answer.casefold()
+    assert "22" in answer.direct_answer
+    assert "bag limit" in lowered
+
+
+def test_permission_question_answers_cabezon_with_size_bag_and_season():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question("is it legal to catch cabezon in pacifica?", "", cache, NOW)
+
+    assert answer.status is AnswerStatus.ANSWERED
+    assert answer.evidence_type is EvidenceType.STRUCTURED_FACT
+    assert answer.species_or_category == "Cabezon"
+    lowered = answer.direct_answer.casefold()
+    # Source-backed cabezon regulation values (CDFW Groundfish Summary).
+    assert "no minimum size limit" in lowered
+    assert "10" in answer.direct_answer  # RCG-complex aggregate bag limit
+    assert "april" in lowered  # RCG-complex season now encoded for the SF management area
+    assert any("groundfish" in title.casefold() for title in answer.source_titles)
+    # States facts, never a bare legality verdict.
+    assert "you may harvest" not in lowered
+    assert "authorized" not in lowered
+
+
+EXPANDED_SEED_CASES = [
+    ("what is the minimum size for california halibut?", "22"),
+    ("white seabass size limit", "28"),
+    ("leopard shark bag limit", "3"),
+    ("rock crab bag limit", "35"),
+    ("purple sea urchin limit", "35"),
+    ("can i take red abalone?", "closed"),
+    ("is it legal to catch white sturgeon?", "catch-and-release"),
+    ("kelp harvest limit", "10 pounds"),
+    ("is it legal to catch rockfish in pacifica?", "no minimum size limit"),
+    ("redtail surfperch minimum size", "10"),
+]
+
+
+def test_general_rules_question_surfaces_real_facts_not_generic_placeholder():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question("dungeness crab rules", "", cache, NOW)
+
+    assert answer.status is AnswerStatus.ANSWERED
+    lowered = answer.direct_answer.casefold()
+    # Real values, not the bare "verify current CDFW Dungeness crab season..." placeholder.
+    assert "10 crab" in lowered
+    assert "5¾" in answer.direct_answer
+    assert "season is open" in lowered
+
+
+def test_model_species_guard_overrides_lexically_implausible_resolution():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    # The small model rounds a rare species to a wrong in-enum species (mussels)
+    # that has no lexical basis in the question.
+    payload = {
+        "species_or_category": "mussels",
+        "location_name": None,
+        "region_key": None,
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+    model = lambda _prompt: json.dumps(payload)
+
+    interpretation = interpret_question(
+        "is it legal to catch soupfin shark?", "", cache, model=model
+    )
+    assert interpretation.species_or_category != "mussels"
+
+    answer = answer_question(
+        "is it legal to catch soupfin shark?", "", cache, NOW, model=model
+    )
+    # Must never answer a shark question with the mussel food-safety advisory.
+    assert "mussel" not in answer.direct_answer.casefold()
+
+
+def test_model_species_guard_prefers_specific_alias_over_model_substring_pick():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    # The model rounds "kelp bass" to the plant "kelp"; the specific fact alias
+    # ("kelp bass") must win over the model's substring pick.
+    payload = {
+        "species_or_category": "kelp_plants",
+        "intent": "general",
+        "requested_fact_types": ["minimum_size"],
+        "confidence": "high",
+    }
+    interpretation = interpret_question(
+        "what is the size limit for kelp bass?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+    assert interpretation.species_or_category == "kelp_bass"
+
+
+def test_model_species_guard_keeps_typo_normalization_when_search_is_empty():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    # Deterministic name search can't resolve the typo, so the model's
+    # normalization (cabazon -> cabezon) must be preserved.
+    payload = {
+        "species_or_category": "cabezon",
+        "location_name": "Pacifica",
+        "region_key": "san_francisco",
+        "intent": "permission_status",
+        "requested_fact_types": ["season"],
+        "confidence": "high",
+    }
+    interpretation = interpret_question(
+        "is it legal to catch cabazon in pacifica?",
+        "",
+        cache,
+        model=lambda _prompt: json.dumps(payload),
+    )
+    assert interpretation.species_or_category == "cabezon"
+
+
+def test_species_without_facts_falls_back_to_reviewed_rule_card_not_wrong_species():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question(
+        "is it legal to catch california scorpionfish?", "", cache, NOW
+    )
+
+    lowered = answer.direct_answer.casefold()
+    # Recognized species with no extracted fact -> reviewed card posture, not a guess.
+    assert answer.status is AnswerStatus.PARTIAL
+    assert "scorpionfish" in answer.species_or_category.casefold()
+    assert "rules apply" in lowered or "verify" in lowered
+    # Must never resolve to an unrelated species' facts.
+    assert "halibut" not in lowered
+    assert "22 inches" not in lowered
+
+
+def test_allowed_species_covers_full_rule_card_taxonomy():
+    from coastwise.data import all_rule_cards
+    from coastwise.qna import _allowed_species_from_cache
+
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+    allowed = _allowed_species_from_cache(cache)
+
+    # Every curated species the deterministic path knows must also be offered to
+    # the model, so it cannot round an unknown species to a wrong neighbor.
+    for card in all_rule_cards():
+        if card.key == "unknown":
+            continue
+        assert card.key in allowed, f"{card.key} missing from allowed species"
+
+
+STATEWIDE_SEED_CASES = [
+    ("kelp bass size limit", "14"),
+    ("california sheephead bag limit", "2"),
+    ("pacific bonito minimum size", "24"),
+    ("california yellowtail bag limit", "10"),
+    ("ocean whitefish size limit", "no minimum size limit"),
+    ("california spiny lobster season", "october"),
+    ("market squid limit", "no daily bag limit"),
+    ("geoduck clam limit", "3"),
+    ("white croaker limit", "10"),
+    ("is it legal to catch giant sea bass?", "prohibited"),
+    ("is it legal to catch white shark?", "prohibited"),
+    ("california grunion season", "april"),
+]
+
+
+@pytest.mark.parametrize("query, must_contain", STATEWIDE_SEED_CASES)
+def test_statewide_seed_answers_real_values(query, must_contain):
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question(query, "", cache, NOW)
+
+    assert answer.status is AnswerStatus.ANSWERED, f"{query!r} -> {answer.status}: {answer.direct_answer}"
+    assert (
+        must_contain.casefold() in answer.direct_answer.casefold()
+    ), f"{query!r} -> {answer.direct_answer}"
+    lowered = answer.direct_answer.casefold()
+    assert "you may harvest" not in lowered
+    assert "is safe to eat" not in lowered
+
+
+@pytest.mark.parametrize("query, must_contain", EXPANDED_SEED_CASES)
+def test_expanded_seed_answers_real_values(query, must_contain):
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    answer = answer_question(query, "", cache, NOW)
+
+    assert answer.status is AnswerStatus.ANSWERED, f"{query!r} -> {answer.status}: {answer.direct_answer}"
+    assert (
+        must_contain.casefold() in answer.direct_answer.casefold()
+    ), f"{query!r} -> {answer.direct_answer}"
+    # Source-backed answers never assert legality or food safety.
+    lowered = answer.direct_answer.casefold()
+    assert "you may harvest" not in lowered
+    assert "is safe to eat" not in lowered

tests/test_real_user_queries.py

@@ -389,12 +389,14 @@ def test_direct_answer_concept_helper_allows_concrete_dungeness_results():
 
 @pytest.mark.parametrize("case", _cases(), ids=lambda case: case["query"])
 def test_real_user_queries_use_saved_evidence_without_generic_answers(case):
+    model_payload = case.get("model_interpretation")
+    model = (lambda _prompt, payload=model_payload: json.dumps(payload)) if model_payload else (lambda _prompt: None)
     answer = answer_question(
         str(case["query"]),
         "",
         load_seed_cache(DEFAULT_SEED_CACHE_DIR),
         NOW,
-        model=lambda _packet: None,
+        model=model,
     )
     payload = answer_to_dict(answer)
     source_material = " ".join(

tests/test_schemas.py

@@ -296,3 +296,42 @@ def test_query_context_and_safety_result_keep_sources_and_status_explicit():
         retrieved_on=date(2026, 6, 1),
     )
     assert source.url.startswith("https://")
+
+
+def test_model_question_interpretation_validates_allowlisted_shape():
+    from coastwise.schemas import ModelQuestionInterpretation, SourceBackedIntent
+
+    interpretation = ModelQuestionInterpretation(
+        species_or_category="dungeness_crab",
+        location_name="Mendocino",
+        region_key="mendocino",
+        intent="permission_status",
+        requested_fact_types=("season", "closure"),
+        confidence="high",
+        notes="Normalized typo species and location.",
+    )
+
+    assert interpretation.intent is SourceBackedIntent.PERMISSION_STATUS
+    assert interpretation.requested_fact_types == (
+        RequestedFactType.SEASON,
+        RequestedFactType.CLOSURE,
+    )
+    assert interpretation.confidence == "high"
+    assert interpretation.species_or_category == "dungeness_crab"
+    assert interpretation.location_name == "Mendocino"
+    assert interpretation.region_key == "mendocino"
+    assert interpretation.notes == "Normalized typo species and location."
+
+
+def test_model_question_interpretation_rejects_unsupported_confidence():
+    from coastwise.schemas import ModelQuestionInterpretation, SourceBackedIntent
+
+    with pytest.raises(ValueError, match="model interpretation confidence"):
+        ModelQuestionInterpretation(
+            species_or_category=None,
+            location_name=None,
+            region_key=None,
+            intent=SourceBackedIntent.GENERAL,
+            requested_fact_types=(RequestedFactType.GENERAL_SUMMARY,),
+            confidence="certain",
+        )

tests/test_search.py

@@ -70,3 +70,13 @@ def test_source_backed_search_handles_public_typos_and_aliases():
         matches = search_source_candidates(query, cache)
         assert matches, query
         assert matches[0].rule_card_key == key
+
+
+def test_source_backed_typos_are_fallback_not_primary_interpretation_contract():
+    cache = load_seed_cache(DEFAULT_SEED_CACHE_DIR)
+
+    matches = search_source_candidates("dugenese crab", cache)
+
+    assert matches
+    assert matches[0].rule_card_key == "dungeness_crab"
+    assert matches[0].reason == "source_alias"

tests/test_source_extract.py

@@ -44,3 +44,27 @@ def test_extract_structured_validation_set_facts_from_seed_chunks():
 
     assert {"lingcod_min_size", "lingcod_bag_limit", "dungeness_crab_bag_limit"} <= fact_ids
     assert not result.issues
+
+
+def test_extract_structured_facts_finds_explicit_season_and_gear_facts():
+    snapshot = SourceSnapshot(
+        source_id="cdfw_crabs",
+        url="https://wildlife.ca.gov/Conservation/Marine/Invertebrates/Crabs",
+        title="CDFW Crabs",
+        retrieved_at="2026-06-14T12:00:00+00:00",
+        content_hash="crabs-test",
+        raw_text=(
+            "Dungeness crab season status is closed for the Mendocino ocean region. "
+            "Dungeness crab trap and hoop net rules apply before harvest."
+        ),
+        origin="seed",
+        refresh_status=RefreshStatus.UNCHANGED,
+    )
+    chunks = extract_source_chunks(snapshot)
+    result = extract_structured_facts(chunks, default_structured_validation_set())
+
+    facts = {(fact.species_or_category, fact.fact_type.value): fact for fact in result.facts}
+
+    assert facts[("dungeness_crab", "season")].region_key == "mendocino"
+    assert "closed" in facts[("dungeness_crab", "season")].value
+    assert "trap" in facts[("dungeness_crab", "gear_or_method")].gear_or_method_notes

tests/test_submission.py

@@ -21,6 +21,15 @@ def test_default_model_inventory_documents_minicpm_under_hackathon_caps():
     assert not validate_model_inventory(inventory)
 
 
+def test_model_inventory_declares_hosted_minicpm_interpreter_role():
+    from coastwise.schemas import ModelRole, RuntimeMode
+
+    entry = default_model_inventory().entries[0]
+
+    assert entry.runtime_mode is RuntimeMode.HOSTED_ENDPOINT
+    assert ModelRole.QUESTION_INTERPRETATION in entry.roles
+
+
 def test_submission_package_validator_flags_missing_public_evidence():
     inventory = default_model_inventory()
     package = SubmissionPackage(
@@ -52,6 +61,7 @@ def test_readme_documents_statewide_source_cache_policy_and_validation_limits():
     assert "structured answers for the reviewed validation set" in readme
     assert "snippet fallback" in readme
     assert "questions and optional beach/coastal-area text are not saved" in readme
+    assert "coastwise_llm_api_key" in readme
     for source in load_official_sources():
         if source.id in coverage.required_source_ids:
             assert source.url.casefold() in readme