Route adapter.diagnostic notifications to diagnostics log

AdapterClient now connects to AdapterProcess::notificationReceived and
emits diagnosticReceived(level, message) for adapter.diagnostic
notifications. ModbusPoll connects to this signal and routes the message
to the existing scopeComm logging category using the appropriate
qCDebug/qCInfo/qCWarning call, so adapter-side log messages flow through
ScopeLogging into DiagnosticModel alongside host-side entries.

Tests updated: notificationIgnored now also verifies diagnosticReceived
stays silent for non-diagnostic notifications. Two new tests cover
warning and debug level forwarding.

https://claude.ai/code/session_01UhRoTiKzKdkuurvzKQBVjr

Author: claude

src/ProtocolAdapter/adapterclient.cpp

@@ -16,6 +16,7 @@ AdapterClient::AdapterClient(AdapterProcess* pProcess, QObject* parent) : QObjec
     connect(_pProcess, &AdapterProcess::errorReceived, this, &AdapterClient::onErrorReceived);
     connect(_pProcess, &AdapterProcess::processError, this, &AdapterClient::onProcessError);
     connect(_pProcess, &AdapterProcess::processFinished, this, &AdapterClient::onProcessFinished);
+    connect(_pProcess, &AdapterProcess::notificationReceived, this, &AdapterClient::onNotificationReceived);
 }
 
 AdapterClient::~AdapterClient() = default;
@@ -159,6 +160,16 @@ void AdapterClient::onHandshakeTimeout()
     emit sessionError("Adapter handshake timed out");
 }
 
+void AdapterClient::onNotificationReceived(QString method, QJsonValue params)
+{
+    if (method == QStringLiteral("adapter.diagnostic"))
+    {
+        QJsonObject obj = params.toObject();
+        emit diagnosticReceived(obj.value(QStringLiteral("level")).toString(),
+                                obj.value(QStringLiteral("message")).toString());
+    }
+}
+
 void AdapterClient::handleLifecycleResponse(const QString& method, const QJsonObject& result)
 {
     if (method == "adapter.initialize" && _state == State::INITIALIZING)

src/ProtocolAdapter/adapterclient.h

@@ -114,6 +114,13 @@ class AdapterClient : public QObject
      */
     void sessionStopped();
 
+    /*!
+     * \brief Emitted when an adapter.diagnostic notification is received from the adapter.
+     * \param level Severity level string: "debug", "info", or "warning".
+     * \param message The diagnostic message from the adapter.
+     */
+    void diagnosticReceived(QString level, QString message);
+
 protected:
     enum class State
     {
@@ -135,6 +142,7 @@ private slots:
     void onProcessError(const QString& message);
     void onProcessFinished();
     void onHandshakeTimeout();
+    void onNotificationReceived(QString method, QJsonValue params);
 
 private:
     void handleLifecycleResponse(const QString& method, const QJsonObject& result);

src/communication/modbuspoll.cpp

@@ -30,6 +30,7 @@ ModbusPoll::ModbusPoll(SettingsModel* pSettingsModel, QObject* parent) : QObject
         _bPollActive = false;
     });
     connect(_pAdapterClient, &AdapterClient::sessionStopped, this, &ModbusPoll::initAdapter);
+    connect(_pAdapterClient, &AdapterClient::diagnosticReceived, this, &ModbusPoll::onAdapterDiagnostic);
 }
 
 ModbusPoll::~ModbusPoll() = default;
@@ -119,6 +120,30 @@ void ModbusPoll::onDescribeResult(const QJsonObject& description)
     _pSettingsModel->updateAdapterFromDescribe("modbus", description);
 }
 
+/*! \brief Route an adapter.diagnostic notification to the diagnostics log.
+ *
+ * Maps the adapter's level string to the appropriate Qt logging severity so
+ * the message flows through ScopeLogging into DiagnosticModel.
+ *
+ * \param level Severity string from the adapter: "debug", "info", or "warning".
+ * \param message The diagnostic message text.
+ */
+void ModbusPoll::onAdapterDiagnostic(const QString& level, const QString& message)
+{
+    if (level == QStringLiteral("debug"))
+    {
+        qCDebug(scopeComm) << message;
+    }
+    else if (level == QStringLiteral("info"))
+    {
+        qCInfo(scopeComm) << message;
+    }
+    else
+    {
+        qCWarning(scopeComm) << message;
+    }
+}
+
 QStringList ModbusPoll::buildRegisterExpressions(const QList<DataPoint>& registerList)
 {
     QStringList expressions;

src/communication/modbuspoll.h

@@ -34,6 +34,7 @@ private slots:
     void triggerRegisterRead();
     void onReadDataResult(ResultDoubleList results);
     void onDescribeResult(const QJsonObject& description);
+    void onAdapterDiagnostic(const QString& level, const QString& message);
 
 private:
     QStringList buildRegisterExpressions(const QList<DataPoint>& registerList);

tests/ProtocolAdapter/tst_adapterclient.cpp

@@ -282,13 +282,43 @@ void TestAdapterClient::notificationIgnored()
     QSignalSpy spyStarted(&client, &AdapterClient::sessionStarted);
     QSignalSpy spyError(&client, &AdapterClient::sessionError);
     QSignalSpy spyData(&client, &AdapterClient::readDataResult);
+    QSignalSpy spyDiagnostic(&client, &AdapterClient::diagnosticReceived);
 
-    /* Simulate a server-initiated notification and verify AdapterClient stays silent */
+    /* Simulate a non-diagnostic notification and verify all signals stay silent */
     mock->injectNotification("adapter.progress", QJsonObject{ { "percent", 50 } });
 
     QCOMPARE(spyStarted.count(), 0);
     QCOMPARE(spyError.count(), 0);
     QCOMPARE(spyData.count(), 0);
+    QCOMPARE(spyDiagnostic.count(), 0);
+}
+
+void TestAdapterClient::diagnosticNotificationForwarded()
+{
+    auto* mock = new MockAdapterProcess();
+    AdapterClient client(mock);
+
+    QSignalSpy spyDiagnostic(&client, &AdapterClient::diagnosticReceived);
+
+    mock->injectNotification("adapter.diagnostic", QJsonObject{ { "level", "warning" }, { "message", "connection lost" } });
+
+    QCOMPARE(spyDiagnostic.count(), 1);
+    QCOMPARE(spyDiagnostic.at(0).at(0).toString(), QStringLiteral("warning"));
+    QCOMPARE(spyDiagnostic.at(0).at(1).toString(), QStringLiteral("connection lost"));
+}
+
+void TestAdapterClient::diagnosticNotificationDebugLevel()
+{
+    auto* mock = new MockAdapterProcess();
+    AdapterClient client(mock);
+
+    QSignalSpy spyDiagnostic(&client, &AdapterClient::diagnosticReceived);
+
+    mock->injectNotification("adapter.diagnostic", QJsonObject{ { "level", "debug" }, { "message", "polling started" } });
+
+    QCOMPARE(spyDiagnostic.count(), 1);
+    QCOMPARE(spyDiagnostic.at(0).at(0).toString(), QStringLiteral("debug"));
+    QCOMPARE(spyDiagnostic.at(0).at(1).toString(), QStringLiteral("polling started"));
 }
 
 void TestAdapterClient::processErrorEmitsSessionError()

tests/ProtocolAdapter/tst_adapterclient.h

@@ -18,6 +18,8 @@ private slots:
     void errorResponseEmitsSessionError();
     void unexpectedResponseEmitsNoSignals();
     void notificationIgnored();
+    void diagnosticNotificationForwarded();
+    void diagnosticNotificationDebugLevel();
     void processErrorEmitsSessionError();
     void stopSessionDuringLifecycle();
     void doubleStopSession();