masarray · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026
diff --git a/apps/arstack_studio/qml/PtpExpertPanel.qml b/apps/arstack_studio/qml/PtpExpertPanel.qml
@@ -12,7 +12,7 @@ SurfacePanel {
     property string monoFont: "Inter"
     property var roleValues: ["SOURCE", "RECEIVER", "MONITOR"]
     property bool advancedVisible: false
-    property bool startPending: false
+    readonly property bool startPending: panel.device && panel.device.ptpStarting
 
     function roleIndex(role) {
         if (role === "RECEIVER") return 1
@@ -27,9 +27,8 @@ SurfacePanel {
         return 0
     }
 
-    function applyProfile() {
-        if (!panel.session) return false
-        return panel.session.requestConfigurePtp({
+    function ptpProfile() {
+        return {
             domain: Number(domainField.text),
             transportSpecific: Number(transportField.text),
             vlanEnabled: vlanCheck.checked,
@@ -38,24 +37,18 @@ SurfacePanel {
             announceIntervalMs: Number(announceField.text),
             syncIntervalMs: Number(syncField.text),
             respondToPeerDelay: pdelayCheck.checked
-        })
+        }
+    }
+
+    function applyProfile() {
+        return panel.session && panel.session.requestConfigurePtp(panel.ptpProfile())
     }
 
     function startSelectedMode() {
         if (!panel.session || !panel.device.ptpAvailable) return
         var role = panel.roleValues[modeCombo.currentIndex]
-        if (!panel.session.requestPtpRole(role)) {
-            if (panel.controller) panel.controller.showMessage("PTP mode could not be selected.", true)
-            return
-        }
-        if (!panel.applyProfile()) {
-            if (panel.controller) panel.controller.showMessage("PTP settings were rejected before start.", true)
-            return
-        }
-        panel.startPending = true
-        if (!panel.session.requestStartPtp()) {
-            panel.startPending = false
-            if (panel.controller) panel.controller.showMessage("PTP start command could not be sent.", true)
+        if (!panel.session.requestStartPtpConfigured(role, panel.ptpProfile())) {
+            if (panel.controller) panel.controller.showMessage("PTP start blocked. See the Timing status for details.", true)
         }
     }
 
@@ -72,36 +65,11 @@ SurfacePanel {
             : panel.device.ptpStatus === "PTP start failed" ? "START FAILED" : "OFF"
 
     Timer {
-        interval: 700
+        // Status refresh only. Native C++ verifies ACKs and owns timeouts.
+        interval: 1000
         repeat: true
         running: panel.startPending || panel.device.ptpRunning
-        onTriggered: {
-            if (panel.session) panel.session.requestPtpRefresh()
-            if (panel.device.ptpRunning) panel.startPending = false
-        }
-    }
-
-    Timer {
-        interval: 3500
-        repeat: false
-        running: panel.startPending
-        onTriggered: {
-            panel.startPending = false
-            if (panel.session) panel.session.requestPtpRefresh()
-            if (!panel.device.ptpRunning && panel.controller)
-                panel.controller.showMessage("PTP did not reach verified transmit state. Check Ethernet link and retry.", true)
-        }
-    }
-
-    Connections {
-        target: panel.device
-        function onPtpStateChanged() {
-            if (panel.device.ptpRunning) {
-                panel.startPending = false
-                if (panel.controller && panel.sourceRole && panel.sourceEvidence)
-                    panel.controller.showMessage("PTP Source active · Announce + Sync + Follow_Up verified.", false)
-            }
-        }
+        onTriggered: if (panel.session) panel.session.requestPtpRefresh()
     }
 
     ScrollView {
@@ -228,7 +196,6 @@ SurfacePanel {
                     text: "Stop PTP"
                     enabled: panel.session && (panel.device.ptpRunning || panel.startPending) && !panel.session.updatingFirmware
                     onClicked: {
-                        panel.startPending = false
                         panel.session.requestStopPtp()
                     }
                 }
@@ -279,7 +246,7 @@ SurfacePanel {
                     Label {
                         Layout.columnSpan: 5
                         text: panel.sourceRole && panel.device.ptpRunning && panel.sourceEvidence
-                            ? "Verified transmit path: Announce + Sync + Follow_Up counters are advancing with zero TX failures."
+                            ? "Board reports Announce + Sync + Follow_Up TX with zero failures. Independent timing is not qualified."
                             : panel.sourceRole && panel.startPending
                                 ? "Waiting for the first verified Announce + Sync + Follow_Up transmission…"
                                 : panel.device.ptpStatus
@@ -344,8 +311,11 @@ SurfacePanel {
                         theme: panel.theme
                         uiFont: panel.uiFont
                         text: "Apply advanced settings"
-                        enabled: panel.session && panel.device.ptpAvailable && !panel.device.ptpRunning
-                        onClicked: panel.applyProfile()
+                        enabled: panel.session && panel.device.ptpAvailable && !panel.device.ptpRunning && !panel.startPending
+                        onClicked: {
+                            if (!panel.applyProfile() && panel.controller)
+                                panel.controller.showMessage("PTP settings rejected.", true)
+                        }
                     }
                 }
 

diff --git a/apps/arstack_studio/src/DeterministicSessionHarness.cpp b/apps/arstack_studio/src/DeterministicSessionHarness.cpp
@@ -39,6 +39,10 @@ class DeterministicSessionHarness final {
             {"manual recovery intent survives IDENTIFY -> firmware required", manualRecoveryIntentArmsFirmwareOffer()},
             {"stale generation release -> ignored", staleReleaseGenerationIsIgnored()},
             {"firmware probe before serial release -> blocked", firmwareProbeRequiresReleasedPort()},
+            {"PTP staged START requires role/config/runtime ACKs", ptpGuidedStartNeedsAcks()},
+            {"PTP rejected config never starts", ptpGuidedRejectedConfigStops()},
+            {"PTP STOP cancels pending start", ptpGuidedStopCancelsStart()},
+            {"PTP role mismatch and new session revoke pending start", ptpGuidedRoleAndGenerationGuards()},
             {"profile timeout -> bounded terminal error", profileTimeoutIsTerminal()},
             {"profile rejection -> bounded terminal error", profileRejectionIsTerminal()},
             {"binary stale ACK identity -> fail closed", binaryProfileStaleAckFailsClosed()},
@@ -453,6 +457,84 @@ class DeterministicSessionHarness final {
             !fixture.session.startReady();
     }
 
+    static QVariantMap ptpValidProfile() {
+        return {{QStringLiteral("domain"), 0},
+                {QStringLiteral("transportSpecific"), 0},
+                {QStringLiteral("vlanEnabled"), false},
+                {QStringLiteral("vlanId"), 100},
+                {QStringLiteral("vlanPriority"), 4},
+                {QStringLiteral("announceIntervalMs"), 1000},
+                {QStringLiteral("syncIntervalMs"), 1000},
+                {QStringLiteral("respondToPeerDelay"), true}};
+    }
+
+    static bool setupGuidedPtp(Fixture& f, const QString& role) {
+        if (!f.profileReady) return false;
+        seedVerified(f, identity(), QStringLiteral("COM7"), false);
+        f.device.ptpAvailable_ = true;
+        f.device.ioWorkerReady_ = true; // No actual COM opened by this harness.
+        return f.session.requestStartPtpConfigured(role, ptpValidProfile());
+    }
+
+    static bool ptpGuidedStartNeedsAcks() {
+        Fixture f;
+        if (!setupGuidedPtp(f, QStringLiteral("RECEIVER"))) return false;
+        auto& d = f.device;
+        if (d.ptpStartStage_ != DeviceController::PtpStartStage::awaiting_role ||
+            d.ptpRunning_ || !d.ptpStarting()) return false;
+        d.processLine(QStringLiteral("PTPROLE role=RECEIVER value=1 running=0"));
+        if (d.ptpStartStage_ != DeviceController::PtpStartStage::awaiting_config ||
+            !d.ptpStarting()) return false;
+        d.processLine(QStringLiteral("PTP configuration accepted"));
+        if (d.ptpStartStage_ != DeviceController::PtpStartStage::awaiting_start ||
+            d.ptpRunning_) return false;
+        d.processLine(QStringLiteral("PTP start accepted"));
+        if (d.ptpStartStage_ != DeviceController::PtpStartStage::awaiting_runtime) return false;
+        d.processLine(QStringLiteral(
+            "PTP status=RUNNING Announce=1 Sync=1 FollowUp=1 PdelayFrames=0 TXfail=0"));
+        return !d.ptpStarting() && d.ptpRunning_ &&
+            d.ptpRole_ == QStringLiteral("RECEIVER") &&
+            d.ptpStatus_.contains(QStringLiteral("external timing still unqualified"));
+    }
+
+    static bool ptpGuidedRejectedConfigStops() {
+        Fixture f;
+        if (!setupGuidedPtp(f, QStringLiteral("SOURCE"))) return false;
+        auto& d = f.device;
+        d.processLine(QStringLiteral("PTPROLE role=SOURCE value=0 running=0"));
+        if (d.ptpStartStage_ != DeviceController::PtpStartStage::awaiting_config) return false;
+        d.processLine(QStringLiteral("PTP configuration rejected: invalid profile"));
+        return !d.ptpStarting() && !d.ptpRunning_ &&
+            d.ptpStatus_ == QStringLiteral("PTP start failed");
+    }
+
+    static bool ptpGuidedStopCancelsStart() {
+        Fixture f;
+        if (!setupGuidedPtp(f, QStringLiteral("SOURCE"))) return false;
+        auto& d = f.device;
+        if (!f.session.requestStopPtp() || d.ptpStarting()) return false;
+        // ACK from now-abandoned transaction cannot trigger CONFIG or START.
+        d.processLine(QStringLiteral("PTPROLE role=SOURCE value=0 running=0"));
+        return !d.ptpStarting() && d.ptpStartStage_ ==
+            DeviceController::PtpStartStage::idle;
+    }
+
+    static bool ptpGuidedRoleAndGenerationGuards() {
+        Fixture f;
+        if (!setupGuidedPtp(f, QStringLiteral("RECEIVER"))) return false;
+        auto& d = f.device;
+        d.processLine(QStringLiteral("PTPROLE role=MONITOR value=2 running=0"));
+        if (d.ptpStarting() || d.ptpStatus_ != QStringLiteral("PTP start failed"))
+            return false;
+        if (!f.session.requestStartPtpConfigured(QStringLiteral("RECEIVER"), ptpValidProfile()))
+            return false;
+        const quint64 previous = d.sessionGeneration_;
+        d.setSessionGeneration(previous + 1);
+        d.processLine(QStringLiteral("PTPROLE role=RECEIVER value=1 running=0"));
+        return !d.ptpStarting() && d.ptpStartStage_ ==
+            DeviceController::PtpStartStage::idle;
+    }
+
     static bool staleReleaseGenerationIsIgnored() {
         Fixture fixture;
         if (!fixture.profileReady) return false;