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>

backends/contracts/analysis.py

@@ -117,12 +117,16 @@ class AnalysisContract(ABC):
         islands inside them — and the headless engine adds ``hatch_style``
         (``normal``/``outer``/``ignore``) so the number can be read against the
         drawing's own island setting. The live backend does not carry that key:
-        it reads ActiveX ``.Area``, and whether that number already has the
-        island style applied is **not verified against a live seat**. Until it
-        is, do not read a COM hatch area as equivalent to the headless one.
+        it reads ActiveX ``.Area``, which **does** apply the island style —
+        verified on a live AutoCAD 2026 (2026-08-06): a hatch of r20 with an
+        r10 island returns 942.478, which is pi*(400-100).
 
-        ``perimeter`` is ``None`` where ActiveX exposes no length for the type
-        (REGION and 3DSOLID among them), and ``perimeter_exact`` is then False.
+        ``perimeter`` is ``None`` where ActiveX exposes no length member for the
+        type, and ``perimeter_exact`` is then False. The member differs per
+        type and was measured rather than assumed: LWPOLYLINE ``.Length``,
+        CIRCLE ``.Circumference``, REGION ``.Perimeter``, HATCH none. A
+        3DSOLID has no ``.Area`` at all — only ``.Volume`` — and is refused by
+        name.
         A missing perimeter is not a reason to discard an area that was read
         successfully — doing exactly that is what made this method raise on
         every ACIS type it advertised.

backends/contracts/premium.py

@@ -11,6 +11,8 @@ import math
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
+from backends.quarantine import DocumentQuarantineError
+
 if TYPE_CHECKING:
     from backends.base import EntityInfo
     from engineering.plan_spec import (
@@ -579,6 +581,11 @@ class PremiumContract(ABC):
         layer = layer or self._role_layer("construction")
         try:
             ents = await self.entity_list(layer_filter=layer, limit=5000)
+        except DocumentQuarantineError:
+            # "deleted: 0" here would read as "there was nothing to clear" on a
+            # document the backend has declared untrusted -- and this is step 9
+            # of the standard workflow, immediately before finalize.
+            raise
         except Exception:
             ents = []
         deleted = 0

backends/contracts/settings.py

@@ -22,8 +22,13 @@ class SettingsContract:
         With ``settings=None`` returns a snapshot of every known setting. With a
         dict, applies each provided key and returns ``{applied, errors, current}``.
         Friendly keys: units, linear_precision, angular_precision, ltscale,
-        dimscale, text_size, point_mode, point_size, osmode, fillet_radius.
-        `units` accepts mm/cm/m/inch/feet (mapped to the INSUNITS code)."""
+        dimscale, dim_text_height, dim_arrow_size, dim_decimals,
+        decimal_separator, zero_suppression, text_size, point_mode, point_size,
+        osmode, fillet_radius. `units` accepts mm/cm/m/inch/feet (mapped to the
+        INSUNITS code) and `decimal_separator` accepts "." or ",".
+
+        Note that a no-argument snapshot is one ``system_get_variable`` per key.
+        Free headless; a COM round trip each on a live seat."""
         if not settings:
             snapshot: dict = {}
             for key, (var, kind) in _SETTING_MAP.items():
@@ -68,6 +73,16 @@ _SETTING_MAP: dict[str, tuple[str, str]] = {
     "angular_precision": ("AUPREC", "int"),
     "ltscale": ("LTSCALE", "float"),
     "dimscale": ("DIMSCALE", "float"),
+    # The dimension variables had no friendly name until v1.5.2, so the only
+    # way to reach dimension lettering was a raw `system_set_variable` — which
+    # is precisely the path that silently did nothing on the headless engine.
+    # `text_size` is TEXTSIZE, the height of a standalone TEXT entity; it has
+    # never had anything to do with the numbers on a dimension.
+    "dim_text_height": ("DIMTXT", "float"),
+    "dim_arrow_size": ("DIMASZ", "float"),
+    "dim_decimals": ("DIMDEC", "int"),
+    "decimal_separator": ("DIMDSEP", "char"),
+    "zero_suppression": ("DIMZIN", "int"),
     "text_size": ("TEXTSIZE", "float"),
     "point_mode": ("PDMODE", "int"),
     "point_size": ("PDSIZE", "float"),
@@ -96,6 +111,13 @@ _UNIT_TO_CODE: dict[str, int] = {
 }
 _CODE_TO_UNIT: dict[int, str] = {0: "unitless", 1: "inch", 2: "feet", 4: "mm", 5: "cm", 6: "m"}
 
+#: DIMDSEP is a character *code*, not a character — ezdxf raises DXFValueError
+#: on a string in the header — so the friendly key is where the translation
+#: belongs. Only two markers are in real use: ISO 129's point and the comma most
+#: of continental Europe drafts with. Anything else lands an arbitrary glyph in
+#: the middle of every number on the sheet, so it is refused rather than stored.
+_DECIMAL_MARKERS = (".", ",")
+
 
 def _encode_setting(key: str, kind: str, value: Any) -> Any:
     """Coerce a friendly value into the raw system-variable value."""
@@ -109,10 +131,62 @@ def _encode_setting(key: str, kind: str, value: Any) -> Any:
                 f"{sorted(set(_UNIT_TO_CODE))} or an INSUNITS integer."
             )
         return code
+    if kind == "char":
+        if isinstance(value, bool):
+            marker = ""
+        elif isinstance(value, (int, float)):
+            code = int(value)
+            marker = chr(code) if 0 < code < 0x110000 else ""
+        else:
+            marker = str(value).strip()
+        if marker not in _DECIMAL_MARKERS:
+            raise ValueError(
+                f"{key}: unknown value {value!r}. Use one of {list(_DECIMAL_MARKERS)}."
+            )
+        return ord(marker)
     if kind == "int":
-        return int(float(value))
+        return _in_range(key, int(float(value)))
     if kind == "float":
-        return float(value)
+        return _in_range(key, float(value))
+    return value
+
+
+#: AutoCAD's own ranges for the settings that now reach the renderer.
+#:
+#: Before the DIM* header fold, an out-of-range value died harmlessly in the
+#: header. Folding it into the per-dimension override is what gave it teeth:
+#: `dim_decimals=-1` reported `ok: True` and then killed the *next* dimension
+#: with `ValueError: Format specifier missing precision` raised from inside
+#: ezdxf's formatter, nowhere near the call responsible; `dim_decimals=40`
+#: printed forty digits of float noise onto the sheet; and a non-positive
+#: length was reported applied and silently discarded. `applied` has to mean
+#: applied.
+_SETTING_RANGES: dict[str, tuple[float, float]] = {
+    "dim_decimals": (0, 8),  # DIMDEC
+    "zero_suppression": (0, 15),  # DIMZIN is a bitmask
+    "linear_precision": (0, 8),  # LUPREC
+    "angular_precision": (0, 8),  # AUPREC
+    "dim_text_height": (1e-9, 1e6),  # DIMTXT, strictly positive
+    "dim_arrow_size": (1e-9, 1e6),  # DIMASZ, strictly positive
+    "text_size": (1e-9, 1e6),  # TEXTSIZE
+    "dimscale": (0, 1e6),  # 0 means "scale to the viewport" and is legal
+    "ltscale": (1e-9, 1e6),
+    "point_size": (-100, 1e6),  # negative is a percentage of the screen
+    "fillet_radius": (0, 1e6),
+}
+
+
+def _in_range(key: str, value: float) -> float:
+    """Refuse a value the renderer cannot use, naming the range."""
+    bounds = _SETTING_RANGES.get(key)
+    if bounds is None:
+        return value
+    low, high = bounds
+    if not low <= value <= high:
+        low_text = "greater than 0" if 0 < low < 1e-6 else f"at least {low:g}"
+        raise ValueError(
+            f"{key}: {value:g} is out of range - must be {low_text} and at most {high:g}."
+        )
     return value
 
 
@@ -126,6 +200,14 @@ def _decode_setting(key: str, kind: str, raw: Any) -> Any:
         except (TypeError, ValueError):
             return raw
         return {"code": code, "name": _CODE_TO_UNIT.get(code, "unknown")}
+    if kind == "char":
+        try:
+            code = int(raw)
+        except (TypeError, ValueError):
+            return raw
+        # ezdxf's renderer reads DIMDSEP 0 as a comma rather than as "unset",
+        # so report the marker that would actually be drawn.
+        return "," if code == 0 else chr(code)
     if kind == "int":
         try:
             return int(raw)