Wake IC-9700 from standby on explicit connect

docs/automation-bridge.md

@@ -3299,6 +3299,15 @@ hardware tests. Raw RS-BA1 datagram logging is intentionally off by default and
 should only be enabled briefly when these structured diagnostics are
 insufficient.
 
+**`civ power standby|wake|probe|setting`** sends the documented CI-V power command through
+the active authenticated Icom session. `wake` applies the active model's
+verified native-LAN framing; unsupported models fail closed. `standby` first
+quiesces CI-V polling, and `probe` sends one identity read while quiesced so a
+hardware test can distinguish an asleep radio from an artificially quiet
+client. This is an explicit hardware-test action only: disconnect never powers
+the radio down. `setting` reads the IC-9700's Power OFF Setting (`1A 05 01 46`)
+without exposing the raw CI-V injector.
+
 ### `controls`
 
 The CI-V control and meter registry, joined against what is actually wired.

src/core/AutomationServer.cpp

@@ -25,13 +25,13 @@
 #include <QLocalServer>
 #include <QScopeGuard>
 #include <QLocalSocket>
 #include <QApplication>
 #include <QScreen>
 #include <QWidget>
 #include <QMainWindow>
 #include <QMenu>
 #include <QMenuBar>
 #include <QTabBar>
 #include <QEnterEvent>
 #include <QMouseEvent>
 #include <QWheelEvent>
@@ -67,11 +67,11 @@
 #include <utility>
 
 // Best-effort value extraction for common control types.
 #include <QAbstractButton>
 #include <QAbstractSlider>
 #include <QAbstractItemView>   // invoke selectRow: QTableWidget/QTreeWidget/QListWidget row select
 #include <QItemSelectionModel>
 #include <QComboBox>
 #include <QLineEdit>
 #include <QLabel>
 #include <QSpinBox>
@@ -3446,7 +3446,7 @@
             });
 
         add("civ", {},
-            "civ <send <hex>|trace [all]|session|scheduler|incident> — CI-V "
+            "civ <send <hex>|power <standby|wake|probe|setting>|trace [all]|session|scheduler|incident> — CI-V "
             "inject, frame trace, lease/scheduler health, or last incident "
             "(Icom; send is TX-gated)",
             parseActionRest,
@@ -7963,12 +7963,13 @@
         return err(QStringLiteral("no backend available"));
 
     const QString a = action.trimmed().toLower();
-    if (a.isEmpty() || (a != QLatin1String("send") && a != QLatin1String("trace")
+    if (a.isEmpty() || (a != QLatin1String("send") && a != QLatin1String("power")
+                        && a != QLatin1String("trace")
                         && a != QLatin1String("session")
                         && a != QLatin1String("incident")
                         && a != QLatin1String("scheduler"))) {
         return err(QStringLiteral(
-            "civ requires an action (send|trace|session|scheduler|incident)"));
+            "civ requires an action (send|power|trace|session|scheduler|incident)"));
     }
     if (a == QLatin1String("send") && !m_txAllowed) {
         return err(QStringLiteral(
@@ -8000,13 +8001,29 @@
         failure = msg;
     }, Qt::DirectConnection);
 
-    const QString verb = a == QLatin1String("send") ? QStringLiteral("civ.send")
+    QString verb;
+    QVariant extensionArg = arg.trimmed();
+    if (a == QLatin1String("power")) {
+        const QString state = arg.trimmed().toLower();
+        if (state != QLatin1String("standby") && state != QLatin1String("wake")
+            && state != QLatin1String("probe") && state != QLatin1String("setting")) {
+            disconnect(okConn);
+            disconnect(errConn);
+            return err(QStringLiteral("civ power requires standby|wake|probe|setting"));
+        }
+        verb = state == QLatin1String("wake") ? QStringLiteral("power.wake")
+             : state == QLatin1String("probe") ? QStringLiteral("power.probe")
+             : state == QLatin1String("setting") ? QStringLiteral("power.setting")
+                                                : QStringLiteral("power.standby");
+    } else {
+        verb = a == QLatin1String("send") ? QStringLiteral("civ.send")
                        : a == QLatin1String("trace") ? QStringLiteral("civ.trace")
                        : a == QLatin1String("incident") ? QStringLiteral("civ.incident")
                        : a == QLatin1String("scheduler")
                            ? QStringLiteral("civ.scheduler.status")
                                                      : QStringLiteral("civ.session");
-    backend->invokeExtension(QStringLiteral("icom"), verb, rid, arg.trimmed());
+    }
+    backend->invokeExtension(QStringLiteral("icom"), verb, rid, extensionArg);
     disconnect(okConn);
     disconnect(errConn);
 

src/core/backends/IRadioBackend.h

@@ -799,6 +799,11 @@ class IRadioBackend : public QObject {
     void disconnected();
     void connectionError(const QString& reason);
 
+    // A non-fatal connection phase the operator is expected to wait through.
+    // Unlike configurationWarning this names no fault, and unlike
+    // connectionError it must never start reconnect policy by itself.
+    void connectionProgress(const QString& message);
+
     // A problem with the RADIO'S CONFIGURATION that the operator should fix,
     // but which does not end the session. Distinct from connectionError, which
     // every consumer treats as fatal: RadioModel starts its reconnect timer on

src/core/backends/icom/CivCodec.cpp

@@ -48,6 +48,20 @@ std::vector<std::uint8_t> buildFrameSub(std::uint8_t to, std::uint8_t cmd, std::
     return buildFrame(to, cmd, body);
 }
 
+std::vector<std::uint8_t> cmdPowerOn(std::uint8_t to, std::size_t extraPreambleBytes,
+                                     std::uint8_t from)
+{
+    std::vector<std::uint8_t> frame = buildFrameSub(to, cmd::kPower, 0x01, {});
+    frame[3] = from;
+    frame.insert(frame.begin(), extraPreambleBytes, kCivPreamble);
+    return frame;
+}
+
+std::vector<std::uint8_t> cmdPowerOff(std::uint8_t to)
+{
+    return buildFrameSub(to, cmd::kPower, 0x00, {});
+}
+
 // Which commands carry a subcommand is a per-command fact, not a positional
 // one. Treating every second byte as a subcommand would turn command 0x05's
 // first frequency digit into a "subcommand"; treating none of them as one
@@ -85,6 +99,16 @@ bool commandHasSubcommand(std::uint8_t command)
 
 std::optional<CivFrame> parseFrame(std::span<const std::uint8_t> frame)
 {
+    // Wake synchronization fill is a run of FE bytes before the standard FE FE
+    // envelope. Parse from the final pair immediately before the first address.
+    std::size_t firstNonPreamble = 0;
+    while (firstNonPreamble < frame.size()
+           && frame[firstNonPreamble] == kCivPreamble) {
+        ++firstNonPreamble;
+    }
+    if (firstNonPreamble > 2) {
+        frame = frame.subspan(firstNonPreamble - 2);
+    }
     // FE FE <to> <from> <cmd> ... <FD>  — the shortest legal frame is 6 bytes
     // (an FB/FA acknowledgement with no payload).
     if (frame.size() < 6)

src/core/backends/icom/CivCodec.h

@@ -230,6 +230,13 @@ inline constexpr std::uint8_t kTuneOffset   = 0x21;
 inline constexpr std::uint8_t kVfoMode      = 0x26;
 }  // namespace cmd
 
+// Wake a transceiver from standby. `extraPreambleBytes` names model/baud-
+// specific FE synchronization fill before the standard two-byte preamble.
+[[nodiscard]] std::vector<std::uint8_t> cmdPowerOff(std::uint8_t to);
+[[nodiscard]] std::vector<std::uint8_t> cmdPowerOn(std::uint8_t to,
+                                                   std::size_t extraPreambleBytes = 0,
+                                                   std::uint8_t from = kControllerAddress);
+
 [[nodiscard]] std::vector<std::uint8_t> cmdSendCwMessage(
     std::uint8_t to, std::string_view ascii);
 [[nodiscard]] std::vector<std::uint8_t> cmdAbortCwMessage(std::uint8_t to);