From 0d1db723ac1fc021e716ddd6bf4468cf201ca723 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bal=C3=A1zs=20Gunics?= <gunicsba@gmail.com>
Date: Mon, 14 Sep 2026 09:52:43 +0200
Subject: [PATCH 1/3] Add on-demand hydrated DDOP snapshots for debugging

A VT "Snapshot DDOP" button on the Implement page writes a derived copy of
the connected implement's DDOP with live process data values filled in, so
tools such as AgIsoDDOPGenerator can show element offsets, working widths
and similar values that are not stored in the uploaded pool.

- Record the latest value per object ID from value commands (clientsMutex)
- On press, request missing allow-listed values and poll for up to
  requestWaitSeconds without blocking the main loop
- Replace patched DeviceProcessData objects with DeviceProperty objects
  (same ID/DDI/designator), prefix the Device designator with "SNAP " and
  alter the structure label
- Write <NAME>/<label>.SNAP-<timestamp>.iop plus a JSON sidecar next to the
  canonical .ddop; the canonical pool and upload handling are unchanged
- Add a placeholder button (6000/11210) to AOG_TC.iop and an offline test

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CMakeLists.txt                       |  21 ++
 docs/CONCURRENCY.md                  |   6 +
 include/app.hpp                      |   3 +
 include/ddop_hydration.hpp           | 134 ++++++++++
 include/settings.hpp                 |   9 +
 include/task_controller.hpp          |  38 +++
 readme.md                            |  19 +-
 resources/AOG_TC.iop                 | Bin 11949 -> 12004 bytes
 resources/AOG_TC.iop.h               |   2 +
 resources/linux/settings.sample.json |   7 +-
 src/app.cpp                          |  53 +++-
 src/ddop_hydration.cpp               | 366 +++++++++++++++++++++++++++
 src/settings.cpp                     |  36 +++
 src/task_controller.cpp              | 173 ++++++++++++-
 tools/ddop_hydration_test.cpp        | 169 +++++++++++++
 15 files changed, 1032 insertions(+), 4 deletions(-)
 create mode 100644 include/ddop_hydration.hpp
 create mode 100644 src/ddop_hydration.cpp
 create mode 100644 tools/ddop_hydration_test.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6785346..45a3814 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -146,6 +146,27 @@ endif()
 
 install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin COMPONENT applications)
 
+option(AOG_TC_BUILD_TESTS "Build and register the unit tests" ON)
+if(AOG_TC_BUILD_TESTS)
+  enable_testing()
+  add_executable(
+    ddop_hydration_test
+    ${CMAKE_CURRENT_LIST_DIR}/tools/ddop_hydration_test.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ddop_hydration.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/settings.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/logging.cpp)
+  target_compile_features(ddop_hydration_test PRIVATE cxx_std_20)
+  set_target_properties(ddop_hydration_test PROPERTIES CXX_EXTENSIONS OFF)
+  target_include_directories(ddop_hydration_test
+                             PRIVATE ${CMAKE_CURRENT_LIST_DIR}/include)
+  target_compile_definitions(
+    ddop_hydration_test PRIVATE PROJECT_VERSION="${PROJECT_VERSION}"
+                                PROJECT_NAME="${PROJECT_NAME}")
+  target_link_libraries(ddop_hydration_test PRIVATE isobus::Isobus isobus::Utility
+                                                    nlohmann_json::nlohmann_json)
+  add_test(NAME ddop_hydration_snapshot COMMAND ddop_hydration_test)
+endif()
+
 option(AOG_TC_VALIDATE_IOP "Build and register the object pool validator test"
        ON)
 if(AOG_TC_VALIDATE_IOP)
diff --git a/docs/CONCURRENCY.md b/docs/CONCURRENCY.md
index 8df81de..396097e 100644
--- a/docs/CONCURRENCY.md
+++ b/docs/CONCURRENCY.md
@@ -57,6 +57,12 @@ registration point itself defers to an `update()` call, or invokes the listener/
   take `clientsMutex` at its top, even though (per the note above) the `TaskControllerServer`
   overrides may turn out to already be main-thread-only — the lock is cheap insurance and keeps
   every entry point consistent regardless of how the library's internals might change.
+- **Hydrated DDOP snapshot state** (`ClientState`'s shadow values, `MyTCServer::pendingHydration`) —
+  also guarded by `clientsMutex`. `on_value_command()` records values; `begin_hydration_snapshot()`
+  and `poll_hydration_snapshot()` run from `Application::update()`. The snapshot wait is polled,
+  never blocked on: `tcServer->update()` runs in the same main loop, and blocking it would stall the
+  responses being waited for. `poll_hydration_snapshot()` copies what it needs and writes files
+  after releasing the lock. The VT button listener only sets an `std::atomic<bool>`.
 
 ## What's *not* protected yet — known gap
 
diff --git a/include/app.hpp b/include/app.hpp
index d74de11..8d80e15 100644
--- a/include/app.hpp
+++ b/include/app.hpp
@@ -8,6 +8,7 @@
  */
 #pragma once
 
+#include <atomic>
 #include <boost/asio.hpp>
 #include <cstdint>
 #include <map>
@@ -68,6 +69,7 @@ class Application
 	void sync_vt_config_once();
 	void update_vt_section_map();
 	void update_vt_status_strings(bool aogConnected);
+	void update_hydration_snapshot();
 
 	void send_vt_string_if_changed(std::uint16_t objectID, const std::string &value);
 	void send_hardware_message(const std::string &text, std::uint8_t duration, std::uint8_t color);
@@ -96,6 +98,7 @@ class Application
 	bool vtWasConnected = false;
 	bool vtConnectionWarningLogged = false;
 	bool vtCapabilitiesLogged = false;
+	std::atomic<bool> hydrationSnapshotRequested{ false }; ///< Set by the VT button listener, handled in update()
 	std::uint8_t nmea2000SequenceIdentifier = 0;
 	std::uint32_t lastJ1939SpeedTransmit = 0;
 	std::uint32_t lastTCStatusTransmit = 0;
diff --git a/include/ddop_hydration.hpp b/include/ddop_hydration.hpp
new file mode 100644
index 0000000..276ccaa
--- /dev/null
+++ b/include/ddop_hydration.hpp
@@ -0,0 +1,134 @@
+/**
+ * @brief On-demand "hydrated" DDOP snapshots for debugging and visualization
+ *
+ * A client's canonical DDOP describes structure only: DeviceProcessData objects carry no value,
+ * those arrive later as process data value commands. A hydrated snapshot is a derived copy of the
+ * canonical pool in which allow-listed DeviceProcessData objects are replaced by DeviceProperty
+ * objects (same object ID, DDI, designator and presentation) holding the latest known value, so
+ * external tools such as AgIsoDDOPGenerator can show those values.
+ *
+ * Snapshots are never uploaded to a TC and never replace or modify the canonical pool.
+ */
+
+#pragma once
+
+#include "isobus/isobus/can_NAME.hpp"
+#include "isobus/isobus/isobus_device_descriptor_object_pool.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ddop_hydration
+{
+	/// @brief Which objects are eligible for hydration. Configurable through settings.json ("ddopHydration").
+	struct AllowList
+	{
+		bool includeDeviceProperties = true; ///< Tier one: DeviceProperty objects (value already in the pool)
+		std::set<std::uint16_t> processDataDDIs; ///< Tier two: on-change DeviceProcessData DDIs (geometry/configuration-like)
+		std::uint32_t requestWaitSeconds = 7; ///< How long to wait for responses to on-demand value requests
+
+		static constexpr std::uint32_t MIN_REQUEST_WAIT_SECONDS = 1;
+		static constexpr std::uint32_t MAX_REQUEST_WAIT_SECONDS = 60;
+
+		/// @brief Working widths, device element offsets and the reference point to ground distance
+		static AllowList defaults();
+
+		/// @brief DDIs that are never hydrated regardless of configuration: totals and transient state
+		/// such as work states, section control state and actual rates.
+		static bool is_always_excluded(std::uint16_t ddi);
+
+		/// @brief Whether a pool object is eligible for hydration under this allow list
+		bool is_eligible(const isobus::task_controller_object::Object &object) const;
+	};
+
+	/// @brief The latest process data value reported by a client for one object
+	struct ShadowValue
+	{
+		std::int32_t value = 0;
+		std::uint32_t timestamp_ms = 0;
+	};
+
+	/// @brief Latest reported process data values per object ID for one client.
+	/// Not thread-safe on its own; MyTCServer guards it with clientsMutex.
+	class ShadowValueStore
+	{
+	public:
+		void record(std::uint16_t objectID, std::int32_t value);
+		bool try_get(std::uint16_t objectID, ShadowValue &shadowValue) const;
+
+	private:
+		std::map<std::uint16_t, ShadowValue> values;
+	};
+
+	/// @brief Maps the (DDI, element number) addressing of process data messages to DDOP object IDs
+	class ProcessDataIndex
+	{
+	public:
+		void build(isobus::DeviceDescriptorObjectPool &pool);
+		bool try_get_object_id(std::uint16_t ddi, std::uint16_t elementNumber, std::uint16_t &objectID) const;
+		bool try_get_element_number(std::uint16_t objectID, std::uint16_t &elementNumber) const;
+
+	private:
+		std::map<std::pair<std::uint16_t, std::uint16_t>, std::uint16_t> ddiAndElementToObjectID;
+		std::map<std::uint16_t, std::uint16_t> objectIDToElementNumber;
+	};
+
+	/// @brief Where a snapshot object's value came from
+	enum class ValueSource : std::uint8_t
+	{
+		Pool, ///< DeviceProperty, value taken from the canonical pool as-is
+		Live, ///< Shadow value that was already known when the snapshot was requested
+		Requested, ///< Value arrived after an on-demand value request
+		NoResponse, ///< Value was requested but did not arrive in time
+		NotRequestable ///< DeviceProcessData that no device element references, so it cannot be addressed
+	};
+
+	const char *to_string(ValueSource source);
+
+	struct SnapshotEntry
+	{
+		static constexpr std::uint16_t NO_ELEMENT = 0xFFFF;
+
+		std::uint16_t objectID = 0;
+		std::uint16_t ddi = 0;
+		std::uint16_t elementNumber = NO_ELEMENT;
+		ValueSource source = ValueSource::NoResponse;
+		std::int32_t value = 0; ///< Only meaningful for Pool, Live and Requested
+	};
+
+	struct SnapshotInput
+	{
+		std::vector<std::vector<std::uint8_t>> canonicalPoolChunks; ///< The client's DDOP exactly as uploaded
+		std::uint8_t taskControllerCompatibilityLevel = 0;
+		std::uint64_t clientName = 0;
+		std::string fileStem; ///< Relative to the settings directory, e.g. "<NAME>/<label>"; the canonical pool is "<fileStem>.ddop"
+		std::vector<SnapshotEntry> entries;
+	};
+
+	struct SnapshotResult
+	{
+		bool success = false;
+		std::string ddopPath;
+		std::string metadataPath;
+		std::size_t patchedObjects = 0;
+		std::size_t missingValues = 0;
+		std::string error;
+	};
+
+	/// @brief Prefix added to the Device designator of a snapshot
+	constexpr const char *SNAPSHOT_DESIGNATOR_PREFIX = "SNAP ";
+	/// @brief Marker in snapshot file names: "<label>.SNAP-<timestamp>.iop" next to "<label>.ddop"
+	constexpr const char *SNAPSHOT_FILENAME_MARKER = ".SNAP-";
+
+	/// @brief Clones the canonical pool, patches in the entries' values and writes the snapshot plus a JSON sidecar
+	SnapshotResult write_snapshot(const SnapshotInput &input);
+
+	/// @brief Whether a file is a hydrated snapshot (or its sidecar) rather than a canonical pool.
+	/// Anything that ever loads stored pools must skip these.
+	bool is_snapshot_file(const std::filesystem::path &path);
+} // namespace ddop_hydration
diff --git a/include/settings.hpp b/include/settings.hpp
index 06f0278..8940a0a 100644
--- a/include/settings.hpp
+++ b/include/settings.hpp
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include "ddop_hydration.hpp"
+
 #include <array>
 #include <cstdint>
 #include <mutex>
@@ -140,6 +142,12 @@ class Settings
 	 */
 	bool set_country_code(std::string code, bool save = true);
 
+	/**
+	 * @brief Get the allow list used for hydrated DDOP snapshots ("ddopHydration")
+	 * @return The allow list (by value; the copy is made under the lock)
+	 */
+	ddop_hydration::AllowList get_ddop_hydration_allow_list() const;
+
 	/**
 	 * @brief Get the absolute path to the settings file
 	 * @param filename The filename to get the path for
@@ -172,4 +180,5 @@ class Settings
 	std::uint8_t tcVersion = DEFAULT_TC_VERSION;
 	std::string languageCode = DEFAULT_LANGUAGE_CODE;
 	std::string countryCode = DEFAULT_COUNTRY_CODE;
+	ddop_hydration::AllowList ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
 };
diff --git a/include/task_controller.hpp b/include/task_controller.hpp
index 705605e..9cf4cb3 100644
--- a/include/task_controller.hpp
+++ b/include/task_controller.hpp
@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include "ddop_hydration.hpp"
 #include "isobus/isobus/isobus_data_dictionary.hpp"
 #include "isobus/isobus/isobus_device_descriptor_object_pool.hpp"
 #include "isobus/isobus/isobus_standard_data_description_indices.hpp"
@@ -16,8 +17,11 @@
 
 #include <cstdint>
 #include <map>
+#include <memory>
 #include <mutex>
+#include <optional>
 #include <queue>
+#include <string>
 
 constexpr std::uint8_t NUMBER_SECTIONS_PER_CONDENSED_MESSAGE = 16;
 
@@ -62,9 +66,19 @@ class ClientState
 	// Element work state management these act like master / override for actual sections
 	void set_element_work_state(std::uint16_t elementNumber, bool isWorking);
 	bool try_get_element_work_state(std::uint16_t elementNumber, bool &isWorking) const;
+	// Hydrated DDOP snapshot support, see ddop_hydration.hpp
+	void set_canonical_pool(std::vector<std::vector<std::uint8_t>> chunks, std::string fileStem);
+	const std::vector<std::vector<std::uint8_t>> &get_canonical_pool_chunks() const;
+	const std::string &get_canonical_file_stem() const;
+	ddop_hydration::ProcessDataIndex &get_process_data_index();
+	ddop_hydration::ShadowValueStore &get_shadow_values();
 
 private:
 	isobus::DeviceDescriptorObjectPool pool; ///< The device descriptor object pool (DDOP) for the TC
+	std::shared_ptr<const std::vector<std::vector<std::uint8_t>>> canonicalPoolChunks; ///< The DDOP exactly as uploaded, shared so get_clients() copies stay cheap
+	std::string canonicalFileStem; ///< "<NAME>/<label>"; the canonical pool is stored as "<stem>.ddop"
+	ddop_hydration::ProcessDataIndex processDataIndex; ///< (DDI, element number) -> object ID
+	ddop_hydration::ShadowValueStore shadowValues; ///< Latest reported process data values by object ID
 	bool areMeasurementCommandsSent = false; ///< Whether or not the measurement commands have been sent
 	std::map<isobus::DataDescriptionIndex, std::uint16_t> ddiToElementNumber; ///< Mapping of DDI to element number // TODO: better way to do this?
 
@@ -116,13 +130,37 @@ class MyTCServer : public isobus::TaskControllerServer
 	void update_section_states(std::vector<bool> &sectionStates);
 	void update_section_control_enabled(bool enabled);
 
+	enum class HydrationStartResult
+	{
+		Started,
+		AlreadyRunning,
+		UnknownClient
+	};
+
+	/// @brief Starts a hydrated DDOP snapshot for a client. Sends value requests for allow-listed
+	/// objects without a known value; does not block. Finish it with poll_hydration_snapshot().
+	HydrationStartResult begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client, const ddop_hydration::AllowList &allowList);
+
+	/// @brief Call from the main loop. Once the request wait has elapsed, writes the snapshot and returns true.
+	/// @param[out] result The outcome of the finished snapshot, only set when this returns true
+	bool poll_hydration_snapshot(ddop_hydration::SnapshotResult &result);
+
 private:
+	struct PendingHydration
+	{
+		std::shared_ptr<isobus::ControlFunction> client;
+		std::vector<ddop_hydration::SnapshotEntry> entries;
+		std::uint32_t startedAt_ms = 0;
+		std::uint32_t wait_ms = 0;
+	};
+
 	void send_section_setpoint_states(std::shared_ptr<isobus::ControlFunction> client, std::uint8_t ddiOffset);
 	void send_section_control_state(std::shared_ptr<isobus::ControlFunction> client, bool enabled);
 	bool is_ddi_settable(std::shared_ptr<isobus::ControlFunction> client, std::uint16_t ddi);
 
 	std::map<std::shared_ptr<isobus::ControlFunction>, ClientState> clients;
 	std::map<std::shared_ptr<isobus::ControlFunction>, std::queue<std::vector<std::uint8_t>>> uploadedPools;
+	std::optional<PendingHydration> pendingHydration; ///< Guarded by clientsMutex
 
 	/// @brief Guards clients and uploadedPools.
 	///
diff --git a/readme.md b/readme.md
index 806746c..bdbbd12 100644
--- a/readme.md
+++ b/readme.md
@@ -62,6 +62,9 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
 | `tcVersion` | `integer` | `3` | Task Controller version code, from `0` through `4`; `3` is Second Edition Draft. |
 | `languageCode` | `string` | `"en"` | Two-character language code advertised on ISOBUS. |
 | `countryCode` | `string` | `"US"` | Two-character country code advertised on ISOBUS. |
+| `ddopHydration.includeDeviceProperties` | `bool` | `true` | Lists DeviceProperty values in hydrated DDOP snapshots. |
+| `ddopHydration.processDataDdis` | `int[]` | `[67, 68, 70, 134, 135, 136, 180]` | On-change DeviceProcessData DDIs whose live values are written into hydrated DDOP snapshots. Totals, work states, section control state and actual rates are always excluded. |
+| `ddopHydration.requestWaitSeconds` | `integer` | `7` | How long a snapshot waits for answers to value requests, `1` through `60`. |
 
 ### Example `settings.json`
 
@@ -74,10 +77,24 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
   "vtEnabled": true,
   "tcVersion": 3,
   "languageCode": "en",
-  "countryCode": "US"
+  "countryCode": "US",
+  "ddopHydration": {
+    "includeDeviceProperties": true,
+    "processDataDdis": [67, 68, 70, 134, 135, 136, 180],
+    "requestWaitSeconds": 7
+  }
 }
 ```
 
+### Hydrated DDOP snapshots
+
+Many implement values, such as element offsets and working width, are not stored in the DDOP; the implement reports them as process data once it is running. The **Snapshot DDOP** button on the VT Implement page writes a copy of the connected implement's DDOP with those values filled in, for viewing in tools such as AgIsoDDOPGenerator.
+
+- Values that were already reported are used directly. For the rest, the TC sends value requests and waits `requestWaitSeconds` for answers.
+- Allow-listed DeviceProcessData objects with a value are replaced by DeviceProperty objects with the same object ID, DDI and designator. The Device designator gets a `SNAP ` prefix and the structure label is changed.
+- The snapshot is stored next to the canonical pool as `<NAME>/<label>.SNAP-<timestamp>.iop`, with a `.json` file that lists every object, its value and where the value came from.
+- Snapshots are for debugging only: never upload one to a TC. The canonical `<label>.ddop` is not changed.
+
 ### Virtual Terminal compatibility
 
 The VT object pool is embedded in the executable and automatically scales from its authored 480-pixel data mask and 80-pixel softkey designator to the connected terminal. It uses five virtual navigation softkeys. A VT with fewer than five physical keys must support softkey paging.
diff --git a/resources/AOG_TC.iop b/resources/AOG_TC.iop
index d90ab25e8fc02e18456eb11aa18f0b159c7f7cc0..4c01a8be29c2b62b00fc0acad2e8dee4173cc6b3 100644
GIT binary patch
delta 73
zcmZ1*`y_V4Ek^E%w{6)9#6K{!F>aP%oT_VBAkKD&L4$!23{PouF>o-P(&j$FAi=<R
aGm`QDe@0%0;Jn0w;*9(f1s50p00sb1#ub17

delta 16
YcmaD7yEb;hEk>@1w{17eF;3M507JM2{r~^~

diff --git a/resources/AOG_TC.iop.h b/resources/AOG_TC.iop.h
index 8a12fbd..3278489 100644
--- a/resources/AOG_TC.iop.h
+++ b/resources/AOG_TC.iop.h
@@ -20,6 +20,7 @@
 #define NavImplement                       5004
 #define NavDiagnostics                     5005
 #define NavConfig                          5006
+#define ImplementSnapshotButton            6000
 #define VTControlFunctionsStr              8000
 #define InputList_10000                   10000
 #define ConfigHydliftAuxN                 10001
@@ -56,6 +57,7 @@
 #define ImplementHint                     11207
 #define ImplementBoomOffsetLabel          11208
 #define ImplementBoomOffset               11209
+#define ImplementSnapshotLabel            11210
 #define DiagnosticsTitle                  11300
 #define DiagnosticsLabels                 11301
 #define DiagnosticsValues                 11302
diff --git a/resources/linux/settings.sample.json b/resources/linux/settings.sample.json
index 5890033..228d81a 100644
--- a/resources/linux/settings.sample.json
+++ b/resources/linux/settings.sample.json
@@ -6,5 +6,10 @@
     "vtEnabled": true,
     "tcVersion": 3,
     "languageCode": "en",
-    "countryCode": "US"
+    "countryCode": "US",
+    "ddopHydration": {
+        "includeDeviceProperties": true,
+        "processDataDdis": [67, 68, 70, 134, 135, 136, 180],
+        "requestWaitSeconds": 7
+    }
 }
diff --git a/src/app.cpp b/src/app.cpp
index 3e9877e..54a1ee4 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -565,6 +565,7 @@ bool Application::update()
 
 	tcServer->request_measurement_commands();
 	tcServer->update();
+	update_hydration_snapshot();
 	if (tcFunctionalities)
 		tcFunctionalities->update();
 	if (tecuFunctionalities)
@@ -882,6 +883,50 @@ void Application::send_task_controller_status_message()
 	lastTCStatusTransmit = transmitAttemptTimestamp;
 }
 
+void Application::update_hydration_snapshot()
+{
+	if (hydrationSnapshotRequested.exchange(false))
+	{
+		auto clients = tcServer->get_clients(); // snapshot copy — see get_clients()'s declaration
+		if (clients.empty())
+		{
+			send_hardware_message("DDOP snapshot: no implement connected", 5, HW_MSG_ALERT);
+		}
+		else
+		{
+			// Same client the Implement page shows, see update_vt_status_strings()
+			switch (tcServer->begin_hydration_snapshot(clients.begin()->first, settings->get_ddop_hydration_allow_list()))
+			{
+				case MyTCServer::HydrationStartResult::Started:
+					send_hardware_message("DDOP snapshot started", 5, HW_MSG_INFO);
+					break;
+				case MyTCServer::HydrationStartResult::AlreadyRunning:
+					send_hardware_message("DDOP snapshot already in progress", 5, HW_MSG_INFO);
+					break;
+				case MyTCServer::HydrationStartResult::UnknownClient:
+					send_hardware_message("DDOP snapshot: implement not active", 5, HW_MSG_ALERT);
+					break;
+			}
+		}
+	}
+
+	ddop_hydration::SnapshotResult result;
+	if (tcServer->poll_hydration_snapshot(result))
+	{
+		if (result.success)
+		{
+			log("TC Server") << "Saved hydrated DDOP snapshot: " << result.ddopPath << " (" << result.patchedObjects << " values patched, "
+			                 << result.missingValues << " missing, details in " << result.metadataPath << ")" << std::endl;
+			send_hardware_message("DDOP snapshot saved: " + std::to_string(result.patchedObjects) + " values, " + std::to_string(result.missingValues) + " missing", 10, HW_MSG_INFO);
+		}
+		else
+		{
+			log("TC Server") << "Hydrated DDOP snapshot failed: " << result.error << std::endl;
+			send_hardware_message("DDOP snapshot failed: " + result.error, 10, HW_MSG_ALERT);
+		}
+	}
+}
+
 void Application::setup_vt_client()
 {
 	vtObjectPool.assign(std::begin(AOG_TC_IOP_DATA), std::end(AOG_TC_IOP_DATA));
@@ -937,8 +982,14 @@ void Application::setup_vt_client()
 			log("VT") << "Navigating to mask " << targetMask << std::endl;
 		}
 	});
-	vtClient->get_vt_button_event_dispatcher().add_listener([](const isobus::VirtualTerminalClient::VTKeyEvent &event) {
+	vtClient->get_vt_button_event_dispatcher().add_listener([this](const isobus::VirtualTerminalClient::VTKeyEvent &event) {
 		log("VT") << "Button event, key=" << static_cast<int>(event.keyNumber) << std::endl;
+		if ((event.objectID == ImplementSnapshotButton) &&
+		    (event.keyEvent == isobus::VirtualTerminalClient::KeyActivationCode::ButtonPressedOrLatched))
+		{
+			// Only flag it: this runs on the CAN thread, the snapshot is driven from update()
+			hydrationSnapshotRequested = true;
+		}
 	});
 	vtUpdateHelper = std::make_unique<isobus::VirtualTerminalClientUpdateHelper>(vtClient);
 	vtUpdateHelper->add_tracked_numeric_value(VTSpeedValue, 0);
diff --git a/src/ddop_hydration.cpp b/src/ddop_hydration.cpp
new file mode 100644
index 0000000..45d6df6
--- /dev/null
+++ b/src/ddop_hydration.cpp
@@ -0,0 +1,366 @@
+/**
+ * @brief On-demand "hydrated" DDOP snapshots for debugging and visualization
+ */
+#include "ddop_hydration.hpp"
+#include "settings.hpp"
+
+#include "isobus/isobus/isobus_data_dictionary.hpp"
+#include "isobus/isobus/isobus_standard_data_description_indices.hpp"
+#include "isobus/utility/system_timing.hpp"
+
+#include <ctime>
+#include <fstream>
+#include <iomanip>
+#include <nlohmann/json.hpp>
+#include <sstream>
+
+using json = nlohmann::json;
+
+namespace ddop_hydration
+{
+	namespace
+	{
+		using isobus::DataDescriptionIndex;
+		using isobus::task_controller_object::DeviceProcessDataObject;
+		using isobus::task_controller_object::DevicePropertyObject;
+		using isobus::task_controller_object::ObjectTypes;
+
+		constexpr std::size_t MAX_DESIGNATOR_LENGTH = 32; // TC version 3 limit; also valid for version 4
+
+		bool ddi_in_range(std::uint16_t ddi, DataDescriptionIndex first, DataDescriptionIndex last)
+		{
+			return (ddi >= static_cast<std::uint16_t>(first)) && (ddi <= static_cast<std::uint16_t>(last));
+		}
+
+		std::string local_timestamp(const char *format)
+		{
+			const std::time_t now = std::time(nullptr);
+			std::tm localTime{};
+#if defined(_WIN32)
+			localtime_s(&localTime, &now);
+#else
+			localtime_r(&now, &localTime);
+#endif
+			std::ostringstream stream;
+			stream << std::put_time(&localTime, format);
+			return stream.str();
+		}
+
+		std::string to_hex(const std::string &bytes)
+		{
+			std::ostringstream stream;
+			for (unsigned char byte : bytes)
+			{
+				stream << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
+			}
+			return stream.str();
+		}
+
+		bool write_file(const std::string &path, const char *data, std::size_t size, std::ios::openmode mode)
+		{
+			std::ofstream file(path, mode | std::ios::trunc);
+			if (!file.is_open())
+			{
+				return false;
+			}
+			file.write(data, static_cast<std::streamsize>(size));
+			return file.good();
+		}
+	} // namespace
+
+	AllowList AllowList::defaults()
+	{
+		AllowList allowList;
+		allowList.processDataDDIs = {
+			static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkingWidth),
+			static_cast<std::uint16_t>(DataDescriptionIndex::DefaultWorkingWidth),
+			static_cast<std::uint16_t>(DataDescriptionIndex::MaximumWorkingWidth),
+			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetX),
+			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetY),
+			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetZ),
+			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceReferencePointDRPtoGroundDistance),
+		};
+		return allowList;
+	}
+
+	bool AllowList::is_always_excluded(std::uint16_t ddi)
+	{
+		if ((ddi == static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::SetpointWorkState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::SectionControlState)) ||
+		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::PrescriptionControlState)) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::ActualCondensedWorkState1_16, DataDescriptionIndex::ActualCondensedWorkState241_256) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::SetpointCondensedWorkState1_16, DataDescriptionIndex::SetpointCondensedWorkState241_256) ||
+		    ddi_in_range(ddi, DataDescriptionIndex::CondensedSectionOverrideState1_16, DataDescriptionIndex::CondensedSectionOverrideState241_256))
+		{
+			return true;
+		}
+
+		// Totals and actual rates change continuously, so a snapshot of them is meaningless as structure.
+		const std::string &name = isobus::DataDictionary::get_entry(ddi).name;
+		const bool isTotal = (name.find("Total") != std::string::npos);
+		const bool isActualRate = (name.rfind("Actual", 0) == 0) && (name.find("Rate") != std::string::npos);
+		return isTotal || isActualRate;
+	}
+
+	bool AllowList::is_eligible(const isobus::task_controller_object::Object &object) const
+	{
+		switch (object.get_object_type())
+		{
+			case ObjectTypes::DeviceProperty:
+			{
+				const auto &property = static_cast<const DevicePropertyObject &>(object);
+				return includeDeviceProperties && !is_always_excluded(property.get_ddi());
+			}
+
+			case ObjectTypes::DeviceProcessData:
+			{
+				const auto &processData = static_cast<const DeviceProcessDataObject &>(object);
+				// has_trigger_method() is not const in AgIsoStack, so test the bitfield directly
+				const std::uint8_t triggers = processData.get_trigger_methods_bitfield();
+				return (0 == (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::Total))) &&
+				  (0 != (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::OnChange))) &&
+				  !is_always_excluded(processData.get_ddi()) &&
+				  (processDataDDIs.count(processData.get_ddi()) > 0);
+			}
+
+			default:
+				return false;
+		}
+	}
+
+	void ShadowValueStore::record(std::uint16_t objectID, std::int32_t value)
+	{
+		values[objectID] = { value, isobus::SystemTiming::get_timestamp_ms() };
+	}
+
+	bool ShadowValueStore::try_get(std::uint16_t objectID, ShadowValue &shadowValue) const
+	{
+		auto it = values.find(objectID);
+		if (it == values.end())
+		{
+			return false;
+		}
+		shadowValue = it->second;
+		return true;
+	}
+
+	void ProcessDataIndex::build(isobus::DeviceDescriptorObjectPool &pool)
+	{
+		ddiAndElementToObjectID.clear();
+		objectIDToElementNumber.clear();
+
+		for (std::uint16_t i = 0; i < pool.size(); i++)
+		{
+			auto object = pool.get_object_by_index(i);
+			if (!object || (object->get_object_type() != ObjectTypes::DeviceElement))
+			{
+				continue;
+			}
+
+			auto element = std::static_pointer_cast<isobus::task_controller_object::DeviceElementObject>(object);
+			for (std::uint16_t childID : element->get_child_object_ids())
+			{
+				auto child = pool.get_object_by_id(childID);
+				if (!child)
+				{
+					continue;
+				}
+
+				std::uint16_t ddi;
+				if (child->get_object_type() == ObjectTypes::DeviceProcessData)
+				{
+					ddi = std::static_pointer_cast<DeviceProcessDataObject>(child)->get_ddi();
+				}
+				else if (child->get_object_type() == ObjectTypes::DeviceProperty)
+				{
+					ddi = std::static_pointer_cast<DevicePropertyObject>(child)->get_ddi();
+				}
+				else
+				{
+					continue;
+				}
+
+				ddiAndElementToObjectID.emplace(std::make_pair(ddi, element->get_element_number()), childID);
+				objectIDToElementNumber.emplace(childID, element->get_element_number());
+			}
+		}
+	}
+
+	bool ProcessDataIndex::try_get_object_id(std::uint16_t ddi, std::uint16_t elementNumber, std::uint16_t &objectID) const
+	{
+		auto it = ddiAndElementToObjectID.find(std::make_pair(ddi, elementNumber));
+		if (it == ddiAndElementToObjectID.end())
+		{
+			return false;
+		}
+		objectID = it->second;
+		return true;
+	}
+
+	bool ProcessDataIndex::try_get_element_number(std::uint16_t objectID, std::uint16_t &elementNumber) const
+	{
+		auto it = objectIDToElementNumber.find(objectID);
+		if (it == objectIDToElementNumber.end())
+		{
+			return false;
+		}
+		elementNumber = it->second;
+		return true;
+	}
+
+	const char *to_string(ValueSource source)
+	{
+		switch (source)
+		{
+			case ValueSource::Pool:
+				return "pool";
+			case ValueSource::Live:
+				return "live";
+			case ValueSource::Requested:
+				return "requested";
+			case ValueSource::NoResponse:
+				return "no_response";
+			case ValueSource::NotRequestable:
+				return "not_requestable";
+		}
+		return "unknown";
+	}
+
+	SnapshotResult write_snapshot(const SnapshotInput &input)
+	{
+		SnapshotResult result;
+
+		// Deserialize a fresh copy: pools copied through ClientState share their objects with the canonical pool.
+		isobus::DeviceDescriptorObjectPool pool;
+		pool.set_task_controller_compatibility_level(input.taskControllerCompatibilityLevel);
+		for (const auto &chunk : input.canonicalPoolChunks)
+		{
+			if (!pool.deserialize_binary_object_pool(chunk.data(), static_cast<std::uint32_t>(chunk.size()), isobus::NAME(input.clientName)))
+			{
+				result.error = "failed to deserialize canonical pool";
+				return result;
+			}
+		}
+
+		std::shared_ptr<isobus::task_controller_object::DeviceObject> device;
+		for (std::uint16_t i = 0; (i < pool.size()) && !device; i++)
+		{
+			auto object = pool.get_object_by_index(i);
+			if (object && (object->get_object_type() == ObjectTypes::Device))
+			{
+				device = std::static_pointer_cast<isobus::task_controller_object::DeviceObject>(object);
+			}
+		}
+		if (!device)
+		{
+			result.error = "pool has no Device object";
+			return result;
+		}
+
+		// Mark the snapshot so neither people nor a stored-pool lookup mistake it for the canonical upload.
+		const std::string canonicalDesignator = device->get_designator();
+		const std::string canonicalStructureLabel = device->get_structure_label();
+		device->set_designator((SNAPSHOT_DESIGNATOR_PREFIX + canonicalDesignator).substr(0, MAX_DESIGNATOR_LENGTH));
+		const std::string snapshotStructureLabel = "SNAP" + canonicalStructureLabel.substr(0, 3);
+		device->set_structure_label(snapshotStructureLabel);
+
+		json objects = json::array();
+		for (const auto &entry : input.entries)
+		{
+			const bool hasValue = (entry.source == ValueSource::Pool) || (entry.source == ValueSource::Live) || (entry.source == ValueSource::Requested);
+			bool patched = false;
+
+			if (hasValue && (entry.source != ValueSource::Pool))
+			{
+				auto object = pool.get_object_by_id(entry.objectID);
+				if (object && (object->get_object_type() == ObjectTypes::DeviceProcessData))
+				{
+					auto processData = std::static_pointer_cast<DeviceProcessDataObject>(object);
+					const std::string designator = processData->get_designator();
+					const std::uint16_t presentationID = processData->get_device_value_presentation_object_id();
+
+					// The parent element keeps referencing the same object ID, so the hierarchy stays intact.
+					pool.remove_object_by_id(entry.objectID);
+					patched = pool.add_device_property(designator, entry.value, entry.ddi, presentationID, entry.objectID);
+					if (!patched)
+					{
+						result.error = "failed to replace object " + std::to_string(entry.objectID);
+						return result;
+					}
+					result.patchedObjects++;
+				}
+			}
+			else if (!hasValue)
+			{
+				result.missingValues++;
+			}
+
+			json item = {
+				{ "objectId", entry.objectID },
+				{ "ddi", entry.ddi },
+				{ "ddiName", isobus::DataDictionary::get_entry(entry.ddi).name },
+				{ "elementNumber", (entry.elementNumber == SnapshotEntry::NO_ELEMENT) ? json(nullptr) : json(entry.elementNumber) },
+				{ "source", to_string(entry.source) },
+				{ "value", hasValue ? json(entry.value) : json(nullptr) },
+				{ "patchedToDeviceProperty", patched },
+			};
+			objects.push_back(item);
+		}
+
+		std::vector<std::uint8_t> binaryPool;
+		if (!pool.generate_binary_object_pool(binaryPool))
+		{
+			result.error = "failed to generate snapshot pool";
+			return result;
+		}
+
+		const std::string createdAt = local_timestamp("%Y-%m-%dT%H:%M:%S");
+		const std::string snapshotStem = input.fileStem + SNAPSHOT_FILENAME_MARKER + local_timestamp("%Y%m%d-%H%M%S");
+		result.ddopPath = Settings::get_filename_path(snapshotStem + ".iop");
+		result.metadataPath = Settings::get_filename_path(snapshotStem + ".json");
+
+		std::ostringstream clientName;
+		clientName << "0x" << std::hex << std::setw(16) << std::setfill('0') << input.clientName;
+
+		json metadata = {
+			{ "kind", "AOG-TaskController hydrated DDOP snapshot" },
+			{ "notForReupload", true },
+			{ "note",
+			  "Derived debugging artifact, not an original upload. Allow-listed DeviceProcessData objects with a known value "
+			  "were replaced by DeviceProperty objects with the same object ID, DDI, designator and presentation. "
+			  "The Device designator is prefixed with 'SNAP ' and the structure label is altered. Never upload this pool to a TC." },
+			{ "createdAt", createdAt },
+			{ "clientName", clientName.str() },
+			{ "canonicalPool", input.fileStem + ".ddop" },
+			{ "canonicalDesignator", canonicalDesignator },
+			{ "canonicalStructureLabelHex", to_hex(canonicalStructureLabel) },
+			{ "snapshotStructureLabelHex", to_hex(snapshotStructureLabel) },
+			{ "taskControllerCompatibilityLevel", input.taskControllerCompatibilityLevel },
+			{ "patchedObjects", result.patchedObjects },
+			{ "missingValues", result.missingValues },
+			{ "objects", objects },
+		};
+		// Designators come from the implement and are not guaranteed to be valid UTF-8.
+		const std::string metadataText = metadata.dump(4, ' ', false, json::error_handler_t::replace);
+
+		if (!write_file(result.ddopPath, reinterpret_cast<const char *>(binaryPool.data()), binaryPool.size(), std::ios::binary))
+		{
+			result.error = "unable to write " + result.ddopPath;
+			return result;
+		}
+		if (!write_file(result.metadataPath, metadataText.data(), metadataText.size(), std::ios::out))
+		{
+			result.error = "unable to write " + result.metadataPath;
+			return result;
+		}
+
+		result.success = true;
+		return result;
+	}
+
+	bool is_snapshot_file(const std::filesystem::path &path)
+	{
+		return path.filename().string().find(SNAPSHOT_FILENAME_MARKER) != std::string::npos;
+	}
+} // namespace ddop_hydration
diff --git a/src/settings.cpp b/src/settings.cpp
index 960927a..4ede22c 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -9,6 +9,7 @@
 #include "settings.hpp"
 #include "logging_utils.hpp"
 
+#include <algorithm>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
@@ -131,6 +132,30 @@ bool Settings::load()
 		countryCode = DEFAULT_COUNTRY_CODE;
 	}
 
+	ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
+	if (data.contains("ddopHydration"))
+	{
+		try
+		{
+			const auto &section = data["ddopHydration"];
+			auto &allowList = ddopHydrationAllowList;
+			allowList.includeDeviceProperties = section.value("includeDeviceProperties", allowList.includeDeviceProperties);
+			if (section.contains("processDataDdis"))
+			{
+				const auto ddis = section["processDataDdis"].get<std::vector<std::uint16_t>>();
+				allowList.processDataDDIs = std::set<std::uint16_t>(ddis.begin(), ddis.end());
+			}
+			allowList.requestWaitSeconds = std::clamp(section.value("requestWaitSeconds", allowList.requestWaitSeconds),
+			                                          ddop_hydration::AllowList::MIN_REQUEST_WAIT_SECONDS,
+			                                          ddop_hydration::AllowList::MAX_REQUEST_WAIT_SECONDS);
+		}
+		catch (const nlohmann::json::exception &e)
+		{
+			std::cout << "[" << get_timestamp() << "] Error parsing 'ddopHydration': " << e.what() << std::endl;
+			ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
+		}
+	}
+
 	return true;
 }
 
@@ -146,6 +171,11 @@ bool Settings::save() const
 	data["tcVersion"] = tcVersion;
 	data["languageCode"] = languageCode;
 	data["countryCode"] = countryCode;
+	data["ddopHydration"] = {
+		{ "includeDeviceProperties", ddopHydrationAllowList.includeDeviceProperties },
+		{ "processDataDdis", ddopHydrationAllowList.processDataDDIs },
+		{ "requestWaitSeconds", ddopHydrationAllowList.requestWaitSeconds },
+	};
 
 	const std::filesystem::path settingsPath(get_filename_path("settings.json"));
 	std::filesystem::path temporaryPath = settingsPath;
@@ -331,6 +361,12 @@ bool Settings::set_country_code(std::string code, bool save)
 	return true;
 }
 
+ddop_hydration::AllowList Settings::get_ddop_hydration_allow_list() const
+{
+	std::scoped_lock lock(settingsMutex);
+	return ddopHydrationAllowList;
+}
+
 namespace
 {
 	std::filesystem::path get_base_config_dir()
diff --git a/src/task_controller.cpp b/src/task_controller.cpp
index 660da73..51ab7b2 100644
--- a/src/task_controller.cpp
+++ b/src/task_controller.cpp
@@ -12,6 +12,7 @@
 
 #include "isobus/isobus/isobus_device_descriptor_object_pool_helpers.hpp"
 #include "isobus/isobus/isobus_task_controller_server.hpp"
+#include "isobus/utility/system_timing.hpp"
 
 #include <bitset>
 #include <fstream>
@@ -202,6 +203,33 @@ void ClientState::mark_measurement_commands_sent()
 	areMeasurementCommandsSent = true;
 }
 
+void ClientState::set_canonical_pool(std::vector<std::vector<std::uint8_t>> chunks, std::string fileStem)
+{
+	canonicalPoolChunks = std::make_shared<const std::vector<std::vector<std::uint8_t>>>(std::move(chunks));
+	canonicalFileStem = std::move(fileStem);
+}
+
+const std::vector<std::vector<std::uint8_t>> &ClientState::get_canonical_pool_chunks() const
+{
+	static const std::vector<std::vector<std::uint8_t>> noChunks;
+	return canonicalPoolChunks ? *canonicalPoolChunks : noChunks;
+}
+
+const std::string &ClientState::get_canonical_file_stem() const
+{
+	return canonicalFileStem;
+}
+
+ddop_hydration::ProcessDataIndex &ClientState::get_process_data_index()
+{
+	return processDataIndex;
+}
+
+ddop_hydration::ShadowValueStore &ClientState::get_shadow_values()
+{
+	return shadowValues;
+}
+
 std::uint16_t ClientState::get_element_number_for_ddi(isobus::DataDescriptionIndex ddi) const
 {
 	auto it = ddiToElementNumber.find(ddi);
@@ -365,11 +393,13 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 	state.get_pool().set_task_controller_compatibility_level(static_cast<std::uint8_t>(TaskControllerVersion::SecondEditionDraft));
 
 	bool deserialized = false;
+	std::vector<std::vector<std::uint8_t>> canonicalPoolChunks;
 	while (!uploadedPools[partnerCF].empty())
 	{
 		auto binaryPool = uploadedPools[partnerCF].front();
 		uploadedPools[partnerCF].pop();
 		deserialized = state.get_pool().deserialize_binary_object_pool(binaryPool.data(), static_cast<std::uint32_t>(binaryPool.size()), partnerCF->get_NAME());
+		canonicalPoolChunks.push_back(std::move(binaryPool));
 	}
 	if (deserialized)
 	{
@@ -409,7 +439,9 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 		auto it = std::find_if(label.begin(), label.end(), [](unsigned char c) { return c < 0x20 || c >= 0x7F; });
 		label.erase(it, label.end());
 
-		auto fileName = std::to_string(partnerCF->get_NAME().get_full_name()) + "/" + sanitize_filename(label) + ".ddop";
+		const auto fileStem = std::to_string(partnerCF->get_NAME().get_full_name()) + "/" + sanitize_filename(label);
+		auto fileName = fileStem + ".ddop";
+		state.set_canonical_pool(std::move(canonicalPoolChunks), fileStem);
 		std::vector<std::uint8_t> binaryPool;
 		if (state.get_pool().generate_binary_object_pool(binaryPool))
 		{
@@ -545,6 +577,7 @@ bool MyTCServer::activate_object_pool(std::shared_ptr<isobus::ControlFunction> p
 		return false;
 	}
 
+	state.get_process_data_index().build(state.get_pool());
 	clients[partnerCF] = state;
 	log("TC Server") << "Client " << partnerCF->get_NAME().get_full_name() << " registered successfully with "
 	                 << static_cast<int>(state.get_number_of_sections()) << " sections." << std::endl;
@@ -632,6 +665,15 @@ bool MyTCServer::on_value_command(std::shared_ptr<isobus::ControlFunction> partn
                                   std::uint8_t &errorCodes)
 {
 	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+
+	// Keep the latest value per object for hydrated DDOP snapshots
+	auto clientIt = clients.find(partner);
+	std::uint16_t objectID;
+	if ((clientIt != clients.end()) && clientIt->second.get_process_data_index().try_get_object_id(dataDescriptionIndex, elementNumber, objectID))
+	{
+		clientIt->second.get_shadow_values().record(objectID, processDataValue);
+	}
+
 	switch (dataDescriptionIndex)
 	{
 		case static_cast<std::uint16_t>(isobus::DataDescriptionIndex::ActualCondensedWorkState1_16):
@@ -710,6 +752,135 @@ std::map<std::shared_ptr<isobus::ControlFunction>, ClientState> MyTCServer::get_
 	return clients; // copy, taken while locked — see the declaration's comment
 }
 
+MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client, const ddop_hydration::AllowList &allowList)
+{
+	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+	if (pendingHydration)
+	{
+		return HydrationStartResult::AlreadyRunning;
+	}
+
+	auto clientIt = clients.find(client);
+	if ((clientIt == clients.end()) || clientIt->second.get_canonical_pool_chunks().empty())
+	{
+		return HydrationStartResult::UnknownClient;
+	}
+
+	auto &state = clientIt->second;
+	PendingHydration pending;
+	pending.client = client;
+	pending.startedAt_ms = isobus::SystemTiming::get_timestamp_ms();
+	std::size_t requestCount = 0;
+
+	for (std::uint16_t i = 0; i < state.get_pool().size(); i++)
+	{
+		auto object = state.get_pool().get_object_by_index(i);
+		if (!object || !allowList.is_eligible(*object))
+		{
+			continue;
+		}
+
+		ddop_hydration::SnapshotEntry entry;
+		entry.objectID = object->get_object_id();
+		state.get_process_data_index().try_get_element_number(entry.objectID, entry.elementNumber);
+
+		if (object->get_object_type() == isobus::task_controller_object::ObjectTypes::DeviceProperty)
+		{
+			auto property = std::static_pointer_cast<isobus::task_controller_object::DevicePropertyObject>(object);
+			entry.ddi = property->get_ddi();
+			entry.value = property->get_value();
+			entry.source = ddop_hydration::ValueSource::Pool;
+		}
+		else
+		{
+			entry.ddi = std::static_pointer_cast<isobus::task_controller_object::DeviceProcessDataObject>(object)->get_ddi();
+
+			ddop_hydration::ShadowValue shadowValue;
+			if (state.get_shadow_values().try_get(entry.objectID, shadowValue))
+			{
+				entry.value = shadowValue.value;
+				entry.source = ddop_hydration::ValueSource::Live;
+			}
+			else if (entry.elementNumber != ddop_hydration::SnapshotEntry::NO_ELEMENT)
+			{
+				// The response arrives through on_value_command, which records it in the shadow store.
+				send_request_value(client, entry.ddi, entry.elementNumber);
+				entry.source = ddop_hydration::ValueSource::Requested;
+				requestCount++;
+			}
+			else
+			{
+				entry.source = ddop_hydration::ValueSource::NotRequestable;
+			}
+		}
+		pending.entries.push_back(entry);
+	}
+
+	pending.wait_ms = (requestCount > 0) ? (allowList.requestWaitSeconds * 1000) : 0;
+	log("TC Server") << "Hydration snapshot for client " << client->get_NAME().get_full_name() << ": " << pending.entries.size()
+	                 << " allow-listed objects, " << requestCount << " value requests sent" << std::endl;
+	pendingHydration = std::move(pending);
+	return HydrationStartResult::Started;
+}
+
+bool MyTCServer::poll_hydration_snapshot(ddop_hydration::SnapshotResult &result)
+{
+	ddop_hydration::SnapshotInput input;
+	{
+		std::lock_guard<std::recursive_mutex> lock(clientsMutex);
+		if (!pendingHydration || !isobus::SystemTiming::time_expired_ms(pendingHydration->startedAt_ms, pendingHydration->wait_ms))
+		{
+			return false;
+		}
+
+		auto clientIt = clients.find(pendingHydration->client);
+		if (clientIt == clients.end())
+		{
+			pendingHydration.reset();
+			result = ddop_hydration::SnapshotResult();
+			result.error = "implement disconnected";
+			return true;
+		}
+
+		auto &state = clientIt->second;
+		for (auto &entry : pendingHydration->entries)
+		{
+			ddop_hydration::ShadowValue shadowValue;
+			if (entry.source != ddop_hydration::ValueSource::Requested)
+			{
+				continue;
+			}
+			if (state.get_shadow_values().try_get(entry.objectID, shadowValue))
+			{
+				entry.value = shadowValue.value;
+			}
+			else
+			{
+				entry.source = ddop_hydration::ValueSource::NoResponse;
+			}
+		}
+
+		input.canonicalPoolChunks = state.get_canonical_pool_chunks();
+		input.taskControllerCompatibilityLevel = state.get_pool().get_task_controller_compatibility_level();
+		input.clientName = pendingHydration->client->get_NAME().get_full_name();
+		input.fileStem = state.get_canonical_file_stem();
+		input.entries = std::move(pendingHydration->entries);
+		pendingHydration.reset();
+	}
+
+	// Deserializing and file I/O happen outside the lock so CAN callbacks are not held up.
+	try
+	{
+		result = ddop_hydration::write_snapshot(input);
+	}
+	catch (const std::exception &e)
+	{
+		result = ddop_hydration::SnapshotResult();
+		result.error = e.what();
+	}
+	return true;
+}
+
 void MyTCServer::request_measurement_commands()
 {
 	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
diff --git a/tools/ddop_hydration_test.cpp b/tools/ddop_hydration_test.cpp
new file mode 100644
index 0000000..e439b61
--- /dev/null
+++ b/tools/ddop_hydration_test.cpp
@@ -0,0 +1,169 @@
+// Offline test for hydrated DDOP snapshots: builds a small DDOP, hydrates it and reads the result back.
+#include "ddop_hydration.hpp"
+
+#include "isobus/isobus/can_constants.hpp"
+#include "isobus/isobus/isobus_standard_data_description_indices.hpp"
+#include "isobus/utility/iop_file_interface.hpp"
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+#include <string>
+
+namespace
+{
+	using isobus::task_controller_object::DeviceElementObject;
+	using isobus::task_controller_object::DeviceProcessDataObject;
+	using isobus::task_controller_object::DevicePropertyObject;
+	using isobus::task_controller_object::ObjectTypes;
+	using Trigger = DeviceProcessDataObject::AvailableTriggerMethods;
+
+	int failures = 0;
+
+	void check(bool condition, const char *description)
+	{
+		if (!condition)
+		{
+			std::printf("FAIL: %s\n", description);
+			failures++;
+		}
+	}
+
+	constexpr std::uint16_t OFFSET_X_ID = 10; // on-change, live value known
+	constexpr std::uint16_t WIDTH_TOTAL_ID = 11; // allow-listed DDI but flagged as a total
+	constexpr std::uint16_t WORK_STATE_ID = 12; // always excluded
+	constexpr std::uint16_t OFFSET_Y_PROPERTY_ID = 13; // tier one property
+	constexpr std::uint16_t OFFSET_Z_ID = 14; // on-change, requested but never answered
+	constexpr std::uint16_t MAX_WIDTH_INTERVAL_ID = 15; // allow-listed DDI without an on-change trigger
+	constexpr std::uint16_t SECTION_ELEMENT_ID = 2;
+	constexpr std::uint16_t SECTION_ELEMENT_NUMBER = 1;
+
+	std::uint8_t triggers(Trigger trigger)
+	{
+		return static_cast<std::uint8_t>(trigger);
+	}
+
+	isobus::DeviceDescriptorObjectPool build_canonical_pool()
+	{
+		using isobus::DataDescriptionIndex;
+		isobus::DeviceDescriptorObjectPool pool(3);
+		pool.add_device("Test sprayer", "1.0", "123", "ABCDEFG", { 'e', 'n', 0x50, 0x00, 0x00, 0x00, 0xFF }, {}, 0);
+		pool.add_device_element("Sprayer", 0, 0, DeviceElementObject::Type::Device, 1);
+		pool.add_device_element("Section 1", SECTION_ELEMENT_NUMBER, 1, DeviceElementObject::Type::Section, SECTION_ELEMENT_ID);
+
+		pool.add_device_process_data("Offset X", static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetX), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), OFFSET_X_ID);
+		pool.add_device_process_data("Width", static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkingWidth), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange) | triggers(Trigger::Total), WIDTH_TOTAL_ID);
+		pool.add_device_process_data("Work state", static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkState), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), WORK_STATE_ID);
+		pool.add_device_property("Offset Y", 500, static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetY), isobus::NULL_OBJECT_ID, OFFSET_Y_PROPERTY_ID);
+		pool.add_device_process_data("Offset Z", static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetZ), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), OFFSET_Z_ID);
+		pool.add_device_process_data("Max width", static_cast<std::uint16_t>(DataDescriptionIndex::MaximumWorkingWidth), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::TimeInterval), MAX_WIDTH_INTERVAL_ID);
+
+		auto section = std::static_pointer_cast<DeviceElementObject>(pool.get_object_by_id(SECTION_ELEMENT_ID));
+		for (std::uint16_t child : { OFFSET_X_ID, WIDTH_TOTAL_ID, WORK_STATE_ID, OFFSET_Y_PROPERTY_ID, OFFSET_Z_ID, MAX_WIDTH_INTERVAL_ID })
+		{
+			section->add_reference_to_child_object(child);
+		}
+		return pool;
+	}
+} // namespace
+
+int main()
+{
+	auto canonicalPool = build_canonical_pool();
+	std::vector<std::uint8_t> canonicalBinary;
+	check(canonicalPool.generate_binary_object_pool(canonicalBinary), "canonical test pool generates");
+
+	// Allow list
+	auto allowList = ddop_hydration::AllowList::defaults();
+	allowList.processDataDDIs.insert(static_cast<std::uint16_t>(isobus::DataDescriptionIndex::ActualWorkState)); // must still be excluded
+	check(allowList.is_eligible(*canonicalPool.get_object_by_id(OFFSET_X_ID)), "on-change offset is eligible");
+	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(WIDTH_TOTAL_ID)), "total is not eligible");
+	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(WORK_STATE_ID)), "work state is not eligible even when configured");
+	check(allowList.is_eligible(*canonicalPool.get_object_by_id(OFFSET_Y_PROPERTY_ID)), "device property is eligible");
+	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(MAX_WIDTH_INTERVAL_ID)), "process data without on-change is not eligible");
+
+	// Index
+	ddop_hydration::ProcessDataIndex index;
+	index.build(canonicalPool);
+	std::uint16_t objectID = 0;
+	check(index.try_get_object_id(static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), SECTION_ELEMENT_NUMBER, objectID) && (objectID == OFFSET_X_ID),
+	      "index maps (DDI, element) to object ID");
+
+	// Snapshot
+	ddop_hydration::SnapshotInput input;
+	input.canonicalPoolChunks = { canonicalBinary };
+	input.taskControllerCompatibilityLevel = 3;
+	input.fileStem = "ddop-hydration-test/test-label";
+	input.entries = {
+		{ OFFSET_X_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::Live, 1234 },
+		{ OFFSET_Y_PROPERTY_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetY), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::Pool, 500 },
+		{ OFFSET_Z_ID, static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetZ), SECTION_ELEMENT_NUMBER, ddop_hydration::ValueSource::NoResponse, 0 },
+	};
+
+	const auto result = ddop_hydration::write_snapshot(input);
+	check(result.success, "snapshot is written");
+	if (!result.success)
+	{
+		std::printf("snapshot error: %s\n", result.error.c_str());
+		return 1;
+	}
+	check(result.patchedObjects == 1, "one object patched");
+	check(result.missingValues == 1, "one value missing");
+	check(ddop_hydration::is_snapshot_file(result.ddopPath), "snapshot file is recognized as a snapshot");
+	check(!ddop_hydration::is_snapshot_file("123/test-label.ddop"), "canonical file is not recognized as a snapshot");
+
+	auto snapshotBinary = isobus::IOPFileInterface::read_iop_file(result.ddopPath);
+	isobus::DeviceDescriptorObjectPool snapshotPool(3);
+	check(snapshotPool.deserialize_binary_object_pool(snapshotBinary), "snapshot deserializes");
+
+	auto patched = snapshotPool.get_object_by_id(OFFSET_X_ID);
+	check(patched && (patched->get_object_type() == ObjectTypes::DeviceProperty), "live process data became a device property");
+	if (patched && (patched->get_object_type() == ObjectTypes::DeviceProperty))
+	{
+		auto property = std::static_pointer_cast<DevicePropertyObject>(patched);
+		check(property->get_value() == 1234, "patched value");
+		check(property->get_ddi() == static_cast<std::uint16_t>(isobus::DataDescriptionIndex::DeviceElementOffsetX), "patched DDI");
+		check(property->get_designator() == "Offset X", "patched designator");
+	}
+	auto missing = snapshotPool.get_object_by_id(OFFSET_Z_ID);
+	check(missing && (missing->get_object_type() == ObjectTypes::DeviceProcessData), "unanswered process data stays process data");
+
+	auto section = std::dynamic_pointer_cast<DeviceElementObject>(snapshotPool.get_object_by_id(SECTION_ELEMENT_ID));
+	bool stillReferenced = false;
+	if (section)
+	{
+		for (std::uint16_t child : section->get_child_object_ids())
+		{
+			stillReferenced = stillReferenced || (child == OFFSET_X_ID);
+		}
+	}
+	check(stillReferenced, "section still references the patched object");
+
+	std::shared_ptr<isobus::task_controller_object::DeviceObject> device;
+	for (std::uint16_t i = 0; (i < snapshotPool.size()) && !device; i++)
+	{
+		auto object = snapshotPool.get_object_by_index(i);
+		if (object && (object->get_object_type() == ObjectTypes::Device))
+		{
+			device = std::static_pointer_cast<isobus::task_controller_object::DeviceObject>(object);
+		}
+	}
+	check(device && (device->get_designator().rfind("SNAP ", 0) == 0), "device designator is prefixed");
+	check(device && (device->get_structure_label().rfind("SNAP", 0) == 0), "structure label is altered");
+
+	auto original = canonicalPool.get_object_by_id(OFFSET_X_ID);
+	check(original && (original->get_object_type() == ObjectTypes::DeviceProcessData), "canonical pool is untouched");
+
+	std::ifstream metadataFile(result.metadataPath);
+	const auto metadata = nlohmann::json::parse(metadataFile, nullptr, false);
+	check(!metadata.is_discarded() && metadata.value("notForReupload", false), "sidecar marks the snapshot as not for re-upload");
+	check(!metadata.is_discarded() && (metadata["objects"].size() == 3), "sidecar lists every entry");
+	metadataFile.close();
+
+	std::error_code cleanupError;
+	std::filesystem::remove_all(std::filesystem::path(result.ddopPath).parent_path(), cleanupError);
+
+	std::printf(failures == 0 ? "All ddop hydration checks passed\n" : "%d ddop hydration check(s) failed\n", failures);
+	return (failures == 0) ? 0 : 1;
+}

From 74174e420be1c92bff9ae1d88d74b19d50c555ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bal=C3=A1zs=20Gunics?= <gunicsba@gmail.com>
Date: Mon, 14 Sep 2026 10:25:23 +0200
Subject: [PATCH 2/3] Simplify DDOP snapshots: automatic eligibility, fixed
 wait, .ddop files

- Drop the configurable allow list and all settings.json changes; objects
  are picked from the pool itself (DeviceProperties, plus on-change
  DeviceProcessData that is not a total, setpoint, work state, section
  control state or actual rate)
- Hardcode the value request wait to 10 seconds
- Write snapshots as <label>.SNAP-<timestamp>.ddop

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 include/ddop_hydration.hpp           | 31 ++++++++---------------
 include/settings.hpp                 |  9 -------
 include/task_controller.hpp          |  4 +--
 readme.md                            | 17 ++++---------
 resources/linux/settings.sample.json |  7 +-----
 src/app.cpp                          |  2 +-
 src/ddop_hydration.cpp               | 37 ++++++++--------------------
 src/settings.cpp                     | 36 ---------------------------
 src/task_controller.cpp              |  8 +++---
 tools/ddop_hydration_test.cpp        | 25 ++++++++++---------
 10 files changed, 46 insertions(+), 130 deletions(-)

diff --git a/include/ddop_hydration.hpp b/include/ddop_hydration.hpp
index 276ccaa..828c2d1 100644
--- a/include/ddop_hydration.hpp
+++ b/include/ddop_hydration.hpp
@@ -3,7 +3,7 @@
  *
  * A client's canonical DDOP describes structure only: DeviceProcessData objects carry no value,
  * those arrive later as process data value commands. A hydrated snapshot is a derived copy of the
- * canonical pool in which allow-listed DeviceProcessData objects are replaced by DeviceProperty
+ * canonical pool in which hydratable DeviceProcessData objects are replaced by DeviceProperty
  * objects (same object ID, DDI, designator and presentation) holding the latest known value, so
  * external tools such as AgIsoDDOPGenerator can show those values.
  *
@@ -18,33 +18,22 @@
 #include <cstdint>
 #include <filesystem>
 #include <map>
-#include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace ddop_hydration
 {
-	/// @brief Which objects are eligible for hydration. Configurable through settings.json ("ddopHydration").
-	struct AllowList
-	{
-		bool includeDeviceProperties = true; ///< Tier one: DeviceProperty objects (value already in the pool)
-		std::set<std::uint16_t> processDataDDIs; ///< Tier two: on-change DeviceProcessData DDIs (geometry/configuration-like)
-		std::uint32_t requestWaitSeconds = 7; ///< How long to wait for responses to on-demand value requests
-
-		static constexpr std::uint32_t MIN_REQUEST_WAIT_SECONDS = 1;
-		static constexpr std::uint32_t MAX_REQUEST_WAIT_SECONDS = 60;
+	/// @brief How long a snapshot waits for answers to its value requests
+	constexpr std::uint32_t REQUEST_WAIT_MS = 10000;
 
-		/// @brief Working widths, device element offsets and the reference point to ground distance
-		static AllowList defaults();
+	/// @brief DDIs that are never hydrated: totals, setpoints and transient state such as work states,
+	/// section control state and actual rates.
+	bool is_always_excluded(std::uint16_t ddi);
 
-		/// @brief DDIs that are never hydrated regardless of configuration: totals and transient state
-		/// such as work states, section control state and actual rates.
-		static bool is_always_excluded(std::uint16_t ddi);
-
-		/// @brief Whether a pool object is eligible for hydration under this allow list
-		bool is_eligible(const isobus::task_controller_object::Object &object) const;
-	};
+	/// @brief Whether a pool object is part of a snapshot, decided from the pool alone: every DeviceProperty,
+	/// and every DeviceProcessData that reports on change, is not a total and is not always excluded.
+	bool is_hydratable(const isobus::task_controller_object::Object &object);
 
 	/// @brief The latest process data value reported by a client for one object
 	struct ShadowValue
@@ -122,7 +111,7 @@ namespace ddop_hydration
 
 	/// @brief Prefix added to the Device designator of a snapshot
 	constexpr const char *SNAPSHOT_DESIGNATOR_PREFIX = "SNAP ";
-	/// @brief Marker in snapshot file names: "<label>.SNAP-<timestamp>.iop" next to "<label>.ddop"
+	/// @brief Marker in snapshot file names: "<label>.SNAP-<timestamp>.ddop" next to "<label>.ddop"
 	constexpr const char *SNAPSHOT_FILENAME_MARKER = ".SNAP-";
 
 	/// @brief Clones the canonical pool, patches in the entries' values and writes the snapshot plus a JSON sidecar
diff --git a/include/settings.hpp b/include/settings.hpp
index 8940a0a..06f0278 100644
--- a/include/settings.hpp
+++ b/include/settings.hpp
@@ -9,8 +9,6 @@
 
 #pragma once
 
-#include "ddop_hydration.hpp"
-
 #include <array>
 #include <cstdint>
 #include <mutex>
@@ -142,12 +140,6 @@ class Settings
 	 */
 	bool set_country_code(std::string code, bool save = true);
 
-	/**
-	 * @brief Get the allow list used for hydrated DDOP snapshots ("ddopHydration")
-	 * @return The allow list (by value; the copy is made under the lock)
-	 */
-	ddop_hydration::AllowList get_ddop_hydration_allow_list() const;
-
 	/**
 	 * @brief Get the absolute path to the settings file
 	 * @param filename The filename to get the path for
@@ -180,5 +172,4 @@ class Settings
 	std::uint8_t tcVersion = DEFAULT_TC_VERSION;
 	std::string languageCode = DEFAULT_LANGUAGE_CODE;
 	std::string countryCode = DEFAULT_COUNTRY_CODE;
-	ddop_hydration::AllowList ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
 };
diff --git a/include/task_controller.hpp b/include/task_controller.hpp
index 9cf4cb3..df85a1e 100644
--- a/include/task_controller.hpp
+++ b/include/task_controller.hpp
@@ -137,9 +137,9 @@ class MyTCServer : public isobus::TaskControllerServer
 		UnknownClient
 	};
 
-	/// @brief Starts a hydrated DDOP snapshot for a client. Sends value requests for allow-listed
+	/// @brief Starts a hydrated DDOP snapshot for a client. Sends value requests for hydratable
 	/// objects without a known value; does not block. Finish it with poll_hydration_snapshot().
-	HydrationStartResult begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client, const ddop_hydration::AllowList &allowList);
+	HydrationStartResult begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client);
 
 	/// @brief Call from the main loop. Once the request wait has elapsed, writes the snapshot and returns true.
 	/// @param[out] result The outcome of the finished snapshot, only set when this returns true
diff --git a/readme.md b/readme.md
index bdbbd12..2ea4433 100644
--- a/readme.md
+++ b/readme.md
@@ -62,9 +62,6 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
 | `tcVersion` | `integer` | `3` | Task Controller version code, from `0` through `4`; `3` is Second Edition Draft. |
 | `languageCode` | `string` | `"en"` | Two-character language code advertised on ISOBUS. |
 | `countryCode` | `string` | `"US"` | Two-character country code advertised on ISOBUS. |
-| `ddopHydration.includeDeviceProperties` | `bool` | `true` | Lists DeviceProperty values in hydrated DDOP snapshots. |
-| `ddopHydration.processDataDdis` | `int[]` | `[67, 68, 70, 134, 135, 136, 180]` | On-change DeviceProcessData DDIs whose live values are written into hydrated DDOP snapshots. Totals, work states, section control state and actual rates are always excluded. |
-| `ddopHydration.requestWaitSeconds` | `integer` | `7` | How long a snapshot waits for answers to value requests, `1` through `60`. |
 
 ### Example `settings.json`
 
@@ -77,12 +74,7 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
   "vtEnabled": true,
   "tcVersion": 3,
   "languageCode": "en",
-  "countryCode": "US",
-  "ddopHydration": {
-    "includeDeviceProperties": true,
-    "processDataDdis": [67, 68, 70, 134, 135, 136, 180],
-    "requestWaitSeconds": 7
-  }
+  "countryCode": "US"
 }
 ```
 
@@ -90,9 +82,10 @@ AOG-TaskController reads its configuration from a `settings.json` file located i
 
 Many implement values, such as element offsets and working width, are not stored in the DDOP; the implement reports them as process data once it is running. The **Snapshot DDOP** button on the VT Implement page writes a copy of the connected implement's DDOP with those values filled in, for viewing in tools such as AgIsoDDOPGenerator.
 
-- Values that were already reported are used directly. For the rest, the TC sends value requests and waits `requestWaitSeconds` for answers.
-- Allow-listed DeviceProcessData objects with a value are replaced by DeviceProperty objects with the same object ID, DDI and designator. The Device designator gets a `SNAP ` prefix and the structure label is changed.
-- The snapshot is stored next to the canonical pool as `<NAME>/<label>.SNAP-<timestamp>.iop`, with a `.json` file that lists every object, its value and where the value came from.
+- The objects are picked from the DDOP itself: every DeviceProperty, and every DeviceProcessData that reports on change and is not a total, a setpoint, a work state, section control state or an actual rate.
+- Values that were already reported are used directly. For the rest, the TC sends value requests and waits 10 seconds for answers.
+- DeviceProcessData objects with a value are replaced by DeviceProperty objects with the same object ID, DDI and designator. The Device designator gets a `SNAP ` prefix and the structure label is changed.
+- The snapshot is stored next to the canonical pool as `<NAME>/<label>.SNAP-<timestamp>.ddop`, with a `.json` file that lists every object, its value and where the value came from.
 - Snapshots are for debugging only: never upload one to a TC. The canonical `<label>.ddop` is not changed.
 
 ### Virtual Terminal compatibility
diff --git a/resources/linux/settings.sample.json b/resources/linux/settings.sample.json
index 228d81a..5890033 100644
--- a/resources/linux/settings.sample.json
+++ b/resources/linux/settings.sample.json
@@ -6,10 +6,5 @@
     "vtEnabled": true,
     "tcVersion": 3,
     "languageCode": "en",
-    "countryCode": "US",
-    "ddopHydration": {
-        "includeDeviceProperties": true,
-        "processDataDdis": [67, 68, 70, 134, 135, 136, 180],
-        "requestWaitSeconds": 7
-    }
+    "countryCode": "US"
 }
diff --git a/src/app.cpp b/src/app.cpp
index 54a1ee4..d17472b 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -895,7 +895,7 @@ void Application::update_hydration_snapshot()
 		else
 		{
 			// Same client the Implement page shows, see update_vt_status_strings()
-			switch (tcServer->begin_hydration_snapshot(clients.begin()->first, settings->get_ddop_hydration_allow_list()))
+			switch (tcServer->begin_hydration_snapshot(clients.begin()->first))
 			{
 				case MyTCServer::HydrationStartResult::Started:
 					send_hardware_message("DDOP snapshot started", 5, HW_MSG_INFO);
diff --git a/src/ddop_hydration.cpp b/src/ddop_hydration.cpp
index 45d6df6..0baa1e6 100644
--- a/src/ddop_hydration.cpp
+++ b/src/ddop_hydration.cpp
@@ -68,22 +68,7 @@ namespace ddop_hydration
 		}
 	} // namespace
 
-	AllowList AllowList::defaults()
-	{
-		AllowList allowList;
-		allowList.processDataDDIs = {
-			static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkingWidth),
-			static_cast<std::uint16_t>(DataDescriptionIndex::DefaultWorkingWidth),
-			static_cast<std::uint16_t>(DataDescriptionIndex::MaximumWorkingWidth),
-			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetX),
-			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetY),
-			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetZ),
-			static_cast<std::uint16_t>(DataDescriptionIndex::DeviceReferencePointDRPtoGroundDistance),
-		};
-		return allowList;
-	}
-
-	bool AllowList::is_always_excluded(std::uint16_t ddi)
+	bool is_always_excluded(std::uint16_t ddi)
 	{
 		if ((ddi == static_cast<std::uint16_t>(DataDescriptionIndex::ActualWorkState)) ||
 		    (ddi == static_cast<std::uint16_t>(DataDescriptionIndex::SetpointWorkState)) ||
@@ -96,22 +81,21 @@ namespace ddop_hydration
 			return true;
 		}
 
-		// Totals and actual rates change continuously, so a snapshot of them is meaningless as structure.
+		// Totals and actual rates change continuously, and setpoints are commands from the TC,
+		// so a snapshot of them says nothing about the implement's configuration.
 		const std::string &name = isobus::DataDictionary::get_entry(ddi).name;
 		const bool isTotal = (name.find("Total") != std::string::npos);
 		const bool isActualRate = (name.rfind("Actual", 0) == 0) && (name.find("Rate") != std::string::npos);
-		return isTotal || isActualRate;
+		const bool isSetpoint = (name.rfind("Setpoint", 0) == 0);
+		return isTotal || isActualRate || isSetpoint;
 	}
 
-	bool AllowList::is_eligible(const isobus::task_controller_object::Object &object) const
+	bool is_hydratable(const isobus::task_controller_object::Object &object)
 	{
 		switch (object.get_object_type())
 		{
 			case ObjectTypes::DeviceProperty:
-			{
-				const auto &property = static_cast<const DevicePropertyObject &>(object);
-				return includeDeviceProperties && !is_always_excluded(property.get_ddi());
-			}
+				return true;
 
 			case ObjectTypes::DeviceProcessData:
 			{
@@ -120,8 +104,7 @@ namespace ddop_hydration
 				const std::uint8_t triggers = processData.get_trigger_methods_bitfield();
 				return (0 == (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::Total))) &&
 				  (0 != (triggers & static_cast<std::uint8_t>(DeviceProcessDataObject::AvailableTriggerMethods::OnChange))) &&
-				  !is_always_excluded(processData.get_ddi()) &&
-				  (processDataDDIs.count(processData.get_ddi()) > 0);
+				  !is_always_excluded(processData.get_ddi());
 			}
 
 			default:
@@ -317,7 +300,7 @@ namespace ddop_hydration
 
 		const std::string createdAt = local_timestamp("%Y-%m-%dT%H:%M:%S");
 		const std::string snapshotStem = input.fileStem + SNAPSHOT_FILENAME_MARKER + local_timestamp("%Y%m%d-%H%M%S");
-		result.ddopPath = Settings::get_filename_path(snapshotStem + ".iop");
+		result.ddopPath = Settings::get_filename_path(snapshotStem + ".ddop");
 		result.metadataPath = Settings::get_filename_path(snapshotStem + ".json");
 
 		std::ostringstream clientName;
@@ -327,7 +310,7 @@ namespace ddop_hydration
 			{ "kind", "AOG-TaskController hydrated DDOP snapshot" },
 			{ "notForReupload", true },
 			{ "note",
-			  "Derived debugging artifact, not an original upload. Allow-listed DeviceProcessData objects with a known value "
+			  "Derived debugging artifact, not an original upload. Hydratable DeviceProcessData objects with a known value "
 			  "were replaced by DeviceProperty objects with the same object ID, DDI, designator and presentation. "
 			  "The Device designator is prefixed with 'SNAP ' and the structure label is altered. Never upload this pool to a TC." },
 			{ "createdAt", createdAt },
diff --git a/src/settings.cpp b/src/settings.cpp
index 4ede22c..960927a 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -9,7 +9,6 @@
 #include "settings.hpp"
 #include "logging_utils.hpp"
 
-#include <algorithm>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
@@ -132,30 +131,6 @@ bool Settings::load()
 		countryCode = DEFAULT_COUNTRY_CODE;
 	}
 
-	ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
-	if (data.contains("ddopHydration"))
-	{
-		try
-		{
-			const auto &section = data["ddopHydration"];
-			auto &allowList = ddopHydrationAllowList;
-			allowList.includeDeviceProperties = section.value("includeDeviceProperties", allowList.includeDeviceProperties);
-			if (section.contains("processDataDdis"))
-			{
-				const auto ddis = section["processDataDdis"].get<std::vector<std::uint16_t>>();
-				allowList.processDataDDIs = std::set<std::uint16_t>(ddis.begin(), ddis.end());
-			}
-			allowList.requestWaitSeconds = std::clamp(section.value("requestWaitSeconds", allowList.requestWaitSeconds),
-			                                          ddop_hydration::AllowList::MIN_REQUEST_WAIT_SECONDS,
-			                                          ddop_hydration::AllowList::MAX_REQUEST_WAIT_SECONDS);
-		}
-		catch (const nlohmann::json::exception &e)
-		{
-			std::cout << "[" << get_timestamp() << "] Error parsing 'ddopHydration': " << e.what() << std::endl;
-			ddopHydrationAllowList = ddop_hydration::AllowList::defaults();
-		}
-	}
-
 	return true;
 }
 
@@ -171,11 +146,6 @@ bool Settings::save() const
 	data["tcVersion"] = tcVersion;
 	data["languageCode"] = languageCode;
 	data["countryCode"] = countryCode;
-	data["ddopHydration"] = {
-		{ "includeDeviceProperties", ddopHydrationAllowList.includeDeviceProperties },
-		{ "processDataDdis", ddopHydrationAllowList.processDataDDIs },
-		{ "requestWaitSeconds", ddopHydrationAllowList.requestWaitSeconds },
-	};
 
 	const std::filesystem::path settingsPath(get_filename_path("settings.json"));
 	std::filesystem::path temporaryPath = settingsPath;
@@ -361,12 +331,6 @@ bool Settings::set_country_code(std::string code, bool save)
 	return true;
 }
 
-ddop_hydration::AllowList Settings::get_ddop_hydration_allow_list() const
-{
-	std::scoped_lock lock(settingsMutex);
-	return ddopHydrationAllowList;
-}
-
 namespace
 {
 	std::filesystem::path get_base_config_dir()
diff --git a/src/task_controller.cpp b/src/task_controller.cpp
index 51ab7b2..baab9af 100644
--- a/src/task_controller.cpp
+++ b/src/task_controller.cpp
@@ -752,7 +752,7 @@ std::map<std::shared_ptr<isobus::ControlFunction>, ClientState> MyTCServer::get_
 	return clients; // copy, taken while locked — see the declaration's comment
 }
 
-MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client, const ddop_hydration::AllowList &allowList)
+MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::shared_ptr<isobus::ControlFunction> client)
 {
 	std::lock_guard<std::recursive_mutex> lock(clientsMutex);
 	if (pendingHydration)
@@ -775,7 +775,7 @@ MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::share
 	for (std::uint16_t i = 0; i < state.get_pool().size(); i++)
 	{
 		auto object = state.get_pool().get_object_by_index(i);
-		if (!object || !allowList.is_eligible(*object))
+		if (!object || !ddop_hydration::is_hydratable(*object))
 		{
 			continue;
 		}
@@ -816,9 +816,9 @@ MyTCServer::HydrationStartResult MyTCServer::begin_hydration_snapshot(std::share
 		pending.entries.push_back(entry);
 	}
 
-	pending.wait_ms = (requestCount > 0) ? (allowList.requestWaitSeconds * 1000) : 0;
+	pending.wait_ms = (requestCount > 0) ? ddop_hydration::REQUEST_WAIT_MS : 0;
 	log("TC Server") << "Hydration snapshot for client " << client->get_NAME().get_full_name() << ": " << pending.entries.size()
-	                 << " allow-listed objects, " << requestCount << " value requests sent" << std::endl;
+	                 << " hydratable objects, " << requestCount << " value requests sent" << std::endl;
 	pendingHydration = std::move(pending);
 	return HydrationStartResult::Started;
 }
diff --git a/tools/ddop_hydration_test.cpp b/tools/ddop_hydration_test.cpp
index e439b61..18cc9c2 100644
--- a/tools/ddop_hydration_test.cpp
+++ b/tools/ddop_hydration_test.cpp
@@ -31,11 +31,12 @@ namespace
 	}
 
 	constexpr std::uint16_t OFFSET_X_ID = 10; // on-change, live value known
-	constexpr std::uint16_t WIDTH_TOTAL_ID = 11; // allow-listed DDI but flagged as a total
+	constexpr std::uint16_t WIDTH_TOTAL_ID = 11; // on-change but flagged as a total
 	constexpr std::uint16_t WORK_STATE_ID = 12; // always excluded
-	constexpr std::uint16_t OFFSET_Y_PROPERTY_ID = 13; // tier one property
+	constexpr std::uint16_t OFFSET_Y_PROPERTY_ID = 13; // device property
 	constexpr std::uint16_t OFFSET_Z_ID = 14; // on-change, requested but never answered
-	constexpr std::uint16_t MAX_WIDTH_INTERVAL_ID = 15; // allow-listed DDI without an on-change trigger
+	constexpr std::uint16_t MAX_WIDTH_INTERVAL_ID = 15; // no on-change trigger
+	constexpr std::uint16_t SETPOINT_ID = 16; // on-change setpoint
 	constexpr std::uint16_t SECTION_ELEMENT_ID = 2;
 	constexpr std::uint16_t SECTION_ELEMENT_NUMBER = 1;
 
@@ -58,9 +59,10 @@ namespace
 		pool.add_device_property("Offset Y", 500, static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetY), isobus::NULL_OBJECT_ID, OFFSET_Y_PROPERTY_ID);
 		pool.add_device_process_data("Offset Z", static_cast<std::uint16_t>(DataDescriptionIndex::DeviceElementOffsetZ), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::OnChange), OFFSET_Z_ID);
 		pool.add_device_process_data("Max width", static_cast<std::uint16_t>(DataDescriptionIndex::MaximumWorkingWidth), isobus::NULL_OBJECT_ID, 0, triggers(Trigger::TimeInterval), MAX_WIDTH_INTERVAL_ID);
+		pool.add_device_process_data("Setpoint width", static_cast<std::uint16_t>(DataDescriptionIndex::SetpointWorkingWidth), isobus::NULL_OBJECT_ID, 2, triggers(Trigger::OnChange), SETPOINT_ID);
 
 		auto section = std::static_pointer_cast<DeviceElementObject>(pool.get_object_by_id(SECTION_ELEMENT_ID));
-		for (std::uint16_t child : { OFFSET_X_ID, WIDTH_TOTAL_ID, WORK_STATE_ID, OFFSET_Y_PROPERTY_ID, OFFSET_Z_ID, MAX_WIDTH_INTERVAL_ID })
+		for (std::uint16_t child : { OFFSET_X_ID, WIDTH_TOTAL_ID, WORK_STATE_ID, OFFSET_Y_PROPERTY_ID, OFFSET_Z_ID, MAX_WIDTH_INTERVAL_ID, SETPOINT_ID })
 		{
 			section->add_reference_to_child_object(child);
 		}
@@ -74,14 +76,13 @@ int main()
 	std::vector<std::uint8_t> canonicalBinary;
 	check(canonicalPool.generate_binary_object_pool(canonicalBinary), "canonical test pool generates");
 
-	// Allow list
-	auto allowList = ddop_hydration::AllowList::defaults();
-	allowList.processDataDDIs.insert(static_cast<std::uint16_t>(isobus::DataDescriptionIndex::ActualWorkState)); // must still be excluded
-	check(allowList.is_eligible(*canonicalPool.get_object_by_id(OFFSET_X_ID)), "on-change offset is eligible");
-	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(WIDTH_TOTAL_ID)), "total is not eligible");
-	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(WORK_STATE_ID)), "work state is not eligible even when configured");
-	check(allowList.is_eligible(*canonicalPool.get_object_by_id(OFFSET_Y_PROPERTY_ID)), "device property is eligible");
-	check(!allowList.is_eligible(*canonicalPool.get_object_by_id(MAX_WIDTH_INTERVAL_ID)), "process data without on-change is not eligible");
+	// Automatic eligibility
+	check(ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(OFFSET_X_ID)), "on-change offset is hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(WIDTH_TOTAL_ID)), "total is not hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(WORK_STATE_ID)), "work state is not hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(SETPOINT_ID)), "setpoint is not hydratable");
+	check(ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(OFFSET_Y_PROPERTY_ID)), "device property is hydratable");
+	check(!ddop_hydration::is_hydratable(*canonicalPool.get_object_by_id(MAX_WIDTH_INTERVAL_ID)), "process data without on-change is not hydratable");
 
 	// Index
 	ddop_hydration::ProcessDataIndex index;

From 7494635ff3b8af2cba1d98c6526af5348c9ebc64 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bal=C3=A1zs=20Gunics?= <gunicsba@gmail.com>
Date: Mon, 14 Sep 2026 16:08:06 +0200
Subject: [PATCH 3/3] Fix CI: build the hydration test before ctest, apply
 cmake-format

- Validate IOP workflow built only iop_validator, so ctest reported
  ddop_hydration_snapshot as "Not Run"; build ddop_hydration_test too
- Release builds pass -DAOG_TC_BUILD_TESTS=OFF, like AOG_TC_VALIDATE_IOP
- Wrap target_link_libraries the way cmake-format expects

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .github/workflows/build.yml        | 4 ++--
 .github/workflows/validate-iop.yml | 4 ++--
 CMakeLists.txt                     | 5 +++--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 54b4250..2b75c8c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -22,7 +22,7 @@ jobs:
       - name: Compile
         run: |
           mkdir build
-          cmake -S . -B build -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -Wno-dev
+          cmake -S . -B build -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DAOG_TC_BUILD_TESTS=OFF -Wno-dev
           cmake --build build --config Release --target package
       - name: 'Upload Windows Installer'
         uses: actions/upload-artifact@v4
@@ -52,7 +52,7 @@ jobs:
           sudo apt-get install -y --no-install-recommends \
             build-essential cmake ninja-build
       - name: Configure (CMake)
-        run: cmake -S . -B build -G Ninja -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DCMAKE_BUILD_TYPE=Release -Wno-dev
+        run: cmake -S . -B build -G Ninja -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF -DAOG_TC_VALIDATE_IOP=OFF -DAOG_TC_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -Wno-dev
       - name: Build
         run: cmake --build build --config Release
       - name: Stage tarball
diff --git a/.github/workflows/validate-iop.yml b/.github/workflows/validate-iop.yml
index 13fd36f..6b018fa 100644
--- a/.github/workflows/validate-iop.yml
+++ b/.github/workflows/validate-iop.yml
@@ -34,7 +34,7 @@ jobs:
           -Wno-dev
 
       - name: Build
-        run: cmake --build build --config Release --target iop_validator
+        run: cmake --build build --config Release --target iop_validator ddop_hydration_test
 
-      - name: Validate object pool
+      - name: Validate object pool and run unit tests
         run: ctest --test-dir build --output-on-failure
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 45a3814..b681570 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -162,8 +162,9 @@ if(AOG_TC_BUILD_TESTS)
   target_compile_definitions(
     ddop_hydration_test PRIVATE PROJECT_VERSION="${PROJECT_VERSION}"
                                 PROJECT_NAME="${PROJECT_NAME}")
-  target_link_libraries(ddop_hydration_test PRIVATE isobus::Isobus isobus::Utility
-                                                    nlohmann_json::nlohmann_json)
+  target_link_libraries(
+    ddop_hydration_test PRIVATE isobus::Isobus isobus::Utility
+                                nlohmann_json::nlohmann_json)
   add_test(NAME ddop_hydration_snapshot COMMAND ddop_hydration_test)
 endif()