fix: surface TreeXML parse failures to the discovery retry mechanism

When parseString failed on the buffered TreeXML response (truncated payload,
encoding glitch, C-Gate restart mid-stream, etc.), the error was logged but
nothing else: no retry was scheduled, no PAUSE state was set, and the
network's discovery status sat in DISCOVERING forever even though no further
work was happening. The watchdog had already been cleared when the 344
end-of-tree was received, so the stuck state was also invisible to
diagnostics.

Now the catch path calls _handleTreeRequestFailure with reason='parse error',
which routes it through the same backoff retry budget used for 401 Network
not found. After the retry limit is exhausted the network transitions to
PAUSED with the standard recovery hint logged.

Regression test added: feed broken XML to handleTreeData/handleTreeEnd,
assert _treeRequestState records the failure and the initial backoff
re-issues the gettree.

Author: dougrathbone

src/haDiscovery.js

@@ -499,6 +499,11 @@ class HaDiscovery {
                     line: err.line,
                     column: err.column
                 });
+                // Surface the parse failure to the retry mechanism so a malformed
+                // response from C-Gate (truncated, mid-restart, encoding glitch)
+                // doesn't leave discovery silently stuck. Same backoff budget as
+                // 401-on-tree applies; we'll PAUSE after the retry limit.
+                this._handleTreeRequestFailure(networkForTree, `parse error: ${err.message || err}`);
             } else {
                 this.logger.info(`Parsed TreeXML for network ${networkForTree} (took ${duration}ms)`);
 

tests/haDiscovery.test.js

@@ -555,6 +555,39 @@ describe('HaDiscovery', () => {
         });
     });
 
+    describe('TreeXML parse failure recovery', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            mockSettings.ha_discovery_networks = ['254'];
+        });
+
+        afterEach(() => {
+            haDiscovery.stop();
+            jest.useRealTimers();
+        });
+
+        it('engages the retry mechanism when parseString fails on malformed XML', () => {
+            haDiscovery.trigger();
+            expect(mockSendCommandFn).toHaveBeenCalledTimes(1);
+
+            // Simulate C-Gate returning a tree that's syntactically broken.
+            haDiscovery.handleTreeStart('343 Begin tree //PROJECT/254');
+            haDiscovery.handleTreeData('<not valid xml');
+            haDiscovery.handleTreeEnd('344 End tree');
+
+            // Retry state for the network must now show one failed attempt,
+            // proving the parseString failure was surfaced as a discovery
+            // failure (not silently swallowed).
+            const state = haDiscovery._treeRequestState.get('254');
+            expect(state).toBeDefined();
+            expect(state.attempts).toBe(1);
+
+            // Initial backoff fires and re-requests the tree.
+            jest.advanceTimersByTime(haDiscovery._treeRetryInitialDelayMs);
+            expect(mockSendCommandFn).toHaveBeenCalledTimes(2);
+        });
+    });
+
     describe('TreeXML retry on startup race (401 Network not found)', () => {
         beforeEach(() => {
             jest.useFakeTimers();