Upload 13 files

CITY_REVIEW_UPDATE.md

@@ -0,0 +1,80 @@
+# City of Calgary Detailed Review alignment
+
+This revision aligns Calgary suite reviews with the structure and review
+discipline demonstrated by City of Calgary file DP2024-00595.
+
+## City-style output
+
+`review_plan_set` returns `city_review_letter_markdown` with:
+
+1. Detailed Review 1 - Development Permit title
+2. Application metadata
+3. General Comments
+4. Bylaw Discrepancies table:
+   `Regulation | Standard | Provided`
+5. Prior to Decision Requirements
+6. Applicant options to cancel, proceed to decision, or amend
+7. Advisory Comments
+
+The City-style letter is a development-permit planning document. NBC-AE and
+engineer-of-record observations remain in `report_markdown` and are not rendered
+as City land-use conditions.
+
+## Municipal context inputs
+
+The following optional `review_plan_set` arguments should be populated whenever
+they are available:
+
+- `application_number`
+- `site_address`
+- `applicant`
+- `community`
+- `land_use_district`
+- `use_type`
+- `planning_contact`
+- `date_dr_sent`
+- `response_due_date`
+- `municipal_records_context`
+
+Municipality-confirmed records override drawing silence. For example, an
+existing secondary suite confirmed by City records is treated as confirmed
+context even when it is absent from the submitted plan set.
+
+## Mandatory Calgary backyard-suite checks
+
+The reconciliation layer accounts for:
+
+- parcel coverage;
+- parking for the principal dwelling;
+- parking for the backyard suite;
+- rear-property-line setback;
+- closest-façade separation;
+- private amenity space; and
+- secondary-suite/backyard-suite density.
+
+A passing check is retained in `mandatory_checks`. A missing check becomes a
+low-confidence clarification; it is not silently omitted and is not converted
+into an invented violation.
+
+## Geometry controls
+
+- A labelled parking rectangle is accepted only when it is inside the legal
+  parcel, dimensioned, accessible, and assigned to a dwelling unit.
+- Rear, side, and front property lines must be classified before selecting a
+  setback dimension.
+- Backyard-suite separation uses the closest applicable façade-to-façade
+  measurement.
+- Numeric discrepancies require Required, Provided, Delta, units, and source.
+  Unreconciled calculations are flagged instead of copied.
+
+## Validation
+
+Run:
+
+```bash
+python smoke_test.py
+```
+
+The test suite validates the MCP surface, City header, City report sections,
+separation of DP and building-code streams, applicant options, mandatory-check
+reconciliation, and corrections-response honesty controls.

README.md

@@ -22,7 +22,7 @@ Claude, ChatGPT, Gemini, n8n, HF UI, local clients, or through a tunnel.
 | `list_municipalities` | Configured jurisdictions and their code/bylaw frameworks |
 | `list_review_tracks` | Review types (suites, multi-residential, institutional…) + available models |
 | `list_knowledge` | The knowledge base reviews are grounded in |
-| `review_plan_set` | Review a plan set (PDF, base64) → grounded correction findings + report |
+| `review_plan_set` | Review a plan set (PDF, base64) → structured findings, technical screening report, and City-style Detailed Review |
 | `analyze_corrections_letter` | Interpret a corrections letter → item-by-item analysis + draft response |
 | `generate_checklist` | Pre-submission checklist for a project type |
 
@@ -36,6 +36,27 @@ the guarantees hold no matter which client calls them. In particular the correct
 draft never claims a correction is resolved; every resolution is an
 `[APPLICANT: …]` placeholder.
 
+### City of Calgary Detailed Review output
+
+For Calgary reviews, pass municipal metadata when it is available:
+
+- `application_number`, `site_address`, `applicant`, and `community`
+- `land_use_district` and `use_type`
+- `planning_contact`, `date_dr_sent`, and `response_due_date`
+- `municipal_records_context` for verified City facts not shown on the drawings,
+  such as an existing registered or permitted secondary suite
+
+The returned `city_review_letter_markdown` follows the City's Development Permit
+sequence: application header, General Comments, Bylaw Discrepancies
+(`Regulation | Standard | Provided`), Prior to Decision Requirements, applicant
+options, and Advisory Comments. Building-code and engineer-of-record observations
+remain in the separate technical report and are not presented as City DP conditions.
+
+The Calgary suite track deterministically reconciles parcel coverage, parking for
+each dwelling unit, backyard-suite rear setback, closest-façade separation, private
+amenity space, and same-parcel suite density. A missing check becomes a verification
+item; the engine does not silently omit it or invent compliance.
+
 ## Running locally (STDIO, e.g. Claude Desktop)
 
 ```bash

engine.py

@@ -472,6 +472,12 @@ CRITICAL_RULES_TMPL = """CRITICAL RULES ({jur_place} jurisdiction — review tra
 - IDENTIFY THE LAND USE DISTRICT FIRST. Every municipal review states the district and the Use Type (Permitted / Discretionary) in its header, because district determines which standards apply. Populate submission_check.land_use_district and use_type. If the drawings do not state the district, set it to "not shown on the submitted plans" and treat EVERY district-dependent conclusion as unconfirmed, saying so — do not assume a district.
 - BYLAW DISCREPANCY FORM (land-use findings): every land-use finding must additionally carry `regulation`, `standard`, and `provided`, taken from the regulation index in the knowledge. `regulation` is the City's heading (e.g. "412 Parcel Coverage"); `standard` is that regulation's Standard wording; `provided` states what the plans actually show, in the City's register, with the numeric delta where measurable (e.g. "Plans indicate a rear setback of 1.02m (-0.48m)." / "Plans do not indicate a designated private amenity space for the Backyard Suite."). Safety-codes and reviewer-items leave these three fields empty.
 - RUN EVERY MANDATORY CHECK. The regulation index lists checks that must be assessed on EVERY suite review — parcel coverage, parking per dwelling unit, suite parking, rear setback, façade separation, amenity space, and same-parcel suite density. If the submitted set does not contain enough information to measure one of them, still raise it, with `provided` stating plainly that the plans do not show it. Silently omitting a mandatory check is a review defect.
+- MUNICIPAL CONTEXT OVERRIDES DRAWING SILENCE. When PROJECT DETAILS supplies a municipality-confirmed district, use type, existing-suite record, application number, or other City record, carry it into the submission check and findings. Do not downgrade a confirmed City record to "not shown on plans." Clearly distinguish municipal-record evidence from drawing evidence in the `provided` wording.
+- LEGAL-PARCEL GATE FOR PARKING. A rectangle or note labelled "parking" is not a compliant designated stall unless the drawings show it wholly inside the legal parcel, dimensioned, accessible, and assigned to the applicable dwelling unit. A stall drawn in a road, cul-de-sac, lane, boulevard, right-of-way, or outside the property boundary is not provided. Assess the Single Detached Dwelling, Backyard Suite, and any confirmed Secondary Suite separately.
+- PROPERTY-LINE CLASSIFICATION BEFORE SETBACKS. Identify the front, rear, and side property lines from the legal parcel, street frontage, lane access, north arrow, and site context before selecting a setback dimension. Do not use the nearest convenient dimension. State the exact drawing dimension and boundary used; mark the finding [VERIFY] with low confidence if orientation is ambiguous.
+- CLOSEST-FAÇADE MEASUREMENT. For Backyard Suite separation, use the closest applicable façade-to-façade distance, including relevant projections where the governing provision requires them. Do not substitute a centreline, eave-to-lot-line, or non-governing parallel dimension.
+- DEVELOPMENT-PERMIT SCOPE. The City-style Bylaw Discrepancies and Prior to Decision sections contain land-use/planning items only. Safety-codes and engineer-of-record observations belong in the separate technical screening report and must not be presented as City development-permit conditions.
+- CALCULATION TRACEABILITY. For every measurable discrepancy, identify Required, Provided, Delta = Provided - Required, units, and the drawing source. Preserve the City's concise `provided` sentence, but place uncertain or unreconciled arithmetic in `information_gaps`; never reproduce a numeric delta that does not reconcile.
 - AVAILABLE TRACKS: {available_tracks}
 - CONVERT UNITS BEFORE JUDGING A DIMENSION. Drawings are often imperial while the code is metric (1 in = 25.4 mm). Never assert that a dimension fails a metric minimum without converting it first and stating the converted value in the finding. A nominal window/door callout (e.g. 48"x32") is a FRAME size, not an unobstructed opening — the correct finding is that operation type and clear-opening dimensions are not stated, not that the unit is undersized.
 - GROUNDED CITATIONS ONLY: every cited clause/section number must appear VERBATIM in the KNOWLEDGE below. Before writing any citation, confirm that exact number string is present in the knowledge text. If the rule is real but its number is not in the knowledge (e.g. a {jur_safety_short} article you recall but that is not quoted below), DO NOT write the number — cite the knowledge reference by name (e.g. a skill reference file) or record the gap under information_gaps. Never emit a clause number you cannot see in the knowledge; a plausible-but-unverified number (e.g. guessing a foundation article) is a citation error.
@@ -504,6 +510,11 @@ OUTPUT: respond with ONLY a JSON object, no markdown fences:
     "use_type": "<Permitted|Discretionary — if the district IS known but its use list is not in the knowledge, write 'not determinable — <district> use list not in loaded knowledge'; only write 'not determinable without the district' when the district itself is unknown>",
     "matches_declared_scope": true, "suggested_track": "", "note": "..."}},
   "sheet_manifest": [{{"page": 1, "sheet_id": "A1", "title": "..."}}],
+  "mandatory_checks": [
+    {{"check_id": "parcel_coverage|parking_main|parking_backyard|parking_secondary|rear_setback|separation|amenity_space|suite_density",
+      "regulation": "...", "status": "pass|fail|unknown",
+      "standard": "...", "provided": "...", "source_page": 1}}
+  ],
   "findings": [
     {{"id": "F-01", "page": 2, "sheet_id": "A2", "discipline": "arch|site|structural|mep|planning",
       "category": "safety-codes|land-use|reviewer-item",
@@ -517,6 +528,62 @@ OUTPUT: respond with ONLY a JSON object, no markdown fences:
                "transition_note": "...", "information_gaps": ["..."]}}
 }}"""
 
+
+CALGARY_BACKYARD_MANDATORY_CHECKS = {
+    "parcel_coverage": {
+        "regulation": "412 Parcel Coverage",
+        "standard": ("(2) Unless otherwise referenced in subsection (3), the max. parcel "
+                     "coverage is 50.0% of the area of a parcel where: (a) the area of a "
+                     "parcel is equal to or less than 300.0m²; and (b) the parcel width is "
+                     "less than 10.0m"),
+        "provided": "Plans do not provide enough information to verify parcel coverage.",
+    },
+    "parking_main": {
+        "regulation": "305, 423 Parking",
+        "standard": ("(c) requires a minimum of 1.0 motor vehicle parking stalls per "
+                     "Dwelling Unit (which includes secondary suites if applicable) "
+                     "(except as per below)"),
+        "provided": ("Plans do not demonstrate a designated compliant motor vehicle "
+                     "parking stall for the Single Detached Dwelling."),
+    },
+    "parking_backyard": {
+        "regulation": "153.1 Backyard Suite",
+        "standard": "(c) requires a minimum of 1.0 motor vehicle parking stall.",
+        "provided": ("Plans do not demonstrate a designated compliant motor vehicle "
+                     "parking stall for the Backyard Suite."),
+    },
+    "rear_setback": {
+        "regulation": "352 Backyard Suite",
+        "standard": ("(1) For a Backyard Suite, the minimum building setback from a rear "
+                     "property line is: (a) 1.5m for any portion of the building used as "
+                     "a Backyard Suite; and"),
+        "provided": "Plans do not provide a verified rear-property-line setback dimension.",
+    },
+    "separation": {
+        "regulation": "352 Backyard Suite",
+        "standard": ("(3) Unless otherwise referenced in subsections (3.1) and (3.2), a "
+                     "minimum separation of 5.0m is required between the closest facade "
+                     "of the main residential building to the closest façade of a "
+                     "Backyard Suite."),
+        "provided": "Plans do not provide a verified closest-façade separation dimension.",
+    },
+    "amenity_space": {
+        "regulation": "352 Backyard Suite",
+        "standard": ("(7) A Backyard Suite must have a private amenity space that: (a) is "
+                     "located outdoors; and (b) has a minimum area of 7.5m² with no "
+                     "dimension less than 1.5m."),
+        "provided": ("Plans do not indicate a designated private amenity space for the "
+                     "Backyard Suite."),
+    },
+    "suite_density": {
+        "regulation": "354 Accessory Suite - Density",
+        "standard": ("(2) Unless otherwise referenced in subsection (4), a Secondary "
+                     "Suite and a Backyard Suite must not be located on the same parcel."),
+        "provided": ("The submitted information does not confirm whether a Secondary "
+                     "Suite exists on the same parcel as the proposed Backyard Suite."),
+    },
+}
+
 DEFAULT_CHAT_SYSTEM_TMPL = """You are a {jur_persona} ({jur_safety} + {jur_landuse}).
 
 HOW TO REASON (follow this every time):
@@ -700,6 +767,82 @@ def route(provider: str, model: str, api_key: str, skills: list[Skill],
         return out, f"router fallback ({exc})"
 
 
+def _reconcile_calgary_backyard_checks(result: dict, jur: Jurisdiction,
+                                        track: dict) -> None:
+    """Ensure a Calgary backyard-suite run accounts for every City DR check.
+
+    A passing check belongs in ``mandatory_checks`` and does not become a
+    discrepancy. A missing check becomes a low-confidence clarification rather
+    than being silently omitted or guessed.
+    """
+    if str(getattr(jur, "name", "")).lower() != "calgary":
+        return
+    sc = result.get("submission_check", {}) or {}
+    project_text = " ".join([
+        str(sc.get("detected_project", "")),
+        str(sc.get("note", "")),
+        str(track.get("label", "")),
+    ]).lower()
+    if "backyard suite" not in project_text:
+        return
+
+    covered = {
+        str(c.get("check_id", "")).strip()
+        for c in (result.get("mandatory_checks") or [])
+        if str(c.get("status", "")).lower() in {"pass", "fail", "unknown"}
+    }
+    for f in result.get("findings") or []:
+        blob = " ".join([
+            str(f.get("regulation", "")), str(f.get("standard", "")),
+            str(f.get("provided", "")), str(f.get("description", "")),
+        ]).lower()
+        if "412" in blob or "parcel coverage" in blob:
+            covered.add("parcel_coverage")
+        if "305" in blob or "423" in blob or "single detached" in blob:
+            covered.add("parking_main")
+        if "153.1" in blob or ("parking" in blob and "backyard suite" in blob):
+            covered.add("parking_backyard")
+        if "rear setback" in blob or ("rear property line" in blob and "1.5" in blob):
+            covered.add("rear_setback")
+        if "separation" in blob or "closest façade" in blob or "closest facade" in blob:
+            covered.add("separation")
+        if "amenity" in blob:
+            covered.add("amenity_space")
+        if "354" in blob or ("secondary suite" in blob and "same parcel" in blob):
+            covered.add("suite_density")
+
+    findings = result.setdefault("findings", [])
+    checks = result.setdefault("mandatory_checks", [])
+    next_num = len(findings) + 1
+    for check_id, spec in CALGARY_BACKYARD_MANDATORY_CHECKS.items():
+        if check_id in covered:
+            continue
+        checks.append({
+            "check_id": check_id,
+            "regulation": spec["regulation"],
+            "status": "unknown",
+            "standard": spec["standard"],
+            "provided": spec["provided"],
+            "source_page": None,
+        })
+        findings.append({
+            "id": f"F-AUTO-{next_num:02d}",
+            "page": None,
+            "sheet_id": "",
+            "discipline": "planning",
+            "category": "land-use",
+            "description": "[VERIFY] " + spec["provided"],
+            "citation": "Land Use Bylaw 1P2007",
+            "severity": "clarify",
+            "confidence": "low",
+            "regulation": spec["regulation"],
+            "standard": spec["standard"],
+            "provided": spec["provided"],
+            "auto_added": True,
+        })
+        next_num += 1
+
+
 def run_review(provider: str, model: str, api_key: str, skills: list[Skill],
                selected: list[Source], project_desc: str, images_b64: list[str],
                page_texts: list[str], system_extra: str = "",
@@ -730,6 +873,7 @@ def run_review(provider: str, model: str, api_key: str, skills: list[Skill],
                    images_b64=images_b64 if vision else None, max_tokens=8000,
                    base_url=base_url)
     result = _parse_json(raw)
+    _reconcile_calgary_backyard_checks(result, jur, track)
 
     # Deterministic reconciliation: the verdict string must not contradict the
     # scope decision or the findings. The model sometimes keeps an "out of scope"
@@ -1188,7 +1332,10 @@ def render_city_letter(result: dict, project_desc: str, pages_reviewed: int,
                        total_pages: int, provider: str, model: str,
                        jur: Jurisdiction | None = None,
                        date_warning: str = "", site_address: str = "",
-                       applicant: str = "", permit_number: str = "") -> str:
+                       applicant: str = "", permit_number: str = "",
+                       community: str = "", land_use_district: str = "",
+                       use_type: str = "", planning_contact: str = "",
+                       date_dr_sent: str = "", response_due_date: str = "") -> str:
     """Render the review in a municipal Detailed-Review letter format."""
     jur = jur or _DEFAULT_JUR
     sc = result.get("submission_check", {}) or {}
@@ -1200,11 +1347,13 @@ def render_city_letter(result: dict, project_desc: str, pages_reviewed: int,
     reviewer = [f for f in findings if f.get("category") == "reviewer-item"]
     must_fix = [f for f in findings if f.get("severity") == "must-fix"]
 
-    district = sc.get("land_use_district") or sc.get("detected_use_or_district") \
+    district = land_use_district or sc.get("land_use_district") or \
+        sc.get("detected_use_or_district") \
         or "not shown on the submitted plans"
-    use_type = sc.get("use_type") or "not determinable without the district"
+    resolved_use_type = use_type or sc.get("use_type") or \
+        "not determinable without the district"
 
-    L = [f"# Detailed Review — {jur.place}", ""]
+    L = ["# Detailed Review 1 – Development Permit", ""]
     if date_warning:
         L += [f"> {date_warning}", ""]
     L += [
@@ -1213,11 +1362,13 @@ def render_city_letter(result: dict, project_desc: str, pages_reviewed: int,
         f"| **Application Number** | {permit_number or '—'} |",
         f"| **Application Description** | {sc.get('detected_project', '—')} |",
         f"| **Land Use District** | {district} |",
-        f"| **Use Type** | {use_type} |",
+        f"| **Use Type** | {resolved_use_type} |",
         f"| **Site Address** | {site_address or '—'} |",
+        f"| **Community** | {community or '—'} |",
         f"| **Applicant** | {applicant or '—'} |",
-        f"| **Review generated** | {date.today().isoformat()} · {provider} / {model} · "
-        f"pages {pages_reviewed}/{total_pages} |",
+        f"| **Date DR Sent** | {date_dr_sent or '—'} |",
+        f"| **Response Due Date** | {response_due_date or '—'} |",
+        f"| **Planning** | {planning_contact or '—'} |",
         "", "## General Comments", "",
     ]
 
@@ -1235,7 +1386,8 @@ def render_city_letter(result: dict, project_desc: str, pages_reviewed: int,
         if themes:
             L += ["The submission does not meet the minimum requirements for the following "
                   "regulations: " + ", ".join(themes) + ".", ""]
-    L += [f"Please review the bylaw discrepancies below. {verdict}", ""]
+    L += ["Please review the following bylaw discrepancies associated with the "
+          "application and respond accordingly.", ""]
     if sc.get("note"):
         L += [sc["note"], ""]
     if s.get("transition_note"):
@@ -1293,39 +1445,54 @@ def render_city_letter(result: dict, project_desc: str, pages_reviewed: int,
               f"district-dependent conclusion in this review is unconfirmed until this is "
               f"provided."]
         n += 1
-    for f in must_fix:
+    for f in [x for x in must_fix if x.get("category") == "land-use"]:
         reg = f.get("regulation") or f.get("citation") or ""
         tag = f" ({reg})" if reg else ""
         L += [f"{n}. {f.get('description', '').strip()}{tag}"]
         n += 1
-    L.append("")
-
-    # ── Safety-codes / building-permit stream ──
-    if safety:
-        L += ["## Building/Safety Codes — separate permit stream", "",
-              f"The following {len(safety)} item(s) fall under the "
-              f"{jur.safety_framework} and are reviewed at building permit stage, not as "
-              "land-use discrepancies:", ""]
-        for f in safety:
-            L += [f"- **{f.get('citation', '—')}** — {f.get('description', '').strip()} "
-                  f"_({f.get('severity', '')})_"]
-        L.append("")
-
-    if reviewer:
-        L += ["## Reviewer / Engineer-of-Record Items", ""]
-        for f in reviewer:
-            L += [f"- {f.get('description', '').strip()}"]
-        L.append("")
+    L += [
+        "",
+        f"{n}. Indicate, in writing, the manner in which the application will proceed:",
+        "",
+        "   **(A)** Request cancellation of the application. Any applicable fee refund "
+        "will be determined at the time of cancellation.",
+        "",
+        "   **(B)** Pursue the application as proposed, with a decision by the Development "
+        "Authority based on the discrepancies listed above.",
+        "",
+        "   **(C)** Amend the application to address all Prior to Decision requirements "
+        "of this Detailed Review.",
+        "",
+    ]
 
     gaps = s.get("information_gaps") or []
+    L += ["## Advisory Comments", "",
+          "The following advisory comments are provided as a courtesy to the Applicant "
+          "and registered property owner. They represent some, but not all, of the "
+          "requirements that may apply:", ""]
     if gaps:
-        L += ["## Advisory Comments", "",
-              "The comments below represent some, but not all, of the requirements that "
-              "must be complied with. They are provided as a courtesy:", ""]
         L += [f"- {g}" for g in gaps]
-        L.append("")
+    if safety or reviewer:
+        L += [
+            f"- A separate technical screening identified {len(safety)} safety-code "
+            f"item(s) and {len(reviewer)} reviewer/engineer item(s). These are not "
+            "Development Permit conditions and should be reviewed under the applicable "
+            "building-permit and professional-design streams."
+        ]
+    if not gaps and not safety and not reviewer:
+        L += ["- Advisory comments will be finalized at the time of the Development "
+              "Authority decision."]
+    L += [
+        "- The Applicant may appeal a decision of the Development Authority, including "
+        "conditions of approval, in accordance with the appeal information provided with "
+        "the decision.",
+        "",
+        "---",
+        f"*Draft City-style screening output generated {date.today().isoformat()} using "
+        f"{provider} / {model}; pages reviewed {pages_reviewed}/{total_pages}. "
+        f"{jur.report_footer}*",
+    ]
 
-    L += ["---", f"*{jur.report_footer}*"]
     return "\n".join(L)
 
 

mcp_server.py

@@ -21,12 +21,8 @@ just the provider name. The MCP client's own model does NOT perform the review
 tools call the configured provider so the deterministic engine logic (scope gate,
 grounding, reconciliation) always runs.
 
-DNS-rebinding note: FastMCP auto-enables Host-header validation when it is
-constructed with the default host (127.0.0.1). Behind the HF Spaces proxy that
-rejects every request to /mcp with 421 Misdirected Request. Setting
-`mcp.settings.host` after construction is too late — the security settings are
-frozen in __init__. Both host and transport_security are therefore passed to the
-constructor below.
+DNS-rebinding note: on HF Spaces behind the proxy, FastMCP must run with
+`stateless_http=True` and rebinding protection disabled (handled below).
 """
 
 from __future__ import annotations
@@ -36,7 +32,6 @@ import os
 from typing import Optional
 
 from mcp.server.fastmcp import FastMCP
-from mcp.server.transport_security import TransportSecuritySettings
 
 import engine as eng
 from jurisdiction import list_jurisdictions, load_jurisdiction_file
@@ -44,44 +39,25 @@ from providers import PROVIDERS
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
-mcp = FastMCP(
-    "crossbeam-plan-review",
-    stateless_http=True,
-    json_response=True,
-    host="0.0.0.0",
-    transport_security=TransportSecuritySettings(enable_dns_rebinding_protection=False),
-)
+mcp = FastMCP("crossbeam-plan-review", stateless_http=True)
 
 
 # ── helpers ────────────────────────────────────────────────────────────────
-def _real_slugs() -> list:
-    """Configured municipality slugs, excluding templates and the root default."""
-    choices = list_jurisdictions(BASE_DIR)
-    return [s for s in choices if not s.startswith("_") and s != "default"]
-
-
 def _slug(slug: str = "") -> str:
-    """Resolve the active municipality slug.
-
-    An unknown slug raises instead of silently falling back to the first configured
-    municipality. Silently substituting Calgary for an unrecognised city would hand
-    the agent a confidently-cited but wrong bylaw, which is worse than no answer.
-    """
+    """Resolve the active municipality slug (falls back to the first configured)."""
     choices = list_jurisdictions(BASE_DIR)
-    real = _real_slugs()
-    if slug:
-        if slug in choices:
-            return slug
-        raise ValueError(
-            f"Unknown municipality '{slug}'. Configured: {', '.join(real) or 'none'}. "
-            "Call list_municipalities() for the valid slugs.")
+    if slug and slug in choices:
+        return slug
+    real = [s for s in choices if not s.startswith("_") and s != "default"]
     return real[0] if real else ""
 
 
 def _jur(slug: str = ""):
     choices = list_jurisdictions(BASE_DIR)
-    resolved = _slug(slug)          # raises on an unknown slug
-    return load_jurisdiction_file(choices.get(resolved, ""))
+    if slug and slug in choices:
+        return load_jurisdiction_file(choices[slug])
+    real = [s for s in choices if not s.startswith("_") and s != "default"]
+    return load_jurisdiction_file(choices[real[0]] if real else "")
 
 
 def _resolve_key(provider: str, api_key: str) -> str:
@@ -295,16 +271,8 @@ def get_corrections_kit(municipality: str = "") -> dict:
     correction has been resolved. Every resolution belongs to the applicant and is
     represented by an [APPLICANT: ...] placeholder."""
     jur = _jur(municipality)
-    # Scope to the requested municipality. Loading unscoped pulled EVERY city's
-    # skills, so a Toronto request was framed as Toronto but grounded in Calgary
-    # clauses — grounded, provenance-tagged, and wrong.
-    skills, _ = eng.load_knowledge(BASE_DIR, jurisdiction=_slug(municipality))
+    skills, _ = eng.load_knowledge(BASE_DIR)
     sk = [x for t in eng.discover_tracks(skills).values() for x in t["skills"]]
-    if not sk:
-        return {"error": f"No review knowledge is configured for '{jur.place}' yet.",
-                "municipality": jur.place,
-                "how_to_fix": ("Add skill folders under skills/ whose SKILL.md frontmatter "
-                               f"declares `jurisdiction: {_slug(municipality)}`.")}
     knowledge = "\n\n".join(
         [f"=== {x.name}/SKILL.md ===\n{x.skill_md}" for x in sk] +
         [f"=== {s.key} ===\n{s.content}" for x in sk for s in x.sources])
@@ -337,6 +305,16 @@ def review_plan_set(
     project_description: str = "",
     max_pages: int = 15,
     base_url: str = "",
+    application_number: str = "",
+    site_address: str = "",
+    applicant: str = "",
+    community: str = "",
+    land_use_district: str = "",
+    use_type: str = "",
+    planning_contact: str = "",
+    date_dr_sent: str = "",
+    response_due_date: str = "",
+    municipal_records_context: str = "",
 ) -> dict:
     """Review a plan set (PDF, base64-encoded) against a municipality's rules and produce
     grounded correction findings. This is the city-side pre-screen. Returns the structured
@@ -355,7 +333,15 @@ def review_plan_set(
     trans = f" (assess against {jur.transition_label})" if jur.transition_label else ""
     desc = (f"Municipality: {jur.place}\nReview type: {tr['label']}\n"
             f"Intended application date: {application_date or 'not stated'}{trans}\n"
-            f"Description: {project_description or 'not provided'}")
+            f"Description: {project_description or 'not provided'}\n"
+            f"Application number: {application_number or 'not provided'}\n"
+            f"Site address: {site_address or 'not provided'}\n"
+            f"Applicant: {applicant or 'not provided'}\n"
+            f"Community: {community or 'not provided'}\n"
+            f"Land Use District supplied by municipality: "
+            f"{land_use_district or 'not provided'}\n"
+            f"Use Type supplied by municipality: {use_type or 'not provided'}\n"
+            f"Municipal records context: {municipal_records_context or 'not provided'}")
     selected, routed = eng.route(provider, model, key, skills, loose, desc,
                                  base_url=base_url, jur=jur)
     result = eng.run_review(provider, model, key, skills, selected, desc, b64s, texts,
@@ -366,7 +352,15 @@ def review_plan_set(
                                provider, model, jur=jur)
     date_warning = eng.check_application_date(application_date, texts)
     city_letter = eng.render_city_letter(result, desc, len(b64s), total, provider, model,
-                                         jur=jur, date_warning=date_warning)
+                                         jur=jur, date_warning=date_warning,
+                                         site_address=site_address, applicant=applicant,
+                                         permit_number=application_number,
+                                         community=community,
+                                         land_use_district=land_use_district,
+                                         use_type=use_type,
+                                         planning_contact=planning_contact,
+                                         date_dr_sent=date_dr_sent,
+                                         response_due_date=response_due_date)
     return {"result": result, "report_markdown": report,
             "city_review_letter_markdown": city_letter,
             "date_warning": date_warning,
@@ -525,18 +519,10 @@ secret (<code>OPENAI_API_KEY</code>, <code>ANTHROPIC_API_KEY</code>,
 
 if __name__ == "__main__":
     if os.environ.get("MCP_HTTP") == "1":
-        import uvicorn
-        from starlette.middleware.cors import CORSMiddleware
-
-        app = mcp.streamable_http_app()
-        app.add_middleware(
-            CORSMiddleware,
-            allow_origins=["*"],
-            allow_methods=["GET", "POST", "DELETE", "OPTIONS"],
-            allow_headers=["*"],
-            expose_headers=["Mcp-Session-Id"],
-        )
-        uvicorn.run(app, host="0.0.0.0",
-                    port=int(os.environ.get("MCP_PORT", "7860")))
+        # HTTP/SSE transport for HF Spaces / n8n / tunnels.
+        port = int(os.environ.get("MCP_PORT", "7860"))
+        mcp.settings.host = "0.0.0.0"
+        mcp.settings.port = port
+        mcp.run(transport="streamable-http")
     else:
-        mcp.run()
+        mcp.run()  # STDIO for Claude Desktop / local clients

requirements.txt

@@ -1,8 +1,7 @@
-mcp>=1.25,<2
+mcp>=1.2
 PyMuPDF>=1.24.0
 requests>=2.31
 ezdxf>=1.3
 matplotlib>=3.7
 PyYAML>=6.0
 uvicorn>=0.30
-starlette>=0.37

smoke_test.py

@@ -47,9 +47,37 @@ eng.llm_call = lambda *a, **k: json.dumps({"submission_check": {"detected_projec
   "summary": {"verdict": "revisions required", "must_fix": 1, "clarify": 0, "advisory": 0}})
 slug = [m["slug"] for m in mun["municipalities"]][0]
 r = mcpsrv.review_plan_set(pdf_base64=base64.b64encode(pdf("A1 suite")).decode(),
-                           api_key="k", municipality=slug)
+                           api_key="k", municipality=slug,
+                           application_number="DP-TEST",
+                           site_address="1 TEST WY NE",
+                           applicant="TEST APPLICANT",
+                           community="TEST COMMUNITY",
+                           land_use_district="Residential - Test District",
+                           use_type="Discretionary",
+                           planning_contact="TEST REVIEWER")
 ok(r.get("result", {}).get("summary", {}).get("must_fix") == 1, "review returns findings via MCP")
 ok("report_markdown" in r and len(r["report_markdown"]) > 50, "report rendered via MCP")
+city = r.get("city_review_letter_markdown", "")
+ok("# Detailed Review 1 – Development Permit" in city, "City DR title rendered")
+ok("DP-TEST" in city and "TEST COMMUNITY" in city and "Discretionary" in city,
+   "municipal header metadata rendered")
+ok("## Bylaw Discrepancies" in city and "## Prior to Decision Requirements" in city,
+   "City DR core sections rendered")
+ok("## Building/Safety Codes" not in city,
+   "building-code stream excluded from City DP conditions")
+ok("**(A)** Request cancellation" in city and "**(C)** Amend the application" in city,
+   "City response options rendered")
+
+backyard = {"submission_check": {"detected_project": "New: Backyard Suite",
+                                  "matches_declared_scope": True},
+            "findings": [], "summary": {}}
+eng._reconcile_calgary_backyard_checks(
+    backyard, load_jurisdiction_file("jurisdictions/calgary.yaml"),
+    {"label": "secondary/backyard suite"})
+ok(len(backyard.get("mandatory_checks", [])) == 7,
+   "all mandatory Calgary backyard-suite checks reconciled")
+ok(all(f.get("severity") == "clarify" for f in backyard.get("findings", [])),
+   "missing mandatory checks become clarifications, not invented violations")
 
 eng.llm_call = lambda *a, **k: json.dumps({"letter_meta": {"permit_number": "X"},
   "corrections": [{"id": "C-01", "city_item": "i", "category": "land-use", "governing_rule": "s.1",