Upload 26 files

COC_END_TO_END_WORKFLOW.md

@@ -0,0 +1,43 @@
+# Generic City of Calgary SWMR workflow
+
+Kincora Phase 2 is a regression fixture only. Production functions do not
+contain Kincora object IDs, values, geometry, or report conclusions.
+
+## MCP sequence
+
+1. `upload_model` — immutable EPA SWMM INP upload and inventory.
+2. `set_report_details` — project, consultant, professional, site, objective,
+   methodology and administrative information.
+3. `set_report_configuration` — project-specific criteria, major routes,
+   special flow limits, facility classifications, drawing inventory,
+   applicable reports and checklist overrides.
+4. `run_simulation` — legacy-default normalization where required, isolated
+   execution, execution-integrity gate, database creation and RPT reconciliation.
+5. `get_table_catalog` / `query_results` — complete tokenized input and result
+   review rather than top-N-only evidence.
+6. `preliminary_design_review`, `get_reconciliation`, `calgary_screening` —
+   deterministic QA/QC and preliminary City screening.
+7. `get_timeseries` and controlled `run_scenario` calls where authorized.
+8. `generate_report` — editable SWMR DOCX plus immutable audit ZIP, model
+   listings, model schematic, depth-velocity figure and readiness registers.
+
+## Execution and readiness gates
+
+- An invalid hydraulic run produces an Input/Configuration Review and no
+  hydraulic screening conclusions.
+- Missing drawings, approved criteria, boundary conditions, current-source
+  verification, or professional fields remain explicit readiness gaps.
+- Generated figures do not replace drawing-to-model reconciliation.
+- The output is never represented as approved, authenticated, or submission
+  ready solely because the automated workflow completed.
+
+## Project-neutral design
+
+- Object selection is derived from each uploaded INP or explicit project
+  configuration.
+- Unit labels and effective solver defaults follow the model unit system.
+- Coordinates and vertices drive schematic geometry; incomplete coordinate
+  sets receive a deterministic topology fallback.
+- Criteria and facility classifications are session-scoped and archived with
+  the report package.
+- Kincora-specific numerical pins remain only in regression tests.

DETERMINISTIC_EXECUTION_GATE.md

@@ -5,9 +5,11 @@ successful SWMR results.
 
 ## Changes
 
-1. Dynamic-wave preflight rejects explicit `MAX_TRIALS <= 0` and
-   `HEAD_TOLERANCE <= 0`. Omitted values remain untouched so the engine default
-   applies. The uploaded INP is never edited.
+1. Dynamic-wave preflight recognizes explicit zero values for `MAX_TRIALS`,
+   `HEAD_TOLERANCE`, and `MIN_SURFAREA` as legacy/default sentinels. It creates
+   an immutable derivative execution copy using unit-aware effective defaults,
+   while preserving and hashing the original upload. Negative and non-numeric
+   values remain blocking errors. Omitted values remain untouched.
 2. Post-run integrity classification records `valid`, `limited`, or `invalid`
    using routing convergence and flow-routing continuity evidence.
 3. A run is invalid when every routing step fails, at least 5% of routing
@@ -22,21 +24,22 @@ successful SWMR results.
 
 ## Kincora failure reproduced
 
-The failed input explicitly contained:
+The legacy input explicitly contained:
 
 ```ini
 MAX_TRIALS       0
 HEAD_TOLERANCE   0
 ```
 
-It produced 7,201/7,201 non-convergent steps and 100% routing continuity
-error. Removing those explicit zero overrides in a separate diagnostic copy
-restored 0 non-convergent steps and 0.022% routing continuity error. This
-revision rejects the failed configuration rather than silently changing it.
+The EPA SWMM 5.2 desktop interface resolves these values to effective defaults.
+For SI models the derivative uses `MAX_TRIALS=8`, `HEAD_TOLERANCE=0.0015 m`,
+and `MIN_SURFAREA=1.167 m2`. Every substitution, both hashes, and both INP files
+are retained in the audit package. This is a disclosed compatibility action,
+not a mutation of the uploaded engineering model.
 
 ## Validation
 
 - Python compilation passed for all packaged modules.
-- 30 deterministic unit checks passed.
+- 35 deterministic unit checks passed.
 - Preflight integration requires the Space dependencies and isolated
   OpenSWMM worker environment described in the existing README.

REV28_CHANGELOG.md

@@ -0,0 +1,31 @@
+# Rev 28 change log
+
+## Fixed
+
+- Corrected the deterministic preflight gate for legacy EPA SWMM dynamic-wave
+  options explicitly stored as zero.
+- `MAX_TRIALS=0`, `HEAD_TOLERANCE=0`, and `MIN_SURFAREA=0` now resolve on an
+  immutable derivative execution copy using unit-aware defaults.
+- Preserved the original uploaded model and added original/execution filenames,
+  SHA-256 hashes, and substitution records to run metadata and report identity.
+- Included both original and derivative INP files in the SWMR audit ZIP.
+- Retained blocking behavior for negative and non-numeric solver values.
+- Added a deterministic Alberta/Calgary depth-velocity criteria figure directly
+  below SWMR Table 9, including model depth/velocity points, peak-flow colour,
+  the tabulated criterion, and audited PNG/CSV source artifacts.
+- Added deterministic SWMM model-schematic automation using INP coordinates,
+  vertices, subcatchment routing and hydraulic topology, with a stable fallback
+  layout plus archived PNG and generation manifest.
+- Exposed the report engine's project-specific City of Calgary configuration
+  through `set_report_configuration`, removing the workflow gap that prevented
+  non-sample projects from supplying major routes, criteria, classifications,
+  drawing inventories, applicable reports and checklist overrides.
+
+## Validation
+
+- Python compilation passed.
+- All 35 deterministic unit checks passed.
+- Exact Kincora legacy-zero normalization was verified without modifying the
+  uploaded INP.
+- Full worker integration must be rerun in the Hugging Face Space image, which
+  supplies the isolated OpenSWMM worker dependencies.

agent.py

@@ -66,6 +66,7 @@ AGENT_TOOLS_DEFAULT = [
     "get_link_results", "get_subcatchment_results", "get_timeseries",
     "query_results", "get_table_catalog", "calgary_screening",
     "preliminary_design_review", "get_reconciliation", "run_scenario",
+    "set_report_details", "set_report_configuration",
 ]
 
 _JSON_TYPES = {str: "string", int: "integer", float: "number", bool: "boolean",

report_engine.py

@@ -32,6 +32,246 @@ from calgary_rules import (
 )
 
 
+def _depth_velocity_figure(
+    compliance: pd.DataFrame,
+    curve: tuple[tuple[float, float], ...],
+    *,
+    results_usable: bool,
+    flow_unit: str,
+) -> bytes:
+    """Render the auditable Alberta/Calgary depth-velocity screening figure."""
+    from matplotlib.backends.backend_agg import FigureCanvasAgg
+    from matplotlib.figure import Figure
+
+    points = sorted((float(v), float(d)) for v, d in curve)
+    fig = Figure(figsize=(7.2, 5.3), dpi=180, facecolor="white")
+    FigureCanvasAgg(fig)
+    ax = fig.add_subplot(111)
+
+    # Extend the first permissible depth horizontally to zero velocity.  Do
+    # not extrapolate beyond the final criterion point (3.0 m/s).
+    boundary_x = [0.0] + [p[0] for p in points]
+    boundary_y = [points[0][1]] + [p[1] for p in points]
+    ax.axhspan(0.0, max(0.9, max(d for _, d in points) * 1.08),
+               color="#f4cccc", alpha=0.42)
+    ax.fill_between(boundary_x, 0.0, boundary_y, color="#d9ead3", alpha=0.72,
+                    label="Acceptable screening region")
+    ax.plot(boundary_x, boundary_y, color="#0057b8", linewidth=2.0,
+            marker="s", markersize=4.5, markerfacecolor="white",
+            label="Alberta/Calgary criterion")
+
+    plotted = 0
+    if results_usable and compliance is not None and not compliance.empty:
+        dcol = next((c for c in compliance if c.startswith("Peak Depth (")), None)
+        vcol = next((c for c in compliance if c.startswith("Peak Velocity (")), None)
+        qcol = next((c for c in compliance if c.startswith("Peak Flow (")), None)
+        if dcol and vcol:
+            data = compliance.copy()
+            data["_d"] = pd.to_numeric(data[dcol], errors="coerce")
+            data["_v"] = pd.to_numeric(data[vcol], errors="coerce")
+            data["_q"] = pd.to_numeric(data[qcol], errors="coerce") if qcol else float("nan")
+            data = data.dropna(subset=["_d", "_v"])
+            plotted = len(data)
+            if plotted:
+                if qcol and data["_q"].notna().any():
+                    scatter = ax.scatter(data["_v"], data["_d"], c=data["_q"],
+                                         cmap="viridis", marker="x", s=48,
+                                         linewidths=1.4, zorder=4,
+                                         label="Model results")
+                    cbar = fig.colorbar(scatter, ax=ax, pad=0.02)
+                    cbar.set_label(f"Peak flow ({flow_unit})", fontsize=8)
+                else:
+                    ax.scatter(data["_v"], data["_d"], color="black", marker="x",
+                               s=48, linewidths=1.4, zorder=4, label="Model results")
+                for _, row in data.iterrows():
+                    label = str(row.get("Segment", "")).strip()
+                    if label:
+                        ax.annotate(label, (row["_v"], row["_d"]), xytext=(3, 3),
+                                    textcoords="offset points", fontsize=6.5)
+
+    ax.text(0.18, 0.10, "ACCEPTABLE", transform=ax.transAxes, color="#548235",
+            fontsize=11, weight="bold", alpha=0.9)
+    ax.text(0.68, 0.52, "NOT ACCEPTABLE", transform=ax.transAxes, color="#a61c00",
+            fontsize=10, weight="bold", alpha=0.82)
+    if not results_usable:
+        ax.text(0.5, 0.02, "Model points withheld: execution-integrity gate failed",
+                transform=ax.transAxes, ha="center", va="bottom", fontsize=8,
+                color="#a61c00", bbox={"facecolor": "white", "edgecolor": "#a61c00", "pad": 3})
+    elif plotted == 0:
+        ax.text(0.5, 0.02, "No modeled overland-route depth/velocity pairs identified",
+                transform=ax.transAxes, ha="center", va="bottom", fontsize=8,
+                bbox={"facecolor": "white", "edgecolor": "#666666", "pad": 3})
+
+    ax.set_xlim(0.0, 4.0)
+    ax.set_ylim(0.0, max(0.9, max(d for _, d in points) * 1.08))
+    ax.set_xlabel("Velocity (m/s)")
+    ax.set_ylabel("Depth (m)")
+    ax.set_title("Depth–Velocity Criteria for Overland Flow")
+    ax.grid(True, color="#777777", linewidth=0.45, alpha=0.65)
+    ax.legend(loc="upper right", fontsize=7.5, frameon=True)
+    fig.tight_layout()
+    out = io.BytesIO()
+    fig.savefig(out, format="png", dpi=180, metadata={"Software": "SWMM Analysis MCP Server"})
+    return out.getvalue()
+
+
+def _model_schematic_figure(inp_sections: Mapping[str, list[list[str]]]) -> tuple[bytes, dict[str, Any]]:
+    """Render a deterministic SWMM topology schematic from tokenized INP data."""
+    from collections import defaultdict
+    from matplotlib.backends.backend_agg import FigureCanvasAgg
+    from matplotlib.figure import Figure
+    from matplotlib.lines import Line2D
+
+    node_sections = {"JUNCTIONS": "Junction", "DIVIDERS": "Junction",
+                     "STORAGE": "Storage", "OUTFALLS": "Outfall"}
+    nodes: dict[str, str] = {}
+    for section, kind in node_sections.items():
+        for row in inp_sections.get(section, []) or []:
+            if row:
+                nodes[str(row[0])] = kind
+    link_sections = ("CONDUITS", "PUMPS", "ORIFICES", "WEIRS", "OUTLETS")
+    links: list[tuple[str, str, str, str]] = []
+    for section in link_sections:
+        for row in inp_sections.get(section, []) or []:
+            if len(row) >= 3:
+                links.append((str(row[0]), str(row[1]), str(row[2]), section[:-1].title()))
+
+    coords: dict[str, tuple[float, float]] = {}
+    for row in inp_sections.get("COORDINATES", []) or []:
+        if len(row) >= 3:
+            try:
+                coords[str(row[0])] = (float(row[1]), float(row[2]))
+            except (TypeError, ValueError):
+                pass
+
+    # Coordinate-free models receive a stable downstream-rank layout.
+    if not all(n in coords for n in nodes):
+        outgoing: dict[str, list[str]] = defaultdict(list)
+        incoming: dict[str, int] = defaultdict(int)
+        for _, source, target, _ in links:
+            outgoing[source].append(target)
+            incoming[target] += 1
+        rank = {n: 0 for n in nodes}
+        queue = sorted(n for n in nodes if incoming[n] == 0)
+        for source in queue:
+            for target in sorted(outgoing[source]):
+                rank[target] = max(rank.get(target, 0), rank[source] + 1)
+                incoming[target] -= 1
+                if incoming[target] == 0:
+                    queue.append(target)
+        groups: dict[int, list[str]] = defaultdict(list)
+        for n in sorted(nodes):
+            groups[rank.get(n, 0)].append(n)
+        for r, names in groups.items():
+            for i, name in enumerate(names):
+                coords.setdefault(name, (float(r), float(-i)))
+        coordinate_basis = "INP coordinates with deterministic topology fallback"
+    else:
+        coordinate_basis = "INP [COORDINATES]"
+
+    vertices: dict[str, list[tuple[float, float]]] = defaultdict(list)
+    for row in inp_sections.get("VERTICES", []) or []:
+        if len(row) >= 3:
+            try:
+                vertices[str(row[0])].append((float(row[1]), float(row[2])))
+            except (TypeError, ValueError):
+                pass
+
+    polygon_points: dict[str, list[tuple[float, float]]] = defaultdict(list)
+    for row in inp_sections.get("POLYGONS", inp_sections.get("Polygons", [])) or []:
+        if len(row) >= 3:
+            try:
+                polygon_points[str(row[0])].append((float(row[1]), float(row[2])))
+            except (TypeError, ValueError):
+                pass
+    subcatchments = []
+    for row in inp_sections.get("SUBCATCHMENTS", []) or []:
+        if len(row) >= 3:
+            sid, outlet = str(row[0]), str(row[2])
+            pts = polygon_points.get(sid, [])
+            if pts:
+                pos = (sum(x for x, _ in pts) / len(pts), sum(y for _, y in pts) / len(pts))
+            elif sid in coords:
+                pos = coords[sid]
+            else:
+                ox, oy = coords.get(outlet, (0.0, 0.0))
+                pos = (ox, oy + 1.0)
+            subcatchments.append((sid, outlet, pos))
+
+    fig = Figure(figsize=(10.5, 7.0), dpi=180, facecolor="white")
+    FigureCanvasAgg(fig)
+    ax = fig.add_subplot(111)
+    link_colors = {"Conduit": "#4472c4", "Outlet": "#7030a0", "Pump": "#ed7d31",
+                   "Orifice": "#a5a5a5", "Weir": "#ffc000"}
+    for lid, source, target, kind in links:
+        if source not in coords or target not in coords:
+            continue
+        path = [coords[source], *vertices.get(lid, []), coords[target]]
+        color = link_colors.get(kind, "#4472c4")
+        for a, b in zip(path[:-1], path[1:]):
+            ax.plot([a[0], b[0]], [a[1], b[1]], color=color, linewidth=1.0, zorder=1)
+        a, b = path[-2], path[-1]
+        ax.annotate("", xy=b, xytext=a,
+                    arrowprops={"arrowstyle": "-|>", "color": color, "lw": 1.0,
+                                "shrinkA": 4, "shrinkB": 6}, zorder=2)
+        mid = path[len(path) // 2]
+        ax.annotate(lid, mid, xytext=(2, 2), textcoords="offset points",
+                    fontsize=5.5, color="#333333")
+
+    node_style = {
+        "Junction": ("o", "#ffffff", "#1f4e79"),
+        "Storage": ("s", "#fff2cc", "#bf9000"),
+        "Outfall": ("v", "#f4cccc", "#990000"),
+    }
+    for name, kind in nodes.items():
+        if name not in coords:
+            continue
+        x, y = coords[name]
+        marker, face, edge = node_style[kind]
+        ax.scatter([x], [y], marker=marker, s=48, facecolor=face, edgecolor=edge,
+                   linewidth=1.1, zorder=4)
+        ax.annotate(name, (x, y), xytext=(4, 4), textcoords="offset points",
+                    fontsize=6.5, zorder=5)
+
+    for sid, outlet, (x, y) in subcatchments:
+        ax.scatter([x], [y], marker="D", s=42, facecolor="#e2f0d9",
+                   edgecolor="#548235", linewidth=1.0, zorder=3)
+        ax.annotate(f"SC {sid}", (x, y), xytext=(4, -8), textcoords="offset points",
+                    fontsize=6.2, zorder=5)
+        if outlet in coords:
+            ax.annotate("", xy=coords[outlet], xytext=(x, y),
+                        arrowprops={"arrowstyle": "->", "color": "#70ad47", "lw": 0.75,
+                                    "linestyle": "--", "shrinkA": 4, "shrinkB": 6}, zorder=1)
+
+    handles = [
+        Line2D([0], [0], marker="D", color="none", markerfacecolor="#e2f0d9",
+               markeredgecolor="#548235", label="Subcatchment"),
+        *[Line2D([0], [0], marker=node_style[k][0], color="none",
+                 markerfacecolor=node_style[k][1], markeredgecolor=node_style[k][2], label=k)
+          for k in ("Junction", "Storage", "Outfall")],
+        Line2D([0], [0], color="#4472c4", label="Hydraulic link / flow direction"),
+        Line2D([0], [0], color="#70ad47", linestyle="--", label="Runoff routing"),
+    ]
+    ax.legend(handles=handles, loc="best", fontsize=7, frameon=True)
+    ax.set_title("Automated SWMM Model Schematic", fontsize=13, weight="bold")
+    ax.set_aspect("equal", adjustable="datalim")
+    ax.axis("off")
+    ax.margins(0.10)
+    fig.tight_layout()
+    out = io.BytesIO()
+    fig.savefig(out, format="png", dpi=180, bbox_inches="tight",
+                metadata={"Software": "SWMM Analysis MCP Server"})
+    manifest = {
+        "coordinate_basis": coordinate_basis,
+        "node_count": len(nodes), "link_count": len(links),
+        "subcatchment_count": len(subcatchments),
+        "node_types": {kind: sum(1 for v in nodes.values() if v == kind)
+                       for kind in sorted(set(nodes.values()))},
+        "limitations": "Topology schematic only; confirm geometry, crossings, scale, and drawing reconciliation before issue.",
+    }
+    return out.getvalue(), manifest
+
+
 @dataclass
 class ReportCriteria:
     node_depth_ratio: float = 0.80
@@ -779,15 +1019,17 @@ def _build_swmr_checklist(metadata: ReportMetadata, criteria: ReportCriteria, *,
         add("SWMR-08","Minor-system routed flows, cumulative design flows, pipe capacities and spare capacity", "Not applicable", "No conduits identified in uploaded model", "Confirm whether a separate minor-system model is within the report scope", "Minor System")
         add("SWMR-09","HGL, surcharge, rim clearance, downstream HWL and backwater assessment", "Requires professional confirmation", "Storage/outfall HGL table; no conduit network identified", "Confirm whether a separate minor-system model and downstream HWL assessment are required", "Minor System")
     add("SWMR-10","Catchbasin, inlet, ICD and outlet rating information", "Complete" if has_controls else "Not applicable / missing", "Hydraulic controls table" if has_controls else "—", "Confirm inlet types, rating curves and drawing locations", "Minor System")
-    add("SWMR-11","Critical overland flows, depths, velocities, spill routes and escape routes", "Partially complete" if has_overland else "Requires drawing review", "Major-system depth-velocity table" if has_overland else "No overland route identified in model", "Confirm overland route, grading, containment, escape routes and safety on drawings", "Major System")
+    add("SWMR-11","Critical overland flows, depths, velocities, spill routes and escape routes", "Partially complete" if has_overland else "Requires drawing review", "Table 9 and deterministic Figure 9-1 depth-velocity screen" if has_overland else "Figure 9-1 criterion included; no overland route identified in model", "Confirm overland route, grading, containment, escape routes and safety on drawings", "Major System")
     add("SWMR-12","Trap-low and storage volume, depth, spill, entrance grade and restrictive covenant information", "Partially complete" if has_storage else "Not applicable", "Storage assessment" if has_storage else "—", "Add spill elevations, building grades and covenant requirements", "Storage")
     add("SWMR-13","Minor and major boundary inflows/outflows and supporting source", "Partially complete" if has_outfalls else "Missing", "Boundary outflow tables" if has_outfalls else "—", "Confirm downstream capacity and external inflows", "Boundary Conditions")
     add("SWMR-14","Private-site permissible discharge and on-site storage requirements", "Missing", "—", "Provide applicable release rates and private-site storage criteria", "Private Sites")
     add("SWMR-15","Water-quality treatment, BMPs, downstream treatment and source controls", "Missing", "—", "Document water-quality strategy and downstream treatment", "Water Quality")
     required_drawings={"site location","study area","catchment plan","model schematic","overland drainage","storm drainage"}
     found=len(required_drawings & drawings)
-    add("SWMR-16","Required figures and drawings", "Complete" if found==len(required_drawings) else ("Partially complete" if found else "Missing"), f"{found}/{len(required_drawings)} core drawings recorded", "Add missing site, catchment, schematic, overland and storm-drainage drawings", "Drawings")
-    add("SWMR-17","Model input/output files, formatted listings, model schematic, drawing reconciliation and auditable digital package", "Partially complete" if has_model and has_results else "Missing", "Digital model package and structured appendices", "Add fixed-width input/output listings, model schematic, drawing-to-model cross-reference, revision metadata and final authenticated files", "Appendices")
+    if has_model and "model schematic" not in drawings:
+        found += 1  # deterministic Figure 3-1 generated from the uploaded INP
+    add("SWMR-16","Required figures and drawings", "Complete" if found==len(required_drawings) else ("Partially complete" if found else "Missing"), f"{found}/{len(required_drawings)} core figures/drawings recorded or generated", "Add missing site, catchment, overland and storm-drainage drawings; reconcile Figure 3-1 to issued drawings", "Drawings")
+    add("SWMR-17","Model input/output files, formatted listings, model schematic, drawing reconciliation and auditable digital package", "Partially complete" if has_model and has_results else "Missing", "Digital model package, Figure 3-1 and structured appendices" if has_model else "—", "Complete drawing-to-model cross-reference, revision metadata and final authenticated files", "Appendices")
     return pd.DataFrame(rows)
 
 def _readiness_scores(checklist: pd.DataFrame) -> pd.DataFrame:
@@ -1202,6 +1444,7 @@ def generate_report_package(
         checklist_table.loc[_m17, "Status"] = "Included (Appendix D listings + digital package)"
         checklist_table.loc[_m17, "Outstanding Action"] = "Verify appendix listings match the issued digital model package"
     readiness_table = _readiness_scores(checklist_table)
+    schematic_png, schematic_manifest = _model_schematic_figure(inp_sections)
 
     doc = Document()
     sec = doc.sections[0]
@@ -1258,14 +1501,21 @@ def generate_report_package(
     doc.add_paragraph("Draft status: suitable for consultant/client discussion and structured engineering review. Human-in-the-loop completion, technical verification, drawing coordination, and professional authentication are required before municipal submission.")
     if model_identity:
         doc.add_heading("1.0a Model Identity and Execution Provenance", level=2)
-        _id_tbl = pd.DataFrame([
+        identity_rows = [
             {"Item": "Model file", "Value": str(model_identity.get("inp_name", "—"))},
             {"Item": "Model SHA-256", "Value": str(model_identity.get("sha256", "—"))},
             {"Item": "Session / run ID", "Value": f"{model_identity.get('session_id', '—')} / {model_identity.get('run_id', '—')}"},
             {"Item": "Engine", "Value": str(model_identity.get("engine", "EPA SWMM / OpenSWMM (crash-isolated worker)"))},
             {"Item": "Execution status", "Value": str(model_identity.get("status", "Completed"))},
             {"Item": "Generated", "Value": str(model_identity.get("generated", metadata.report_date))},
-        ])
+        ]
+        if model_identity.get("legacy_defaults_normalized"):
+            identity_rows.extend([
+                {"Item": "Execution derivative", "Value": str(model_identity.get("execution_inp_name", "—"))},
+                {"Item": "Execution SHA-256", "Value": str(model_identity.get("execution_sha256", "—"))},
+                {"Item": "Legacy option handling", "Value": "Zero/default sentinels normalized in an immutable derivative; original upload preserved"},
+            ])
+        _id_tbl = pd.DataFrame(identity_rows)
         _add_df_table(doc, "Table 0A - Model Identity", _id_tbl, font_size=8.0)
         _rev_tbl = pd.DataFrame([{"Rev": "P0", "Date": metadata.report_date,
                                   "Description": "Preliminary server-generated draft for engineering review",
@@ -1326,6 +1576,17 @@ def generate_report_package(
     )
     if options.get("FLOW_ROUTING", "").upper() == "KINWAVE":
         doc.add_paragraph("Modelling limitation: kinematic-wave routing does not fully represent backwater, pressurization, reverse flow, or complex surcharge interactions. Dynamic-wave routing should be considered where these effects are material.")
+    doc.add_picture(io.BytesIO(schematic_png), width=Inches(7.15))
+    doc.paragraphs[-1].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    schematic_caption = doc.add_paragraph(
+        "Figure 3-1 - Automated SWMM Model Schematic. Solid arrows show hydraulic-link "
+        "direction and dashed arrows show subcatchment runoff routing. This topology figure "
+        "is generated from the uploaded INP and must be reconciled to the issued drainage drawings."
+    )
+    schematic_caption.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in schematic_caption.runs:
+        run.italic = True
+        run.font.size = Pt(8)
     doc.add_heading("3.3 Major-Minor System", level=2)
     doc.add_paragraph("Open channels, swales, gutters, culverts, and closed conduits represented in the model were reviewed. Final major/minor classification must be confirmed against the approved drainage concept and drawings.")
     if scenario_comparison is not None and not scenario_comparison.empty:
@@ -1393,6 +1654,25 @@ def generate_report_package(
                 overland_compliance[col] = "Not assessed - hydraulic routing solution invalid"
         if "Spill Active" in overland_compliance:
             overland_compliance["Spill Active"] = "Not assessed"
+    depth_velocity_png = _depth_velocity_figure(
+        overland_compliance, calgary.depth_velocity_curve,
+        results_usable=integrity["results_usable"], flow_unit=units.flow)
+    doc.add_picture(io.BytesIO(depth_velocity_png), width=Inches(6.65))
+    doc.paragraphs[-1].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    caption = doc.add_paragraph(
+        "Figure 9-1 - Alberta/Calgary Depth–Velocity Criteria for Overland Flow. "
+        "Model points are derived from Table 9; marker colour represents peak flow. "
+        "Straight-line interpolation is used between the tabulated points. The 2011 baseline "
+        "envelope must be checked against current and project-specific requirements."
+    )
+    caption.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for run in caption.runs:
+        run.italic = True
+        run.font.size = Pt(8)
+    curve_table = pd.DataFrame(calgary.depth_velocity_curve,
+                               columns=["Water Velocity (m/s)", "Permissible Depth (m)"])
+    _add_df_table(doc, "Figure 9-1A - Permissible Depth and Velocity of Overland Flow",
+                  curve_table, landscape=False, font_size=8.0)
     if not overland_compliance.empty:
         _add_df_table(doc, "Table 9A - Calgary Major-System Depth-Velocity Screening", overland_compliance, landscape=True, font_size=7.2)
 
@@ -1613,6 +1893,10 @@ def generate_report_package(
         zf.writestr("tables/calgary_criteria_register.csv", criteria_table.to_csv(index=False))
         zf.writestr("tables/calgary_minor_system_capacity.csv", minor_capacity.to_csv(index=False))
         zf.writestr("tables/calgary_major_system_compliance.csv", overland_compliance.to_csv(index=False))
+        zf.writestr("tables/depth_velocity_criterion.csv", curve_table.to_csv(index=False))
+        zf.writestr("figures/figure_9_1_depth_velocity_criteria.png", depth_velocity_png)
+        zf.writestr("figures/figure_3_1_model_schematic.png", schematic_png)
+        zf.writestr("metadata/model_schematic_manifest.json", json.dumps(schematic_manifest, indent=2))
         zf.writestr("tables/calgary_storage_assessment.csv", storage_calgary.to_csv(index=False))
         zf.writestr("tables/calgary_swmr_completeness_register.csv", checklist_table.to_csv(index=False))
         zf.writestr("tables/swmr_draft_readiness.csv", readiness_table.to_csv(index=False))
@@ -1637,6 +1921,9 @@ def generate_report_package(
             if model_listings.get("inp_text"):
                 zf.writestr(f"model/{_safe_name(model_listings.get('inp_name', 'model.inp'))}",
                             model_listings["inp_text"])
+            if model_listings.get("execution_inp_text"):
+                zf.writestr(f"model/{_safe_name(model_listings.get('execution_inp_name', 'execution_model.inp'))}",
+                            model_listings["execution_inp_text"])
             if model_listings.get("rpt_text"):
                 zf.writestr(f"model/{_safe_name(model_listings.get('rpt_name', 'model.rpt'))}",
                             model_listings["rpt_text"])

requirements.txt

@@ -6,5 +6,6 @@ httpx>=0.27
 requests>=2.31
 pandas>=2.0
 numpy>=1.26
+matplotlib>=3.8
 python-docx>=1.1
 PyYAML>=6.0

screening_logic.py

@@ -26,19 +26,29 @@ import pandas as pd
 # Solver-option and execution-integrity gates
 # ---------------------------------------------------------------------------
 
-def validate_solver_options(options: Mapping[str, Any]) -> list[str]:
-    """Return deterministic blocking errors for unusable solver settings.
+def resolve_legacy_solver_options(options: Mapping[str, Any]) -> dict[str, Any]:
+    """Resolve auditable SWMM legacy-zero sentinels for an execution copy.
 
-    The uploaded engineering model remains immutable.  This function never
-    substitutes defaults or edits the INP; it only prevents a known-invalid
-    configuration from being presented as a completed hydraulic analysis.
+    Older/converted INP files can explicitly serialize zero for dynamic-wave
+    options that EPA SWMM displays and executes using unit-aware defaults.
+    This function returns substitutions for an immutable derivative; it never
+    edits the uploaded source model. Negative and non-numeric values remain
+    blocking errors. Omitted values remain omitted for the engine to default.
     """
     opts = {str(k).upper(): str(v).strip() for k, v in options.items()}
     if opts.get("FLOW_ROUTING", "").upper() != "DYNWAVE":
-        return []
+        return {"effective_options": dict(opts), "substitutions": [], "errors": []}
+    flow_units = opts.get("FLOW_UNITS", "").upper()
+    si_units = flow_units in {"CMS", "LPS", "MLD"}
+    defaults = {
+        "MAX_TRIALS": (8.0, "count"),
+        "HEAD_TOLERANCE": (0.0015 if si_units else 0.005, "m" if si_units else "ft"),
+        "MIN_SURFAREA": (1.167 if si_units else 12.566, "m2" if si_units else "ft2"),
+    }
+    effective = dict(opts)
+    substitutions: list[dict[str, Any]] = []
     errors: list[str] = []
-    for name, label in (("MAX_TRIALS", "hydraulic trials"),
-                        ("HEAD_TOLERANCE", "head tolerance")):
+    for name, (default, units) in defaults.items():
         if name not in opts:
             continue  # omitted means use the engine default
         try:
@@ -46,12 +56,25 @@ def validate_solver_options(options: Mapping[str, Any]) -> list[str]:
         except (TypeError, ValueError):
             errors.append(f"{name} must be numeric for dynamic-wave routing.")
             continue
-        if value <= 0:
+        if value < 0:
             errors.append(
-                f"{name} must be greater than zero for dynamic-wave routing; "
-                f"the uploaded value {opts[name]!r} disables a usable {label}."
+                f"{name} cannot be negative for dynamic-wave routing; "
+                f"the uploaded value is {opts[name]!r}."
             )
-    return errors
+        elif value == 0:
+            effective[name] = format(default, "g")
+            substitutions.append({
+                "option": name, "original_value": opts[name],
+                "effective_value": default, "units": units,
+                "reason": "Recognized legacy zero/default sentinel",
+            })
+    return {"effective_options": effective,
+            "substitutions": substitutions, "errors": errors}
+
+
+def validate_solver_options(options: Mapping[str, Any]) -> list[str]:
+    """Return only blocking errors after legacy-default resolution."""
+    return list(resolve_legacy_solver_options(options)["errors"])
 
 
 def execution_integrity_assessment(metadata: Mapping[str, Any]) -> dict[str, Any]:

server.py

@@ -43,7 +43,7 @@ from sessions import SESSION_ROOT, STORE
 from tools import TOOL_REGISTRY
 
 SERVER_NAME = "swmm-analysis"
-SERVER_VERSION = "1.0.0 (engine Rev 23.2)"
+SERVER_VERSION = "1.0.4 (engine Rev 23.2; generic CoC workflow Rev 28)"
 
 # ---------------------------------------------------------------------------
 # MCP surface

test_regression.py

@@ -44,12 +44,24 @@ def unit_tests() -> None:
                                  execution_integrity_assessment,
                                  effective_velocity_table,
                                  missing_information_register,
+                                 resolve_legacy_solver_options,
                                  validate_solver_options)
 
     solver_errors = validate_solver_options({
         "FLOW_ROUTING": "DYNWAVE", "MAX_TRIALS": "0", "HEAD_TOLERANCE": "0"})
-    check("zero MAX_TRIALS rejected", any("MAX_TRIALS" in x for x in solver_errors))
-    check("zero HEAD_TOLERANCE rejected", any("HEAD_TOLERANCE" in x for x in solver_errors))
+    check("legacy zero sentinels are not blocking", solver_errors == [])
+    resolved = resolve_legacy_solver_options({
+        "FLOW_ROUTING": "DYNWAVE", "FLOW_UNITS": "CMS",
+        "MIN_SURFAREA": "0", "MAX_TRIALS": "0", "HEAD_TOLERANCE": "0"})
+    effective = resolved["effective_options"]
+    check("SI legacy MAX_TRIALS resolves to 8", effective["MAX_TRIALS"] == "8")
+    check("SI legacy HEAD_TOLERANCE resolves to 0.0015", effective["HEAD_TOLERANCE"] == "0.0015")
+    check("SI legacy MIN_SURFAREA resolves to 1.167", effective["MIN_SURFAREA"] == "1.167")
+    check("three substitutions are audited", len(resolved["substitutions"]) == 3)
+    check("negative values remain blocked", any("cannot be negative" in x for x in
+          validate_solver_options({"FLOW_ROUTING": "DYNWAVE", "MAX_TRIALS": "-1"})))
+    check("non-numeric values remain blocked", any("must be numeric" in x for x in
+          validate_solver_options({"FLOW_ROUTING": "DYNWAVE", "HEAD_TOLERANCE": "bad"})))
     check("omitted dynamic-wave overrides use engine defaults",
           validate_solver_options({"FLOW_ROUTING": "DYNWAVE"}) == [])
 
@@ -220,6 +232,12 @@ def docx_tests(docx_path: str) -> None:
     check("preliminary disclaimer present", "professional authentication are required" in joined)
     check("no calibration/validation claims",
           "calibrated" not in joined.lower() and "validated model" not in joined.lower())
+    check("mandatory depth-velocity figure caption present",
+          "Figure 9-1 - Alberta/Calgary Depth–Velocity Criteria" in joined)
+    check("depth-velocity criterion table present",
+          "Figure 9-1A - Permissible Depth and Velocity" in joined)
+    check("automated model schematic caption present",
+          "Figure 3-1 - Automated SWMM Model Schematic" in joined)
 
     # No unsupported storage Pass: scan tables for a bare "Pass" in Calgary Status
     bare_pass = False

tools.py

@@ -33,7 +33,7 @@ from results_db import ResultDatabase
 from sessions import STORE
 from sql_agent import SafeSQLAgent
 from swmm_core import run_swmm
-from screening_logic import execution_integrity_assessment, validate_solver_options
+from screening_logic import execution_integrity_assessment, resolve_legacy_solver_options
 
 MAX_ROWS = 60
 MAX_TS_POINTS = 200
@@ -59,6 +59,34 @@ def _options_map(sections: dict[str, list[list[str]]]) -> dict[str, str]:
     return {str(r[0]).upper(): str(r[1]) for r in sections.get("OPTIONS", []) if len(r) >= 2}
 
 
+def _write_normalized_execution_copy(source: Path, substitutions: list[dict[str, Any]]) -> Path:
+    """Write a derivative INP containing only audited legacy substitutions."""
+    replacements = {str(s["option"]).upper(): format(float(s["effective_value"]), "g")
+                    for s in substitutions}
+    lines = source.read_text(encoding="utf-8", errors="replace").splitlines(keepends=True)
+    in_options = False
+    changed: set[str] = set()
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            in_options = stripped.upper() == "[OPTIONS]"
+            continue
+        if not in_options or not stripped or stripped.startswith(";"):
+            continue
+        parts = stripped.split()
+        key = parts[0].upper() if parts else ""
+        if key in replacements:
+            newline = "\r\n" if line.endswith("\r\n") else "\n"
+            lines[i] = f"{parts[0]:<20} {replacements[key]}{newline}"
+            changed.add(key)
+    missing = sorted(set(replacements) - changed)
+    if missing:
+        raise ValueError("Could not normalize legacy [OPTIONS] values: " + ", ".join(missing))
+    target = source.with_name(f"{source.stem}_legacy_defaults_normalized{source.suffix}")
+    target.write_text("".join(lines), encoding="utf-8", newline="")
+    return target
+
+
 # ---------------------------------------------------------------------------
 # Model lifecycle
 # ---------------------------------------------------------------------------
@@ -108,18 +136,30 @@ def run_simulation(session_id: str) -> dict:
     if not inp_path:
         raise ValueError("Session has no uploaded model.")
     sections = session.data["sections"]
-    option_errors = validate_solver_options(_options_map(sections))
+    resolution = resolve_legacy_solver_options(_options_map(sections))
+    option_errors = resolution["errors"]
     if option_errors:
         session.data["input_validation_errors"] = option_errors
         raise ValueError(
             "Input validation failed; simulation was not run. " + " ".join(option_errors)
         )
-    results = run_swmm(inp_path)
+    original_path = Path(inp_path)
+    substitutions = list(resolution["substitutions"])
+    execution_path = (_write_normalized_execution_copy(original_path, substitutions)
+                      if substitutions else original_path)
+    results = run_swmm(str(execution_path))
     md = results["metadata"]
     import hashlib, datetime
-    sha256 = hashlib.sha256(Path(inp_path).read_bytes()).hexdigest()
+    original_sha256 = hashlib.sha256(original_path.read_bytes()).hexdigest()
+    execution_sha256 = hashlib.sha256(execution_path.read_bytes()).hexdigest()
     run_id = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
-    md["model_sha256"] = sha256
+    md["model_sha256"] = original_sha256
+    md["original_model_sha256"] = original_sha256
+    md["execution_model_sha256"] = execution_sha256
+    md["original_model_filename"] = original_path.name
+    md["execution_model_filename"] = execution_path.name
+    md["legacy_defaults_normalized"] = bool(substitutions)
+    md["solver_option_substitutions"] = substitutions
     md["run_id"] = run_id
     integrity = execution_integrity_assessment(md)
     md.update({
@@ -140,7 +180,7 @@ def run_simulation(session_id: str) -> dict:
         if "Status" in link_df:
             link_df["Status"] = invalid_label
     db = ResultDatabase(str(session.workdir / "results.sqlite"))
-    db.load(node_df, link_df, sub_df, inp_path=inp_path, results=results)
+    db.load(node_df, link_df, sub_df, inp_path=original_path, results=results)
 
     recon = {"verdict": "Not performed"}
     recon_links = recon_nodes = recon_cont = None
@@ -153,6 +193,7 @@ def run_simulation(session_id: str) -> dict:
 
     session.data.update({
         "results": results, "node_df": node_df, "link_df": link_df, "sub_df": sub_df,
+        "execution_inp_path": str(execution_path),
         "db": db, "recon_links": recon_links, "recon_nodes": recon_nodes,
         "recon_continuity": recon_cont, "recon_summary": recon,
     })
@@ -163,7 +204,10 @@ def run_simulation(session_id: str) -> dict:
         "simulation": "completed" if integrity["results_usable"] else "completed_invalid",
         "execution_integrity": integrity,
         "results_usable": integrity["results_usable"],
-        "model_sha256": sha256,
+        "model_sha256": original_sha256,
+        "execution_model_sha256": execution_sha256,
+        "legacy_defaults_normalized": bool(substitutions),
+        "solver_option_substitutions": substitutions,
         "run_id": run_id,
         "flow_units": md.get("flow_units"),
         "runoff_continuity_error_pct": round(float(md.get("runoff_error", 0.0)), 3),
@@ -302,22 +346,39 @@ def calgary_screening(session_id: str) -> dict:
     """
     session = STORE.get(session_id)
     _require_results(session)
+    cfg = dict(session.data.get("report_configuration", {}))
+    crit = CalgaryCriteria(
+        minor_release_rate_lps_ha=cfg.get("minor_release_rate_lps_ha"),
+        trap_low_max_depth_m=cfg.get("trap_low_max_depth_m", 0.50),
+        entrance_grade_margin_m=cfg.get("entrance_grade_margin_m", 0.30),
+        pipe_advisory_velocity_mps=cfg.get("velocity_advisory", 3.0),
+        pipe_critical_velocity_mps=cfg.get("velocity_threshold", 4.0),
+        conduit_capacity_review_ratio=cfg.get("conduit_depth_ratio", 0.80),
+        conduit_capacity_warning_ratio=cfg.get("conduit_capacity_warning_ratio", 0.95),
+        continuity_review_pct=cfg.get("continuity_review", 0.50),
+        continuity_warning_pct=cfg.get("continuity_warning", 1.00),
+        special_link_limits=cfg.get("special_link_limits", {}),
+        storage_classification=cfg.get("storage_classification", {}),
+        outfall_classification=cfg.get("outfall_classification", {}),
+    )
     integrity = execution_integrity_assessment(session.data["results"].get("metadata", {}))
     if not integrity["results_usable"]:
         return {
             "velocity_screen_flagged": _df_records(pd.DataFrame(), 30),
             "storage_classification": _df_records(pd.DataFrame(), 30),
-            "criteria_register": _df_records(criteria_register(CalgaryCriteria()), 40),
+            "criteria_register": _df_records(criteria_register(crit), 40),
             "status": "Not assessed - hydraulic routing solution invalid",
             "execution_integrity": integrity,
         }
-    crit = CalgaryCriteria()
     link_df = session.data["link_df"]
     node_df = session.data["node_df"]
     vel_col = next((c for c in link_df.columns if c.startswith("Peak Velocity")), None)
     lv = link_df[["Link ID", vel_col, "Depth Ratio"]].copy()
     lv["Screen"] = lv[vel_col].apply(
-        lambda v: "CRITICAL > 4.0" if v > 4.0 else ("Advisory > 3.0" if v > 3.0 else "OK"))
+        lambda v: (f"CRITICAL > {crit.pipe_critical_velocity_mps:g}"
+                   if v > crit.pipe_critical_velocity_mps else
+                   (f"Advisory > {crit.pipe_advisory_velocity_mps:g}"
+                    if v > crit.pipe_advisory_velocity_mps else "OK")))
     flagged = lv[lv["Screen"] != "OK"].sort_values(vel_col, ascending=False)
     storage = node_df[node_df["Type"].astype(str).str.lower() == "storage"].copy()
     storage_class = apply_storage_classification(storage, crit, "m") if not storage.empty else pd.DataFrame()
@@ -489,6 +550,87 @@ def set_report_details(session_id: str, details: dict | str) -> dict:
             "next_step": "generate_report will include these details; readiness scoring reflects them."}
 
 
+_REPORT_CONFIG_FIELDS = {
+    "node_depth_ratio", "minimum_freeboard", "conduit_depth_ratio",
+    "velocity_threshold", "velocity_advisory", "continuity_review",
+    "continuity_warning", "suppress_empty_sections", "major_link_ids",
+    "area_classification", "calgary_enabled", "minor_release_rate_lps_ha",
+    "trap_low_max_depth_m", "entrance_grade_margin_m",
+    "conduit_capacity_warning_ratio", "special_link_limits",
+    "storage_classification", "outfall_classification", "checklist_overrides",
+    "drawing_inventory", "applicable_reports",
+}
+_REPORT_CONFIG_LISTS = {"major_link_ids", "drawing_inventory", "applicable_reports"}
+_REPORT_CONFIG_MAPS = {
+    "area_classification", "special_link_limits", "storage_classification",
+    "outfall_classification", "checklist_overrides",
+}
+_REPORT_CONFIG_BOOLS = {"suppress_empty_sections", "calgary_enabled"}
+
+
+def set_report_configuration(session_id: str, configuration: dict | str) -> dict:
+    """Set project-specific City of Calgary SWMR criteria and evidence inputs.
+
+    Use this after upload and before generate_report. Supported configuration
+    includes major_link_ids, project-specific flow limits, storage/outfall/area
+    classifications, numerical screening thresholds, drawing_inventory,
+    applicable_reports, and checklist_overrides. Repeated calls merge; JSON
+    null removes a field. This configures deterministic screening and report
+    completeness—it does not establish municipal acceptance or professional
+    authentication.
+    """
+    session = STORE.get(session_id)
+    if isinstance(configuration, str):
+        configuration = json.loads(configuration)
+    if not isinstance(configuration, dict):
+        raise ValueError("configuration must be a JSON object.")
+    unknown = sorted(set(configuration) - _REPORT_CONFIG_FIELDS)
+    if unknown:
+        raise ValueError(f"Unknown report configuration field(s): {unknown}. "
+                         f"Supported: {sorted(_REPORT_CONFIG_FIELDS)}")
+    normalized: dict[str, Any] = {}
+    for key, value in configuration.items():
+        if value is None:
+            normalized[key] = None
+        elif key in _REPORT_CONFIG_LISTS:
+            if not isinstance(value, (list, tuple)):
+                raise ValueError(f"{key} must be a JSON array.")
+            normalized[key] = tuple(str(x).strip() for x in value if str(x).strip())
+        elif key in _REPORT_CONFIG_MAPS:
+            if not isinstance(value, dict):
+                raise ValueError(f"{key} must be a JSON object.")
+            if key == "special_link_limits":
+                try:
+                    normalized[key] = {str(k): float(v) for k, v in value.items()}
+                except (TypeError, ValueError):
+                    raise ValueError("special_link_limits values must be numeric.")
+            else:
+                normalized[key] = {str(k): str(v) for k, v in value.items()}
+        elif key in _REPORT_CONFIG_BOOLS:
+            if not isinstance(value, bool):
+                raise ValueError(f"{key} must be true or false.")
+            normalized[key] = value
+        else:
+            if isinstance(value, bool):
+                raise ValueError(f"{key} must be numeric or null.")
+            try:
+                normalized[key] = float(value)
+            except (TypeError, ValueError):
+                raise ValueError(f"{key} must be numeric or null.")
+    stored = session.data.setdefault("report_configuration", {})
+    for key, value in normalized.items():
+        if value is None:
+            stored.pop(key, None)
+        else:
+            stored[key] = value
+    return {
+        "session_id": session.id,
+        "report_configuration": stored,
+        "next_step": "Run Calgary screening/review as needed, then call generate_report.",
+        "disclaimer": "Project criteria and classifications require responsible-engineer verification.",
+    }
+
+
 def generate_report(session_id: str, project_name: str, client: str = "",
                     consultant: str = "", prepared_by: str = "",
                     outline_plan_no: str = "",
@@ -502,7 +644,7 @@ def generate_report(session_id: str, project_name: str, client: str = "",
     Returns download paths served by this Space at /files/{session_id}/{name}.
     The draft-readiness score honestly reflects missing project information.
     """
-    from report_engine import ReportMetadata, generate_report_package
+    from report_engine import ReportCriteria, ReportMetadata, generate_report_package
     session = STORE.get(session_id)
     _require_results(session)
     stored = dict(session.data.get("report_details", {}))
@@ -514,11 +656,18 @@ def generate_report(session_id: str, project_name: str, client: str = "",
             meta_kwargs[key] = value
     narrative = {k: v for k, v in stored.items() if k in _NARRATIVE_FIELDS}
     meta = ReportMetadata(project_name=project_name, **meta_kwargs)
+    report_criteria = ReportCriteria(**dict(session.data.get("report_configuration", {})))
     model_listings = None
     if include_model_appendix:
         inp_p = Path(session.data["inp_path"])
         model_listings = {"inp_name": inp_p.name,
                           "inp_text": inp_p.read_text(encoding="utf-8", errors="replace")}
+        execution_p = Path(session.data.get("execution_inp_path", inp_p))
+        if execution_p != inp_p:
+            model_listings.update({
+                "execution_inp_name": execution_p.name,
+                "execution_inp_text": execution_p.read_text(encoding="utf-8", errors="replace"),
+            })
         rpt_p = (session.data["results"].get("metadata", {}) or {}).get("report_path")
         if rpt_p and Path(str(rpt_p)).exists():
             model_listings["rpt_name"] = Path(str(rpt_p)).name
@@ -529,6 +678,7 @@ def generate_report(session_id: str, project_name: str, client: str = "",
         node_summary=session.data["node_df"], link_summary=session.data["link_df"],
         sub_summary=session.data["sub_df"],
         simulation_metadata=session.data["results"]["metadata"],
+        criteria=report_criteria,
         result_db_bytes=session.data["db"].export_bytes(),
         preliminary_review_artifacts={
             "findings": findings, "status": "Preliminary",
@@ -541,6 +691,10 @@ def generate_report(session_id: str, project_name: str, client: str = "",
                         "summary": session.data.get("recon_summary", {})},
         model_identity={"inp_name": Path(session.data["inp_path"]).name,
                         "sha256": session.data["results"]["metadata"].get("model_sha256", "—"),
+                        "execution_inp_name": session.data["results"]["metadata"].get("execution_model_filename"),
+                        "execution_sha256": session.data["results"]["metadata"].get("execution_model_sha256"),
+                        "legacy_defaults_normalized": session.data["results"]["metadata"].get("legacy_defaults_normalized", False),
+                        "solver_option_substitutions": session.data["results"]["metadata"].get("solver_option_substitutions", []),
                         "session_id": session.id,
                         "run_id": session.data["results"]["metadata"].get("run_id", "—"),
                         "engine": "EPA SWMM / OpenSWMM 6 (crash-isolated worker, engine Rev 23.2)",
@@ -573,6 +727,7 @@ TOOL_REGISTRY: dict[str, Callable[..., dict]] = {
         get_node_results, get_link_results, get_subcatchment_results,
         get_timeseries, query_results, get_table_catalog,
         calgary_screening, preliminary_design_review, get_reconciliation,
-        run_scenario, attach_figure, set_report_details, generate_report,
+        run_scenario, attach_figure, set_report_details, set_report_configuration,
+        generate_report,
     ]
 }