fix: seven defects an adversarial audit found, and the gates that missed them

Every one of these was reported ok/clean to the caller while being wrong.

Silently wrong numbers
- selection_filter(min_area) read `entity.dxf.get("area", 0.0)` for SOLID,
  TRACE and HATCH, none of which carry that attribute, so every hatch
  measured 0.0. A 1600 mm^2 hatch was excluded by min_area=1.0 while
  `filtered_by` asserted the filter had run, and COM (which reads ActiveX
  .Area) returned a different selection for the same call. It now answers
  from the measurement `entity_measure` uses, so the two cannot disagree.
- Every headless dimension rendered through ezdxf's bare `Standard` style:
  1.0 mm text with a comma decimal marker, against ISO 3098's 2.5 mm minimum
  and ISO 129's point -- while the document header itself said $DIMTXT 2.5.
  `ezdxf.new(setup=True)` is not the fix; measured, it renders a 100 mm
  dimension as "10000". The attributes are now stored explicitly.
- Saving writes `dimrnd = 0.0` onto the Standard style, and ezdxf applies
  `xround(value, dimrnd)` whenever the attribute is present at all --
  `xround(33.333, 0.0)` is 33. So on any reopened file, including one this
  server saved, every dimension was rounded to a whole unit before DIMDEC
  formatted it: a 12.75 mm feature dimensioned 13. AutoCAD means DIMRND 0 as
  *no* rounding; the sentinel is now discarded at every load site, and a real
  0.5 mm rounding is left alone.
- The DIM* header fold gave out-of-range values teeth they did not have when
  they died in the header: dim_decimals=-1 returned ok and then killed the
  next dimension with `ValueError: Format specifier missing precision` from
  inside ezdxf, and 40 printed forty digits of float noise onto the sheet.
  Ranges are now AutoCAD's own (DIMDEC 0-8, DIMZIN 0-15, lengths positive).

Security
- security.py recorded the policy as "sanitize_command and sanitize_lisp each
  have exactly ONE caller ... the policy is scoped to the CHANNEL". The
  premise was false. `_ensure_linetype_loaded` and `ComBackend.linetype_load`
  build `_-LINETYPE _LOAD {name} {file}` and hand it to SendCommand, which
  treats a newline and ';' as segment separators -- so a `linetype=` argument
  carrying either injected further AutoCAD commands, and the 36-verb denylist
  never saw that channel. Guarded with the DXF symbol-name rule (the
  injection characters fall out of it rather than being enumerated) plus
  validate_path for the file argument, which was also the one path-taking
  tool reaching the filesystem unchecked. The policy comment is corrected.

Gates that could not see
- drawing_critique returned zero issues on a quarantined document: all seven
  checks wrapped their backend call in a bare `except Exception`. CLAUDE.md
  rule 7 makes that call the gate an agent is told to trust. Only the
  quarantine now escapes; an ordinary broken check still degrades.
  `_check_dimension_legibility` also read `_doc` directly from the event loop
  thread, missing the gate and performing exactly the unsynchronised access
  the quarantine exists to prevent. `construction_clear` answered
  "deleted: 0" -- there was nothing to clear -- for the same reason.
- The iso128 focus checked layer lineweights only, so a sheet lettered at
  1.0 mm critiqued clean. It now reads the effective dimension height and
  separator, header-then-style, in the order the renderer resolves.
- check_doc_numbers.py derived five values it never checked, and those were
  the ones that had drifted. The collected-test count (README said 1274, the
  tree had 1369) and the A/B pass-rate and Fixed columns are now gated.
- benchmarks/README.md's v1.4.0 table was impossible on its face -- 21
  passing plus 5 fixed is 26, not 24 -- and contradicted the report it
  linked, because `ab-v1.4.0-vs-v1.5.0.json` was regenerated from a tree that
  already carried the dimension fixes and so never measured the v1.5.0 tag.
  Replaced with a real run: ab-v1.4.0-vs-v1.5.1.json, 21/26 -> 26/26.

Release gate
- release.yml ran one ubuntu/3.11 lane, so a Windows-only defect could reach
  PyPI with no Windows job having executed. That is not hypothetical: v1.5.0
  shipped `except pywintypes.com_error` raising NameError wherever pywin32 is
  absent. It now runs the same three lanes as ci.yml, Windows included.

1368 passed, 1 xfailed. ruff clean. Tool inventory and all 16 gated document
numbers match the tree.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

engineering/critique.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 import math
 from typing import TYPE_CHECKING
 
+from backends.quarantine import DocumentQuarantineError, quarantine_refusal
+
 from .layers import ENGINEERING_LAYERS
 from .plan_spec import (
     ALL_CRITIQUE_FOCUSES,
@@ -45,6 +47,8 @@ async def _check_iso128(backend: AutoCADBackend) -> list[Issue]:
     issues: list[Issue] = []
     try:
         layers = await backend.layer_list()
+    except DocumentQuarantineError:
+        raise
     except Exception as exc:
         return [Issue("warning", "iso128", f"layer_list failed: {exc}")]
     allowed = set(ISO_128_LINEWEIGHTS_MM)
@@ -73,6 +77,87 @@ async def _check_iso128(backend: AutoCADBackend) -> list[Issue]:
                     detail={"layer": lyr.name, "lineweight": lw},
                 )
             )
+    issues.extend(_check_dimension_legibility(backend))
+    return issues
+
+
+#: ISO 3098 minimum lettering height for technical drawings, in mm.
+ISO_3098_MIN_TEXT_MM = 2.5
+
+
+def _check_dimension_legibility(backend: AutoCADBackend) -> list[Issue]:
+    """Dimension text must be readable and use an ISO 129 decimal marker.
+
+    This lane was blind: `iso128` checked layer lineweights only, so a sheet
+    whose dimensions rendered at ezdxf's bare 1.0 mm with a comma separator
+    critiqued clean — and "zero issues" is the claim that the drawing is
+    conformant. Reading the settings rather than the rendered block keeps it
+    cheap and catches the case before a dimension is even drawn.
+
+    It reads the *effective* value — header first, then the stored dimstyle
+    attribute, then ezdxf's renderer fallback — because that is the order the
+    renderer resolves in since the DIM* header variables started reaching it.
+    Grading the dimstyle alone made this check wrong in both directions: it
+    would report a 1.0 mm defect on a sheet the header letters at 2.5, and clear
+    a sheet the header letters at 1.0 because the style still said 2.5.
+
+    Headless only by construction: a live AutoCAD document carries the
+    operator's own template, and second-guessing it from here would report
+    their house standard as a defect.
+    """
+    doc = getattr(backend, "_doc", None)
+    if doc is None:  # the live backend has no ezdxf document to read
+        return []
+
+    # This is the one check that reads `_doc` directly instead of going through
+    # `_async`, so it also misses `_async`'s quarantine gate — and it runs on
+    # the event loop thread, which is exactly the unsynchronised access to a
+    # document an abandoned worker may still be writing that the quarantine
+    # exists to prevent. Refuse here rather than read.
+    record = getattr(backend, "_quarantine", None)
+    if record is not None:
+        reap = getattr(backend, "_reap_quarantine", None)
+        if reap is not None:
+            reap()
+        record = getattr(backend, "_quarantine", None)
+        if record is not None:
+            raise quarantine_refusal(record)
+
+    from backends.ezdxf_backend import effective_dimvar
+
+    try:
+        height = float(effective_dimvar(doc, "dimtxt"))
+        separator = int(effective_dimvar(doc, "dimdsep"))
+    except DocumentQuarantineError:
+        raise
+    except Exception:
+        return []
+
+    issues: list[Issue] = []
+    if height < ISO_3098_MIN_TEXT_MM:
+        issues.append(
+            Issue(
+                severity="warning",
+                focus="iso128",
+                message=(
+                    f"Dimension text is {height:g} mm; ISO 3098 sets the minimum "
+                    f"lettering height at {ISO_3098_MIN_TEXT_MM} mm."
+                ),
+                detail={"dimtxt": height, "minimum": ISO_3098_MIN_TEXT_MM},
+            )
+        )
+    # DIMDSEP 0 is not "unset" — ezdxf's `get_decimal_separator` renders it as a
+    # comma — so it is the violation, not an excuse to skip the check.
+    marker = "," if separator == 0 else chr(separator)
+    if marker != ".":
+        issues.append(
+            Issue(
+                severity="warning",
+                focus="iso128",
+                message=(f"Dimension decimal marker is {marker!r}; ISO 129 uses a point."),
+                detail={"dimdsep": separator},
+            )
+        )
     return issues
 
 
@@ -81,6 +166,8 @@ async def _check_layer_color(backend: AutoCADBackend) -> list[Issue]:
     issues: list[Issue] = []
     try:
         layers = await backend.layer_list()
+    except DocumentQuarantineError:
+        raise
     except Exception:
         return []
     for lyr in layers:
@@ -111,6 +198,8 @@ async def _check_construction_left(backend: AutoCADBackend) -> list[Issue]:
     """
     try:
         ents = await backend.entity_list(limit=5000)
+    except DocumentQuarantineError:
+        raise
     except Exception:
         return []
     leftover = [e for e in ents if "CONST" in (e.layer or "").upper()]
@@ -139,6 +228,8 @@ async def _check_untrimmed_corner(backend: AutoCADBackend) -> list[Issue]:
     tol = 0.5  # mm — generous; tighten via PlanSpec.notes later
     try:
         lines = await backend.entity_list(type_filter="LINE", limit=5000)
+    except DocumentQuarantineError:
+        raise
     except Exception:
         return []
     endpoints: list[tuple[str, tuple[float, float]]] = []
@@ -182,6 +273,8 @@ async def _check_duplicate_entities(backend: AutoCADBackend) -> list[Issue]:
     """Two LINEs with identical endpoints (in either direction) are duplicates."""
     try:
         lines = await backend.entity_list(type_filter="LINE", limit=5000)
+    except DocumentQuarantineError:
+        raise
     except Exception:
         return []
     seen: dict[tuple, str] = {}
@@ -240,6 +333,8 @@ async def _check_dim_overlap(backend: AutoCADBackend) -> list[Issue]:
     tol = 5.0  # mm
     try:
         ents = await backend.entity_list(limit=5000)
+    except DocumentQuarantineError:
+        raise
     except Exception:
         return []
     dim_points: list[tuple[str, tuple[float, float]]] = []