From 4cb7a50045601e75877b60b4caf8f579aca3810d Mon Sep 17 00:00:00 2001
From: Quinten Steenhuis <qsteenhuis@suffolk.edu>
Date: Sat, 5 Sep 2026 09:35:12 -0400
Subject: [PATCH 1/3] Add structured court selector per jurisdiction
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the flat court dropdown with a multi-step court selector that
walks a filer through the right questions for each jurisdiction:

- Illinois routes by county using a regex group on the Tyler court list,
  then optionally by division (Cook County gets sub-grouped by district).
- Massachusetts asks for department first, then uses MACourts to match a
  typed town/address to the courts that serve it; the full list is always
  shown alongside as a fallback.
- Vermont asks for Superior Court division, then uses VTCourts to look up
  the unit from a town, county, or ZIP; the dropdown stays for those who
  know their unit.

New services and files:
- efile/services/court_selection.py -- YAML-driven selector engine; parses
  the court_selector block, evaluates when: conditions, filters courts by
  name_pattern/exclude_name_pattern, and computes defaults.
- efile/services/court_location.py -- location-to-court matchers for MA
  (MACourts) and VT (VTCourts), plus parse_place() for free-text input.
- efile/api/court_selector_views.py -- /dropdowns/court-selector/ endpoint
  that serialises the selector state for the active jurisdiction.
- efile/static/js/court-selector.js + css/components/court-selector.css --
  progressive-disclosure UI; each step appears only when its when: conditions
  are met, and location steps fire the court-lookup API.

Supporting changes:
- is_non_filing_court() extracted from dropdown_views into court_selection
  so the same filter applies to both the flat list and the selector.
- EXTRACTION_KEY_ALIASES + _normalized_key() added to extraction_fields so
  LLM variants of party-name labels ("plaintiff name", "petitioner names" …)
  all resolve to the canonical key.
- State YAML files (illinois, massachusetts, vermont) gain the court_selector
  block documented in jurisdiction-config.md.
- Playwright test utilities updated with a selectCourt() helper that drives
  the new selector UI; existing tests updated to use it.
---
 Dockerfile                                    |   5 +-
 .../partners-courts/jurisdiction-config.md    | 139 +++
 efile_app/efile/api/court_selector_views.py   |  91 ++
 efile_app/efile/api/dropdown_views.py         |  24 +-
 efile_app/efile/api/urls.py                   |   2 +
 .../prompts/document_evidence_extraction.yaml |   2 +
 efile_app/efile/services/court_location.py    | 212 +++++
 efile_app/efile/services/court_selection.py   | 824 ++++++++++++++++++
 efile_app/efile/services/extraction_fields.py |  28 +-
 .../efile/static/config/states/illinois.yaml  | 255 ++++++
 .../static/config/states/massachusetts.yaml   | 143 +++
 .../efile/static/config/states/vermont.yaml   |  97 +++
 .../static/css/components/court-selector.css  | 229 +++++
 .../efile/static/css/reorganized-flow.css     |   7 +
 efile_app/efile/static/js/case-lookup.js      |  24 +
 efile_app/efile/static/js/court-selector.js   | 414 +++++++++
 .../efile/static/js/extraction-review.js      |  36 +
 .../efile/templates/efile/case_lookup.html    |  10 +-
 .../templates/efile/extraction_review.html    |   3 +
 .../efile/templates/efile/workflow_base.html  |   2 +
 efile_app/efile/tests/test_court_selection.py | 574 ++++++++++++
 .../efile/tests/test_document_extractions.py  |  17 +-
 efile_app/playwright.config.js                |  10 +-
 efile_app/pyproject.toml                      |   6 +
 .../document-classification-sentinel.spec.js  |  24 +-
 .../tests/reorganized-filing-matrix.spec.js   |  43 +-
 .../tests/test-optional-services-e2e.spec.js  |  32 +-
 efile_app/tests/test-utils.js                 | 104 ++-
 efile_app/uv.lock                             |  68 ++
 29 files changed, 3335 insertions(+), 90 deletions(-)
 create mode 100644 efile_app/efile/api/court_selector_views.py
 create mode 100644 efile_app/efile/services/court_location.py
 create mode 100644 efile_app/efile/services/court_selection.py
 create mode 100644 efile_app/efile/static/css/components/court-selector.css
 create mode 100644 efile_app/efile/static/js/court-selector.js
 create mode 100644 efile_app/efile/tests/test_court_selection.py

diff --git a/Dockerfile b/Dockerfile
index 2920b109..c1e32475 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -4,9 +4,10 @@ FROM python:3.12-slim AS base
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1
 
-# Install system deps (curl for uv installer, build tools only if needed)
+# Install system deps (curl for the uv installer; git because MACourts and
+# VTCourts are installed straight from GitHub until they are on PyPI)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl ca-certificates \
+    curl ca-certificates git \
  && rm -rf /var/lib/apt/lists/*
 
 # Install uv
diff --git a/docs/docs/partners-courts/jurisdiction-config.md b/docs/docs/partners-courts/jurisdiction-config.md
index 3b27693b..d0f3f4a5 100644
--- a/docs/docs/partners-courts/jurisdiction-config.md
+++ b/docs/docs/partners-courts/jurisdiction-config.md
@@ -140,3 +140,142 @@ A misspelled key is ignored, which means the page quietly keeps the default word
 ### Translation
 
 Strings configured here are translatable along with the rest of the application. `xgettext` cannot read YAML, so `manage.py extract_config_text` restates them in a generated Python file that `makemessages` reads. Each string carries its key as the gettext message context, so one key's Illinois wording and Vermont wording stay separate messages for a translator. See `efile_app/efile/locale/README.md` for the full workflow.
+
+---
+
+## 4. The court question
+
+Every filing needs a court, and the e-filing service answers that question with one flat list: 207 courts in Illinois, 170 in Massachusetts. A single dropdown over that list asks a filer to recognize their court among the ones that happen to sort next to it.
+
+`court_selector` replaces the list with the questions your state's court structure is actually made of. Illinois routes by county, Massachusetts by court department plus a place the filer knows, Vermont by Superior Court unit — and each of them narrows the same live court list. A jurisdiction with no `court_selector` section keeps the flat list.
+
+```yaml
+court_selector:
+  title: "Choose the Vermont court for this filing"
+  lede: >-
+    Start with the court on your paperwork. Superior Court filings then need a
+    division, and most divisions need the court unit the case belongs to.
+  steps:
+    - id: level
+      type: choice
+      label: "What Vermont court is this filing for?"
+      options:
+        - value: superior
+          label: "Superior Court"
+          help: "Vermont's trial court. You will choose a division next."
+          courts:
+            name_pattern: "Unit$|^Environmental Division$"
+        - value: supreme
+          label: "Supreme Court"
+          courts:
+            name_pattern: "^Supreme Court$"
+
+    - id: unit
+      type: select
+      when:
+        level: [superior]
+      label: "Which court unit?"
+      placeholder: "Choose a unit…"
+      options_from_courts:
+        match:
+          name_pattern: " Unit$"
+        strip: " Unit$"
+        label: "{name} ({stem} County)"
+```
+
+### How the questions run
+
+An answered question folds to a single line with a **Change** link, and once there is a court, every question folds and the screen states the answer. The court field shares a row with the case category and type, so the cascade has to collapse rather than push them down the page.
+
+Steps are asked in order. A step is shown when its `when:` conditions hold and it has something to ask; the filer's answer narrows the pool of courts, and the deepest answer wins, so "Cook County" is replaced by the division under it. When the pool is down to one court, that is the court. When it is down to a handful, the filer chooses among those rather than among two hundred.
+
+| Key | Meaning |
+| --- | --- |
+| `type` | `choice` (radio cards), `select` (a dropdown), or `location` (a place lookup). |
+| `when` | `{level: [trial]}` shows the step only for those answers; `{department: {not: [land]}}` hides it for those. |
+| `options` | Written-out answers. Each may carry a `courts:` query and any data a matcher needs. |
+| `options_from_courts` | Answers read off the live court list instead — counties, Cook County's divisions, Vermont's units. A step generated this way disappears when it has fewer than two options, which is how only the counties that divide their Circuit Court get asked about divisions. |
+| `option_groups` | One option per `members:` entry, all sharing the group's `courts:` query. Illinois asks which county an appeal came from and answers with its appellate district. |
+| `alternative_to` | Two questions that name the same court. Both stay on screen; answering either one answers for both. |
+| `short_label` | What the question is called once it is answered and folded to one line, e.g. `Division or courthouse`. Defaults to the full `label`, which is usually too long to read well there. |
+| `default_by` / `default_hint` | Start a question at an answer, chosen from an earlier one: `{answer: county, values: {Cook: "cook:cvd"}}` starts a Cook County filing at Municipal Civil. A suggested answer never folds away and carries `default_hint` saying it is a suggestion, so it cannot be mistaken for something the filer said. |
+
+### Naming the courts
+
+E-filing services name courts so that they sort. Massachusetts lists a court as `Juvenile Court -- Suffolk County -- Boston`, department first, because that is how the list is organized — but nobody calls it that, and a filer holding paperwork is looking for the Boston Juvenile Court. `court_names` puts the name back:
+
+```yaml
+court_names:
+  - match: '^Juvenile Court -+ (?P<county>.+?) -+ (?P<place>.+)$'
+    name: "{place} Juvenile Court - {county}"
+  - match: '^District Court -+ (?P<place>.+)$'
+    name: "{place} District Court"
+```
+
+Each rule is a regular expression with named captures, and `name` is the rewrite. The first rule that matches wins; a name no rule matches is already right, so Vermont's `Addison Unit` and Massachusetts' `Middlesex Probate and Family Court` need no rules at all.
+
+The rewrite happens once, when the court list is read, so everything downstream — the questions, the court finally chosen, and what is saved on the filing — uses the readable name. That includes the `courts:` queries below, so write them against the names as they read, not as the service lists them.
+
+### Court queries
+
+A `courts:` query says which courts an answer leads to. Every rule is optional and they combine with "and":
+
+| Rule | Matches |
+| --- | --- |
+| `codes` | Exact court codes, in the order given. |
+| `code_prefix`, `code_pattern` | The court's code starts with, or matches, this. |
+| `name_pattern` | The court's name matches this (case-insensitive). |
+| `exclude_code_pattern`, `exclude_name_pattern` | Drop the courts these match. |
+| `group` | The court belongs to this group — see `group_by` below. |
+
+Courts that are only a heading over the courts beneath them never reach the questions at all. "Cook County" is such a row: every Cook filing goes to one of the eighty locations whose code hangs off it, and choosing the county itself returns an empty case-category list with nothing to explain why. A court is dropped only when the e-filing service leaves it out of its fileable list **and** other courts hang off its code — Cook County - Chancery fails the second test, has locations under it, and takes filings of its own. A caption that names only such a county still routes: the questions it does settle are filled in, and `default_by` can start the rest somewhere sensible.
+
+Prefer `name_pattern`. Court **names** are stable and readable; Tyler's codes differ from court to court and change without notice. `{value}`, and any earlier step's id, can be used as a placeholder inside a query.
+
+`option_group_pattern` groups a dropdown under headings. It is matched against each court's name (after `strip`), and its named captures say which part is which: `group` is the heading, `label` is what to show under it, and `extra` is anything worth adding only when it is not the heading's own place. Cook County lists more than eighty locations, and reading them as one alphabetical run is what made the old dropdown unusable.
+
+```yaml
+        option_group_pattern: '^(?P<label>.*?)\s+-\s+(?P<group>District \d+)\b(?:\s+-\s+(?P<extra>.*))?$'
+        option_group_names:
+          - "District 1 - Chicago"
+          - "District 2 - Skokie"
+        option_group_other: "No courthouse given"
+```
+
+`option_group_names` gives each heading its full name and, by the order they are written in, the order they are shown in. That is how the Chicago courts come first in Cook County, where most of its filings go, rather than wherever the alphabet puts them; `option_group_other` heads the courts the pattern found no heading for, and they come last. Without `option_group_names`, headings are taken from the pattern itself and sorted, and a heading over a single court is dropped so that court keeps its full name.
+
+`group_by` on the selector itself is a regular expression whose first capture is the group a court belongs to. Illinois needs one because it names its counties' courts every which way — `Adams County`, `Kankakee - Civil`, `Peoria CR`, `St. Clair County-Backlog` — and they all have to land in one county.
+
+### Asking for a place instead of a county
+
+A `location` step hands what the filer types to a matcher:
+
+```yaml
+    - id: place
+      type: location
+      when:
+        level: [trial]
+        department:
+          not: [land]
+      label: "Where is the case connected to?"
+      placeholder: "Town, city, or street address"
+      button_label: "Find courts"
+      examples: ["Cambridge", "Somerville", "24 Beacon St, Boston"]
+      matcher: macourts
+      court_types_from: department
+      manual_label: "Or choose your court from the list"
+```
+
+`matcher:` names the library that answers the question. `macourts` uses [MACourts](https://github.com/SuffolkLITLab/MACourts), which owns the Massachusetts court records and jurisdiction rules; `vtcourts` uses [VTCourts](https://github.com/SuffolkLITLab/VTCourts), which resolves a Vermont town, county, or ZIP to its Superior Court unit. `court_types_from` names the step whose chosen option carries the `court_types:` the matcher should search, where a matcher needs one. Matches are mapped back onto the e-filing service's own courts — by code where the source carries one, by name otherwise — and a court this environment does not carry is dropped rather than offered.
+
+Massachusetts asks this way because its Trial Court departments do not divide the state the same way: the District Court that serves Somerville is not in the county its Probate and Family Court is, and which Boston Municipal Court division serves an address is a question about which side of a ward line the building is on. A filer knows their town. Asking them for a county produces a confident wrong answer.
+
+The lookup is always an alternative, never a requirement, and there are two ways to say so. Massachusetts sets `manual_label`, which puts the department's full court list beside the lookup for a filer who already knows their court and for a place the rules cannot resolve. Vermont instead marks its lookup `alternative_to: unit`: the unit dropdown stays where it is, and the lookup is the way in for a filer who knows their town but not that the town is in the Washington Unit. Answering either one answers for both.
+
+`no_match_hint` is what the screen says when the lookup finds nothing — worth wording per jurisdiction, since it should point at whichever alternative that state actually offers.
+
+A cross-county ZIP, or two courts with overlapping jurisdiction, come back as a short list to confirm rather than as a guess between them.
+
+:::tip Check your patterns against the live list
+The court names a pattern has to match are the ones the e-filing service returns, and they need no authentication to read: `curl "https://efile-test.suffolklitlab.org/jurisdictions/vermont/codes/courts?with_names=true"`.
+:::
diff --git a/efile_app/efile/api/court_selector_views.py b/efile_app/efile/api/court_selector_views.py
new file mode 100644
index 00000000..41c606df
--- /dev/null
+++ b/efile_app/efile/api/court_selector_views.py
@@ -0,0 +1,91 @@
+"""The court selector's one endpoint: answers in, the next question out.
+
+The screen holds no court data of its own. Every time the filer answers
+something it posts the answers back here and redraws from what comes back, so
+the questions, the courts they narrow to, and the court finally chosen are all
+decided in one place against the live court list.
+"""
+
+import json
+import logging
+
+import requests
+from django.views.decorators.http import require_http_methods
+
+from efile.services.court_selection import (
+    build_selection,
+    derive_answers,
+    derive_answers_from_guess,
+    fetch_courts,
+)
+from efile.utils.jurisdiction_stuff import get_jurisdiction_from_request
+
+from .base import APIResponseMixin
+
+logger = logging.getLogger(__name__)
+
+# Enough for the deepest configured cascade several times over, and small enough
+# that a malformed query cannot turn into work.
+MAX_ANSWERS = 20
+
+
+def _answers(request):
+    raw = request.GET.get("answers", "")
+    if not raw:
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(parsed, dict):
+        return {}
+    return {str(key): str(value) for key, value in list(parsed.items())[:MAX_ANSWERS] if value not in (None, "")}
+
+
+@require_http_methods(["GET"])
+def get_court_selector(request):
+    """The questions to ask now, the courts they lead to, and the court chosen.
+
+    ``available: false`` means this jurisdiction has no configured selector, and
+    the caller should fall back to the flat court list it used before.
+    """
+
+    jurisdiction = get_jurisdiction_from_request(request)
+    if not jurisdiction:
+        return APIResponseMixin.error_response("Missing required jurisdiction parameter")
+
+    answers = _answers(request)
+    saved_court = request.GET.get("court", "")
+    guessed_court = request.GET.get("guessed_court", "")
+    from_document: list[str] = []
+
+    try:
+        courts = fetch_courts(jurisdiction)
+    except (requests.RequestException, ValueError) as error:
+        logger.warning("Could not load the court list for %s: %s", jurisdiction, error)
+        return APIResponseMixin.error_response("We could not load the list of courts. Try again in a moment.")
+
+    if not answers:
+        # A saved court is only worth working backwards from while it is still a
+        # court this service offers. One that is not -- a court retired since the
+        # draft was saved, or a county heading that turned out to take no filings
+        # -- would otherwise wipe out everything the document said, and leave the
+        # filer starting from nothing.
+        known = saved_court and any(court["value"] == saved_court for court in courts)
+        if known:
+            answers = derive_answers(jurisdiction, saved_court, courts)
+            answers["court"] = saved_court
+        elif guessed_court:
+            # The document named a court. Whatever its words actually settle is
+            # filled in and labelled as coming from the document; the rest stays
+            # for the filer to answer.
+            answers = derive_answers_from_guess(jurisdiction, guessed_court, courts)
+            from_document = [key for key in answers if key != "court"]
+
+    selection = build_selection(jurisdiction, answers, courts)
+    if selection is None:
+        return APIResponseMixin.success_response({"available": False})
+
+    for step in selection["steps"]:
+        step["from_document"] = step["id"] in from_document and bool(step["answer"])
+    return APIResponseMixin.success_response({"available": True, **selection})
diff --git a/efile_app/efile/api/dropdown_views.py b/efile_app/efile/api/dropdown_views.py
index 9fb320db..b1e13509 100644
--- a/efile_app/efile/api/dropdown_views.py
+++ b/efile_app/efile/api/dropdown_views.py
@@ -11,6 +11,7 @@
 from django.conf import settings
 from django.views.decorators.http import require_http_methods
 
+from efile.services.court_selection import is_non_filing_court
 from efile.services.efsp_payload import parse_optional_services
 from efile.utils.jurisdiction_stuff import get_jurisdiction_from_request
 
@@ -285,24 +286,11 @@ def get_courts(request):
                     if isinstance(api_data, list):
                         for court in api_data:
                             if isinstance(court, dict) and "code" in court and "name" in court:
-                                # Filter out courts with unwanted patterns in the name
-                                court_name_standardized = court["name"].lower()
-                                if any(
-                                    pattern in court_name_standardized
-                                    for pattern in [
-                                        "(zodyssey)",
-                                        "z -",
-                                        "zz",
-                                        "zdev",
-                                        "courtview test",
-                                        "rsi test",
-                                        "do not use",
-                                        "not used",
-                                        "file & serve",
-                                        "system",
-                                    ]
-                                ):
-                                    continue  # Skip this court
+                                # Rows that exist only inside Tyler -- test
+                                # fixtures, retired locations -- are not courts
+                                # anyone can file into.
+                                if is_non_filing_court(court["name"]):
+                                    continue
 
                                 courts.append({"value": court["code"], "text": court["name"]})
 
diff --git a/efile_app/efile/api/urls.py b/efile_app/efile/api/urls.py
index 2c860db9..61bd48b7 100644
--- a/efile_app/efile/api/urls.py
+++ b/efile_app/efile/api/urls.py
@@ -15,6 +15,7 @@
 )
 from .case_type_config import get_case_type_config
 from .config_views import get_filer_roles, get_form_config
+from .court_selector_views import get_court_selector
 from .dropdown_views import (
     get_case_categories,
     get_case_types,
@@ -45,6 +46,7 @@
     path("dropdowns/case-types/", get_case_types, name="case_types"),
     path("dropdowns/filing-types/", get_filing_types, name="filing_types"),
     path("dropdowns/courts/", get_courts, name="courts"),
+    path("dropdowns/court-selector/", get_court_selector, name="court_selector"),
     path("dropdowns/document-types/", get_document_types, name="document_types"),
     path("dropdowns/optional-services/", get_optional_services, name="optional_services"),
     path("dropdowns/party-types/", get_party_types, name="party_types"),
diff --git a/efile_app/efile/prompts/document_evidence_extraction.yaml b/efile_app/efile/prompts/document_evidence_extraction.yaml
index b1ded219..117d7d9f 100644
--- a/efile_app/efile/prompts/document_evidence_extraction.yaml
+++ b/efile_app/efile/prompts/document_evidence_extraction.yaml
@@ -51,6 +51,7 @@ versions:
         * Keep form purpose to one short, evidence-grounded sentence; do not add legal conclusions or a taxonomy label.
         * Return monetary amounts as a JSON array. Each item must have `label`, `raw`, `amount`, `currency`, and `evidence`. Copy `raw` exactly; use plain decimal digits without currency symbols or separators for `amount`; use `USD` when a dollar sign or dollars label establishes it. Omit a property that the source does not establish.
         * Keep classification evidence, requested relief, and selected options as JSON arrays. Other fields are strings; join multiple names with semicolons.
+        * Treat the case caption as required evidence: when a document labels a plaintiff, petitioner, defendant, or respondent and prints a name for that role, always return that name in the corresponding requested names field. Read the filled value near the label even when instructions or blank lines appear between them.
         * Include only evidence relevant to identifying the document or its underlying proceeding.
         * Omit unsupported fields. Use "unknown" only for filing phase when the document does not establish it.
         * Do not include addresses, phone numbers, email addresses, financial account numbers, or unrelated allegations in classification evidence.
@@ -74,6 +75,7 @@ versions:
         * Keep form purpose to one short, evidence-grounded sentence; do not add legal conclusions or a taxonomy label.
         * Return monetary amounts as a JSON array. Each item must have `label`, `raw`, `amount`, `currency`, and `evidence`. Copy `raw` exactly; use plain decimal digits without currency symbols or separators for `amount`; use `USD` when a dollar sign or dollars label establishes it. Omit a property that the source does not establish.
         * Keep classification evidence, requested relief, and selected options as JSON arrays. Other fields are strings; join multiple names with semicolons.
+        * Treat the case caption as required evidence: when the text labels a plaintiff, petitioner, defendant, or respondent and includes a nearby filled name for that role, always return that name in the corresponding requested names field. Read past intervening instructions or blank lines when necessary.
         * Include only evidence relevant to identifying the document or its underlying proceeding.
         * Omit unsupported fields. Use "unknown" only for filing phase when the document does not establish it.
         * Do not include addresses, phone numbers, email addresses, financial account numbers, or unrelated allegations in classification evidence.
diff --git a/efile_app/efile/services/court_location.py b/efile_app/efile/services/court_location.py
new file mode 100644
index 00000000..5f4423a8
--- /dev/null
+++ b/efile_app/efile/services/court_location.py
@@ -0,0 +1,212 @@
+"""Turn a place a filer knows into the courts that serve it.
+
+Massachusetts is where this started. Its Trial Court departments do not
+divide the state the same way -- the District Court that serves Somerville is
+not in the county its Probate and Family Court is, and which Boston Municipal
+Court division serves an address is a question about which side of a ward line
+the building is on. A filer knows their town, or their address. They very often
+do not know their county, and asking for it produces a confident wrong answer.
+
+So Massachusetts asks for a place and hands it to `MACourts
+<https://github.com/SuffolkLITLab/MACourts>`_, the shared library that owns the
+Massachusetts court records and the jurisdiction rules. What comes back are
+court *names*, which this module maps onto the e-filing service's own court
+codes through the ``tyler_code`` each record carries, keeping only the courts
+this environment actually offers.
+
+Vermont is the simpler shape of the same problem. It has one Superior Court unit
+per county, and the units are named after their counties -- but a filer knows
+they live in Barre, not that Barre is in Washington County, and the Judiciary
+calls it a unit rather than a county. `VTCourts
+<https://github.com/SuffolkLITLab/VTCourts>`_ answers that from a town, a
+county, or a ZIP, and identifies the court by unit name.
+
+Location matching is always an alternative, never a requirement. Massachusetts
+offers the department's court list beside the lookup; Vermont keeps its unit
+dropdown, with the lookup as the way through for a filer who knows their town
+and not their unit. A state that needs neither simply configures no matcher.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from functools import lru_cache
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_ZIP = re.compile(r"\b(\d{5})(?:-\d{4})?\b")
+_STATE_SUFFIX = re.compile(r",?\s*\b(MA|Mass\.?|Massachusetts|VT|Vt\.?|Vermont)\b\.?\s*$", re.IGNORECASE)
+
+
+class LocationLookupUnavailable(RuntimeError):
+    """The matcher a jurisdiction asked for is not installed."""
+
+
+def normalize_court_code(code: str) -> str:
+    """Compare court codes the way two systems that both meant the same court do.
+
+    Tyler writes a Juvenile Court session as ``0965:BE`` in one place and
+    ``965:BE`` in another, and the case of the suffix is not consistent either.
+    Neither difference means anything, so neither should decide a match.
+    """
+
+    parts = []
+    for part in str(code or "").strip().split(":"):
+        parts.append(part.lstrip("0") or "0" if part.isdigit() else part.casefold())
+    return ":".join(parts)
+
+
+def normalize_court_name(name: str) -> str:
+    """Compare court names past the spacing and case nobody means anything by."""
+
+    return " ".join(str(name or "").split()).casefold()
+
+
+def parse_place(place: str) -> dict[str, str]:
+    """Read a typed place into the fields a court lookup can use.
+
+    Filers type what they have: "Cambridge", "Boston 02108", "24 Beacon St,
+    Boston". Everything here is optional -- the matcher decides what it can do
+    with a bare ZIP or a street with no city.
+    """
+
+    text = str(place or "").strip()
+    postal_code = ""
+    zip_match = _ZIP.search(text)
+    if zip_match:
+        postal_code = zip_match.group(1)
+        text = (text[: zip_match.start()] + " " + text[zip_match.end() :]).strip()
+    text = _STATE_SUFFIX.sub("", text).strip().strip(",").strip()
+
+    street_address = ""
+    city = text
+    parts = [part.strip() for part in text.split(",") if part.strip()]
+    if len(parts) >= 2 and parts[0][:1].isdigit():
+        street_address, city = parts[0], parts[1]
+    elif len(parts) >= 2:
+        city = parts[-1]
+    elif parts and parts[0][:1].isdigit():
+        # A street with no city. The ZIP, if one was typed, is what places it.
+        street_address, city = parts[0], ""
+
+    return {"street_address": street_address, "city": city, "postal_code": postal_code}
+
+
+@lru_cache(maxsize=1)
+def _finder():
+    """The MACourts finder, built once: it loads court records and ward geometry."""
+
+    from macourts import build_default_finder
+
+    return build_default_finder()
+
+
+def _massachusetts_matches(place: str, court_types: list[str]) -> list[dict[str, Any]]:
+    try:
+        from macourts import Location
+    except ImportError as error:  # pragma: no cover - depends on the install
+        raise LocationLookupUnavailable(
+            "Massachusetts court lookup needs the MACourts package to be installed."
+        ) from error
+
+    fields = parse_place(place)
+    if not any(fields.values()):
+        return []
+    location = Location(
+        city=fields["city"] or None,
+        postal_code=fields["postal_code"] or None,
+        street_address=fields["street_address"] or None,
+        state="Massachusetts",
+    )
+    matches = _finder().find(location, court_types=court_types or None)
+    found = []
+    for match in matches:
+        for record in match.records:
+            if not record.tyler_code:
+                continue
+            found.append(
+                {
+                    "code": str(record.tyler_code),
+                    "name": match.name,
+                    "department": match.department,
+                    "reason": match.reasons[0].detail if match.reasons else "",
+                }
+            )
+    return found
+
+
+@lru_cache(maxsize=1)
+def _vermont_finder():
+    from vtcourts import build_default_finder
+
+    return build_default_finder()
+
+
+def _vermont_matches(place: str, court_types: list[str]) -> list[dict[str, Any]]:
+    """Vermont units, found from a town, a county, or a ZIP.
+
+    A unit is named after its county, so the court is identified by name rather
+    than by code -- the e-filing service's own code for one of them carries a
+    spelling the name does not.
+    """
+
+    try:
+        from vtcourts import Location
+    except ImportError as error:  # pragma: no cover - depends on the install
+        raise LocationLookupUnavailable("Vermont court lookup needs the VTCourts package to be installed.") from error
+
+    fields = parse_place(place)
+    if not any(fields.values()):
+        return []
+    location = Location(
+        city=fields["city"] or None,
+        postal_code=fields["postal_code"] or None,
+        street_address=fields["street_address"] or None,
+        state="Vermont",
+    )
+    return [
+        {
+            "code": "",
+            "court_name": f"{match.unit} Unit",
+            "name": f"{match.unit} Unit",
+            "department": match.county,
+            "reason": match.reasons[0].detail if match.reasons else "",
+        }
+        for match in _vermont_finder().find_units(location)
+    ]
+
+
+MATCHERS = {"macourts": _massachusetts_matches, "vtcourts": _vermont_matches}
+
+
+def find_courts(matcher: str, place: str, court_types: list[str], courts: list[dict[str, str]]) -> list[dict[str, Any]]:
+    """The courts in ``courts`` that serve ``place``, with the reason for each.
+
+    ``courts`` is the pool the filer's earlier answers already narrowed to, so a
+    match outside it -- a Housing Court returned while the filer is choosing a
+    District Court, or a court this e-filing environment does not carry -- is
+    dropped rather than offered.
+    """
+
+    lookup = MATCHERS.get(matcher)
+    if lookup is None:
+        raise LocationLookupUnavailable(f"No court location lookup is configured for '{matcher}'.")
+
+    # A source identifies a court by whichever it actually holds: MACourts
+    # records carry the e-filing service's own code, and Vermont's units are
+    # known by name.
+    by_code = {normalize_court_code(court["value"]): court for court in courts}
+    by_name = {normalize_court_name(court["text"]): court for court in courts}
+    results: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for match in lookup(place, court_types):
+        court = by_code.get(normalize_court_code(match["code"])) if match.get("code") else None
+        if court is None and match.get("court_name"):
+            court = by_name.get(normalize_court_name(match["court_name"]))
+        if court is None or court["value"] in seen:
+            continue
+        seen.add(court["value"])
+        results.append({**court, "reason": match["reason"], "matched_name": match["name"]})
+    return results
diff --git a/efile_app/efile/services/court_selection.py b/efile_app/efile/services/court_selection.py
new file mode 100644
index 00000000..007f8f65
--- /dev/null
+++ b/efile_app/efile/services/court_selection.py
@@ -0,0 +1,824 @@
+"""Ask a filer the questions their own state's court structure actually needs.
+
+Every e-filing service hands us one flat list of "courts": 207 of them in
+Illinois, 170 in Massachusetts, 24 in Vermont. Dropping that list into a single
+dropdown asks the filer to recognize their court among the ones that come
+alphabetically near it, which is why a Peoria filer used to open the list on a
+Cook County division.
+
+The way out is not one better dropdown. It is asking the questions each state's
+hierarchy is actually made of -- Illinois routes by county, Massachusetts by
+court department plus a place the filer knows, Vermont by Superior Court unit --
+and letting the answers narrow the same live list. So the questions live in each
+jurisdiction's YAML (``court_selector:``) rather than in this module, and this
+module is the small engine that runs them:
+
+* a **step** is one question. It is shown when its ``when:`` conditions hold and
+  it has something to ask; ``choice`` renders as radio cards, ``select`` as a
+  dropdown, and ``location`` as a place lookup handed to a matcher.
+* an **option** may carry a **court query** -- a few declarative rules matched
+  against the live list. Answering a step narrows the pool to that query.
+* the deepest answered step wins, so a broad answer ("Cook County") is replaced
+  by the narrower one under it ("Cook County - Chancery - District 1").
+* when the pool is down to a single court, that is the selection. When it is
+  down to a handful, the filer picks from those instead of from 207.
+
+Nothing here hardcodes a state. A jurisdiction with no ``court_selector:`` block
+keeps the flat list it has today.
+
+Court **names**, not codes, are what partner configuration matches on wherever
+there is a choice: Tyler's codes differ per court and change without notice.
+Codes still do the filing.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+import requests
+from django.conf import settings
+from django.core.cache import cache
+
+from efile.services.court_location import LocationLookupUnavailable, find_courts
+from efile.utils.config_loader import config_loader
+
+logger = logging.getLogger(__name__)
+
+# Courts the e-filing service lists but nobody can file into: test fixtures,
+# retired locations, and the "System" row. Matched against the lowercased name.
+NON_FILING_COURT_MARKERS: tuple[str, ...] = (
+    "(zodyssey)",
+    "z -",
+    "zz",
+    "zdev",
+    "courtview test",
+    "rsi test",
+    "do not use",
+    "not used",
+    "file & serve",
+    "system",
+)
+
+# How long the live court list is reused for. It changes a few times a year, and
+# the selector re-reads it on every answer the filer gives.
+COURT_LIST_TTL_SECONDS = 600
+
+_PLACEHOLDER = re.compile(r"\{(\w+)\}")
+
+
+def is_non_filing_court(name: str) -> bool:
+    """Whether a court name marks a row that exists only inside Tyler."""
+
+    lowered = str(name or "").lower()
+    return any(marker in lowered for marker in NON_FILING_COURT_MARKERS)
+
+
+def selector_config(jurisdiction: str) -> dict[str, Any] | None:
+    """The ``court_selector:`` block for a jurisdiction, if it has one."""
+
+    try:
+        config = config_loader.load_jurisdiction_config(jurisdiction)
+    except Exception:  # pragma: no cover - a missing config is already logged
+        logger.exception("Could not load configuration for %s", jurisdiction)
+        return None
+    selector = (config or {}).get("court_selector")
+    if not isinstance(selector, dict) or not selector.get("steps"):
+        return None
+    return selector
+
+
+def fetch_courts(jurisdiction: str) -> list[dict[str, str]]:
+    """Every court the e-filing service will accept a filing for, as options.
+
+    ``fileable_only`` is unreliable on the test service -- it hides courts that
+    do offer filing categories -- so the whole named list is fetched and the
+    rows that are plainly not courts are dropped here instead.
+    """
+
+    cache_key = f"court-selector:courts:{jurisdiction}"
+    cached = cache.get(cache_key)
+    if cached is not None:
+        return cached
+
+    url = f"{settings.EFSP_URL}/jurisdictions/{jurisdiction}/codes/courts/"
+    response = requests.get(url, params={"fileable_only": False, "with_names": True}, timeout=15)
+    response.raise_for_status()
+    payload = response.json()
+    courts = [
+        {"value": str(court["code"]), "text": str(court["name"]).strip()}
+        for court in payload
+        if isinstance(court, dict) and court.get("code") and court.get("name")
+        if not is_non_filing_court(court["name"])
+    ]
+    fileable = _fileable_codes(jurisdiction)
+    courts = [court for court in courts if not _is_heading_only(court, courts, fileable)]
+    rules = (selector_config(jurisdiction) or {}).get("court_names") or []
+    for court in courts:
+        court["text"] = _readable_name(court["text"], rules)
+    courts.sort(key=lambda court: court["text"])
+    cache.set(cache_key, courts, COURT_LIST_TTL_SECONDS)
+    return courts
+
+
+def _readable_name(name: str, rules: list[dict[str, str]]) -> str:
+    """The name of a court as a court is named, not as the service files it.
+
+    E-filing services name courts so they sort: "Juvenile Court -- Suffolk
+    County -- Boston" puts the department first because that is how the list is
+    organized. Nobody calls it that. It is the Boston Juvenile Court, and a
+    filer holding paperwork is looking for those words. The first rule that
+    matches wins, and a name no rule matches is already right.
+    """
+
+    for rule in rules:
+        match = re.match(str(rule.get("match", "")), name, re.IGNORECASE)
+        if not match:
+            continue
+        rewritten = str(rule.get("name", ""))
+        for field, value in match.groupdict().items():
+            rewritten = rewritten.replace(f"{{{field}}}", (value or "").strip())
+        return " ".join(rewritten.split())
+    return name
+
+
+def _fileable_codes(jurisdiction: str) -> set[str] | None:
+    """The courts the e-filing service says accept filings, or ``None``.
+
+    Taken as a hint rather than as the truth. It is demonstrably incomplete --
+    Cook County's Chancery division is missing from it and offers three case
+    categories -- so it is only ever used to confirm something already suspected
+    from the shape of the list, and a request that fails changes nothing.
+    """
+
+    try:
+        response = requests.get(
+            f"{settings.EFSP_URL}/jurisdictions/{jurisdiction}/codes/courts/",
+            params={"fileable_only": True, "with_names": True},
+            timeout=15,
+        )
+        response.raise_for_status()
+        return {str(court["code"]) for court in response.json() if isinstance(court, dict) and court.get("code")}
+    except (requests.RequestException, ValueError, KeyError):
+        logger.warning("Could not read the fileable court list for %s", jurisdiction)
+        return None
+
+
+def _is_heading_only(court: dict[str, str], courts: list[dict[str, str]], fileable: set[str] | None) -> bool:
+    """Whether a court is only a heading over the courts underneath it.
+
+    "Cook County" is such a row: every Cook filing goes to one of the eighty
+    locations whose code hangs off it, and choosing the county itself is a dead
+    end -- the case category list comes back empty and the filer is stuck with
+    no way to see why. Both things have to be true to drop it, because a
+    division like Cook County - Chancery has locations under it and still takes
+    filings of its own.
+    """
+
+    if fileable is None or court["value"] in fileable:
+        return False
+    prefix = f"{court['value']}:"
+    return any(other["value"].startswith(prefix) for other in courts)
+
+
+def _fill(template: Any, answers: dict[str, str]) -> Any:
+    """Substitute ``{step_id}`` placeholders with the answers given so far."""
+
+    if isinstance(template, str):
+        return _PLACEHOLDER.sub(lambda match: str(answers.get(match.group(1), "")), template)
+    if isinstance(template, list):
+        return [_fill(item, answers) for item in template]
+    if isinstance(template, dict):
+        return {key: _fill(value, answers) for key, value in template.items()}
+    return template
+
+
+def _group_key(name: str, pattern: str) -> str:
+    """The grouping name a court belongs to, e.g. "Kankakee" for four courts.
+
+    Illinois names its counties' courts every which way -- "Adams County",
+    "Kankakee - Civil", "Peoria CR", "St. Clair County-Backlog" -- so the county
+    a court belongs to is read off the front of its name with a partner-supplied
+    pattern rather than assumed to be the whole name.
+    """
+
+    match = re.match(pattern, name, re.IGNORECASE)
+    if not match:
+        return ""
+    return (match.group(1) or "").strip()
+
+
+def match_courts(
+    courts: list[dict[str, str]],
+    query: dict[str, Any] | None,
+    answers: dict[str, str] | None = None,
+    group_by: str = "",
+) -> list[dict[str, str]]:
+    """The courts a query selects, in the order the query implies.
+
+    Supported rules, all optional and all combined with "and":
+
+    ``codes``
+        exact court codes, and the order to return them in.
+    ``code_prefix`` / ``code_pattern``
+        the code starts with, or matches, this.
+    ``name_pattern``
+        the name matches this (case-insensitive).
+    ``group``
+        the court's ``group_by`` name equals this.
+    ``exclude_code_pattern`` / ``exclude_name_pattern``
+        drop the courts these match.
+    """
+
+    if query is None:
+        return list(courts)
+    query = _fill(dict(query), answers or {})
+
+    codes = [str(code) for code in query.get("codes", []) if code]
+    code_prefix = query.get("code_prefix", "")
+    code_pattern = query.get("code_pattern", "")
+    name_pattern = query.get("name_pattern", "")
+    group = query.get("group", "")
+    exclude_code = query.get("exclude_code_pattern", "")
+    exclude_name = query.get("exclude_name_pattern", "")
+
+    selected = []
+    for court in courts:
+        code, name = court["value"], court["text"]
+        if codes and code not in codes:
+            continue
+        if code_prefix and not code.startswith(code_prefix):
+            continue
+        if code_pattern and not re.search(code_pattern, code, re.IGNORECASE):
+            continue
+        if name_pattern and not re.search(name_pattern, name, re.IGNORECASE):
+            continue
+        if group and (not group_by or _group_key(name, group_by).casefold() != group.casefold()):
+            continue
+        if exclude_code and re.search(exclude_code, code, re.IGNORECASE):
+            continue
+        if exclude_name and re.search(exclude_name, name, re.IGNORECASE):
+            continue
+        selected.append(court)
+
+    if codes:
+        order = {code: index for index, code in enumerate(codes)}
+        selected.sort(key=lambda court: order.get(court["value"], len(order)))
+    return selected
+
+
+def _visible(step: dict[str, Any], answers: dict[str, str]) -> bool:
+    """Whether a step's ``when:`` conditions hold.
+
+    ``when: {level: [trial], department: {not: [land]}}`` reads as "only for a
+    Trial Court filing, and not for the Land Court". An unanswered step named in
+    a condition fails it, which is what keeps later questions hidden until the
+    ones they depend on are answered.
+    """
+
+    for field, condition in (step.get("when") or {}).items():
+        answer = answers.get(field, "")
+        if isinstance(condition, dict) and "not" in condition:
+            # "not land" means "not known to be the Land Court". An unanswered
+            # field passes: forward building never gets here with one, because
+            # an unanswered step stops the walk, and working backwards from a
+            # saved court has to be able to pass a step it cannot derive.
+            if answer in {str(value) for value in condition["not"]}:
+                return False
+        else:
+            allowed = condition if isinstance(condition, list) else [condition]
+            if answer not in {str(value) for value in allowed}:
+                return False
+    return True
+
+
+def _static_options(step: dict[str, Any]) -> list[dict[str, Any]]:
+    options = [dict(option) for option in step.get("options", []) if isinstance(option, dict)]
+    for group in step.get("option_groups", []) or []:
+        # One option per member, each carrying the group's court query. Illinois
+        # asks for the county an appeal came from and answers with its appellate
+        # district, so the county is the option and the district is the court.
+        for member in group.get("members", []) or []:
+            options.append(
+                {
+                    "value": str(member),
+                    "label": str(group.get("member_label", "{member} - {group}"))
+                    .replace("{member}", str(member))
+                    .replace("{group}", str(group.get("label", ""))),
+                    "courts": group.get("courts"),
+                }
+            )
+    return options
+
+
+def _dynamic_options(
+    step: dict[str, Any],
+    courts: list[dict[str, str]],
+    answers: dict[str, str],
+    group_by: str,
+) -> list[dict[str, Any]]:
+    """Options read off the live court list rather than written out in YAML.
+
+    Counties, Cook County's divisions and Vermont's units are all just the court
+    list seen at a different depth, and generating them means the questions stay
+    right when the e-filing service adds or renames a court.
+    """
+
+    spec = step.get("options_from_courts")
+    if not isinstance(spec, dict):
+        return []
+
+    pool = match_courts(courts, spec.get("match"), answers, group_by)
+    label_template = spec.get("label", "{name}")
+    strip = spec.get("strip", "")
+    grouping = group_by if spec.get("group") else spec.get("group_by", "")
+
+    options: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for court in pool:
+        name = court["text"]
+        if grouping:
+            key = _group_key(name, grouping)
+            if not key or key.casefold() in seen:
+                continue
+            seen.add(key.casefold())
+            options.append(
+                {
+                    "value": key,
+                    "label": label_template.replace("{group}", key).replace("{name}", name),
+                    "courts": spec.get("courts", {"group": "{value}"}),
+                }
+            )
+            continue
+        stem = re.sub(strip, "", name).strip() if strip else name
+        label = label_template.replace("{name}", name).replace("{stem}", stem).replace("{code}", court["value"])
+        group, within, extra = _option_group(spec.get("option_group_pattern", ""), stem)
+        options.append(
+            {
+                "value": court["value"],
+                "label": within or label,
+                # What it has to be called away from its heading -- in the list
+                # of answers already given, where there is no heading to read.
+                "full_label": label,
+                "group": group,
+                "extra": extra,
+                "courts": spec.get("courts", {"codes": ["{value}"]}),
+            }
+        )
+    group_names = list(spec.get("option_group_names", []) or [])
+    if group_names:
+        return _name_groups(options, group_names, spec.get("option_group_other", ""))
+    for option in options:
+        option.pop("extra", "")
+    return _demote_lonely_groups(sorted(options, key=lambda option: (option.get("group", ""), option["label"])))
+
+
+def _option_group(pattern: str, name: str) -> tuple[str, str, str]:
+    """Split a court's name into the heading it sits under and what is left.
+
+    Cook County's e-filing locations are one long alphabetical run -- Chancery,
+    then twenty-odd criminal branches, then the municipal districts -- and a
+    filer is looking for their courthouse. Named captures say which part is
+    which: ``group`` is the heading, ``label`` what to show under it, and
+    ``extra`` anything that only matters when it is not the heading's own place.
+    """
+
+    if not pattern:
+        return "", "", ""
+    match = re.match(pattern, name, re.IGNORECASE)
+    if not match:
+        return "", "", ""
+    named = match.groupdict()
+    if "group" in named:
+        return (
+            (named.get("group") or "").strip(),
+            (named.get("label") or "").strip(),
+            (named.get("extra") or "").strip(),
+        )
+    groups = match.groups()
+    within = (groups[1] or "").strip() if len(groups) > 1 else ""
+    return (groups[0] or "").strip(), within, ""
+
+
+def _name_groups(
+    options: list[dict[str, Any]],
+    names: list[str],
+    other: str,
+) -> list[dict[str, Any]]:
+    """Give each heading its full name and its place in the order.
+
+    Partners write the headings out because the court list does not carry them:
+    the names say "District 2", and the filer knows the place. The order they
+    are written in is the order they are shown in, which is how the Chicago
+    courts come first in Cook County -- where most of its filings go.
+    """
+
+    headings = {}
+    for position, name in enumerate(names):
+        key = name.split(" - ")[0].strip()
+        headings[key] = (position, name, name[len(key) :].lstrip(" -").strip())
+
+    for option in options:
+        position, heading, place = headings.get(option.get("group", ""), (len(names), "", ""))
+        extra = option.pop("extra", "")
+        if extra and extra != place:
+            # A branch court inside the district, which its division alone does
+            # not tell apart from the district's own courthouse.
+            option["label"] = f"{option['label']} - {extra}" if option["label"] else extra
+        option["group"] = heading if option.get("group") else other
+        option["order"] = position if heading else len(names) + 1
+    return sorted(options, key=lambda option: (option["order"], option["label"]))
+
+
+def _demote_lonely_groups(options: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """A heading over one court is a heading that says nothing twice."""
+
+    counts: dict[str, int] = {}
+    for option in options:
+        group = option.get("group", "")
+        counts[group] = counts.get(group, 0) + 1
+    for option in options:
+        if counts.get(option.get("group", ""), 0) < 2:
+            option["group"] = ""
+            option["label"] = option.get("full_label") or option["label"]
+    # Ungrouped courts read first, then each heading with its own -- and under a
+    # heading, the division itself before the courthouses inside it.
+    return sorted(
+        options,
+        key=lambda option: (
+            option.get("group", ""),
+            option["label"] != option.get("group", ""),
+            option["label"],
+        ),
+    )
+
+
+def _default_answer(step: dict[str, Any], answers: dict[str, str]) -> str:
+    """The answer to start this question at, given what is answered already.
+
+    ``default_by`` reads one earlier answer and maps it to a court: Cook County
+    starts at its Municipal Civil division, where most Cook filings go, because
+    "Cook County" on its own is not a court anyone can file into.
+    """
+
+    spec = step.get("default_by")
+    if not isinstance(spec, dict):
+        return ""
+    return str((spec.get("values") or {}).get(answers.get(spec.get("answer", ""), ""), ""))
+
+
+def _answered_option(step: dict[str, Any], options: list[dict[str, Any]], answer: str) -> dict[str, Any] | None:
+    for option in options:
+        if str(option.get("value")) == answer:
+            return option
+    return None
+
+
+def _public_step(step: dict[str, Any], options: list[dict[str, Any]], answer: str) -> dict[str, Any]:
+    return {
+        "id": step["id"],
+        "type": step.get("type", "select"),
+        "label": step.get("label", ""),
+        "short_label": step.get("short_label", step.get("label", "")),
+        "hint": step.get("hint", ""),
+        "placeholder": step.get("placeholder", ""),
+        "alternative_to": step.get("alternative_to", ""),
+        "answer": answer,
+        "defaulted": False,
+        "default_hint": step.get("default_hint", ""),
+        "options": [
+            {
+                "value": option["value"],
+                "label": option.get("label", ""),
+                "full_label": option.get("full_label", ""),
+                "help": option.get("help", ""),
+                "group": option.get("group", ""),
+            }
+            for option in options
+        ],
+    }
+
+
+def build_selection(
+    jurisdiction: str,
+    answers: dict[str, str],
+    courts: list[dict[str, str]] | None = None,
+) -> dict[str, Any] | None:
+    """Run the configured questions against the live court list.
+
+    Returns what the screen needs to draw itself: the questions to ask now, the
+    courts the answers have narrowed to, and the one court chosen if the answers
+    have got that far. ``None`` means this jurisdiction has no configured
+    selector and should keep its flat list.
+
+    ``answers["court"]`` is the filer's final pick, and it is kept separate from
+    the routing answers above it: a court is only ever the selection while it is
+    still one of the courts those answers lead to.
+    """
+
+    config = selector_config(jurisdiction)
+    if config is None:
+        return None
+    if courts is None:
+        courts = fetch_courts(jurisdiction)
+
+    answers = {key: str(value) for key, value in (answers or {}).items() if value not in (None, "")}
+    group_by = config.get("group_by", "")
+
+    steps: list[dict[str, Any]] = []
+    chosen_options: dict[str, dict[str, Any]] = {}
+    pool = list(courts)
+    path: list[str] = []
+    waiting = False  # a visible step is unanswered, so nothing below it applies
+    waiting_on = ""
+    location: dict[str, Any] | None = None
+
+    for raw_step in config["steps"]:
+        if not _visible(raw_step, answers):
+            continue
+        # Two ways of naming the same court -- the appellate district itself, or
+        # the county the case came from. Both stay on screen so the filer can
+        # use whichever their paperwork supports, but only one of them answers:
+        # once its partner is answered, this step has nothing left to decide.
+        alternative_to = raw_step.get("alternative_to", "")
+        answered_instead = bool(alternative_to and answers.get(alternative_to))
+        if waiting and alternative_to != waiting_on:
+            continue
+
+        if raw_step.get("type") == "location":
+            step = _public_step(raw_step, [], "" if answered_instead else answers.get(raw_step["id"], ""))
+            step["examples"] = list(raw_step.get("examples", []) or [])
+            step["manual_label"] = raw_step.get("manual_label", "")
+            step["button_label"] = raw_step.get("button_label", "")
+            step["no_match_hint"] = raw_step.get(
+                "no_match_hint",
+                "We could not match that place to a court. Try adding more detail, or choose your court from the list.",
+            )
+            steps.append(step)
+            if answered_instead:
+                # The filer named their court outright, so there is nothing to
+                # look up. The box stays on screen as the other way in.
+                continue
+            location = _lookup_location(raw_step, answers, chosen_options, pool)
+            # One court serves this place, so that is the answer, shown by name
+            # with the reason it was chosen. Anything else -- overlapping
+            # jurisdictions, or a place the rules could not place at all --
+            # leaves the filer to say which court is theirs, from the matches or
+            # from the whole department. The pool stays the whole department
+            # either way, because the list is always the way out.
+            if location.get("place"):
+                path.append(location["place"])
+            matched = location.get("matched") or []
+            if len(matched) == 1:
+                answers.setdefault("court", matched[0]["value"])
+                if waiting and alternative_to == waiting_on:
+                    waiting, waiting_on = False, ""
+            elif not waiting:
+                waiting, waiting_on = True, raw_step["id"]
+            continue
+
+        options = _static_options(raw_step) or _dynamic_options(raw_step, pool, answers, group_by)
+        if raw_step.get("options_from_courts") and len(options) < 2:
+            # Nothing to ask: this county has one court, or this department one
+            # location. Skipping keeps the extra question for the places that
+            # genuinely have one, which in Illinois is mostly Cook County.
+            continue
+
+        given = "" if answered_instead else answers.get(raw_step["id"], "")
+        chosen = _answered_option(raw_step, options, given)
+        # A county with dozens of filing locations can start the filer at the
+        # one most filings go to rather than at nothing. The question stays on
+        # screen with that answer in it, so a suggestion is never mistaken for
+        # something the filer said.
+        defaulted = chosen is None and not answered_instead
+        if defaulted:
+            chosen = _answered_option(raw_step, options, _default_answer(raw_step, answers))
+            defaulted = chosen is not None
+        step = _public_step(raw_step, options, chosen["value"] if chosen else "")
+        step["defaulted"] = defaulted
+        steps.append(step)
+        if chosen is None:
+            if not waiting and not answered_instead:
+                waiting, waiting_on = True, raw_step["id"]
+            continue
+        if waiting and alternative_to == waiting_on:
+            waiting, waiting_on = False, ""
+
+        chosen_options[raw_step["id"]] = chosen
+        # The whole name, not the short one its heading made possible: the
+        # trail is read on its own, with no heading above it.
+        path.append(chosen.get("full_label") or chosen.get("label", ""))
+        if chosen.get("courts"):
+            pool = match_courts(pool, chosen["courts"], {**answers, "value": chosen["value"]}, group_by)
+
+    # One court left, and every question answered, is an answer in itself: there
+    # is nothing to choose between, so the filer is not asked to.
+    selected = None
+    picked = answers.get("court", "")
+    if picked:
+        selected = next((court for court in pool if court["value"] == picked), None)
+    if selected is None and not waiting and len(pool) == 1:
+        selected = pool[0]
+
+    return {
+        "jurisdiction": jurisdiction,
+        "title": config.get("title", ""),
+        "lede": config.get("lede", ""),
+        "steps": steps,
+        "path": path,
+        "courts": pool,
+        "location": location,
+        "waiting": waiting,
+        "selected": selected,
+        "complete": selected is not None,
+    }
+
+
+def _lookup_location(
+    step: dict[str, Any],
+    answers: dict[str, str],
+    chosen_options: dict[str, dict[str, Any]],
+    pool: list[dict[str, str]],
+) -> dict[str, Any]:
+    """Ask the configured matcher which of ``pool`` serves the place typed in.
+
+    A lookup that finds nothing is not an error and not a dead end: the same
+    screen still offers every court in ``pool`` to choose from by hand, which is
+    the only way through for an address the rules cannot place -- a Boston
+    neighborhood with no street number, say, where which BMC division serves it
+    is a question about a specific building.
+    """
+
+    place = answers.get(step["id"], "")
+    source = step.get("court_types_from", "")
+    court_types = list((chosen_options.get(source) or {}).get("court_types", []) or [])
+    result: dict[str, Any] = {"place": place, "matched": [], "searched": bool(place), "error": ""}
+    if not place:
+        return result
+    try:
+        result["matched"] = find_courts(step.get("matcher", ""), place, court_types, pool)
+    except LocationLookupUnavailable as error:
+        logger.warning("Court location lookup unavailable for %s: %s", step.get("matcher", ""), error)
+        result["error"] = str(error)
+    except Exception:
+        logger.exception("Court location lookup failed for place %r", place)
+        result["error"] = "We could not look that place up just now. Choose a court from the list instead."
+    return result
+
+
+def derive_answers(jurisdiction: str, court_code: str, courts: list[dict[str, str]] | None = None) -> dict[str, str]:
+    """Work backwards from a saved court code to the answers that reach it.
+
+    A filer who comes back to a draft, or whose document named their court,
+    should find the questions already answered rather than an empty first step.
+    Each step is asked which of its options still contains the saved court, and
+    the answer that does is filled in.
+    """
+
+    config = selector_config(jurisdiction)
+    if config is None or not court_code:
+        return {}
+    if courts is None:
+        courts = fetch_courts(jurisdiction)
+    if not any(court["value"] == court_code for court in courts):
+        return {}
+
+    group_by = config.get("group_by", "")
+    answers: dict[str, str] = {}
+    pool = list(courts)
+    for _ in range(len(config["steps"])):
+        progressed = False
+        for raw_step in config["steps"]:
+            if raw_step["id"] in answers or raw_step.get("type") == "location":
+                continue
+            if answers.get(raw_step.get("alternative_to", "")):
+                # Its partner already named this court; asking twice would only
+                # invite the two answers to disagree.
+                continue
+            if not _visible(raw_step, answers):
+                continue
+            options = _static_options(raw_step) or _dynamic_options(raw_step, pool, answers, group_by)
+            if raw_step.get("options_from_courts") and len(options) < 2:
+                continue
+            for option in options:
+                query = option.get("courts")
+                narrowed = match_courts(pool, query, {**answers, "value": option["value"]}, group_by) if query else pool
+                if query and any(court["value"] == court_code for court in narrowed):
+                    answers[raw_step["id"]] = str(option["value"])
+                    pool = narrowed
+                    progressed = True
+                    break
+            if progressed:
+                break
+        if not progressed:
+            break
+    return answers
+
+
+def _significant_words(text: str) -> set[str]:
+    return {word for word in re.split(r"[^a-z0-9]+", str(text or "").lower()) if word}
+
+
+def courts_matching_text(guess: str, courts: list[dict[str, str]], group_by: str = "") -> list[dict[str, str]]:
+    """The courts a free-text court name from a document could be naming.
+
+    A court matches when every word of its name appears in the guess, so a
+    caption reading "In the Circuit Court of Cook County" matches "Cook County"
+    and not "Cook County - Chancery - District 1 - Chicago", which says three
+    things the document never did. Only the most specific matches are kept: a
+    document that did name the division should not still be offered the county.
+
+    A match that other courts sit under brings them with it. "Circuit Court of
+    Cook County" is true of every Cook division, so it can settle the county and
+    nothing below it -- which is the point: the document named a county, and
+    choosing a division on its behalf would be inventing something it never said.
+    """
+
+    words = _significant_words(guess)
+    if not words:
+        return []
+    matches = [court for court in courts if _significant_words(court["text"]) <= words]
+    if not matches and group_by:
+        # No single court, but the document may still have named the county
+        # every court in it belongs to. "Circuit Court of Cook County" is the
+        # ordinary case: Cook has no court of its own to match, and eighty
+        # locations that all belong to it.
+        named = {
+            key
+            for key in (_group_key(court["text"], group_by) for court in courts)
+            if key and _significant_words(key) <= words
+        }
+        return [court for court in courts if _group_key(court["text"], group_by) in named]
+    if not matches:
+        return []
+    longest = max(len(_significant_words(court["text"])) for court in matches)
+    matches = [court for court in matches if len(_significant_words(court["text"])) == longest]
+
+    found = {court["value"]: court for court in matches}
+    for match in matches:
+        for court in courts:
+            under = court["value"].startswith(f"{match['value']}:") or (
+                court["text"].startswith(match["text"]) and court["text"] != match["text"]
+            )
+            if under:
+                found[court["value"]] = court
+    return list(found.values())
+
+
+def derive_answers_from_guess(
+    jurisdiction: str,
+    guess: str,
+    courts: list[dict[str, str]] | None = None,
+) -> dict[str, str]:
+    """Answer the questions a document's own words already settle.
+
+    A caption that names the county answers the county question, even when it
+    leaves the division open -- which is the ordinary case, since captions say
+    "Circuit Court of Cook County" and stop there. A step is only answered when
+    every court the guess could mean falls under one of its options, so nothing
+    here decides something the document did not say.
+    """
+
+    config = selector_config(jurisdiction)
+    if config is None or not guess:
+        return {}
+    if courts is None:
+        courts = fetch_courts(jurisdiction)
+
+    group_by = config.get("group_by", "")
+    candidates = courts_matching_text(guess, courts, group_by)
+    if not candidates:
+        return {}
+    if len(candidates) == 1:
+        answers = derive_answers(jurisdiction, candidates[0]["value"], courts)
+        answers["court"] = candidates[0]["value"]
+        return answers
+
+    wanted = {court["value"] for court in candidates}
+    answers = {}
+    pool = list(courts)
+    for _ in range(len(config["steps"])):
+        progressed = False
+        for raw_step in config["steps"]:
+            if raw_step["id"] in answers or raw_step.get("type") == "location":
+                continue
+            if answers.get(raw_step.get("alternative_to", "")) or not _visible(raw_step, answers):
+                continue
+            options = _static_options(raw_step) or _dynamic_options(raw_step, pool, answers, group_by)
+            if raw_step.get("options_from_courts") and len(options) < 2:
+                continue
+            for option in options:
+                query = option.get("courts")
+                if not query:
+                    continue
+                narrowed = match_courts(pool, query, {**answers, "value": option["value"]}, group_by)
+                if wanted <= {court["value"] for court in narrowed}:
+                    answers[raw_step["id"]] = str(option["value"])
+                    pool, progressed = narrowed, True
+                    break
+            if progressed:
+                break
+        if not progressed:
+            break
+    return answers
diff --git a/efile_app/efile/services/extraction_fields.py b/efile_app/efile/services/extraction_fields.py
index 7bdf508a..39fa01d7 100644
--- a/efile_app/efile/services/extraction_fields.py
+++ b/efile_app/efile/services/extraction_fields.py
@@ -38,6 +38,28 @@
     "classification evidence": "Classification evidence",
 }
 
+EXTRACTION_KEY_ALIASES = {
+    "plaintiff name": "plaintiff or petitioner names",
+    "plaintiff names": "plaintiff or petitioner names",
+    "petitioner name": "plaintiff or petitioner names",
+    "petitioner names": "plaintiff or petitioner names",
+    "plaintiff/petitioner names": "plaintiff or petitioner names",
+    "plaintiff and petitioner names": "plaintiff or petitioner names",
+    "defendant name": "defendant or respondent names",
+    "defendant names": "defendant or respondent names",
+    "respondent name": "defendant or respondent names",
+    "respondent names": "defendant or respondent names",
+    "defendant/respondent names": "defendant or respondent names",
+    "defendant and respondent names": "defendant or respondent names",
+    "other parties": "other party names",
+    "other party name": "other party names",
+}
+
+
+def _normalized_key(raw_key):
+    key = str(raw_key).strip().lower()
+    return EXTRACTION_KEY_ALIASES.get(key, key)
+
 
 def normalize_extracted_fields(found_fields):
     """Keep every extracted value while normalizing keys used by the workflow."""
@@ -48,7 +70,7 @@ def normalize_extracted_fields(found_fields):
     for raw_key, value in found_fields.items():
         if value in (None, "", [], {}):
             continue
-        key = str(raw_key).strip().lower()
+        key = _normalized_key(raw_key)
         if key in {"court name", "court unit", "court or county"}:
             key = "court"
         elif key in {"docker number", "case number"}:
@@ -71,7 +93,7 @@ def normalize_document_evidence(found_fields):
     for raw_key, value in found_fields.items():
         if value in (None, "", [], {}):
             continue
-        key = str(raw_key).strip().lower()
+        key = _normalized_key(raw_key)
         if key in {"court unit", "court or county"}:
             key = "court name"
         elif key in {"monetary amount", "amount in controversy"}:
@@ -88,7 +110,7 @@ def display_extracted_fields(found_fields):
     for raw_key, value in found_fields.items():
         if value in (None, "", [], {}):
             continue
-        key = str(raw_key).strip().lower()
+        key = _normalized_key(raw_key)
         if key in {"court name", "court unit", "court or county"}:
             key = "court"
         if isinstance(value, list):
diff --git a/efile_app/efile/static/config/states/illinois.yaml b/efile_app/efile/static/config/states/illinois.yaml
index f02db12e..66e9b4f1 100644
--- a/efile_app/efile/static/config/states/illinois.yaml
+++ b/efile_app/efile/static/config/states/illinois.yaml
@@ -551,3 +551,258 @@ court_specific_requirements:
             modifications:
               conditional_requirements:
                 hidden_for_courts: ["bond"]
+
+# How a filer says which court this filing goes to.
+#
+# Illinois routes by county: the e-filing service lists more than 200 courts,
+# and all but a handful of them belong to one county. So the county question
+# does nearly all the narrowing, and only the counties that divide their
+# Circuit Court further -- Cook above all -- get asked a second question. An
+# appeal can be identified either way round: by the appellate district if the
+# paperwork names one, or by the county the Circuit Court case came from.
+court_selector:
+  title: "Choose the Illinois court for this filing"
+  lede: >-
+    Start with the court level shown on your paperwork.
+  # The county a court belongs to, read off the front of its name. Illinois
+  # names them every which way -- "Adams County", "Kankakee - Civil", "Peoria
+  # CR", "St. Clair County-Backlog" -- and they all have to land in one group.
+  group_by: '^(.*?)(?:\s+County\b.*|\s+-\s+.*|\s+(?:CR|CS|TR)$|$)'
+  steps:
+    - id: level
+      type: choice
+      short_label: "Court level"
+      label: "What level of Illinois court is this filing for?"
+      options:
+        - value: circuit
+          label: "Circuit Court"
+          help: "The Illinois trial court."
+          courts:
+            # "Goodin ECF5" is a vendor test location that the e-filing
+            # service lists alongside the real courts.
+            exclude_name_pattern: 'Supreme Court|Appellate Court|ARDC|^Goodin'
+        - value: appellate
+          label: "Appellate Court"
+          help: "The Illinois intermediate appellate court."
+          courts:
+            name_pattern: 'Appellate Court'
+        - value: supreme
+          label: "Illinois Supreme Court"
+          help: "The highest court in Illinois."
+          courts:
+            name_pattern: 'Supreme Court of Illinois'
+
+    - id: county
+      type: select
+      short_label: "County"
+      when:
+        level: [circuit]
+      label: "Which county is the Circuit Court case in?"
+      placeholder: "Choose a county…"
+      hint: >-
+        The county your case is in. It is usually named at the top of your
+        paperwork.
+      options_from_courts:
+        # One option per county, gathered from every court in it -- including
+        # counties that only appear as divisions, and counties whose own row the
+        # e-filing service does not offer for filing.
+        group: true
+        label: "{group} County"
+        courts:
+          group: "{value}"
+
+    - id: division
+      type: select
+      short_label: "Division or courthouse"
+      when:
+        level: [circuit]
+      label: "Which division or courthouse does your paperwork name?"
+      placeholder: "Choose a division or courthouse…"
+      hint: >-
+        Your paperwork names a division, a district, or a courthouse. Look for
+        it near the top of the first page.
+      # "Cook County" on its own is not a court anyone can file into, and a
+      # caption naming only the county is the ordinary case. Municipal Civil is
+      # where most Cook filings go, so the question starts there.
+      default_by:
+        answer: county
+        values:
+          Cook: "cook:cvd"
+      default_hint: >-
+        We have started you at Municipal Civil, where most Cook County filings
+        go. Change it if your paperwork names a different division or courthouse.
+      options_from_courts:
+        match:
+          group: "{county}"
+        strip: '^.*?\s+-\s+'
+        label: "{stem}"
+        # Cook County lists more than eighty locations in one alphabetical run.
+        # Grouped by courthouse, a filer finds the building they are going to and
+        # then the division -- and the Chicago courts, where most Cook filings
+        # go, are all together at the top.
+        option_group_pattern: '^(?P<label>.*?)\s+-\s+(?P<group>District \d+)\b(?:\s+-\s+(?P<extra>.*))?$'
+        # The court list names each district by number; the filer knows the
+        # place. Written here in the order they are shown in.
+        option_group_names:
+          - "District 1 - Chicago"
+          - "District 2 - Skokie"
+          - "District 3 - Rolling Meadows"
+          - "District 4 - Maywood"
+          - "District 5 - Bridgeview"
+          - "District 6 - Markham"
+        option_group_other: "No courthouse given"
+
+    - id: appellate_district
+      type: select
+      short_label: "Appellate district"
+      when:
+        level: [appellate]
+      label: "Which appellate district?"
+      placeholder: "Choose a district…"
+      hint: >-
+        If your paperwork names the appellate district, choose it here.
+        Otherwise use the county question below. You only need one of them.
+      options_from_courts:
+        match:
+          name_pattern: 'Appellate Court'
+        label: "{name}"
+
+    - id: appellate_county
+      type: select
+      short_label: "County the case came from"
+      when:
+        level: [appellate]
+      alternative_to: appellate_district
+      label: "Or the county the Circuit Court case came from"
+      placeholder: "Choose a county instead…"
+      hint: >-
+        The county the original case was filed in. Each one shows the appellate
+        district it belongs to.
+      option_groups:
+        - label: "1st Appellate District"
+          member_label: "{member} County — {group}"
+          courts:
+            name_pattern: '1st District'
+          members:
+            - "Cook"
+        - label: "2nd Appellate District"
+          member_label: "{member} County — {group}"
+          courts:
+            name_pattern: '2nd District'
+          members:
+            - "DeKalb"
+            - "Kane"
+            - "Kendall"
+            - "Lake"
+            - "McHenry"
+        - label: "3rd Appellate District"
+          member_label: "{member} County — {group}"
+          courts:
+            name_pattern: '3rd District'
+          members:
+            - "Bureau"
+            - "DuPage"
+            - "Grundy"
+            - "Iroquois"
+            - "Kankakee"
+            - "LaSalle"
+            - "Will"
+        - label: "4th Appellate District"
+          member_label: "{member} County — {group}"
+          courts:
+            name_pattern: '4th District'
+          members:
+            - "Adams"
+            - "Boone"
+            - "Brown"
+            - "Calhoun"
+            - "Carroll"
+            - "Cass"
+            - "Fulton"
+            - "Greene"
+            - "Hancock"
+            - "Henderson"
+            - "Henry"
+            - "Jersey"
+            - "Jo Daviess"
+            - "Knox"
+            - "Lee"
+            - "Livingston"
+            - "Logan"
+            - "Macoupin"
+            - "Marshall"
+            - "Mason"
+            - "McDonough"
+            - "McLean"
+            - "Menard"
+            - "Mercer"
+            - "Morgan"
+            - "Ogle"
+            - "Peoria"
+            - "Pike"
+            - "Putnam"
+            - "Rock Island"
+            - "Sangamon"
+            - "Schuyler"
+            - "Scott"
+            - "Stark"
+            - "Stephenson"
+            - "Tazewell"
+            - "Warren"
+            - "Whiteside"
+            - "Winnebago"
+            - "Woodford"
+            - "Ford"
+        - label: "5th Appellate District"
+          member_label: "{member} County — {group}"
+          courts:
+            name_pattern: '5th District'
+          members:
+            - "Alexander"
+            - "Bond"
+            - "Champaign"
+            - "Christian"
+            - "Clark"
+            - "Clay"
+            - "Clinton"
+            - "Coles"
+            - "Crawford"
+            - "Cumberland"
+            - "De Witt"
+            - "Douglas"
+            - "Edgar"
+            - "Edwards"
+            - "Effingham"
+            - "Fayette"
+            - "Franklin"
+            - "Gallatin"
+            - "Hamilton"
+            - "Hardin"
+            - "Jackson"
+            - "Jasper"
+            - "Jefferson"
+            - "Johnson"
+            - "Lawrence"
+            - "Macon"
+            - "Madison"
+            - "Marion"
+            - "Massac"
+            - "Monroe"
+            - "Montgomery"
+            - "Moultrie"
+            - "Perry"
+            - "Piatt"
+            - "Pope"
+            - "Pulaski"
+            - "Randolph"
+            - "Richland"
+            - "Saline"
+            - "Shelby"
+            - "St. Clair"
+            - "Union"
+            - "Vermilion"
+            - "Wabash"
+            - "Washington"
+            - "Wayne"
+            - "White"
+            - "Williamson"
diff --git a/efile_app/efile/static/config/states/massachusetts.yaml b/efile_app/efile/static/config/states/massachusetts.yaml
index fe5be992..e98d1921 100644
--- a/efile_app/efile/static/config/states/massachusetts.yaml
+++ b/efile_app/efile/static/config/states/massachusetts.yaml
@@ -131,3 +131,146 @@ terminology:
   petitioner: "Plaintiff"
   case_number: "Docket Number"
   filing_fee: "Entry Fee"
+
+# How a filer says which court this filing goes to.
+#
+# Massachusetts does not route by county, and asking a filer for one produces a
+# confident wrong answer: the District Court that serves Somerville is not in
+# the county its Probate and Family Court is, and which Boston Municipal Court
+# division serves an address is a question about a specific building. So the
+# Trial Court asks for a department and then for a place the filer knows, and
+# MACourts turns that place into the courts that serve it. The list is always
+# there as well -- the lookup is an alternative, never a requirement.
+court_selector:
+  title: "Choose the Massachusetts court for this filing"
+  # The e-filing service names courts so that they sort -- department first,
+  # then county, then place -- which is not what anyone calls them. A filer
+  # holding paperwork is looking for "Boston Juvenile Court", so that is what
+  # the list says. The first rule that matches wins.
+  court_names:
+    - match: '^Juvenile Court -+ (?P<county>.+?) -+ (?P<place>.+)$'
+      name: "{place} Juvenile Court - {county}"
+    - match: '^District Court -+ (?P<place>.+)$'
+      name: "{place} District Court"
+    - match: '^BMC -+ (?P<place>.+)$'
+      name: "{place} Division, Boston Municipal Court"
+    - match: '^Superior Court -+ (?P<place>.+)$'
+      name: "{place} Superior Court"
+    - match: '^Housing -+ (?P<place>[^(]+?) \((?P<city>.+)\)$'
+      name: "{place} Housing Court ({city})"
+    - match: '^Housing -+ (?P<place>.+)$'
+      name: "{place} Housing Court"
+  lede: >-
+    Start with the court shown on your paperwork.
+  steps:
+    - id: level
+      type: choice
+      short_label: "Court level"
+      label: "What level of Massachusetts court is this filing for?"
+      options:
+        - value: trial
+          label: "Trial Court"
+          help: "District/BMC, Housing, Probate and Family, Juvenile, Superior, or Land Court."
+          courts:
+            exclude_name_pattern: "Appeals Court|Supreme Judicial Court"
+        - value: appeals
+          label: "Appeals Court"
+          help: "For a filing in the Massachusetts Appeals Court."
+          courts:
+            name_pattern: "Appeals Court"
+        - value: sjc
+          label: "Supreme Judicial Court"
+          help: "The highest court in Massachusetts."
+          courts:
+            name_pattern: "Supreme Judicial Court"
+
+    - id: proceeding
+      type: choice
+      short_label: "Proceeding"
+      when:
+        level: [appeals]
+      label: "Which Appeals Court proceeding?"
+      hint: >-
+        The docket number on your paperwork tells you which one: a P docket is
+        a panel, a J docket is a single justice.
+      options:
+        - value: panel
+          label: "Panel"
+          help: "A regular appellate panel proceeding (P docket)."
+          courts:
+            name_pattern: "Panel"
+        - value: single_justice
+          label: "Single justice"
+          help: "A single-justice proceeding (J docket)."
+          courts:
+            name_pattern: "Single Justice"
+
+    - id: department
+      type: select
+      short_label: "Department"
+      when:
+        level: [trial]
+      label: "Which Trial Court department?"
+      placeholder: "Choose a department…"
+      hint: >-
+        The department is named on your paperwork. Choose District Court or
+        Boston Municipal Court for either of those.
+      # `court_types` are the department names MACourts matches on. `courts` is
+      # how that department's locations are picked out of the e-filing service's
+      # own list, by name -- the parent rows Tyler carries for a whole
+      # department ("Housing Courts", "Superior Courts") are not places to file.
+      options:
+        - value: district
+          label: "District Court or Boston Municipal Court"
+          court_types: ["District Court", "Boston Municipal Court"]
+          courts:
+            name_pattern: "District Court$|Boston Municipal Court$"
+        - value: housing
+          label: "Housing Court"
+          court_types: ["Housing Court"]
+          courts:
+            name_pattern: "Housing"
+            exclude_name_pattern: "^Housing Courts$"
+        - value: probate
+          label: "Probate and Family Court"
+          court_types: ["Probate and Family Court"]
+          courts:
+            name_pattern: "Probate and Family Court$"
+        - value: juvenile
+          label: "Juvenile Court"
+          court_types: ["Juvenile Court"]
+          courts:
+            name_pattern: "Juvenile Court - .+ County$"
+        - value: superior
+          label: "Superior Court"
+          court_types: ["Superior Court"]
+          courts:
+            name_pattern: "Superior Court"
+            exclude_name_pattern: "^Superior Courts$"
+        - value: land
+          label: "Land Court"
+          help: "The Land Court covers all of Massachusetts."
+          court_types: ["Land Court"]
+          courts:
+            name_pattern: "^Land Court$"
+
+    - id: place
+      type: location
+      short_label: "Place"
+      when:
+        level: [trial]
+        department:
+          not: [land]
+      label: "Where is the case connected to?"
+      placeholder: "Town, city, or street address"
+      button_label: "Find courts"
+      hint: >-
+        A town, a city, or a street address -- whatever you know. For a Boston
+        address, include the street.
+      examples: ["Cambridge", "Somerville", "24 Beacon St, Boston", "Brockton", "Northampton"]
+      matcher: macourts
+      court_types_from: department
+      manual_label: "Or choose your court from the list"
+      no_match_hint: >-
+        We could not match that place to a court. Try adding a street address,
+        or choose your court from the list below.
diff --git a/efile_app/efile/static/config/states/vermont.yaml b/efile_app/efile/static/config/states/vermont.yaml
index 5ee22949..d566bf13 100644
--- a/efile_app/efile/static/config/states/vermont.yaml
+++ b/efile_app/efile/static/config/states/vermont.yaml
@@ -63,3 +63,100 @@ case_types:
     # Vermont requires, and what its courts call each form, is not what Illinois
     # requires -- so add `matches` and `documents` here to turn one on. See the
     # "Document checklists" section of ../README.md.
+
+# How a filer says which court this filing goes to.
+#
+# Vermont's public hierarchy is already close to its e-filing hierarchy: court
+# level, then Superior Court division, then the geographic unit for the
+# divisions that have one. Units follow county lines, so each one is labelled
+# with its county -- the Judiciary says "unit", and filers say "county".
+court_selector:
+  title: "Choose the Vermont court for this filing"
+  lede: >-
+    Start with the court shown on your paperwork.
+  steps:
+    - id: level
+      type: choice
+      short_label: "Court"
+      label: "What Vermont court is this filing for?"
+      options:
+        - value: superior
+          label: "Superior Court"
+          help: "Vermont's trial court."
+          courts:
+            name_pattern: "Unit$|^Environmental Division$"
+        - value: supreme
+          label: "Supreme Court"
+          help: "Vermont's appellate court. It sits statewide."
+          courts:
+            name_pattern: "^Supreme Court$"
+        - value: bureau
+          label: "Judicial Bureau"
+          help: "Traffic tickets and other civil violations, statewide."
+          courts:
+            name_pattern: "^Judicial Bureau$"
+
+    - id: division
+      type: select
+      short_label: "Division"
+      when:
+        level: [superior]
+      label: "Which Superior Court division?"
+      placeholder: "Choose a division…"
+      hint: "The division is named on your paperwork."
+      # Only the Environmental Division is its own e-filing location. The other
+      # four are divisions of the unit the case is filed in, so they narrow
+      # nothing here and the unit question below does the routing.
+      options:
+        - value: civil
+          label: "Civil Division"
+        - value: criminal
+          label: "Criminal Division"
+        - value: family
+          label: "Family Division"
+        - value: probate
+          label: "Probate Division"
+        - value: environmental
+          label: "Environmental Division"
+          courts:
+            name_pattern: "^Environmental Division$"
+
+    - id: unit
+      type: select
+      short_label: "Unit"
+      when:
+        level: [superior]
+        division:
+          not: [environmental]
+      label: "Which court unit?"
+      placeholder: "Choose a unit…"
+      hint: >-
+        Court units follow county lines, so each one is shown with the county
+        it covers.
+      options_from_courts:
+        match:
+          name_pattern: " Unit$"
+        strip: " Unit$"
+        label: "{name} ({stem} County)"
+
+    # A filer knows the town they live in. Whether that town is in the Washington
+    # Unit is a different question, and one they should not have to answer, so
+    # the unit dropdown above and this lookup are two ways into the same answer.
+    - id: place
+      type: location
+      short_label: "Town or ZIP code"
+      when:
+        level: [superior]
+        division:
+          not: [environmental]
+      alternative_to: unit
+      label: "Or find the unit from a town or ZIP code"
+      placeholder: "Town, city, or ZIP code"
+      button_label: "Find unit"
+      hint: >-
+        The town or ZIP code the case is connected to.
+      examples: ["Burlington", "Montpelier", "Rutland", "Brattleboro", "05487"]
+      matcher: vtcourts
+      no_match_hint: >-
+        We could not match that town or ZIP code to a unit. Check the spelling,
+        or choose the unit from the list above.
diff --git a/efile_app/efile/static/css/components/court-selector.css b/efile_app/efile/static/css/components/court-selector.css
new file mode 100644
index 00000000..fa50e4cb
--- /dev/null
+++ b/efile_app/efile/static/css/components/court-selector.css
@@ -0,0 +1,229 @@
+/* The guided court question: a short cascade of answers that narrows the
+   e-filing service's whole court list down to one court. Drawn by
+   court-selector.js from what each jurisdiction's YAML configures, so the same
+   styles carry a three-question Illinois cascade and a Massachusetts place
+   lookup. */
+.court-selector:empty {
+    display: none;
+}
+
+.court-selector__lede {
+    color: var(--text-muted);
+    margin: 0 0 1rem;
+}
+
+/* Questions already answered, folded to one line each. The whole point is
+   height: the court field sits beside three others on the confirm-filing
+   screen, and an open cascade pushed them off the screen. */
+.court-selector__trail {
+    display: grid;
+    gap: 0.35rem;
+    margin-bottom: 0.9rem;
+}
+
+.court-selector__answered {
+    align-items: baseline;
+    background: var(--surface-subtle);
+    border: 1px solid var(--border-default);
+    border-radius: 8px;
+    cursor: pointer;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    padding: 0.4rem 0.7rem;
+    text-align: left;
+    width: 100%;
+}
+
+.court-selector__answered-label {
+    color: var(--text-muted);
+    flex: 0 0 auto;
+    font-size: 0.8rem;
+}
+
+.court-selector__answered-value {
+    color: var(--text-heading);
+    flex: 1 1 auto;
+    font-weight: 600;
+}
+
+.court-selector__change {
+    color: var(--better-blue);
+    flex: 0 0 auto;
+    font-size: 0.85rem;
+    font-weight: 600;
+    text-decoration: underline;
+}
+
+@media (hover: hover) {
+    .court-selector__answered:hover {
+        border-color: var(--better-blue);
+    }
+}
+
+.court-selector__step {
+    border: 0;
+    margin: 0 0 1.15rem;
+    padding: 0;
+}
+
+.court-selector__step legend,
+.court-selector__label {
+    color: var(--text-heading);
+    display: block;
+    float: none;
+    font-size: 1rem;
+    font-weight: 600;
+    margin-bottom: 0.4rem;
+    width: auto;
+}
+
+.court-selector__hint {
+    color: var(--text-muted);
+    display: block;
+    font-size: 0.86rem;
+    margin: 0 0 0.5rem;
+}
+
+/* Where an answer came from the uploaded document rather than the filer. */
+.court-selector__source {
+    color: var(--better-blue);
+    display: block;
+    font-size: 0.84rem;
+    font-weight: 600;
+    margin: 0 0 0.5rem;
+}
+
+.court-selector__choices {
+    display: grid;
+    gap: 0.6rem;
+}
+
+.court-selector__choice,
+.court-selector__candidate {
+    align-items: flex-start;
+    background: #fff;
+    border: 1px solid var(--border-default);
+    border-radius: 8px;
+    cursor: pointer;
+    display: flex;
+    gap: 0.75rem;
+    margin: 0 0 0.5rem;
+    padding: 0.8rem;
+}
+
+.court-selector__choice:has(input:checked),
+.court-selector__candidate:has(input:checked) {
+    background: var(--surface-accent);
+    border-color: var(--better-blue);
+}
+
+.court-selector__choice strong,
+.court-selector__candidate strong {
+    color: var(--text-heading);
+    display: block;
+}
+
+.court-selector__choice small,
+.court-selector__candidate small {
+    color: var(--text-muted);
+    display: block;
+}
+
+/* The place lookup. The button sits beside the box on a wide screen and under
+   it on a narrow one, where a half-width text box would be unusable. */
+.court-selector__lookup {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.court-selector__lookup input {
+    flex: 1 1 14rem;
+}
+
+.court-selector__examples {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    margin-top: 0.5rem;
+}
+
+.court-selector__example {
+    background: #fff;
+    border: 1px solid var(--border-default);
+    border-radius: 999px;
+    color: var(--better-blue);
+    cursor: pointer;
+    font-size: 0.82rem;
+    font-weight: 600;
+    padding: 0.3rem 0.65rem;
+}
+
+@media (hover: hover) {
+    .court-selector__example:hover {
+        background: var(--surface-accent);
+        border-color: var(--better-blue);
+    }
+}
+
+.court-selector__subhead {
+    color: var(--text-heading);
+    font-weight: 600;
+    margin: 1rem 0 0.5rem;
+}
+
+.court-selector__note {
+    background: var(--warning-surface);
+    border: 1px solid var(--warning-border);
+    border-radius: 8px;
+    font-size: 0.9rem;
+    margin: 0.8rem 0;
+    padding: 0.75rem 0.9rem;
+}
+
+.court-selector__manual {
+    margin: 0.8rem 0;
+}
+
+.court-selector__manual summary {
+    color: var(--better-blue);
+    cursor: pointer;
+    font-weight: 600;
+}
+
+.court-selector__manual-body {
+    padding-top: 0.7rem;
+}
+
+.court-selector__result {
+    background: var(--success-surface);
+    border: 1px solid var(--success-border);
+    border-radius: 10px;
+    margin-top: 1rem;
+    padding: 0.85rem 1rem;
+}
+
+.court-selector__result-label {
+    color: var(--text-muted);
+    display: block;
+    font-size: 0.75rem;
+    font-weight: 700;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+
+.court-selector__result strong {
+    color: var(--text-heading);
+    display: block;
+    font-size: 1.05rem;
+}
+
+.court-selector__result small {
+    color: var(--text-muted);
+    display: block;
+}
+
+.court-selector__path {
+    margin-top: 0.2rem;
+}
\ No newline at end of file
diff --git a/efile_app/efile/static/css/reorganized-flow.css b/efile_app/efile/static/css/reorganized-flow.css
index 65cf029b..d64f3191 100644
--- a/efile_app/efile/static/css/reorganized-flow.css
+++ b/efile_app/efile/static/css/reorganized-flow.css
@@ -464,6 +464,13 @@
     grid-template-columns: repeat(2, minmax(0, 1fr));
 }
 
+/* The guided court questions are taller than the dropdowns beside them, so the
+   court takes a row of its own rather than stretching its neighbour to match.
+   Only where the selector actually drew itself: a flat court list stays paired. */
+.review-field:has(.court-selector:not(:empty)) {
+    grid-column: 1 / -1;
+}
+
 .extracted-details {
     background: var(--surface-subtle);
     border: 1px solid var(--border-default);
diff --git a/efile_app/efile/static/js/case-lookup.js b/efile_app/efile/static/js/case-lookup.js
index 3d528033..fea577c3 100644
--- a/efile_app/efile/static/js/case-lookup.js
+++ b/efile_app/efile/static/js/case-lookup.js
@@ -11,7 +11,30 @@
     const extractionHelp = document.getElementById("court-extraction-help");
     const selectedCourtCode = JSON.parse(document.getElementById("selected-court-code").textContent || '""');
 
+    async function mountCourtSelector() {
+        const container = document.getElementById("court-selector");
+        if (!container || !window.courtSelector) return false;
+        const selector = window.courtSelector.mount({
+            container,
+            jurisdiction: apiUtils.getCurrentJurisdiction(),
+            select: courtSelect,
+        });
+        const started = await selector.start(selectedCourtCode || "", guessedCourt || "");
+        if (!started) {
+            container.remove();
+            return false;
+        }
+        courtSelect.hidden = true;
+        // Native validation cannot point at a hidden field, and the selector is
+        // what asks for the court now, so the check moves into the submit below.
+        courtSelect.required = false;
+        return true;
+    }
+
     async function loadCourts() {
+        // Guided questions where the jurisdiction configures them, the flat
+        // list everywhere else. Either way the answer lands in the same select.
+        if (await mountCourtSelector()) return;
         try {
             const response = await apiUtils.fetchJSON("/api/dropdowns/courts/", "GET", {
                 jurisdiction: apiUtils.getCurrentJurisdiction(),
@@ -47,6 +70,7 @@
         submitButton.disabled = true;
 
         try {
+            if (!courtSelect.value) throw new Error("Choose a court to search for your case.");
             const jurisdiction = apiUtils.getCurrentJurisdiction();
             const lookup = await apiUtils.fetchJSON("/api/suffolk/lookup-case/", "GET", {
                 court: courtSelect.value,
diff --git a/efile_app/efile/static/js/court-selector.js b/efile_app/efile/static/js/court-selector.js
new file mode 100644
index 00000000..7185ab65
--- /dev/null
+++ b/efile_app/efile/static/js/court-selector.js
@@ -0,0 +1,414 @@
+/**
+ * The court question, asked the way the filer's own state is organized.
+ *
+ * The component holds no court data. Every answer is posted back to
+ * /api/dropdowns/court-selector/, which decides against the live court list
+ * which questions to ask next, which courts the answers narrow to, and whether
+ * one court has been settled on; this file draws whatever comes back. That is
+ * what lets Illinois route by county, Massachusetts by department plus a place,
+ * and Vermont by Superior Court unit without any of them being written here.
+ *
+ * Mount it over a court <select> that is already on the page. The select keeps
+ * carrying the answer -- it is what the form posts, and what the rest of the
+ * screen listens to -- so nothing downstream has to know the selector exists.
+ */
+(function() {
+    const SELECT_THRESHOLD = 8; // more courts than this read better as a dropdown
+
+    function escapeHtml(value) {
+        const holder = document.createElement("span");
+        holder.textContent = value ?? "";
+        return holder.innerHTML;
+    }
+
+    function optionsHtml(courts, chosen, placeholder) {
+        return [`<option value="">${escapeHtml(placeholder)}</option>`]
+            .concat(courts.map((court) => {
+                const selected = court.value === chosen ? " selected" : "";
+                return `<option value="${escapeHtml(court.value)}"${selected}>${escapeHtml(court.text || court.label)}</option>`;
+            }))
+            .join("");
+    }
+
+    function stepHtml(step) {
+        // Where an answer came from the uploaded document rather than the
+        // filer, the screen says so, next to the answer it is talking about.
+        let source = "";
+        if (step.from_document) {
+            source = `<small class="court-selector__source">Filled in from your document. Change it if it is wrong.</small>`;
+        } else if (step.defaulted && step.default_hint) {
+            source = `<small class="court-selector__source">${escapeHtml(step.default_hint)}</small>`;
+        }
+        const hint = (step.hint ? `<small class="court-selector__hint" id="${step.id}-hint">${escapeHtml(step.hint)}</small>` : "") + source;
+        const describedBy = step.hint ? ` aria-describedby="${step.id}-hint"` : "";
+
+        if (step.type === "choice") {
+            const choices = step.options.map((option) => `
+                <label class="court-selector__choice">
+                    <input type="radio" name="court-step-${escapeHtml(step.id)}" value="${escapeHtml(option.value)}"
+                           data-step="${escapeHtml(step.id)}"${option.value === step.answer ? " checked" : ""} />
+                    <span><strong>${escapeHtml(option.label)}</strong>${option.help ? `<small>${escapeHtml(option.help)}</small>` : ""}</span>
+                </label>`).join("");
+            return `
+                <fieldset class="court-selector__step" data-step="${escapeHtml(step.id)}">
+                    <legend>${escapeHtml(step.label)}</legend>
+                    ${hint}
+                    <div class="court-selector__choices">${choices}</div>
+                </fieldset>`;
+        }
+
+        if (step.type === "location") {
+            const examples = (step.examples || []).map((example) => `
+                <button type="button" class="court-selector__example" data-place="${escapeHtml(example)}">${escapeHtml(example)}</button>`).join("");
+            return `
+                <div class="court-selector__step" data-step="${escapeHtml(step.id)}">
+                    <label class="court-selector__label" for="court-step-${escapeHtml(step.id)}">${escapeHtml(step.label)}</label>
+                    ${hint}
+                    <div class="court-selector__lookup">
+                        <input type="text" class="form-control" id="court-step-${escapeHtml(step.id)}"
+                               data-location-step="${escapeHtml(step.id)}" value="${escapeHtml(step.answer)}"
+                               placeholder="${escapeHtml(step.placeholder)}" autocomplete="off"${describedBy} />
+                        <button type="button" class="btn btn-outline-primary" data-find-courts="${escapeHtml(step.id)}">
+                            ${escapeHtml(step.button_label || "Find courts")}
+                        </button>
+                    </div>
+                    ${examples ? `<div class="court-selector__examples">${examples}</div>` : ""}
+                </div>`;
+        }
+
+        return `
+            <div class="court-selector__step" data-step="${escapeHtml(step.id)}">
+                <label class="court-selector__label" for="court-step-${escapeHtml(step.id)}">${escapeHtml(step.label)}</label>
+                ${hint}
+                <select class="form-select" id="court-step-${escapeHtml(step.id)}" data-step="${escapeHtml(step.id)}"${describedBy}>
+                    <option value="">${escapeHtml(step.placeholder || "Choose one…")}</option>
+                    ${groupedOptionsHtml(step)}
+                </select>
+            </div>`;
+    }
+
+    function groupedOptionsHtml(step) {
+        // Headings where the courts have them: Cook County's eighty-odd
+        // locations are a division and then a courthouse, and reading them as
+        // one alphabetical run is what made the old list unusable.
+        let html = "";
+        let group = null;
+        step.options.forEach((option) => {
+            const heading = option.group || "";
+            if (heading !== group) {
+                if (group) html += "</optgroup>";
+                if (heading) html += `<optgroup label="${escapeHtml(heading)}">`;
+                group = heading;
+            }
+            const selected = option.value === step.answer ? " selected" : "";
+            html += `<option value="${escapeHtml(option.value)}"${selected}>${escapeHtml(option.label)}</option>`;
+        });
+        return group ? `${html}</optgroup>` : html;
+    }
+
+    function answerLabel(step) {
+        if (step.type === "location") return step.answer;
+        const chosen = step.options.find((option) => option.value === step.answer);
+        if (!chosen) return step.answer;
+        // Away from its heading, an option needs the name that tells it apart:
+        // "Municipal Civil" alone is true of seven Cook County courthouses.
+        return chosen.full_label || chosen.label;
+    }
+
+    function trailHtml(steps) {
+        // An answered question folds down to one line. The filer works down a
+        // short list rather than scrolling back up past the questions they have
+        // already dealt with -- which matters most on the confirm-filing screen,
+        // where the court sits beside three other fields.
+        if (!steps.length) return "";
+        const rows = steps.map((step) => `
+            <button type="button" class="court-selector__answered" data-change="${escapeHtml(step.id)}">
+                <span class="court-selector__answered-label">${escapeHtml(step.short_label || step.label)}</span>
+                <span class="court-selector__answered-value">${escapeHtml(answerLabel(step))}</span>
+                <span class="court-selector__change">Change</span>
+            </button>`).join("");
+        return `<div class="court-selector__trail">${rows}</div>`;
+    }
+
+    function candidatesHtml(matched, chosen) {
+        // What the location lookup found. More than one is normal where court
+        // jurisdictions overlap, so they are offered rather than guessed between.
+        const heading = matched.length === 1 ?
+            "The court that serves this place" :
+            "Courts that serve this place";
+        const items = matched.map((court) => `
+            <label class="court-selector__candidate">
+                <input type="radio" name="court-candidate" value="${escapeHtml(court.value)}"${court.value === chosen ? " checked" : ""} />
+                <span>
+                    <strong>${escapeHtml(court.text)}</strong>
+                    ${court.matched_name && court.matched_name !== court.text ? `<small>${escapeHtml(court.matched_name)}</small>` : ""}
+                    ${court.reason ? `<small>${escapeHtml(court.reason)}</small>` : ""}
+                </span>
+            </label>`).join("");
+        return `<div class="court-selector__candidates"><p class="court-selector__subhead">${escapeHtml(heading)}</p>${items}</div>`;
+    }
+
+    function manualHtml(courts, chosen, label, open) {
+        // Always offered, never required: a filer who knows their court by name
+        // should not have to describe where they live to reach it, and a place
+        // the rules cannot resolve has to have a way through.
+        if (!courts.length) return "";
+        const body = courtListHtml(courts, chosen, "manual");
+        return `
+            <details class="court-selector__manual"${open ? " open" : ""}>
+                <summary>${escapeHtml(label)}</summary>
+                <div class="court-selector__manual-body">${body}</div>
+            </details>`;
+    }
+
+    function courtListHtml(courts, chosen, kind) {
+        if (courts.length > SELECT_THRESHOLD) {
+            return `<select class="form-select" data-court-list="${kind}">${optionsHtml(courts, chosen, "Choose a court…")}</select>`;
+        }
+        return courts.map((court) => `
+            <label class="court-selector__candidate">
+                <input type="radio" name="court-candidate" value="${escapeHtml(court.value)}"${court.value === chosen ? " checked" : ""} />
+                <span><strong>${escapeHtml(court.text)}</strong></span>
+            </label>`).join("");
+    }
+
+    function noteHtml(message) {
+        return `<p class="court-selector__note court-selector__note--warn">${escapeHtml(message)}</p>`;
+    }
+
+    function locationHtml(data, chosen) {
+        const location = data.location;
+        const matched = location.matched || [];
+        const step = data.steps.find((item) => item.type === "location") || {};
+        let html = "";
+        if (location.error) {
+            html += noteHtml(location.error);
+        } else if (location.searched && !matched.length) {
+            html += noteHtml(step.no_match_hint);
+        } else if (matched.length) {
+            html += candidatesHtml(matched, chosen);
+        }
+        // Only where the lookup is the main way in. Vermont keeps its unit
+        // dropdown above, so repeating the same courts here would say nothing.
+        if (!step.manual_label) return html;
+        const openManually = Boolean(location.searched) && !matched.length;
+        return html + manualHtml(data.courts || [], chosen, step.manual_label, openManually);
+    }
+
+    function resultHtml(data) {
+        const selected = data.selected;
+        if (!selected) return "";
+        // The answers that led here, so the filer can check the route as well
+        // as the court at the end of it.
+        const path = (data.path || []).filter(Boolean).join(" › ");
+        return `
+            <div class="court-selector__result">
+                <span class="court-selector__result-label">Court</span>
+                <strong>${escapeHtml(selected.text)}</strong>
+                ${selected.reason ? `<small>${escapeHtml(selected.reason)}</small>` : ""}
+                ${path ? `<small class="court-selector__path">${escapeHtml(path)}</small>` : ""}
+            </div>`;
+    }
+
+    function extraHtml(data, chosen) {
+        if (data.location) return locationHtml(data, chosen);
+        // Every routing question is answered and more than one court is still on
+        // the table -- the last of the narrowing is the filer's.
+        if (data.waiting || (data.courts || []).length < 2) return "";
+        return `<p class="court-selector__subhead">Which of these is your court?</p>${courtListHtml(data.courts, chosen, "final")}`;
+    }
+
+    function mount(options) {
+        const {
+            container,
+            jurisdiction,
+            select,
+            nameInput,
+            onSelect
+        } = options;
+        const answers = {};
+        let latest = 0;
+        let lastSteps = [];
+        let expanded = ""; // the answered question the filer reopened
+        let lastRender = {
+            steps: []
+        }; // redrawn as-is when only the folding changes
+        // Mounting again over the same element retires the previous mount's
+        // listeners, so two selectors can never both answer one click.
+        if (container.courtSelectorListeners) container.courtSelectorListeners.abort();
+        const listeners = new AbortController();
+        container.courtSelectorListeners = listeners;
+
+        function open(step, data) {
+            // An unanswered question is always open, and so is one the filer
+            // asked to change. A place that matched nothing stays open too:
+            // retyping it is the obvious next move, not a click away.
+            // A suggested answer is not one the filer gave, so it stays in
+            // front of them rather than folding away as settled.
+            if (expanded === step.id || !step.answer || step.defaulted) return true;
+            if (step.type === "location" && data.location) {
+                return Boolean(data.location.searched) && !(data.location.matched || []).length;
+            }
+            return false;
+        }
+
+        function render(data) {
+            lastSteps = data.steps || [];
+            const chosen = data.selected ? data.selected.value : "";
+            // Once there is a court, the questions that produced it fold away
+            // and so does everything that was there to choose between: the
+            // answer is stated, and "Change" is how the filer goes back to it.
+            const settled = Boolean(data.selected) && !expanded && !lastSteps.some((step) => step.defaulted);
+            const steps = settled ? [] : lastSteps.filter((step) => open(step, data));
+            const answered = settled ?
+                lastSteps.filter((step) => step.answer) :
+                lastSteps.filter((step) => !open(step, data));
+            container.innerHTML = `
+                ${steps.length && data.lede ? `<p class="court-selector__lede">${escapeHtml(data.lede)}</p>` : ""}
+                ${trailHtml(answered)}
+                <div class="court-selector__steps">${steps.map(stepHtml).join("")}</div>
+                ${settled ? "" : extraHtml(data, chosen)}
+                ${resultHtml(data)}`;
+            publish(data.selected, data.courts || []);
+        }
+
+        function publish(selected, courts) {
+            // The <select> under this component is what the form posts, so it
+            // carries whatever has been settled on -- and only that, so a form
+            // submitted mid-question cannot carry a court nobody chose.
+            const before = select.value;
+            const pool = selected ? [selected] : courts;
+            select.innerHTML = optionsHtml(pool, selected ? selected.value : "", "");
+            select.value = selected ? selected.value : "";
+            if (nameInput) nameInput.value = selected ? selected.text : "";
+            // Only when the court actually changed: everything downstream --
+            // case categories, types, fees -- is refetched off this event.
+            if (select.value !== before) select.dispatchEvent(new Event("change", {
+                bubbles: true
+            }));
+            if (onSelect) onSelect(selected);
+        }
+
+        async function refresh() {
+            const request = ++latest;
+            const query = new URLSearchParams({
+                jurisdiction,
+                answers: JSON.stringify(answers)
+            });
+            container.setAttribute("aria-busy", "true");
+            try {
+                const response = await fetch(`/api/dropdowns/court-selector/?${query}`, {
+                    headers: {
+                        "X-CSRFToken": apiUtils.getCSRFToken()
+                    },
+                });
+                const result = await response.json();
+                if (request !== latest) return; // a later answer already went out
+                if (!response.ok || !result.success) throw new Error(result.error || "Could not load the court questions.");
+                if (!result.data.available) throw new Error("This jurisdiction no longer has guided court questions. Reload the page.");
+                lastRender = result.data;
+                render(result.data);
+            } catch (error) {
+                if (request === latest) {
+                    container.innerHTML = `<p class="court-selector__note court-selector__note--warn">${escapeHtml(error.message)}</p>`;
+                }
+            } finally {
+                container.removeAttribute("aria-busy");
+            }
+        }
+
+        function answerStep(stepId, value) {
+            answers[stepId] = value;
+            expanded = "";
+            // Two steps that are alternatives to each other are two ways of
+            // naming one court, so answering either clears the other rather
+            // than leaving a stale answer to disagree with it.
+            (lastSteps || []).forEach((step) => {
+                if (step.alternative_to === stepId || (step.id === stepId && step.alternative_to)) {
+                    delete answers[step.alternative_to === stepId ? step.id : step.alternative_to];
+                }
+            });
+            // A different route means a different court: whatever was chosen
+            // under the old answer cannot survive it.
+            delete answers.court;
+            refresh();
+        }
+
+        container.addEventListener("change", (event) => {
+            const target = event.target;
+            if (target.name === "court-candidate" || target.dataset.courtList) {
+                answers.court = target.value;
+                refresh();
+                return;
+            }
+            const stepId = target.dataset.step;
+            if (stepId) answerStep(stepId, target.value);
+        }, {
+            signal: listeners.signal
+        });
+
+        container.addEventListener("click", (event) => {
+            const reopen = event.target.closest("[data-change]");
+            if (reopen) {
+                expanded = reopen.dataset.change;
+                render(lastRender);
+                return;
+            }
+            const findButton = event.target.closest("[data-find-courts]");
+            if (findButton) {
+                const input = container.querySelector(`[data-location-step="${findButton.dataset.findCourts}"]`);
+                answerStep(findButton.dataset.findCourts, input ? input.value.trim() : "");
+                return;
+            }
+            const example = event.target.closest(".court-selector__example");
+            if (example) {
+                const input = container.querySelector("[data-location-step]");
+                if (input) {
+                    input.value = example.dataset.place;
+                    answerStep(input.dataset.locationStep, example.dataset.place);
+                }
+            }
+        }, {
+            signal: listeners.signal
+        });
+
+        container.addEventListener("keydown", (event) => {
+            if (event.key === "Enter" && event.target.dataset.locationStep) {
+                // Enter in a lookup box means "find", not "submit the filing".
+                event.preventDefault();
+                answerStep(event.target.dataset.locationStep, event.target.value.trim());
+            }
+        }, {
+            signal: listeners.signal
+        });
+
+        return {
+            /** Draw the first questions, picking up a court already chosen. */
+            async start(courtCode, guessedCourt) {
+                const query = new URLSearchParams({
+                    jurisdiction
+                });
+                if (courtCode) query.set("court", courtCode);
+                if (guessedCourt) query.set("guessed_court", guessedCourt);
+                const response = await fetch(`/api/dropdowns/court-selector/?${query}`, {
+                    headers: {
+                        "X-CSRFToken": apiUtils.getCSRFToken()
+                    },
+                });
+                const result = await response.json();
+                if (!response.ok || !result.success || !result.data.available) return false;
+                (result.data.steps || []).forEach((step) => {
+                    if (step.answer) answers[step.id] = step.answer;
+                });
+                if (result.data.selected) answers.court = result.data.selected.value;
+                lastRender = result.data;
+                render(result.data);
+                return true;
+            },
+        };
+    }
+
+    window.courtSelector = {
+        mount
+    };
+})();
\ No newline at end of file
diff --git a/efile_app/efile/static/js/extraction-review.js b/efile_app/efile/static/js/extraction-review.js
index c210afd0..5447ddca 100644
--- a/efile_app/efile/static/js/extraction-review.js
+++ b/efile_app/efile/static/js/extraction-review.js
@@ -146,8 +146,36 @@
         }
     }
 
+    async function mountCourtSelector(field) {
+        const container = document.getElementById("court-selector");
+        if (!container || !window.courtSelector) return false;
+        const selector = window.courtSelector.mount({
+            container,
+            jurisdiction: context.jurisdiction,
+            select: field.select,
+            nameInput: field.nameInput,
+        });
+        const started = await selector.start(field.savedCode || "", guesses.court || "");
+        if (!started) {
+            container.remove();
+            return false;
+        }
+        // The selector shows the court it settled on, and stays open so the
+        // filer can change it, so the field's own found/edit panels have
+        // nothing left to say.
+        field.select.hidden = true;
+        field.select.disabled = false; // a disabled select is never submitted
+        field.display.remove();
+        setMode("court", "edit");
+        return true;
+    }
+
     async function loadCourts() {
         const field = fields.court;
+        // Where the jurisdiction configures guided questions, they replace the
+        // flat list: the filer answers their own state's routing questions and
+        // the selector writes the court into the same <select> the form posts.
+        if (await mountCourtSelector(field)) return;
         field.select.disabled = true;
         field.select.innerHTML = "<option value=\"\">Loading courts…</option>";
         try {
@@ -179,6 +207,14 @@
                 court: courtCode,
                 guessed_case_category: guesses["case category"] || "",
             })}`);
+            if (!options.length) {
+                // Some courts in the court list take no filings at all. Saying
+                // so beats leaving the filer with three dropdowns that will not
+                // open and no idea which choice caused it.
+                resetField("case_category", "Choose a case category");
+                field.hint.textContent = gettext("This court does not accept filings through e-filing. Choose a different court above.");
+                return;
+            }
             await populate("case_category", options, "Choose a case category");
         } catch (error) {
             resetField("case_category", "Choose a case category");
diff --git a/efile_app/efile/templates/efile/case_lookup.html b/efile_app/efile/templates/efile/case_lookup.html
index 248d6d9d..699ff8fc 100644
--- a/efile_app/efile/templates/efile/case_lookup.html
+++ b/efile_app/efile/templates/efile/case_lookup.html
@@ -21,19 +21,22 @@ <h1>{% translate "Find your court case" %}</h1>
         <form id="case-lookup-form">
             {% csrf_token %}
             <div class="lookup-fields">
-                <label class="form-field" for="court">
+                <div class="form-field">
                     <span>{% translate "Court" %}</span>
+                    {# Filled in by court-selector.js where the jurisdiction configures guided questions. The select below keeps carrying the answer either way. #}
+                    <div class="court-selector" id="court-selector"></div>
                     <select class="form-select"
                             id="court"
                             name="court"
+                            aria-label="{% translate 'Court' %}"
                             {% if guessed_court %}aria-describedby="court-hint"{% endif %}
                             required>
-                        <option value="">{% translate "Loading Illinois courts…" %}</option>
+                        <option value="">{% translate "Loading courts…" %}</option>
                     </select>
                     {% if guessed_court %}
                         <small id="court-hint">{% blocktranslate %}Suggested from your document: {{ guessed_court }}{% endblocktranslate %}</small>
                     {% endif %}
-                </label>
+                </div>
                 <label class="form-field" for="case-number">
                     <span>{% translate "Case number" %}</span>
                     <input class="form-control"
@@ -65,5 +68,6 @@ <h1>{% translate "Find your court case" %}</h1>
     {{ selected_court_code|json_script:"selected-court-code" }}
 {% endblock workflow_content %}
 {% block extra_js %}
+    <script src="{% static 'js/court-selector.js' %}"></script>
     <script src="{% static 'js/case-lookup.js' %}"></script>
 {% endblock extra_js %}
diff --git a/efile_app/efile/templates/efile/extraction_review.html b/efile_app/efile/templates/efile/extraction_review.html
index c500b007..07bb6d75 100644
--- a/efile_app/efile/templates/efile/extraction_review.html
+++ b/efile_app/efile/templates/efile/extraction_review.html
@@ -118,6 +118,8 @@ <h1>{% translate "Tell us about your case" %}</h1>
                         </button>
                     </div>
                     <div class="review-field__input">
+                        {# Filled in by court-selector.js where the jurisdiction configures guided questions. The select below keeps carrying the answer either way. #}
+                        <div class="court-selector" id="court-selector"></div>
                         <select class="form-select"
                                 name="court_code"
                                 id="court_code"
@@ -426,5 +428,6 @@ <h1>{% translate "Tell us about your case" %}</h1>
     {{ extraction_context|json_script:"extraction-context" }}
 {% endblock workflow_content %}
 {% block extra_js %}
+    <script src="{% static 'js/court-selector.js' %}"></script>
     <script src="{% static 'js/extraction-review.js' %}"></script>
 {% endblock extra_js %}
diff --git a/efile_app/efile/templates/efile/workflow_base.html b/efile_app/efile/templates/efile/workflow_base.html
index 5b809d5a..1562329e 100644
--- a/efile_app/efile/templates/efile/workflow_base.html
+++ b/efile_app/efile/templates/efile/workflow_base.html
@@ -16,6 +16,8 @@
               rel="stylesheet" />
         <link rel="stylesheet" href="{% static 'css/common.css' %}" />
         <link rel="stylesheet" href="{% static 'css/reorganized-flow.css' %}" />
+        <link rel="stylesheet"
+              href="{% static 'css/components/court-selector.css' %}" />
         {% block extra_css %}
         {% endblock extra_css %}
     </head>
diff --git a/efile_app/efile/tests/test_court_selection.py b/efile_app/efile/tests/test_court_selection.py
new file mode 100644
index 00000000..0a70d6c4
--- /dev/null
+++ b/efile_app/efile/tests/test_court_selection.py
@@ -0,0 +1,574 @@
+"""The guided court question, per jurisdiction.
+
+The court lists here are trimmed copies of what the e-filing service returns,
+kept small enough to read but keeping the shapes that matter: Cook County's
+divisions, a county with one court, Vermont's units, and the Massachusetts
+departments whose names have nothing in common.
+"""
+
+import json
+from unittest.mock import Mock, patch
+
+import pytest
+
+from efile.services.court_location import normalize_court_code, parse_place
+from efile.services.court_selection import (
+    _readable_name,
+    build_selection,
+    derive_answers,
+    derive_answers_from_guess,
+    fetch_courts,
+    is_non_filing_court,
+    selector_config,
+)
+
+ILLINOIS_COURTS = [
+    {"value": "TSUPCRT", "text": "Supreme Court of Illinois"},
+    {"value": "cook:cvd1", "text": "Cook County - Municipal Civil - District 1 - Chicago"},
+    {"value": "cook:cvd2", "text": "Cook County - Municipal Civil - District 2 - Skokie"},
+    {"value": "TAC1", "text": "Appellate Court – 1st District"},
+    {"value": "TAC3", "text": "Appellate Court – 3rd District"},
+    {"value": "ardc", "text": "ARDC Clerk's Office"},
+    {"value": "cook", "text": "Cook County"},
+    {"value": "cook:chd1", "text": "Cook County - Chancery - District 1 - Chicago"},
+    {"value": "cook:law1", "text": "Cook County - Law - District 1 - Chicago"},
+    {"value": "KankakeeCV", "text": "Kankakee - Civil"},
+    {"value": "KankakeeCR", "text": "Kankakee - Criminal"},
+    {"value": "peoria", "text": "Peoria County"},
+    {"value": "peoriacr", "text": "Peoria CR"},
+    {"value": "peoriatr", "text": "Peoria TR"},
+    {"value": "will", "text": "Will County"},
+]
+
+VERMONT_COURTS = [
+    {"value": "sc:addison", "text": "Addison Unit"},
+    {"value": "sc:chittendon", "text": "Chittenden Unit"},
+    {"value": "sc:rutland", "text": "Rutland Unit"},
+    {"value": "vermont:ed", "text": "Environmental Division"},
+    {"value": "vermont:jb", "text": "Judicial Bureau"},
+    {"value": "vermont:supreme", "text": "Supreme Court"},
+]
+
+# As the questions see them: the e-filing service's own names, put back the way
+# a court is named, by the `court_names` rules in the Massachusetts config.
+MASSACHUSETTS_COURTS = [
+    {"value": "appeals:acp", "text": "Appeals Court - Panel (P docket)"},
+    {"value": "appeals:acsj", "text": "Appeals Court - Single Justice (J Docket)"},
+    {"value": "1245", "text": "Central Division, Boston Municipal Court"},
+    {"value": "490", "text": "Cambridge District Court"},
+    {"value": "504", "text": "Somerville District Court"},
+    {"value": "537", "text": "Eastern Housing Court (Boston)"},
+    {"value": "hc", "text": "Housing Courts"},
+    {"value": "1086:BO", "text": "Boston Juvenile Court - Suffolk County"},
+    {"value": "210", "text": "Land Court"},
+    {"value": "344", "text": "Middlesex Probate and Family Court"},
+    {"value": "sjc", "text": "Supreme Judicial Court - Commonwealth"},
+]
+
+
+def select(jurisdiction, answers, courts):
+    """build_selection, for the jurisdictions that have a selector configured."""
+    selection = build_selection(jurisdiction, answers, courts)
+    assert selection is not None
+    return selection
+
+
+def step(selection, step_id):
+    return next((item for item in selection["steps"] if item["id"] == step_id), None)
+
+
+def values(selection, step_id):
+    return [option["value"] for option in step(selection, step_id)["options"]]
+
+
+class TestCourtListFiltering:
+    @pytest.mark.parametrize(
+        "name",
+        ["Courtview Test - Trial Courts", "ZZZ - Essex Probate and Family Court", "System", "File & Serve"],
+    )
+    def test_rows_that_are_not_courts_are_dropped(self, name):
+        assert is_non_filing_court(name)
+
+    def test_real_courts_are_kept(self):
+        assert not is_non_filing_court("District Court - Cambridge")
+        assert not is_non_filing_court("Cook County - Chancery - District 1 - Chicago")
+
+
+class TestIllinois:
+    def test_the_first_question_is_the_court_level(self):
+        selection = select("illinois", {}, ILLINOIS_COURTS)
+        assert values(selection, "level") == ["circuit", "appellate", "supreme"]
+        assert selection["selected"] is None
+
+    def test_the_supreme_court_needs_no_geography(self):
+        selection = select("illinois", {"level": "supreme"}, ILLINOIS_COURTS)
+        assert selection["selected"]["value"] == "TSUPCRT"
+        assert selection["complete"]
+
+    def test_counties_are_one_option_each_however_their_courts_are_named(self):
+        selection = select("illinois", {"level": "circuit"}, ILLINOIS_COURTS)
+        # Kankakee's four courts and Peoria's two are one county option each,
+        # and the appellate and administrative courts are not counties at all.
+        assert values(selection, "county") == ["Cook", "Kankakee", "Peoria", "Will"]
+
+    def test_a_county_with_one_court_is_not_asked_a_second_question(self):
+        selection = select("illinois", {"level": "circuit", "county": "Will"}, ILLINOIS_COURTS)
+        assert step(selection, "division") is None
+        assert selection["selected"]["value"] == "will"
+
+    def test_cook_county_is_asked_which_division(self):
+        selection = select("illinois", {"level": "circuit", "county": "Cook"}, ILLINOIS_COURTS)
+        assert selection["selected"] is None
+        # Every Cook location, grouped by the courthouse it sits in.
+        assert set(values(selection, "division")) == {"cook:chd1", "cook", "cook:law1", "cook:cvd1", "cook:cvd2"}
+        # The county prefix every option shares is not worth reading twice.
+        labels = [option["label"] for option in step(selection, "division")["options"]]
+        assert not any(label.startswith("Cook County -") for label in labels)
+
+    def test_cook_countys_courts_read_under_their_courthouse(self):
+        selection = select("illinois", {"level": "circuit", "county": "Cook"}, ILLINOIS_COURTS)
+        options = step(selection, "division")["options"]
+        headings = [option["group"] for option in options]
+        # The Chicago courthouse comes first, where most Cook filings go, and
+        # the outlying districts follow in their own order rather than
+        # alphabetically. Courts with no courthouse in their name come last.
+        assert headings[0] == "District 1 - Chicago"
+        assert headings.index("District 2 - Skokie") > headings.index("District 1 - Chicago")
+        assert headings[-1] == "No courthouse given"
+        under_chicago = {option["label"] for option in options if option["group"] == "District 1 - Chicago"}
+        assert {"Chancery", "Law", "Municipal Civil"} <= under_chicago
+        # The courthouse is the heading, so it is not repeated on every line --
+        # but away from that heading the court still needs its whole name.
+        chosen = next(option for option in options if option["value"] == "cook:cvd2")
+        assert chosen["label"] == "Municipal Civil"
+        assert chosen["full_label"] == "Municipal Civil - District 2 - Skokie"
+
+    def test_a_cook_division_resolves_to_one_court(self):
+        selection = select("illinois", {"level": "circuit", "county": "Cook", "division": "cook:law1"}, ILLINOIS_COURTS)
+        assert selection["selected"]["value"] == "cook:law1"
+        assert selection["complete"]
+
+    def test_an_appeal_can_be_identified_by_district_or_by_county(self):
+        selection = select("illinois", {"level": "appellate"}, ILLINOIS_COURTS)
+        # Both ways are offered at once; the filer uses whichever their
+        # paperwork supports.
+        assert step(selection, "appellate_district") is not None
+        assert step(selection, "appellate_county") is not None
+
+    def test_the_county_an_appeal_came_from_names_its_district(self):
+        selection = select("illinois", {"level": "appellate", "appellate_county": "DuPage"}, ILLINOIS_COURTS)
+        assert selection["selected"]["value"] == "TAC3"
+        # Both ways stay on screen, but only the one that was answered answers.
+        assert step(selection, "appellate_district")["answer"] == ""
+
+    def test_choosing_the_district_directly_answers_for_the_county_question(self):
+        selection = select(
+            "illinois",
+            {"level": "appellate", "appellate_district": "TAC1", "appellate_county": "Cook"},
+            ILLINOIS_COURTS,
+        )
+        assert selection["selected"]["value"] == "TAC1"
+        assert step(selection, "appellate_county")["answer"] == ""
+
+
+class TestVermont:
+    def test_units_are_labelled_with_the_county_they_cover(self):
+        selection = select("vermont", {"level": "superior", "division": "family"}, VERMONT_COURTS)
+        labels = [option["label"] for option in step(selection, "unit")["options"]]
+        assert labels == [
+            "Addison Unit (Addison County)",
+            "Chittenden Unit (Chittenden County)",
+            "Rutland Unit (Rutland County)",
+        ]
+
+    def test_a_statewide_division_is_not_asked_for_a_unit(self):
+        selection = select("vermont", {"level": "superior", "division": "environmental"}, VERMONT_COURTS)
+        assert step(selection, "unit") is None
+        assert selection["selected"]["value"] == "vermont:ed"
+
+    def test_a_unit_resolves_to_one_court(self):
+        selection = select("vermont", {"level": "superior", "division": "civil", "unit": "sc:rutland"}, VERMONT_COURTS)
+        assert selection["selected"]["value"] == "sc:rutland"
+
+    def test_a_town_finds_the_unit_the_filer_may_not_know(self):
+        selection = select(
+            "vermont",
+            {"level": "superior", "division": "family", "place": "Burlington"},
+            VERMONT_COURTS,
+        )
+        # Vermont's own code for the Chittenden Unit carries a spelling its name
+        # does not, so the match is made on the name.
+        assert selection["selected"]["value"] == "sc:chittendon"
+        assert selection["location"]["matched"][0]["reason"]
+
+    def test_a_cross_county_zip_offers_both_units_rather_than_guessing(self):
+        selection = select(
+            "vermont",
+            {"level": "superior", "division": "family", "place": "05487"},
+            VERMONT_COURTS,
+        )
+        assert [court["value"] for court in selection["location"]["matched"]] == ["sc:addison", "sc:chittendon"]
+        assert selection["selected"] is None
+
+    def test_choosing_a_unit_leaves_the_lookup_on_screen_and_unused(self):
+        selection = select(
+            "vermont",
+            {"level": "superior", "division": "family", "unit": "sc:rutland", "place": "Burlington"},
+            VERMONT_COURTS,
+        )
+        assert selection["selected"]["value"] == "sc:rutland"
+        assert step(selection, "place")["answer"] == ""
+
+    def test_the_judicial_bureau_needs_no_geography(self):
+        selection = select("vermont", {"level": "bureau"}, VERMONT_COURTS)
+        assert selection["selected"]["value"] == "vermont:jb"
+
+
+class TestMassachusetts:
+    def test_the_land_court_never_asks_where(self):
+        selection = select("massachusetts", {"level": "trial", "department": "land"}, MASSACHUSETTS_COURTS)
+        assert step(selection, "place") is None
+        assert selection["selected"]["value"] == "210"
+
+    def test_a_department_is_asked_for_a_place_not_a_county(self):
+        selection = select("massachusetts", {"level": "trial", "department": "district"}, MASSACHUSETTS_COURTS)
+        place = step(selection, "place")
+        assert place["type"] == "location"
+        assert "county" not in place["label"].lower()
+
+    def test_a_town_resolves_to_the_court_that_serves_it(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "district", "place": "Cambridge"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["selected"]["value"] == "490"
+        assert selection["location"]["matched"][0]["reason"]
+
+    def test_a_town_is_matched_within_the_chosen_department(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "housing", "place": "Somerville"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["selected"]["value"] == "537"
+
+    def test_a_place_that_cannot_be_matched_leaves_the_list(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "district", "place": "Nowhere At All"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["location"]["searched"] is True
+        assert selection["location"]["matched"] == []
+        # The department's own courts are still there to choose from by hand.
+        assert {court["value"] for court in selection["courts"]} == {"1245", "490", "504"}
+        assert selection["selected"] is None
+
+    def test_a_court_can_be_chosen_by_hand_without_a_place(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "district", "court": "504"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["selected"]["value"] == "504"
+        assert selection["complete"]
+
+    def test_a_court_outside_the_answers_is_not_the_selection(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "district", "court": "210"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["selected"] is None
+
+    def test_the_appeals_court_asks_which_proceeding_and_no_geography(self):
+        selection = select("massachusetts", {"level": "appeals", "proceeding": "single_justice"}, MASSACHUSETTS_COURTS)
+        assert selection["selected"]["value"] == "appeals:acsj"
+        assert step(selection, "place") is None
+
+
+class TestDerivingAnswersFromASavedCourt:
+    @pytest.mark.parametrize(
+        ("jurisdiction", "courts", "code", "expected"),
+        [
+            ("illinois", ILLINOIS_COURTS, "cook:law1", {"level": "circuit", "county": "Cook", "division": "cook:law1"}),
+            ("illinois", ILLINOIS_COURTS, "will", {"level": "circuit", "county": "Will"}),
+            ("vermont", VERMONT_COURTS, "sc:rutland", {"level": "superior", "unit": "sc:rutland"}),
+            ("massachusetts", MASSACHUSETTS_COURTS, "490", {"level": "trial", "department": "district"}),
+            ("massachusetts", MASSACHUSETTS_COURTS, "210", {"level": "trial", "department": "land"}),
+        ],
+    )
+    def test_a_saved_court_fills_the_questions_back_in(self, jurisdiction, courts, code, expected):
+        assert derive_answers(jurisdiction, code, courts) == expected
+
+    def test_a_court_that_is_not_on_the_list_derives_nothing(self):
+        assert derive_answers("illinois", "not-a-court", ILLINOIS_COURTS) == {}
+
+
+class TestPlaceParsing:
+    @pytest.mark.parametrize(
+        ("typed", "expected"),
+        [
+            ("Cambridge", {"street_address": "", "city": "Cambridge", "postal_code": ""}),
+            ("Boston 02108", {"street_address": "", "city": "Boston", "postal_code": "02108"}),
+            ("24 Beacon St, Boston", {"street_address": "24 Beacon St", "city": "Boston", "postal_code": ""}),
+            ("Somerville, MA", {"street_address": "", "city": "Somerville", "postal_code": ""}),
+            ("02108", {"street_address": "", "city": "", "postal_code": "02108"}),
+        ],
+    )
+    def test_a_typed_place_is_read_into_the_fields_a_lookup_uses(self, typed, expected):
+        assert parse_place(typed) == expected
+
+    def test_court_codes_compare_past_padding_and_case(self):
+        # Tyler writes the same Juvenile Court session both ways.
+        assert normalize_court_code("0965:BE") == normalize_court_code("965:be")
+        assert normalize_court_code("490") != normalize_court_code("491")
+
+
+@pytest.mark.django_db
+class TestCourtSelectorEndpoint:
+    def test_it_returns_the_first_question(self, client):
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=ILLINOIS_COURTS):
+            response = client.get("/api/dropdowns/court-selector/", {"jurisdiction": "illinois"})
+        data = json.loads(response.content)["data"]
+        assert data["available"] is True
+        assert data["steps"][0]["id"] == "level"
+
+    def test_it_answers_the_questions_it_is_given(self):
+        query = {"jurisdiction": "illinois", "answers": json.dumps({"level": "circuit", "county": "Will"})}
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=ILLINOIS_COURTS):
+            response = client_get(query)
+        assert response["selected"]["value"] == "will"
+
+    def test_a_saved_court_comes_back_with_its_questions_answered(self):
+        query = {"jurisdiction": "illinois", "court": "cook:chd1"}
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=ILLINOIS_COURTS):
+            response = client_get(query)
+        assert response["selected"]["value"] == "cook:chd1"
+        assert [item["answer"] for item in response["steps"]] == ["circuit", "Cook", "cook:chd1"]
+
+    def test_a_jurisdiction_with_no_configured_questions_says_so(self, client):
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=[]):
+            response = client.get("/api/dropdowns/court-selector/", {"jurisdiction": "atlantis"})
+        assert json.loads(response.content)["data"] == {"available": False}
+
+    def test_a_court_list_that_will_not_load_is_reported(self, client):
+        import requests
+
+        with patch("efile.api.court_selector_views.fetch_courts", side_effect=requests.RequestException("down")):
+            response = client.get("/api/dropdowns/court-selector/", {"jurisdiction": "illinois"})
+        assert response.status_code == 400
+        assert json.loads(response.content)["success"] is False
+
+
+def client_get(query):
+    from django.test import Client
+
+    response = Client().get("/api/dropdowns/court-selector/", query)
+    return json.loads(response.content)["data"]
+
+
+class TestFetchingTheCourtList:
+    @staticmethod
+    def _fetch(all_courts, fileable):
+        """fetch_courts against a stubbed pair of court lists."""
+
+        def response(url, params=None, **kwargs):
+            listing = fileable if (params or {}).get("fileable_only") else all_courts
+            stub = Mock()
+            stub.json.return_value = listing
+            stub.raise_for_status.return_value = None
+            return stub
+
+        with (
+            patch("efile.services.court_selection.requests.get", side_effect=response),
+            patch("efile.services.court_selection.cache") as cache,
+        ):
+            cache.get.return_value = None
+            return fetch_courts("illinois")
+
+    def test_rows_that_are_not_courts_never_reach_the_questions(self):
+        payload = [
+            {"code": "will", "name": "Will County"},
+            {"code": "0", "name": "System"},
+            {"code": "9418", "name": "Courtview Test - BMC - Brighton"},
+        ]
+        assert self._fetch(payload, payload) == [{"value": "will", "text": "Will County"}]
+
+    def test_a_county_that_only_heads_its_divisions_is_not_offered(self):
+        payload = [
+            {"code": "cook", "name": "Cook County"},
+            {"code": "cook:chd", "name": "Cook County - Chancery"},
+            {"code": "cook:cvd1", "name": "Cook County - Municipal Civil - District 1 - Chicago"},
+            {"code": "will", "name": "Will County"},
+        ]
+        # The e-filing service leaves both Cook rows out of its fileable list,
+        # but only the county is a dead end: Chancery has locations under it and
+        # takes filings of its own, so the flag alone is not enough to drop it.
+        courts = self._fetch(payload, [{"code": "cook:cvd1"}, {"code": "will"}])
+        assert [court["value"] for court in courts] == ["cook:chd", "cook:cvd1", "will"]
+
+    def test_nothing_is_dropped_when_the_fileable_list_cannot_be_read(self):
+        payload = [
+            {"code": "cook", "name": "Cook County"},
+            {"code": "cook:cvd1", "name": "Cook County - Municipal Civil - District 1 - Chicago"},
+        ]
+        with (
+            patch("efile.services.court_selection.requests.get") as get,
+            patch("efile.services.court_selection.cache") as cache,
+        ):
+            cache.get.return_value = None
+            get.return_value.json.side_effect = [payload, ValueError("not json")]
+            get.return_value.raise_for_status.return_value = None
+            assert len(fetch_courts("illinois")) == 2
+
+
+@pytest.mark.django_db
+class TestTheScreensThatAskForACourt:
+    """The selector draws itself over the court <select> already on the page."""
+
+    @pytest.fixture
+    def draft(self, client, django_user_model):
+        from efile.models import FilingDocument, FilingDraft
+        from efile.services.current_drafts import CURRENT_DRAFT_SESSION_KEY
+
+        user = django_user_model.objects.create_user(username="court-user", tyler_jurisdiction="illinois")
+        draft = FilingDraft.objects.create(user=user, jurisdiction="illinois", workflow_version=2)
+        FilingDocument.objects.create(draft=draft, role=FilingDocument.Role.LEAD, name="petition.pdf")
+        client.force_login(user)
+        session = client.session
+        session[CURRENT_DRAFT_SESSION_KEY] = draft.pk
+        session["auth_tokens"] = {"TYLER-TOKEN-ILLINOIS": "token"}
+        session["jurisdiction"] = "illinois"
+        session.save()
+        return draft
+
+    @pytest.mark.parametrize("view", ["extraction_review", "case_lookup"])
+    def test_the_court_field_carries_the_selector(self, client, draft, view):
+        from django.urls import reverse
+
+        if view == "case_lookup":
+            draft.existing_case = "existing"
+            draft.save()
+        content = client.get(reverse(view, kwargs={"jurisdiction": "illinois"})).content.decode()
+        assert 'id="court-selector"' in content
+        assert "js/court-selector.js" in content
+
+
+class TestWhatTheDocumentAlreadySaid:
+    """A caption names a court in its own words. Whatever those words settle is
+    filled in; whatever they leave open stays a question."""
+
+    def test_a_caption_that_names_the_county_answers_the_county(self):
+        answers = derive_answers_from_guess(
+            "illinois", "IN THE CIRCUIT COURT OF COOK COUNTY, ILLINOIS", ILLINOIS_COURTS
+        )
+        assert answers == {"level": "circuit", "county": "Cook"}
+
+    def test_it_does_not_choose_a_division_the_document_never_named(self):
+        answers = derive_answers_from_guess("illinois", "Circuit Court of Cook County", ILLINOIS_COURTS)
+        assert "division" not in answers
+        assert "court" not in answers
+
+    def test_a_caption_that_names_one_court_settles_it(self):
+        answers = derive_answers_from_guess("illinois", "Will County Circuit Court", ILLINOIS_COURTS)
+        assert answers["court"] == "will"
+
+    def test_a_court_named_in_another_order_still_matches(self):
+        answers = derive_answers_from_guess("massachusetts", "Cambridge District Court", MASSACHUSETTS_COURTS)
+        assert answers["court"] == "490"
+
+    def test_words_the_courts_do_not_share_settle_nothing(self):
+        assert derive_answers_from_guess("illinois", "Superior Court of California", ILLINOIS_COURTS) == {}
+
+    def test_the_document_only_fills_in_what_is_still_unanswered(self, client):
+        query = {"jurisdiction": "illinois", "guessed_court": "Circuit Court of Cook County"}
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=ILLINOIS_COURTS):
+            data = json.loads(client.get("/api/dropdowns/court-selector/", query).content)["data"]
+        answered = {item["id"]: (item["answer"], item["from_document"]) for item in data["steps"]}
+        assert answered["level"] == ("circuit", True)
+        assert answered["county"] == ("Cook", True)
+        # The division is still the filer's to answer, and is not labelled as
+        # something the document said.
+        assert answered["division"] == ("", False)
+
+    def test_a_saved_court_wins_over_the_document(self, client):
+        query = {
+            "jurisdiction": "illinois",
+            "court": "cook:chd1",
+            "guessed_court": "Circuit Court of Cook County",
+        }
+        with patch("efile.api.court_selector_views.fetch_courts", return_value=ILLINOIS_COURTS):
+            data = json.loads(client.get("/api/dropdowns/court-selector/", query).content)["data"]
+        assert data["selected"]["value"] == "cook:chd1"
+        assert not any(item["from_document"] for item in data["steps"])
+
+
+class TestWhereACountyHasNoCourtOfItsOwn:
+    """Cook County is a heading over eighty locations, not a court."""
+
+    def test_a_caption_naming_only_the_county_still_finds_it(self):
+        # The county's own row is not in the list, because it takes no filings.
+        courts = [court for court in ILLINOIS_COURTS if court["value"] != "cook"]
+        answers = derive_answers_from_guess("illinois", "IN THE CIRCUIT COURT OF COOK COUNTY", courts)
+        assert answers["level"] == "circuit"
+        assert answers["county"] == "Cook"
+
+    def test_the_county_starts_at_the_division_most_filings_go_to(self):
+        courts = [court for court in ILLINOIS_COURTS if court["value"] != "cook"] + [
+            {"value": "cook:cvd", "text": "Cook County - Municipal Civil"}
+        ]
+        selection = select("illinois", {"level": "circuit", "county": "Cook"}, courts)
+        division = step(selection, "division")
+        assert division["answer"] == "cook:cvd"
+        # Suggested, not chosen: the question stays on screen saying so.
+        assert division["defaulted"] is True
+        assert division["default_hint"]
+        assert selection["selected"]["value"] == "cook:cvd"
+
+    def test_a_division_the_filer_chose_is_not_marked_as_a_suggestion(self):
+        selection = select("illinois", {"level": "circuit", "county": "Cook", "division": "cook:law1"}, ILLINOIS_COURTS)
+        assert step(selection, "division")["defaulted"] is False
+
+    def test_a_county_with_no_default_is_left_to_the_filer(self):
+        selection = select("illinois", {"level": "circuit", "county": "Peoria"}, ILLINOIS_COURTS)
+        assert step(selection, "division")["answer"] == ""
+        assert selection["selected"] is None
+
+
+class TestHowCourtsAreNamed:
+    """The service names courts so they sort. Nobody calls them that."""
+
+    @pytest.mark.parametrize(
+        ("listed", "called"),
+        [
+            ("Juvenile Court -- Suffolk County -- Boston", "Boston Juvenile Court - Suffolk County"),
+            ("District Court - Cambridge", "Cambridge District Court"),
+            ("BMC -  Charlestown", "Charlestown Division, Boston Municipal Court"),
+            ("Superior Court - Bristol", "Bristol Superior Court"),
+            ("Housing - Eastern (Boston)", "Eastern Housing Court (Boston)"),
+            ("Housing - Northeast", "Northeast Housing Court"),
+            # Already the right way round, and left alone.
+            ("Middlesex Probate and Family Court", "Middlesex Probate and Family Court"),
+            ("Southeast Housing Court - Brockton", "Southeast Housing Court - Brockton"),
+            ("Land Court", "Land Court"),
+        ],
+    )
+    def test_massachusetts_courts_read_as_they_are_named(self, listed, called):
+        config = selector_config("massachusetts")
+        assert config is not None
+        rules = config["court_names"]
+        assert _readable_name(listed, rules) == called
+
+    def test_a_jurisdiction_with_no_rules_keeps_every_name(self):
+        assert (selector_config("vermont") or {}).get("court_names") is None
+        assert _readable_name("Addison Unit", []) == "Addison Unit"
+
+    def test_the_renamed_court_is_what_the_filer_picks_and_what_is_saved(self):
+        selection = select(
+            "massachusetts",
+            {"level": "trial", "department": "juvenile", "court": "1086:BO"},
+            MASSACHUSETTS_COURTS,
+        )
+        assert selection["selected"]["text"] == "Boston Juvenile Court - Suffolk County"
diff --git a/efile_app/efile/tests/test_document_extractions.py b/efile_app/efile/tests/test_document_extractions.py
index 169c288f..72efb653 100644
--- a/efile_app/efile/tests/test_document_extractions.py
+++ b/efile_app/efile/tests/test_document_extractions.py
@@ -15,7 +15,7 @@
     process_document_extraction,
     queue_document_extraction,
 )
-from efile.services.extraction_fields import normalize_extracted_fields
+from efile.services.extraction_fields import normalize_document_evidence, normalize_extracted_fields
 from efile.services.taxonomy_classification import ClassificationRun, HierarchicalDocumentClassifier
 from efile.workflow import ExistingCase
 
@@ -55,6 +55,21 @@ def test_normalization_keeps_every_extracted_field():
     }
 
 
+@pytest.mark.parametrize("normalizer", [normalize_extracted_fields, normalize_document_evidence])
+def test_normalization_canonicalizes_common_party_name_keys(normalizer):
+    normalized = normalizer(
+        {
+            "petitioner names": "Dana Kim",
+            "respondent name": "Elliot Kim",
+            "other parties": "Ari Kim (Child)",
+        }
+    )
+
+    assert normalized["plaintiff or petitioner names"] == "Dana Kim"
+    assert normalized["defendant or respondent names"] == "Elliot Kim"
+    assert normalized["other party names"] == "Ari Kim (Child)"
+
+
 @pytest.mark.django_db
 def test_worker_caps_pages_and_persists_the_complete_payload(extraction_draft):
     document = FilingDocument.objects.create(
diff --git a/efile_app/playwright.config.js b/efile_app/playwright.config.js
index f3170bb7..4fd6a2bb 100644
--- a/efile_app/playwright.config.js
+++ b/efile_app/playwright.config.js
@@ -17,8 +17,10 @@ module.exports = defineConfig({
     // Global setup file (uncomment to use setup.js)
     globalSetup: require.resolve('./tests/setup.js'),
 
-    // Run tests in files in parallel
-    fullyParallel: true,
+    // Filing drafts are durable user-owned records. The E2E suite uses one
+    // Tyler test account, so parallel browser contexts can replace each
+    // other's current draft even though their cookies are isolated.
+    fullyParallel: false,
 
     // Fail the build on CI if you accidentally left test.only in the source code
     forbidOnly: !!process.env.CI,
@@ -26,8 +28,8 @@ module.exports = defineConfig({
     // Retry on CI only
     retries: process.env.CI ? 2 : 0,
 
-    // Opt out of parallel tests on CI
-    workers: process.env.CI ? 1 : undefined,
+    // Keep the shared test account on one filing at a time locally and in CI.
+    workers: 1,
 
     // Reporter to use
     reporter: 'list',
diff --git a/efile_app/pyproject.toml b/efile_app/pyproject.toml
index 34669e00..1a8cf58d 100644
--- a/efile_app/pyproject.toml
+++ b/efile_app/pyproject.toml
@@ -22,6 +22,12 @@ dependencies = [
     "bleach>=6.2,<7",
     "markdown>=3.10.2",
     "markdownify>=1.2.2",
+    # Massachusetts court records and jurisdiction matching, shared with
+    # docassemble-MACourts. Pinned to the GitHub repository until it is
+    # published to PyPI.
+    "suffolklitlab-macourts @ git+https://github.com/SuffolkLITLab/MACourts@main",
+    # Vermont Superior Court unit lookup by town, county, or ZIP.
+    "suffolklitlab-vtcourts @ git+https://github.com/SuffolkLITLab/VTCourts@main",
 ]
 
 [build-system]
diff --git a/efile_app/tests/document-classification-sentinel.spec.js b/efile_app/tests/document-classification-sentinel.spec.js
index 51c14425..4b3611a7 100644
--- a/efile_app/tests/document-classification-sentinel.spec.js
+++ b/efile_app/tests/document-classification-sentinel.spec.js
@@ -40,15 +40,25 @@ test('real uploaded PDF is extracted and classified against live Tyler choices',
     ]);
 
     await expect(page.getByRole('heading', {
-        name: /Here is everything we pulled from your document/i
+        name: /Check what we read from your document/i
     })).toBeVisible();
-    await expect(page.locator('.extracted-details')).toContainText('Dana Kim');
-    await expect(page.locator('.extracted-details')).toContainText('Elliot Kim');
     await expect(page.locator('.extracted-details')).toContainText(/Petition for Divorce with Children/i);
+    await expect(page.locator('.extracted-details')).toContainText('ATJ 105.3');
+    const partyNames = page.locator('.review-parties input[name="party_name"]');
+    await expect(partyNames.nth(0)).toHaveValue('Dana Kim');
+    await expect(partyNames.nth(1)).toHaveValue('Elliot Kim');
 
-    await expect(page.locator('#court_name')).toHaveValue(/Lake County/i);
-    await expect(page.locator('#case_category_name')).toHaveValue('Dissolution (Divorce) with Children');
-    await expect(page.locator('#case_type_name')).toHaveValue('Dissolution (with children)');
-    await expect(page.locator('#filing_type_name')).toHaveValue('Petition Dissolution of Marriage/Civil Union');
+    await expect(page.locator('#court_name')).toHaveValue(/Lake County/i, {
+        timeout: 120000
+    });
+    await expect(page.locator('#case_category_name')).toHaveValue('Dissolution (Divorce) with Children', {
+        timeout: 120000
+    });
+    await expect(page.locator('#case_type_name')).toHaveValue('Dissolution (with children)', {
+        timeout: 120000
+    });
+    await expect(page.locator('#filing_type_name')).toHaveValue('Petition Dissolution of Marriage/Civil Union', {
+        timeout: 120000
+    });
     await expect(page.locator('input[type="radio"][name="existing_case"][value="new"]')).toBeChecked();
 });
\ No newline at end of file
diff --git a/efile_app/tests/reorganized-filing-matrix.spec.js b/efile_app/tests/reorganized-filing-matrix.spec.js
index 59c53807..656d18ed 100644
--- a/efile_app/tests/reorganized-filing-matrix.spec.js
+++ b/efile_app/tests/reorganized-filing-matrix.spec.js
@@ -5,7 +5,10 @@ const {
 const path = require('path');
 const {
     getTestConfig,
-    loginViaLoginPage
+    loginViaLoginPage,
+    continueFromExtractionReview,
+    continueFromDocumentChecklist,
+    selectGuidedCourt
 } = require('./test-utils');
 
 const SAMPLE_PDF = path.resolve(__dirname, '../../testing/sample_test.pdf');
@@ -153,7 +156,7 @@ async function selectAfterLoad(page, selector, value) {
 
 async function fillRequiredInputs(page, values) {
     for (const [name, value] of Object.entries(values)) {
-        const field = page.locator(`[name="${name}"]`);
+        const field = page.locator(`[name="${name}"]:visible`).first();
         if (await field.count()) await field.fill(value);
     }
     const required = page.locator('input[required]:visible');
@@ -175,6 +178,8 @@ async function completeParty(page, ordinal) {
         await roleRadios.first().check();
     }
     await page.locator('input[name="party_kind"][value="person"]').check();
+    const addressToggle = page.locator('#add-party-address');
+    if (await addressToggle.count()) await addressToggle.check();
     await fillRequiredInputs(page, {
         first_name: `Alex${ordinal}`,
         last_name: `Respondent${ordinal}`,
@@ -214,13 +219,7 @@ async function completeQuestions(page) {
 
 async function finishFiling(page, scenario, ordinal) {
     console.log(`${scenario.label}: confirming checklist`);
-    await page.locator('input[name="documents_complete"]').check();
-    await Promise.all([
-        page.waitForURL(/\/organize-documents\//),
-        page.getByRole('button', {
-            name: /Continue to organize/i
-        }).click(),
-    ]);
+    await continueFromDocumentChecklist(page);
     console.log(`${scenario.label}: organizing document`);
     const filingType = page.locator('.organize-card .filing-type');
     if (scenario.filingType) {
@@ -368,19 +367,12 @@ async function runNewCase(page, scenario, ordinal) {
     ]);
 
     console.log(`${scenario.label}: selecting case codes`);
-    await selectAfterLoad(page, '#court_code', scenario.court);
+    await selectGuidedCourt(page, 'illinois', scenario.court);
     await selectAfterLoad(page, '#case_category_code', scenario.category);
     await selectAfterLoad(page, '#case_type_code', scenario.caseType);
     await selectAfterLoad(page, '#filing_type_code', scenario.filingType);
-    await page.locator('input[name="existing_case"][value="new"]').check();
-    await Promise.all([
-        page.waitForURL(/\/document-checklist\//, {
-            timeout: 120000
-        }),
-        page.getByRole('button', {
-            name: /Confirm and continue/i
-        }).click(),
-    ]);
+    await page.locator('input[type="radio"][name="existing_case"][value="new"]').check();
+    await continueFromExtractionReview(page, /\/document-checklist\//);
 
     await finishFiling(page, scenario, ordinal);
 }
@@ -400,16 +392,9 @@ async function runExistingCase(page, scenario, ordinal) {
         page.locator('#continue-to-analysis').click(),
     ]);
 
-    await selectAfterLoad(page, '#court_code', scenario.court);
-    await page.locator('input[name="existing_case"][value="existing"]').check();
-    await Promise.all([
-        page.waitForURL(/\/case-lookup\//, {
-            timeout: 120000
-        }),
-        page.getByRole('button', {
-            name: /Confirm and continue/i
-        }).click(),
-    ]);
+    await selectGuidedCourt(page, 'illinois', scenario.court);
+    await page.locator('input[type="radio"][name="existing_case"][value="existing"]').check();
+    await continueFromExtractionReview(page, /\/case-lookup\//);
     await selectAfterLoad(page, '#court', scenario.court);
     await page.locator('#case-number').fill(scenario.caseNumber);
     const lookupOutcome = await Promise.race([
diff --git a/efile_app/tests/test-optional-services-e2e.spec.js b/efile_app/tests/test-optional-services-e2e.spec.js
index 6a66d996..886baa23 100644
--- a/efile_app/tests/test-optional-services-e2e.spec.js
+++ b/efile_app/tests/test-optional-services-e2e.spec.js
@@ -5,7 +5,10 @@ const {
 const path = require('path');
 const {
     getTestConfig,
-    loginViaLoginPage
+    loginViaLoginPage,
+    continueFromExtractionReview,
+    continueFromDocumentChecklist,
+    selectGuidedCourt
 } = require('./test-utils');
 
 const SAMPLE_PDF = path.resolve(__dirname, '../../testing/sample_test.pdf');
@@ -19,7 +22,7 @@ async function selectAfterLoad(page, selector, value) {
 
 async function fillRequiredInputs(page, values) {
     for (const [name, value] of Object.entries(values)) {
-        const field = page.locator(`[name="${name}"]`);
+        const field = page.locator(`[name="${name}"]:visible`).first();
         if (await field.count()) await field.fill(value);
     }
     const required = page.locator('input[required]:visible');
@@ -43,6 +46,8 @@ async function completeParty(page, ordinal) {
         await roleRadios.first().check();
     }
     await page.locator('input[name="party_kind"][value="person"]').check();
+    const addressToggle = page.locator('#add-party-address');
+    if (await addressToggle.count()) await addressToggle.check();
     await fillRequiredInputs(page, {
         first_name: `Alex${ordinal}`,
         last_name: `Respondent${ordinal}`,
@@ -97,11 +102,7 @@ test('adding and removing optional services dynamically updates calculated fees
     ]);
 
     console.log('Step 4: Selecting case codes (Adams County - Small Claims)...');
-    const reviewedCheckbox = page.locator('input[name="reviewed_extraction"]');
-    if (await reviewedCheckbox.count()) {
-        await reviewedCheckbox.check();
-    }
-    await selectAfterLoad(page, '#court_code', 'adams');
+    await selectGuidedCourt(page, 'illinois', 'adams');
     await selectAfterLoad(page, '#case_category_code', '6198'); // Small Claims
     await selectAfterLoad(page, '#case_type_code', '183541'); // Contract
     await selectAfterLoad(page, '#filing_type_code', '143132'); // Amended Complaint
@@ -109,23 +110,10 @@ test('adding and removing optional services dynamically updates calculated fees
     if (await radioNew.count()) {
         await radioNew.check();
     }
-    await Promise.all([
-        page.waitForURL(/\/document-checklist\//, {
-            timeout: 120000
-        }),
-        page.getByRole('button', {
-            name: /Confirm and continue/i
-        }).click(),
-    ]);
+    await continueFromExtractionReview(page, /\/document-checklist\//);
 
     console.log('Step 5: Confirming checklist...');
-    await page.locator('input[name="documents_complete"]').check();
-    await Promise.all([
-        page.waitForURL(/\/organize-documents\//),
-        page.getByRole('button', {
-            name: /Continue to organize/i
-        }).click(),
-    ]);
+    await continueFromDocumentChecklist(page);
 
     console.log('Step 6: Organizing document with Optional Service (Certification with Seal - $6.00)...');
     const filingType = page.locator('.organize-card .filing-type');
diff --git a/efile_app/tests/test-utils.js b/efile_app/tests/test-utils.js
index 442c8e8b..c8c1316b 100644
--- a/efile_app/tests/test-utils.js
+++ b/efile_app/tests/test-utils.js
@@ -94,6 +94,105 @@ async function loginViaLoginPage(page, config = getTestConfig()) {
     await waitForLogin(page);
 }
 
+/**
+ * Submit the extraction review after answering its conditional questions.
+ * The filer-side question only appears for case types whose checklist differs
+ * by side, and it is populated asynchronously after the taxonomy choices.
+ */
+async function continueFromExtractionReview(page, nextUrl = /\/(document-checklist|case-lookup)\//) {
+    const reviewed = page.locator('input[name="reviewed_extraction"]');
+    if (await reviewed.count()) await reviewed.check();
+
+    const roleField = page.locator('#filer-role-field');
+    if (await roleField.count()) {
+        await page.waitForLoadState('networkidle', {
+            timeout: 120000
+        });
+        if (await roleField.isVisible()) {
+            await roleField.locator('input[name="filer_role"]').first().check();
+        }
+    }
+
+    await Promise.all([
+        page.waitForURL(nextUrl, {
+            timeout: 120000
+        }),
+        page.getByRole('button', {
+            name: /Confirm and continue/i
+        }).click(),
+    ]);
+}
+
+/**
+ * Confirm the document checklist, first resolving a filer-side question if a
+ * caller reached this page from an older or incomplete draft.
+ */
+async function continueFromDocumentChecklist(page) {
+    const role = page.locator('input[name="filer_role"]:visible').first();
+    if (await role.count()) {
+        await role.check();
+        await page.getByRole('button', {
+            name: /Show my documents/i
+        }).click();
+        await page.locator('input[name="documents_complete"]').waitFor({
+            state: 'visible',
+            timeout: 120000
+        });
+    }
+
+    await page.locator('input[name="documents_complete"]').check();
+    await Promise.all([
+        page.waitForURL(/\/organize-documents\//, {
+            timeout: 120000
+        }),
+        page.getByRole('button', {
+            name: /Continue to organize/i
+        }).click(),
+    ]);
+}
+
+/**
+ * Choose a known court through the jurisdiction's visible guided questions.
+ * Asking the selector endpoint for the route keeps state-specific court logic
+ * out of the browser suite; the test still answers each rendered control.
+ */
+async function selectGuidedCourt(page, jurisdiction, courtCode) {
+    const response = await page.request.get('/api/dropdowns/court-selector/', {
+        params: {
+            jurisdiction,
+            court: courtCode
+        }
+    });
+    if (!response.ok()) throw new Error(`Could not resolve the guided route for court ${courtCode}`);
+    const payload = await response.json();
+    const data = payload.data || {};
+    if (!payload.success || !data.available) {
+        throw new Error(`No guided court selector is available for ${jurisdiction}`);
+    }
+
+    for (const step of data.steps || []) {
+        if (!step.answer) continue;
+        const choice = page.locator(`#court-selector input[data-step="${step.id}"][value="${step.answer}"]`);
+        const select = page.locator(`#court-selector select[data-step="${step.id}"]`);
+        if (await choice.count()) {
+            await choice.check();
+        } else {
+            await select.waitFor({
+                state: 'visible',
+                timeout: 120000
+            });
+            await select.selectOption(step.answer);
+        }
+    }
+
+    await page.locator('#court_code').waitFor({
+        state: 'attached'
+    });
+    await page.waitForFunction((expected) => document.getElementById('court_code')?.value === expected, courtCode, {
+        timeout: 120000
+    });
+}
+
 // Alias for backward compatibility
 const loginUser = loginViaLogout;
 
@@ -101,5 +200,8 @@ module.exports = {
     getTestConfig,
     loginUser,
     loginViaLogout,
-    loginViaLoginPage
+    loginViaLoginPage,
+    continueFromExtractionReview,
+    continueFromDocumentChecklist,
+    selectGuidedCourt
 };
\ No newline at end of file
diff --git a/efile_app/uv.lock b/efile_app/uv.lock
index bef5158e..a79e3d83 100644
--- a/efile_app/uv.lock
+++ b/efile_app/uv.lock
@@ -891,6 +891,8 @@ dependencies = [
     { name = "python-dotenv" },
     { name = "pyyaml" },
     { name = "requests" },
+    { name = "suffolklitlab-macourts" },
+    { name = "suffolklitlab-vtcourts" },
     { name = "tiktoken" },
     { name = "uvicorn" },
     { name = "whitenoise" },
@@ -928,6 +930,8 @@ requires-dist = [
     { name = "python-dotenv", specifier = ">=1.0" },
     { name = "pyyaml", specifier = ">=6.0,<7" },
     { name = "requests", specifier = ">=2.31,<3" },
+    { name = "suffolklitlab-macourts", git = "https://github.com/SuffolkLITLab/MACourts?rev=main" },
+    { name = "suffolklitlab-vtcourts", git = "https://github.com/SuffolkLITLab/VTCourts?rev=main" },
     { name = "tiktoken", specifier = ">=0.12.0" },
     { name = "uvicorn", specifier = ">=0.30" },
     { name = "whitenoise", specifier = ">=6.7" },
@@ -1693,6 +1697,57 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6d/4f/d073e09df851cfa251ef7840007d04db3293a0482ce607d2b993926089be/s3transfer-0.13.1-py3-none-any.whl", hash = "sha256:a981aa7429be23fe6dfc13e80e4020057cbab622b08c0315288758d67cabc724", size = 85308, upload-time = "2025-07-18T19:22:40.947Z" },
 ]
 
+[[package]]
+name = "shapely"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },
+    { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },
+    { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },
+    { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" },
+    { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" },
+    { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" },
+    { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c4/3ce4c2d9b6aabd27d26ec988f08cb877ba9e6e96086eff81bfea93e688c7/shapely-2.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223", size = 1831290, upload-time = "2025-09-24T13:51:13.56Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b9/f6ab8918fc15429f79cb04afa9f9913546212d7fb5e5196132a2af46676b/shapely-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c", size = 1641463, upload-time = "2025-09-24T13:51:14.972Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/57/91d59ae525ca641e7ac5551c04c9503aee6f29b92b392f31790fcb1a4358/shapely-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df", size = 2970145, upload-time = "2025-09-24T13:51:16.961Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cb/4948be52ee1da6927831ab59e10d4c29baa2a714f599f1f0d1bc747f5777/shapely-2.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf", size = 3073806, upload-time = "2025-09-24T13:51:18.712Z" },
+    { url = "https://files.pythonhosted.org/packages/03/83/f768a54af775eb41ef2e7bec8a0a0dbe7d2431c3e78c0a8bdba7ab17e446/shapely-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4", size = 3980803, upload-time = "2025-09-24T13:51:20.37Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cb/559c7c195807c91c79d38a1f6901384a2878a76fbdf3f1048893a9b7534d/shapely-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc", size = 4133301, upload-time = "2025-09-24T13:51:21.887Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cd/60d5ae203241c53ef3abd2ef27c6800e21afd6c94e39db5315ea0cbafb4a/shapely-2.1.2-cp314-cp314-win32.whl", hash = "sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566", size = 1583247, upload-time = "2025-09-24T13:51:23.401Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d4/135684f342e909330e50d31d441ace06bf83c7dc0777e11043f99167b123/shapely-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c", size = 1773019, upload-time = "2025-09-24T13:51:24.873Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/05/a44f3f9f695fa3ada22786dc9da33c933da1cbc4bfe876fe3a100bafe263/shapely-2.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a", size = 1834137, upload-time = "2025-09-24T13:51:26.665Z" },
+    { url = "https://files.pythonhosted.org/packages/52/7e/4d57db45bf314573427b0a70dfca15d912d108e6023f623947fa69f39b72/shapely-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076", size = 1642884, upload-time = "2025-09-24T13:51:28.029Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/27/4e29c0a55d6d14ad7422bf86995d7ff3f54af0eba59617eb95caf84b9680/shapely-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1", size = 3018320, upload-time = "2025-09-24T13:51:29.903Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/bb/992e6a3c463f4d29d4cd6ab8963b75b1b1040199edbd72beada4af46bde5/shapely-2.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0", size = 3094931, upload-time = "2025-09-24T13:51:32.699Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/16/82e65e21070e473f0ed6451224ed9fa0be85033d17e0c6e7213a12f59d12/shapely-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26", size = 4030406, upload-time = "2025-09-24T13:51:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/75/c24ed871c576d7e2b64b04b1fe3d075157f6eb54e59670d3f5ffb36e25c7/shapely-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0", size = 4169511, upload-time = "2025-09-24T13:51:36.297Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f7/b3d1d6d18ebf55236eec1c681ce5e665742aab3c0b7b232720a7d43df7b6/shapely-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735", size = 1602607, upload-time = "2025-09-24T13:51:37.757Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/f6/f09272a71976dfc138129b8faf435d064a811ae2f708cb147dccdf7aacdb/shapely-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9", size = 1796682, upload-time = "2025-09-24T13:51:39.233Z" },
+]
+
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -1738,6 +1793,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c5/97/bba6e7ec2f5498b9dcb7b1b6400086b80ae5a8ebaff4b25e8c8add75f439/stevedore-5.9.1-py3-none-any.whl", hash = "sha256:5c8ff3a9f336cc1a06ac0f597bc79d11a2f950bfd32e290ca56b5a301fafafbf", size = 54931, upload-time = "2026-08-20T15:25:13.602Z" },
 ]
 
+[[package]]
+name = "suffolklitlab-macourts"
+version = "0.1.0"
+source = { git = "https://github.com/SuffolkLITLab/MACourts?rev=main#dbd718f37a251d2bb0b215c44ce9693766cf1a8c" }
+dependencies = [
+    { name = "shapely" },
+]
+
+[[package]]
+name = "suffolklitlab-vtcourts"
+version = "0.1.0"
+source = { git = "https://github.com/SuffolkLITLab/VTCourts?rev=main#aefa2b78456ff9ac37d2acc3e55bbf3ef74c8c6e" }
+
 [[package]]
 name = "sympy"
 version = "1.14.0"

From d706e3eb4b077fd43ed26fe51924d68a89d694b7 Mon Sep 17 00:00:00 2001
From: Quinten Steenhuis <qsteenhuis@gmail.com>
Date: Sat, 5 Sep 2026 16:08:40 -0400
Subject: [PATCH 2/3] Refactor handling of step types in test-utils.js

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 efile_app/tests/test-utils.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/efile_app/tests/test-utils.js b/efile_app/tests/test-utils.js
index c8c1316b..cda23473 100644
--- a/efile_app/tests/test-utils.js
+++ b/efile_app/tests/test-utils.js
@@ -172,15 +172,16 @@ async function selectGuidedCourt(page, jurisdiction, courtCode) {
 
     for (const step of data.steps || []) {
         if (!step.answer) continue;
+        if (step.type === 'location') continue;
+
         const choice = page.locator(`#court-selector input[data-step="${step.id}"][value="${step.answer}"]`);
         const select = page.locator(`#court-selector select[data-step="${step.id}"]`);
-        if (await choice.count()) {
+
+        if (step.type === 'choice') {
+            await choice.waitFor({ state: 'visible', timeout: 120000 });
             await choice.check();
         } else {
-            await select.waitFor({
-                state: 'visible',
-                timeout: 120000
-            });
+            await select.waitFor({ state: 'visible', timeout: 120000 });
             await select.selectOption(step.answer);
         }
     }

From e0fab222445c5c917622e2d78c6985e690129a9b Mon Sep 17 00:00:00 2001
From: Quinten Steenhuis <qsteenhuis@suffolk.edu>
Date: Sat, 5 Sep 2026 16:24:15 -0400
Subject: [PATCH 3/3] Fix formatting

---
 efile_app/tests/test-utils.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/efile_app/tests/test-utils.js b/efile_app/tests/test-utils.js
index cda23473..2e7cc977 100644
--- a/efile_app/tests/test-utils.js
+++ b/efile_app/tests/test-utils.js
@@ -178,10 +178,16 @@ async function selectGuidedCourt(page, jurisdiction, courtCode) {
         const select = page.locator(`#court-selector select[data-step="${step.id}"]`);
 
         if (step.type === 'choice') {
-            await choice.waitFor({ state: 'visible', timeout: 120000 });
+            await choice.waitFor({
+                state: 'visible',
+                timeout: 120000
+            });
             await choice.check();
         } else {
-            await select.waitFor({ state: 'visible', timeout: 120000 });
+            await select.waitFor({
+                state: 'visible',
+                timeout: 120000
+            });
             await select.selectOption(step.answer);
         }
     }