diff --git a/AGENTS.md b/AGENTS.md
index d81bd0a06..474bdfe90 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -54,7 +54,7 @@ Evaluate every change against the repository's three core layers in strict prior
 ## Detailed Engineering Conventions
 
 ### 1. Typing & Data Models
-- **Subclass `RoborockBase`**: Define structured domain and wire data models as `@dataclass` subclassing `RoborockBase` (`from_dict`, `as_dict`). Avoid `TypedDict` or loose dicts. (Binary protocol packets, transport message envelopes, and map layers are exempt).
+- **Subclass `RoborockBase`**: Define structured domain and wire data models as `@dataclass` subclassing `RoborockBase` (`from_dict`, `as_dict`). Avoid `TypedDict` or loose dicts. (Binary protocol packets, transport message envelopes, and map layers are exempt). The existing frozen `Q10RoborockPoint` coordinate value is also exempt: it must retain immutability and hashability, and Python disallows frozen dataclass inheritance from the non-frozen `RoborockBase`. This exception does not extend to other domain models.
 - **Enum Fallback Resilience**: All enums representing device status, firmware modes, error codes, and wire protocol integer codes MUST inherit from `RoborockEnum` (defining a lowercase `unknown = -1` or `0` member) or `RoborockModeEnum` (using `from_code_optional()`). Internal enums not decoding unknown firmware codes remain standard `Enum`/`StrEnum`.
 - **Strongly Type What You Know; Contain `Any` to the Wire**: Public trait APIs, method signatures, properties, and domain models MUST declare concrete types. `Any` is accepted only where the underlying wire protocol is dynamic or polymorphic (Tuya DPS maps, low-level RPC dispatch, serialization helpers, evolving cloud schemas).
 - **Avoid Forward References & `TYPE_CHECKING`**: Avoid stringified forward references (`"ClassName"`) and `if typing.TYPE_CHECKING:` guards wherever possible. They typically indicate circular dependencies or coupling that should be refactored by extracting shared models.
diff --git a/roborock/map/b01_q10_map_parser.py b/roborock/map/b01_q10_map_parser.py
index 5d28f825a..ad520b4f6 100644
--- a/roborock/map/b01_q10_map_parser.py
+++ b/roborock/map/b01_q10_map_parser.py
@@ -1,8 +1,9 @@
 """Parser for Roborock Q10 (B01/ss07) map packets.
 
-Q10 devices deliver map data as a protocol-301 ``MAP_RESPONSE`` message after a
-``dpMultiMap`` list/get request. Unlike the Q7 ``SCMap`` protobuf
-format, the Q10 uses a custom, unencrypted binary packet:
+Q10 devices deliver map data as protocol-301 ``MAP_RESPONSE`` pushes. Current
+maps follow a read-only status request, while saved-map and clean-record detail
+packets follow their respective ``select`` requests. Unlike the Q7 ``SCMap``
+protobuf format, the Q10 uses a custom, unencrypted binary packet:
 
 - ``01 01`` marker, then a ``u32be`` map id (bytes 2-5) and two consecutive
   ``u16be`` dimensions: grid width (bytes 7-8) and grid height (bytes 9-10).
@@ -22,6 +23,7 @@
 import io
 import math
 import statistics
+import struct
 from dataclasses import dataclass, field, replace
 
 from PIL import Image
@@ -30,6 +32,7 @@
 from vacuum_map_parser_base.map_data import ImageData, MapData, Point
 
 from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
+from roborock.data.code_mappings import RoborockEnum
 from roborock.data.containers import RoborockBase
 from roborock.exceptions import RoborockException
 
@@ -67,9 +70,6 @@ def classify_q10_cell(value: int) -> str:
     return LAYER_FLOOR
 
 
-MAP_PACKET_MARKER = b"\x01\x01"
-TRACE_PACKET_MARKER = b"\x02\x01"
-
 _MAP_ID_OFFSET = 2
 # Width and height are two consecutive u16be fields. An earlier revision read the
 # width as u16le at offset 8; that high byte is actually the height's high byte,
@@ -84,6 +84,7 @@ def classify_q10_cell(value: int) -> str:
 _ROOM_RECORD_LENGTH = 47
 _ROOM_NAME_LENGTH_OFFSET = 26
 _MAX_ROOMS = 32
+_MAX_GRID_CELLS = 16_000_000
 # Sanity bound for the erase-zone vector section's vertices-per-polygon field.
 _MAX_ERASE_ZONE_VERTICES = 16
 
@@ -195,10 +196,34 @@ def charger_pixels(self) -> tuple[float, float] | None:
         )
 
 
+class Q10MapPacketKind(RoborockEnum):
+    """Semantic kind identified by a Q10 map packet's two-byte marker."""
+
+    unknown = -1
+    CURRENT = 1
+    TRACE = 2
+    CLEAN_RECORD_DETAIL = 3
+    SAVED_MAP_DETAIL = 4
+
+    @property
+    def marker(self) -> bytes:
+        """Return the two-byte wire marker for this packet kind."""
+        return b"" if self is self.unknown else bytes((self.value, 1))
+
+    @classmethod
+    def from_payload(cls, payload: bytes) -> "Q10MapPacketKind | None":
+        """Return the recognized kind for a payload marker."""
+        if len(payload) < 2 or payload[1] != 1:
+            return None
+        kind = cls(payload[0])
+        return None if kind is cls.unknown else kind
+
+
 @dataclass
 class Q10MapPacket:
-    """Decoded contents of a Q10 ``01 01`` map packet."""
+    """Decoded contents of a Q10 current or archived map packet."""
 
+    kind: Q10MapPacketKind
     map_id: int
     width: int
     height: int
@@ -271,6 +296,33 @@ def robot_position(self) -> Q10Point | None:
         return self.points[-1] if self.points else None
 
 
+@dataclass
+class Q10HistoricalTracePacket:
+    """Cleaning path embedded in a Q10 ``03 01`` clean-record detail packet.
+
+    This is a different wire layout from the live ``02 01`` trace. Its header
+    carries a 16-bit format version, a 32-bit opaque value, a 32-bit
+    point count, a signed heading, and a zero reserved word. Points use the same
+    signed big-endian ``(x, y)`` coordinate pairs as the live trace.
+    """
+
+    points: list[Q10Point] = field(default_factory=list)
+    heading: int = 0
+
+    @property
+    def robot_position(self) -> Q10Point | None:
+        """The final recorded position, if the historical path is non-empty."""
+        return self.points[-1] if self.points else None
+
+
+@dataclass
+class Q10CleanRecordDetail:
+    """A clean-record response containing a map and its recorded path."""
+
+    map: Q10MapPacket
+    trace: Q10HistoricalTracePacket | None = None
+
+
 # Trace packet (``02 01``): a 14-byte header followed by big-endian int16 (x, y)
 # point pairs forming the accumulated session path. Header layout confirmed
 # against live ss07 captures and cross-checked by @andrewlyeats:
@@ -280,18 +332,26 @@ def robot_position(self) -> Q10Point | None:
 # - bytes 10-11: the 0201 SLAM heading (s16be degrees; 0 = +x, +90 = +y,
 #   +-180 = -x, -90 = -y) -- the robot's current orientation.
 # - bytes 12-13: a constant (0x0000).
-# - byte 14 onward: the path points.
+# - byte 14 onward: exactly ``point_count`` path points.
 # An earlier revision used a 10-byte header, which folded the heading word into
 # a phantom leading point ``(heading, 0)`` -- that is the "stray point" the
 # heuristic below was papering over, and why the count read "one high". The
-# parser reads all 4-byte pairs in the body rather than trusting the count
-# field, so a truncated tail can't desync it.
+# parser requires the declared point count to match the complete body, so a
+# truncated or extended tail cannot be silently interpreted as path data.
 # NOTE: the format documented by roborock-qseries-map-bridge (18-byte header)
 # did not match this firmware -- this 14-byte layout is what the device sent.
 _TRACE_HEADER_LENGTH = 14
 _TRACE_SEQUENCE_OFFSET = 3
+_TRACE_POINT_COUNT_OFFSET = 8
 _TRACE_HEADING_OFFSET = 10
 
+_HISTORICAL_TRACE_HEADER_LENGTH = 14
+_HISTORICAL_TRACE_PREFIX_LENGTH = 1
+_HISTORICAL_TRACE_VERSION = 1
+_HISTORICAL_TRACE_POINT_COUNT_OFFSET = 6
+_HISTORICAL_TRACE_HEADING_OFFSET = 10
+_HISTORICAL_TRACE_RESERVED_OFFSET = 12
+
 # Some cleans still prepend a single near-origin sentinel as the first real
 # point (e.g. ~(5, 76) / (-3, 0) when the path proper starts near (-1700, -800));
 # it skews the rendered start/bounding box and any path-based calibration. (This
@@ -306,12 +366,12 @@ def robot_position(self) -> Q10Point | None:
 
 def is_map_packet(payload: bytes) -> bool:
     """Return True if the payload is a Q10 full-map (``01 01``) packet."""
-    return payload[:2] == MAP_PACKET_MARKER
+    return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.CURRENT
 
 
 def is_trace_packet(payload: bytes) -> bool:
     """Return True if the payload is a Q10 live trace (``02 01``) packet."""
-    return payload[:2] == TRACE_PACKET_MARKER
+    return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.TRACE
 
 
 def parse_trace_packet(payload: bytes) -> Q10TracePacket:
@@ -323,6 +383,9 @@ def parse_trace_packet(payload: bytes) -> Q10TracePacket:
     body = payload[_TRACE_HEADER_LENGTH:]
     if len(body) % 4:
         raise RoborockException("Q10 trace points are not 4-byte (x, y) pairs")
+    declared_point_count = int.from_bytes(payload[_TRACE_POINT_COUNT_OFFSET : _TRACE_POINT_COUNT_OFFSET + 2], "big")
+    if declared_point_count != len(body) // 4:
+        raise RoborockException("Q10 trace point count does not match its payload")
 
     heading = int.from_bytes(payload[_TRACE_HEADING_OFFSET : _TRACE_HEADING_OFFSET + 2], "big", signed=True)
     points = [
@@ -353,11 +416,13 @@ def _drop_stray_leading_point(points: list[Q10Point]) -> list[Q10Point]:
     return points
 
 
-def lz4_block_decompress(data: bytes) -> bytes:
+def lz4_block_decompress(data: bytes, max_output_size: int) -> bytes:
     """Decompress a raw LZ4 *block* (no frame header).
 
     The Q10 map grid is stored as a single LZ4 block. This implements the
-    standard LZ4 block format so we don't add a native dependency.
+    standard LZ4 block format so we don't add a native dependency. Expansion beyond
+    ``max_output_size`` is rejected before
+    allocating the excess output.
     """
     index = 0
     output = bytearray()
@@ -385,6 +450,8 @@ def read_length(value: int) -> int:
         end = index + literal_length
         if end > len(data):
             raise RoborockException("Truncated LZ4 block while reading literals")
+        if len(output) + literal_length > max_output_size:
+            raise RoborockException("LZ4 block exceeds maximum output size")
         output.extend(data[index:end])
         index = end
 
@@ -399,6 +466,8 @@ def read_length(value: int) -> int:
             raise RoborockException("Invalid LZ4 back-reference offset")
 
         match_length = read_length(token & 0x0F) + 4
+        if len(output) + match_length > max_output_size:
+            raise RoborockException("LZ4 block exceeds maximum output size")
         for _ in range(match_length):
             output.append(output[-offset])
 
@@ -463,8 +532,24 @@ def _parse_rooms(room_data: bytes, grid: bytes) -> list[Q10Room]:
 
 
 def parse_map_packet(payload: bytes) -> Q10MapPacket:
-    """Parse a Q10 ``01 01`` map packet into grid + room metadata."""
-    if len(payload) < _LAYOUT_COMPRESSED_OFFSET or not is_map_packet(payload):
+    """Parse the raster and shared metadata of a current or archived map."""
+    packet, _, _ = _parse_map_layout(payload)
+    return packet
+
+
+def parse_clean_record_detail(payload: bytes) -> Q10CleanRecordDetail:
+    """Parse a clean-record response into its map and optional recorded path."""
+    if Q10MapPacketKind.from_payload(payload) is not Q10MapPacketKind.CLEAN_RECORD_DETAIL:
+        raise RoborockException("Payload is not a Q10 clean-record detail packet")
+    packet, tail, trace_offset = _parse_map_layout(payload)
+    trace = _parse_clean_record_trace(tail, trace_offset) if trace_offset is not None else None
+    return Q10CleanRecordDetail(map=packet, trace=trace)
+
+
+def _parse_map_layout(payload: bytes) -> tuple[Q10MapPacket, bytes, int | None]:
+    """Decode shared map fields and return the tail and historical path offset."""
+    kind = Q10MapPacketKind.from_payload(payload)
+    if len(payload) < _LAYOUT_COMPRESSED_OFFSET or kind is None or kind is Q10MapPacketKind.TRACE:
         raise RoborockException("Payload is not a Q10 map packet")
 
     map_id = int.from_bytes(payload[_MAP_ID_OFFSET : _MAP_ID_OFFSET + 4], "big")
@@ -472,6 +557,8 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket:
     height = int.from_bytes(payload[_HEIGHT_OFFSET : _HEIGHT_OFFSET + 2], "big")
     if width <= 0:
         raise RoborockException("Q10 map packet has invalid width")
+    if height > 0 and width * height > _MAX_GRID_CELLS:
+        raise RoborockException("Q10 map packet dimensions exceed the supported grid size")
 
     compressed_length = int.from_bytes(
         payload[_COMPRESSED_LAYOUT_LENGTH_OFFSET : _COMPRESSED_LAYOUT_LENGTH_OFFSET + 2], "big"
@@ -480,7 +567,10 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket:
     if compressed_length <= 0 or layout_end > len(payload):
         raise RoborockException("Q10 map packet has invalid layout block length")
 
-    decoded = lz4_block_decompress(payload[_LAYOUT_COMPRESSED_OFFSET:layout_end])
+    decoded = lz4_block_decompress(
+        payload[_LAYOUT_COMPRESSED_OFFSET:layout_end],
+        max_output_size=_MAX_GRID_CELLS + 2 + _MAX_ROOMS * _ROOM_RECORD_LENGTH,
+    )
     # Prefer the header height; fall back to inference if it doesn't line up
     # (e.g. older captures/fixtures that don't populate the height field).
     split = _split_with_dims(decoded, width, height) if height > 0 else None
@@ -491,9 +581,10 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket:
     rooms = _parse_rooms(room_data, grid)
     tail = payload[layout_end:]
     erase_zones = _parse_erase_zones(tail)
-    carpet_mask = _parse_carpet_mask(tail, width, height)
+    carpet_mask, carpet_end = _parse_carpet_block(tail, width, height)
     header_calibration = _parse_header_calibration(payload)
-    return Q10MapPacket(
+    packet = Q10MapPacket(
+        kind=kind,
         map_id=map_id,
         width=width,
         height=height,
@@ -503,6 +594,7 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket:
         header_calibration=header_calibration,
         carpet_mask=carpet_mask,
     )
+    return packet, tail, carpet_end
 
 
 def _parse_header_calibration(payload: bytes) -> Q10HeaderCalibration | None:
@@ -574,7 +666,18 @@ def _carpet_offset(tail: bytes) -> int:
     return 2 + count * vertices_per * 4
 
 
-def _parse_carpet_mask(tail: bytes, width: int, height: int) -> bytes | None:
+def _erase_section_end(tail: bytes) -> int:
+    """Return the end of a complete, structurally valid erase section."""
+    if len(tail) < 2:
+        return 0
+    count, vertices_per = tail[0], tail[1]
+    if count and not 1 <= vertices_per <= _MAX_ERASE_ZONE_VERTICES:
+        return 0
+    end = _carpet_offset(tail)
+    return end if end <= len(tail) else 0
+
+
+def _parse_carpet_block(tail: bytes, width: int, height: int) -> tuple[bytes | None, int | None]:
     """Decode the carpet mask that follows the erase section in the packet tail.
 
     Framing matches the main grid block: ``[u32 uncompressed_len]``
@@ -583,23 +686,73 @@ def _parse_carpet_mask(tail: bytes, width: int, height: int) -> bytes | None:
     non-zero cell is carpet (the value is the carpet kind). Confirmed byte-exact
     on live ss07 captures (R1 / RDC), where ``uncompressed_len == width*height``.
 
-    Returns the decompressed mask, or ``None`` if the section is absent or does
-    not line up (the ``uncompressed_len == width*height`` invariant is used as the
-    guard so a mis-located section yields no carpet rather than garbage).
+    Returns the decompressed mask and its end offset. Both are ``None`` if the
+    section is absent or does not line up. The end offset is used to anchor
+    optional later sections without scanning arbitrary trailing bytes.
     """
-    offset = _carpet_offset(tail)
+    offset = _erase_section_end(tail)
+    if offset == 0:
+        return None, None
     if offset + 6 > len(tail):
-        return None
+        return None, None
     uncompressed_len = int.from_bytes(tail[offset : offset + 4], "big")
     compressed_len = int.from_bytes(tail[offset + 4 : offset + 6], "big")
     block_end = offset + 6 + compressed_len
     if uncompressed_len != width * height or compressed_len <= 0 or block_end > len(tail):
-        return None
+        return None, None
     try:
-        mask = lz4_block_decompress(tail[offset + 6 : block_end])
+        mask = lz4_block_decompress(tail[offset + 6 : block_end], max_output_size=width * height)
     except RoborockException:
+        return None, None
+    if len(mask) != width * height:
+        return None, None
+    return mask, block_end
+
+
+def _parse_clean_record_trace(
+    tail: bytes,
+    offset: int,
+) -> Q10HistoricalTracePacket | None:
+    """Decode the bounded historical path following a ``03 01`` carpet block.
+
+    The header and declared point count were validated against a physical ss07
+    clean-record response and its point bytes match captured prefixes of the
+    corresponding live trace exactly. One observed zero byte precedes the path;
+    its meaning is unknown, so a non-zero value makes the entire section opaque.
+    Any unsupported version, non-zero reserved word, or truncated point table is
+    likewise left completely opaque. Bytes after the declared points are
+    deliberately not consumed: the observed 12-byte suffix appears structured,
+    but there is not enough controlled evidence to name or decode it safely.
+    """
+    if offset >= len(tail) or tail[offset] != 0:
+        return None
+    offset += _HISTORICAL_TRACE_PREFIX_LENGTH
+    header_end = offset + _HISTORICAL_TRACE_HEADER_LENGTH
+    if header_end > len(tail):
         return None
-    return mask if len(mask) == width * height else None
+    version = int.from_bytes(tail[offset : offset + 2], "big")
+    reserved = int.from_bytes(
+        tail[offset + _HISTORICAL_TRACE_RESERVED_OFFSET : offset + _HISTORICAL_TRACE_RESERVED_OFFSET + 2],
+        "big",
+    )
+    if version != _HISTORICAL_TRACE_VERSION or reserved != 0:
+        return None
+    point_count = int.from_bytes(
+        tail[offset + _HISTORICAL_TRACE_POINT_COUNT_OFFSET : offset + _HISTORICAL_TRACE_POINT_COUNT_OFFSET + 4],
+        "big",
+    )
+    points_end = header_end + point_count * 4
+    if points_end > len(tail):
+        return None
+    coordinates = struct.iter_unpack(">hh", memoryview(tail)[header_end:points_end])
+    return Q10HistoricalTracePacket(
+        points=_drop_stray_leading_point([Q10Point(x=x, y=y) for x, y in coordinates]),
+        heading=int.from_bytes(
+            tail[offset + _HISTORICAL_TRACE_HEADING_OFFSET : offset + _HISTORICAL_TRACE_HEADING_OFFSET + 2],
+            "big",
+            signed=True,
+        ),
+    )
 
 
 def erased_packet(packet: "Q10MapPacket", cells: set[int]) -> "Q10MapPacket":
diff --git a/roborock/map/b01_q10_render.py b/roborock/map/b01_q10_render.py
index 0e61452f3..a24df43cc 100644
--- a/roborock/map/b01_q10_render.py
+++ b/roborock/map/b01_q10_render.py
@@ -34,6 +34,7 @@
     B01Q10MapParser,
     B01Q10MapParserConfig,
     Q10EraseZone,
+    Q10HistoricalTracePacket,
     Q10MapPacket,
     Q10TracePacket,
     erased_packet,
@@ -62,7 +63,6 @@
 # a much shorter path suffices to confirm it (early in a clean, not just a dense
 # one). See :func:`solve_calibration_with_origin`.
 _MIN_HEADER_CALIBRATION_POINTS = 4
-
 _Q10_DRAWABLE_TYPES = {
     Drawable.CHARGER,
     Drawable.NO_GO_AREAS,
@@ -84,7 +84,7 @@ class Q10MapOverlays:
 
 def render_q10_map(
     packet: Q10MapPacket,
-    trace: Q10TracePacket | None,
+    trace: Q10TracePacket | Q10HistoricalTracePacket | None,
     overlays: Q10MapOverlays,
     *,
     config: B01Q10MapParserConfig,
@@ -133,7 +133,7 @@ def render_q10_map(
 
 def solve_q10_calibration(
     packet: Q10MapPacket,
-    trace: Q10TracePacket | None,
+    trace: Q10TracePacket | Q10HistoricalTracePacket | None,
 ) -> GridCalibration | None:
     """Derive world-to-pixel calibration from a map and its current trace.
 
@@ -232,7 +232,7 @@ def _erased_cells(
 def _place_trace(
     map_data: MapData,
     calibration: GridCalibration,
-    trace: Q10TracePacket,
+    trace: Q10TracePacket | Q10HistoricalTracePacket,
     *,
     charger_heading: int | None = None,
 ) -> None:
diff --git a/roborock/protocols/b01_q10_protocol.py b/roborock/protocols/b01_q10_protocol.py
index 2eccb15b8..a3a18fa1b 100644
--- a/roborock/protocols/b01_q10_protocol.py
+++ b/roborock/protocols/b01_q10_protocol.py
@@ -11,10 +11,11 @@
 from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
 from roborock.exceptions import RoborockException
 from roborock.map.b01_q10_map_parser import (
+    Q10CleanRecordDetail,
     Q10MapPacket,
+    Q10MapPacketKind,
     Q10TracePacket,
-    is_map_packet,
-    is_trace_packet,
+    parse_clean_record_detail,
     parse_map_packet,
     parse_trace_packet,
 )
@@ -155,24 +156,27 @@ class Q10DpsUpdate:
 # A single decoded message from a Q10 device: a DPS status update, a full map
 # packet, or a live cleaning-path (trace) packet. Map/trace packets arrive as
 # protocol-301 ``MAP_RESPONSE`` pushes; everything else is a DPS update.
-Q10Message = Q10DpsUpdate | Q10MapPacket | Q10TracePacket
+Q10Message = Q10DpsUpdate | Q10MapPacket | Q10TracePacket | Q10CleanRecordDetail
 
 
 def decode_message(message: RoborockMessage) -> Q10Message | None:
     """Decode a pushed Q10 ``RoborockMessage`` into a typed message.
 
-    ``MAP_RESPONSE`` (protocol 301) payloads carry the binary map (``01 01``) or
-    trace (``02 01``) packets, which are parsed by the map parser; any other
-    ``MAP_RESPONSE`` marker is unrecognized and yields ``None``. Every other
-    protocol is treated as a DPS status update.
+    ``MAP_RESPONSE`` (protocol 301) payloads carry binary current-map (``01
+    01``), trace (``02 01``), clean-record detail (``03 01``), or saved-map
+    detail (``04 01``) packets. Any other marker is unrecognized and yields
+    ``None``. Every other protocol is treated as a DPS status update.
 
     Raises ``RoborockException`` if a recognized payload fails to parse.
     """
     if message.protocol == RoborockMessageProtocol.MAP_RESPONSE:
         payload = message.payload or b""
-        if is_map_packet(payload):
-            return parse_map_packet(payload)
-        if is_trace_packet(payload):
+        kind = Q10MapPacketKind.from_payload(payload)
+        if kind is Q10MapPacketKind.TRACE:
             return parse_trace_packet(payload)
+        if kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL:
+            return parse_clean_record_detail(payload)
+        if kind is not None:
+            return parse_map_packet(payload)
         return None
     return Q10DpsUpdate(dps=decode_rpc_response(message))
diff --git a/tests/conformance/test_model_conformance.py b/tests/conformance/test_model_conformance.py
index 52979d662..634df643b 100644
--- a/tests/conformance/test_model_conformance.py
+++ b/tests/conformance/test_model_conformance.py
@@ -10,6 +10,7 @@
 import pytest
 
 import roborock.data
+from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
 from roborock.data.containers import RoborockBase
 from tests.conformance.discovery import discover_dataclasses, to_pytest_params
 
@@ -20,6 +21,12 @@
 )
 def test_data_model_subclasses_roborock_base(model_cls: type) -> None:
     """All domain dataclasses in roborock.data must inherit from RoborockBase."""
+    # This immutable coordinate value predates the conformance suite. Frozen
+    # dataclasses cannot inherit from the non-frozen RoborockBase dataclass.
+    # Keep this exception explicit; other models must satisfy the normal rule.
+    if model_cls is Q10RoborockPoint:
+        assert model_cls.__dataclass_params__.frozen  # type: ignore[attr-defined]
+        return
     assert issubclass(model_cls, RoborockBase), (
         f"{model_cls.__module__}.{model_cls.__name__} is a dataclass but does not inherit from RoborockBase. "
         "Per AGENTS.md, domain containers must subclass RoborockBase for serialization."
diff --git a/tests/data/b01_q10/test_b01_q10_containers.py b/tests/data/b01_q10/test_b01_q10_containers.py
index f355e06e2..b5d406000 100644
--- a/tests/data/b01_q10/test_b01_q10_containers.py
+++ b/tests/data/b01_q10/test_b01_q10_containers.py
@@ -1,5 +1,7 @@
 """Tests for Q10 data containers."""
 
+from dataclasses import FrozenInstanceError
+
 import pytest
 
 from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
@@ -47,3 +49,15 @@ def test_q10_roborock_point_rejects_invalid_vector_coordinates(
     """Outbound vector coordinates must fit the signed wire grid exactly."""
     with pytest.raises(ValueError):
         point.to_vector()
+
+
+@pytest.mark.parametrize("field", ["x", "y"])
+def test_roborock_point_preserves_immutable_value_contract(field: str) -> None:
+    point = Q10RoborockPoint(25500, 25500)
+    original_hash = hash(point)
+    with pytest.raises(FrozenInstanceError):
+        setattr(point, field, 0)
+    with pytest.raises(FrozenInstanceError):
+        delattr(point, field)
+    assert point == Q10RoborockPoint(25500, 25500)
+    assert hash(point) == original_hash
diff --git a/tests/map/test_b01_q10_map_parser.py b/tests/map/test_b01_q10_map_parser.py
index c0200ff58..e0585c719 100644
--- a/tests/map/test_b01_q10_map_parser.py
+++ b/tests/map/test_b01_q10_map_parser.py
@@ -2,6 +2,7 @@
 
 import io
 from pathlib import Path
+from typing import Any
 
 import pytest
 from PIL import Image
@@ -10,11 +11,14 @@
 from roborock.map.b01_grid_layers import LAYER_BACKGROUND, LAYER_FLOOR, LAYER_WALL
 from roborock.map.b01_q10_map_parser import (
     B01Q10MapParser,
+    Q10MapPacketKind,
+    Q10Point,
     Q10Room,
     classify_q10_cell,
     is_map_packet,
     is_trace_packet,
     lz4_block_decompress,
+    parse_clean_record_detail,
     parse_map_packet,
     parse_trace_packet,
 )
@@ -96,7 +100,7 @@ def test_lz4_block_roundtrip_all_literals() -> None:
     block.append(0x0F << 4)
     block.append(len(original) - 15)
     block += original
-    assert lz4_block_decompress(bytes(block)) == original
+    assert lz4_block_decompress(bytes(block), max_output_size=len(original)) == original
 
 
 def test_lz4_block_back_reference() -> None:
@@ -104,7 +108,14 @@ def test_lz4_block_back_reference() -> None:
     # seq1: 1 literal 'A', then match (offset 1, length 4+4=8) -> 'A' x9.
     # seq2: final literals-only token (0 literals) ends the block per LZ4 spec.
     block = bytes([0x14, ord("A"), 0x01, 0x00, 0x00])
-    assert lz4_block_decompress(block) == b"A" * 9
+    assert lz4_block_decompress(block, max_output_size=9) == b"A" * 9
+
+
+def test_lz4_block_rejects_output_over_limit() -> None:
+    block = bytes([0x14, ord("A"), 0x01, 0x00, 0x00])
+
+    with pytest.raises(RoborockException, match="maximum output size"):
+        lz4_block_decompress(block, max_output_size=8)
 
 
 def test_is_map_packet() -> None:
@@ -356,6 +367,16 @@ def test_parse_trace_rejects_misaligned_points() -> None:
         parse_trace_packet(b"\x02\x01" + b"\x00" * 12 + b"\x01\x02\x03")
 
 
+@pytest.mark.parametrize("declared_count", [0, 2])
+def test_parse_trace_rejects_declared_count_mismatch(declared_count: int) -> None:
+    """An aligned body cannot silently disagree with the firmware count."""
+    payload = bytearray(_trace_payload([(10, 20)]))
+    payload[8:10] = declared_count.to_bytes(2, "big")
+
+    with pytest.raises(RoborockException, match="point count"):
+        parse_trace_packet(bytes(payload))
+
+
 def test_parse_rejects_bad_layout_length() -> None:
     payload = bytearray(_payload())
     payload[27:29] = (0xFFFF).to_bytes(2, "big")  # compressed length past the buffer
@@ -363,6 +384,15 @@ def test_parse_rejects_bad_layout_length() -> None:
         parse_map_packet(bytes(payload))
 
 
+def test_parse_rejects_unreasonable_header_dimensions() -> None:
+    payload = bytearray(_payload())
+    payload[7:9] = (65535).to_bytes(2, "big")
+    payload[9:11] = (65535).to_bytes(2, "big")
+
+    with pytest.raises(RoborockException, match="supported grid size"):
+        parse_map_packet(bytes(payload))
+
+
 def test_parse_erase_zones_from_map_packet_tail() -> None:
     """Erase rectangles appended after the grid decode to world polygons."""
     rects = [
@@ -387,6 +417,32 @@ def _carpet_tail(width: int, height: int, carpet: bytes, erase: bytes = bytes([0
     return erase + (width * height).to_bytes(4, "big") + len(block).to_bytes(2, "big") + block
 
 
+def _map_detail_payload(
+    marker: bytes,
+    points: list[tuple[int, int]],
+    *,
+    version: int = 1,
+    opaque_value: int = 2,
+    heading: int = 3,
+    reserved: int = 0,
+    prefix: int = 0,
+    trailing: bytes = b"",
+) -> bytes:
+    """Build a neutral synthetic detail packet from the existing map fixture."""
+    header = (
+        version.to_bytes(2, "big")
+        + opaque_value.to_bytes(4, "big")
+        + len(points).to_bytes(4, "big")
+        + heading.to_bytes(2, "big", signed=True)
+        + reserved.to_bytes(2, "big")
+    )
+    point_table = b"".join(x.to_bytes(2, "big", signed=True) + y.to_bytes(2, "big", signed=True) for x, y in points)
+    history = bytes([prefix]) + header + point_table
+    payload = bytearray(FIXTURE.read_bytes() + _carpet_tail(8, 6, bytes(48)) + history + trailing)
+    payload[:2] = marker
+    return bytes(payload)
+
+
 def test_parse_carpet_mask_from_map_packet_tail() -> None:
     """A carpet mask after the erase section decodes to a same-dims grid.
 
@@ -415,6 +471,82 @@ def test_parse_map_packet_without_carpet() -> None:
     assert parse_map_packet(FIXTURE.read_bytes()).carpet_mask is None
 
 
+def test_classify_current_clean_record_and_saved_map_packets() -> None:
+    """All known map markers retain an explicit semantic kind."""
+    current = FIXTURE.read_bytes()
+    clean_record = _map_detail_payload(b"\x03\x01", [(10, -20)])
+    saved_map = _map_detail_payload(b"\x04\x01", [(10, -20)])
+
+    assert is_map_packet(current)
+    assert parse_map_packet(current).kind is Q10MapPacketKind.CURRENT
+    assert parse_map_packet(clean_record).kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL
+    assert parse_map_packet(saved_map).kind is Q10MapPacketKind.SAVED_MAP_DETAIL
+
+
+def test_parse_clean_record_historical_trace_with_unknown_tail() -> None:
+    """The bounded historical path is decoded without interpreting later bytes."""
+    packet = parse_clean_record_detail(
+        _map_detail_payload(b"\x03\x01", [(10, -20), (-30, 40)], trailing=b"future-section")
+    )
+
+    assert packet.trace is not None
+    assert [(point.x, point.y) for point in packet.trace.points] == [(10, -20), (-30, 40)]
+    assert packet.trace.heading == 3
+    assert packet.trace.robot_position == Q10Point(-30, 40)
+
+
+def test_zero_point_historical_trace_with_following_section() -> None:
+    """A zero-point path remains valid when a later section follows it."""
+    packet = parse_clean_record_detail(_map_detail_payload(b"\x03\x01", [], trailing=b"recorded-path"))
+
+    assert packet.trace is not None
+    assert packet.trace.points == []
+
+
+def test_historical_trace_is_not_inferred_for_other_packet_kinds() -> None:
+    """The validated ``03 01`` layout is not assumed for current or saved maps."""
+    current = parse_map_packet(_map_detail_payload(b"\x01\x01", [(10, -20)]))
+    saved_map = parse_map_packet(_map_detail_payload(b"\x04\x01", [(10, -20)]))
+
+    assert current.kind is Q10MapPacketKind.CURRENT
+    assert saved_map.kind is Q10MapPacketKind.SAVED_MAP_DETAIL
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"version": 2},
+        {"reserved": 1},
+        {"prefix": 1},
+    ],
+)
+def test_unsupported_historical_trace_header_is_ignored(kwargs: dict[str, Any]) -> None:
+    payload = _map_detail_payload(b"\x03\x01", [(10, -20)], **kwargs)
+    packet = parse_clean_record_detail(payload)
+
+    assert packet.trace is None
+
+
+def test_truncated_historical_trace_is_ignored() -> None:
+    payload = _map_detail_payload(b"\x03\x01", [(10, -20)])[:-2]
+    packet = parse_clean_record_detail(payload)
+
+    assert packet.trace is None
+
+
+def test_invalid_erase_section_is_ignored() -> None:
+    """An invalid erase header cannot become an anchor for later sections."""
+    tail = b"\x01\xffopaque-tail"
+    payload = bytearray(FIXTURE.read_bytes() + tail)
+    payload[:2] = b"\x03\x01"
+
+    packet = parse_clean_record_detail(bytes(payload))
+
+    assert packet.map.erase_zones == []
+    assert packet.map.carpet_mask is None
+    assert packet.trace is None
+
+
 def test_carpet_mask_ignored_when_uncompressed_len_mismatches() -> None:
     """If the section doesn't line up (uncompressed_len != w*h) carpet is dropped."""
     carpet = bytes([4] * 48)
@@ -473,3 +605,36 @@ def test_real_fixture_header_calibration_is_keepalive() -> None:
     """The synthetic fixture carries no header origin, so callers fall back to a fit."""
     cal = parse_map_packet(FIXTURE.read_bytes()).header_calibration
     assert cal is not None and cal.is_keepalive
+
+
+@pytest.mark.parametrize("payload", [b"", b"\x01", b"\x00\x01", b"\xff\x01", b"\x01\x02"])
+def test_unknown_map_markers_are_not_current_maps(payload: bytes) -> None:
+    assert Q10MapPacketKind.from_payload(payload) is None
+    with pytest.raises(RoborockException):
+        parse_map_packet(payload)
+
+
+def test_map_kind_unknown_fallback() -> None:
+    assert Q10MapPacketKind(255) is Q10MapPacketKind.unknown
+    assert Q10MapPacketKind.unknown.marker == b""
+
+
+@pytest.mark.parametrize(
+    "points, expected",
+    [
+        ([(0, 0), (1000, 1000), (1001, 1001), (1002, 1002)], [(1000, 1000), (1001, 1001), (1002, 1002)]),
+        ([(0, 0), (1, 1), (2, 2)], [(0, 0), (1, 1), (2, 2)]),
+        ([(0, 0), (1000, 1000)], [(0, 0), (1000, 1000)]),
+    ],
+)
+def test_clean_record_path_stray_point_handling(points: list[tuple[int, int]], expected: list[tuple[int, int]]) -> None:
+    detail = parse_clean_record_detail(_map_detail_payload(b"\x03\x01", points))
+    assert detail.trace is not None
+    assert [(point.x, point.y) for point in detail.trace.points] == expected
+    assert detail.map.grid
+
+
+@pytest.mark.parametrize("marker", [b"\x01\x01", b"\x02\x01", b"\x04\x01"])
+def test_clean_record_parser_rejects_other_packet_kinds(marker: bytes) -> None:
+    with pytest.raises(RoborockException, match="not a Q10 clean-record"):
+        parse_clean_record_detail(marker + FIXTURE.read_bytes()[2:])
diff --git a/tests/map/test_b01_q10_render.py b/tests/map/test_b01_q10_render.py
index c8436aa2f..fed6b1eb2 100644
--- a/tests/map/test_b01_q10_render.py
+++ b/tests/map/test_b01_q10_render.py
@@ -16,8 +16,10 @@
 from roborock.map.b01_grid_layers import GridCalibration
 from roborock.map.b01_q10_map_parser import (
     B01Q10MapParserConfig,
+    Q10CleanRecordDetail,
     Q10EraseZone,
     Q10HeaderCalibration,
+    Q10HistoricalTracePacket,
     Q10MapPacket,
     Q10Point,
     Q10TracePacket,
@@ -58,7 +60,7 @@ def _packet() -> Q10MapPacket:
 def _render(
     packet: Q10MapPacket | None = None,
     *,
-    trace: Q10TracePacket | None = None,
+    trace: Q10TracePacket | Q10HistoricalTracePacket | None = None,
     overlays: Q10MapOverlays | None = None,
 ) -> bytes:
     return render_q10_map(
@@ -117,6 +119,16 @@ def test_render_draws_path_and_position() -> None:
     assert rendered.getpixel(image_position) == (255, 255, 255, 255)
 
 
+def test_render_accepts_historical_trace() -> None:
+    """A validated clean-record path uses the same calibrated drawing path."""
+    packet, live_trace = _calibrated_inputs()
+    historical = Q10HistoricalTracePacket(points=live_trace.points, heading=live_trace.heading)
+
+    archived = Q10CleanRecordDetail(map=packet, trace=historical)
+    assert _render(archived.map, trace=archived.trace) == _render(packet, trace=live_trace)
+    assert _render(archived.map) != _render(archived.map, trace=archived.trace)
+
+
 def test_render_draws_zones_and_virtual_walls() -> None:
     """Decoded DPS overlays are included in the composed image."""
     packet, trace = _calibrated_inputs()
diff --git a/tests/protocols/test_b01_q10_protocol.py b/tests/protocols/test_b01_q10_protocol.py
index db2a8097f..16fe9a108 100644
--- a/tests/protocols/test_b01_q10_protocol.py
+++ b/tests/protocols/test_b01_q10_protocol.py
@@ -15,7 +15,7 @@
 from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
 from roborock.data.code_mappings import completed_warnings
 from roborock.exceptions import RoborockException
-from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket
+from roborock.map.b01_q10_map_parser import Q10CleanRecordDetail, Q10MapPacket, Q10MapPacketKind, Q10TracePacket
 from roborock.protocols.b01_q10_protocol import (
     CleanParams,
     Q10DpsUpdate,
@@ -139,6 +139,27 @@ def test_decode_message_map_packet() -> None:
     assert {room.id: room.name for room in decoded.rooms} == {2: "Living Room", 3: "Bedroom"}
 
 
+@pytest.mark.parametrize(
+    ("marker", "kind"),
+    [
+        (b"\x03\x01", Q10MapPacketKind.CLEAN_RECORD_DETAIL),
+        (b"\x04\x01", Q10MapPacketKind.SAVED_MAP_DETAIL),
+    ],
+)
+def test_decode_message_archived_map_packet(marker: bytes, kind: Q10MapPacketKind) -> None:
+    """The decoder recognizes both archived map-detail markers."""
+    fixture = MAP_FIXTURE.read_bytes()
+    decoded = decode_message(_message(marker + fixture[2:], RoborockMessageProtocol.MAP_RESPONSE))
+
+    if kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL:
+        assert isinstance(decoded, Q10CleanRecordDetail)
+        assert decoded.map.kind is kind
+        assert decoded.trace is None
+    else:
+        assert isinstance(decoded, Q10MapPacket)
+        assert decoded.kind is kind
+
+
 def test_decode_message_trace_packet() -> None:
     """A MAP_RESPONSE 02 01 payload decodes into a Q10TracePacket."""
     message = _message(TRACE_FIXTURE.read_bytes(), RoborockMessageProtocol.MAP_RESPONSE)